Add Jedit-owned Edict flat-text replacement reference

.github/workflows/ci.yml

@@ -168,9 +168,94 @@ jobs:
       - name: Run Echo release gate
         run: npm run release-gate:jedit-echo
 
+  edict-replace-range:
+    name: edict / replace-range package and pure runtime chain
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout Jedit
+        uses: actions/checkout@v6.0.2
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+          path: jedit
+
+      - name: Verify literal submitted head
+        working-directory: jedit
+        env:
+          EXPECTED_JEDIT_HEAD: ${{ github.event.pull_request.head.sha || github.sha }}
+        run: test "$(git rev-parse HEAD)" = "$EXPECTED_JEDIT_HEAD"
+
+      - name: Read pinned toolchain commits
+        id: toolchain
+        working-directory: jedit
+        run: |
+          node --input-type=module <<'NODE' >> "$GITHUB_OUTPUT"
+          import { readFileSync } from "node:fs";
+          const lock = JSON.parse(
+            readFileSync("edict/replace-range/edict.toolchain-lock.json", "utf8"),
+          );
+          console.log(`edict_commit=${lock.edict.commit}`);
+          console.log(`echo_commit=${lock.echo.commit}`);
+          console.log(`rust_toolchain=${lock.rust.toolchain}`);
+          console.log(`node_version=${lock.validation.nodeVersion}`);
+          NODE
+
+      - name: Checkout pinned Edict
+        uses: actions/checkout@v6.0.2
+        with:
+          repository: flyingrobots/edict
+          ref: ${{ steps.toolchain.outputs.edict_commit }}
+          path: edict
+
+      - name: Checkout pinned Echo
+        uses: actions/checkout@v6.0.2
+        with:
+          repository: flyingrobots/echo
+          ref: ${{ steps.toolchain.outputs.echo_commit }}
+          path: echo
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6.4.0
+        with:
+          node-version: ${{ steps.toolchain.outputs.node_version }}
+          cache: 'npm'
+          cache-dependency-path: jedit/package-lock.json
+
+      - name: Setup pinned Rust
+        run: rustup toolchain install '${{ steps.toolchain.outputs.rust_toolchain }}' --profile minimal
+
+      - name: Install Jedit dependencies
+        working-directory: jedit
+        run: npm ci
+
+      - name: Compile the pinned test-only pure runtime host
+        working-directory: jedit
+        env:
+          CARGO_TARGET_DIR: ${{ github.workspace }}/runtime-target
+        run: cargo +${{ steps.toolchain.outputs.rust_toolchain }} test --locked --manifest-path edict/replace-range/tests/runtime/Cargo.toml --test compiled_boundary --no-run
+
+      - name: Verify exact package and pure runtime chain with adversarial regressions
+        working-directory: jedit
+        env:
+          EDICT_REPO: ${{ github.workspace }}/edict
+          ECHO_REPO: ${{ github.workspace }}/echo
+          CARGO_TARGET_DIR: ${{ github.workspace }}/runtime-target
+        run: node --test edict/replace-range/tests/proof-harness.spec.mjs
+
+      - name: Verify authoritative checkouts remain clean
+        run: |
+          for repository in jedit edict echo; do
+            if [[ -n "$(git -C "$repository" status --porcelain=v1 --untracked-files=all)" ]]; then
+              echo "$repository changed during the package-chain gate" >&2
+              git -C "$repository" status --short >&2
+              exit 1
+            fi
+          done
+
   check:
     name: check
-    needs: [ plan, build, test-shards, quality, release-gate ]
+    needs: [ plan, build, test-shards, quality, release-gate, edict-replace-range ]
     if: always()
     runs-on: ubuntu-latest
 
@@ -182,9 +267,10 @@ jobs:
           TEST_SHARDS_RESULT: ${{ needs.test-shards.result }}
           QUALITY_RESULT: ${{ needs.quality.result }}
           RELEASE_GATE_RESULT: ${{ needs.release-gate.result }}
+          EDICT_REPLACE_RANGE_RESULT: ${{ needs.edict-replace-range.result }}
         run: |
           failed=0
-          for result in "$PLAN_RESULT" "$BUILD_RESULT" "$QUALITY_RESULT"; do
+          for result in "$PLAN_RESULT" "$BUILD_RESULT" "$QUALITY_RESULT" "$EDICT_REPLACE_RANGE_RESULT"; do
             if [[ "$result" != "success" ]]; then
               failed=1
             fi
@@ -205,5 +291,6 @@ jobs:
             echo "| test shards | $TEST_SHARDS_RESULT |"
             echo "| quality | $QUALITY_RESULT |"
             echo "| release gate | $RELEASE_GATE_RESULT |"
+            echo "| edict / replace-range package chain | $EDICT_REPLACE_RANGE_RESULT |"
           } >> "$GITHUB_STEP_SUMMARY"
           exit "$failed"

.gitignore

@@ -7,6 +7,9 @@ title-recordings/
 .wesley-cache/
 .jedit-cache/
 .jedit/
+.build/
+.vendor.edict-lawpack-build.lock
+.jedit-text.edict-lawpack-build.lock
 .obsidian/
 .claude/
 src/generated/jedit/structural-history-replace-text-range.wesley.generated.ts

CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## Unreleased
 
+- Added DL-0159, a draft representation for the Edict-authored rope: schema 2
+  with typed Echo edges for every structural relation, canonical CBOR facts,
+  content-addressed immutable nodes, and an import anchor tying every head to
+  its file. The graph holds only the current rope; Echo's ticks and receipts
+  own history, and retention of superseded nodes is Echo's policy.
+- Added complete, not-yet-compiling drafts of `ReplaceRange` in Edict source
+  under `edict/replace-range/draft/`: a flat-text semantic reference and the
+  persistent AVL rope. Their README classifies every blocker by owner and
+  states the evidence plan. They are not part of the application gate.
+- Repinned the ReplaceRange Edict application to Edict main `e60411fc` and
+  Echo main `9b3b9396` (provider and pure evaluator), with Rust 1.96.0 as Edict
+  now requires. The verified executable subject is byte-identical to the
+  earlier candidate pins; only the build closure changed. The leaf-slice and
+  range-assembly probe sources now build against Edict main; the Buffer decoder
+  still refuses at lexing.
+- Fixed the Edict package-chain harness to use Cargo's reported executable path
+  when CI redirects build output with `CARGO_TARGET_DIR`. The regression compiles
+  and executes the real pinned package without a default-path compiler binary;
+  compiler, provider, evaluator, and application artifact identities are unchanged.
+- Added a separate Docker-only state-read ordering probe for ReplaceRange. It
+  reproduces Edict's refusal of an effect-dependent basis guard and confirms
+  that removing the guard reaches an unsupported-provider refusal. This is
+  development evidence, not stateful execution; existing producer pins remain
+  unchanged. Ordered Target IR is tracked in flyingrobots/edict#218.
+- Added the Jedit-owned `ReplaceRange.edict` application root and canonical
+  `jedit.text@1` lawpack publication. With Edict #201, its executable integration
+  gate now proves that real source lowers into generic pure Target IR and reaches
+  Echo's checked lowerer through the exact generic pure target configuration.
+  Echo's generic pure-program lowerer now emits the exact compiler-produced
+  package, and its structurally separate verifier independently accepts the
+  package relation. The integration gate pins clean Edict and Echo revisions,
+  verifies the committed lawpack closure without repairing it, and rejects
+  authoritative-input mutation outside its disposable build root. Runtime
+  evaluation and rope mutation remain unimplemented.
 - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact
   requested-range materialization before no-op classification, so truncated or
   absent retained roots fail with a typed malformed-rope obstruction.

docs/BEARING.md

@@ -124,6 +124,16 @@ or support-policy logic.
 
 ## Immediate Roadmap
 
+- [x] Execute compiler-produced flat-text replacement against literal UTF-8
+  cases, then range, UTF-8, no-op and resource refusals. This is the logical-text
+  reference for the persistent-rope differential gate, not graph admission or
+  recovery evidence.
+
+- [x] Make the pinned Edict package-chain harness discover Cargo's actual
+  executable when its output is redirected. Preserve producer pins and verify
+  the emitted pure package in Echo; this does not complete the authored rope
+  operation or its stateful runtime path.
+
 1. Keep the narrow create/replace/checkpoint/read corridor green against
    Echo-owned WAL, admission, scheduling, graph state, receipts, and restart
    recovery.