# #70 — INV-5 Reject-After-Interior-Edit Gap Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** `✗ Reject` on an optimistically-applied proposal restores the retained original (INV-5) even after the writer typed inside the pending range — and when it genuinely cannot locate the applied span, it fails loudly instead of reporting success while leaving the proposed text behind.

**Architecture:** Issue #70's fix direction **(a)** with an honest **(b)** fallback. A new per-doc `appliedSpans: Map<proposalId, OffsetRange>` becomes the real F12 applied-range bookkeeping: written at optimistic-apply time, re-synced whenever the exact anchor resolves at `renderAll`, shifted through interior-safe buffer edits (`shift()`), and **deleted (distrusted)** when an edit straddles a span boundary (e.g. a whole-buffer external replace — a shifted range clamps to garbage there, and restoring at a guessed offset would corrupt the doc, INV-11's "never applied by guess"). `revertInPlace` then reverts via exact resolve → `appliedSpans` fallback → hard failure (warning, proposal kept, `false` returned). Direction (c) (fuzzy resolve) is rejected: it guesses. `rejectAll` orders by the same fallback and reports skips like `acceptAllProposals` does.

**Tech Stack:** TypeScript VS Code extension; `npm test` (vitest unit), `npm run test:e2e` (@vscode/test-electron host suite — `ProposalController` is vscode-coupled, so coverage is host E2E, matching every existing F12 test).

## Global Constraints

- INV-5: "Reject restores the retained original exactly" — the contract this fix enforces; `revertInPlace`'s doc comment already promises "reverts the whole block regardless of any in-place edits the human made".
- INV-11: anchors are immutable for a proposal's life; stale text is flagged, **never applied by guess** — the fallback must only use a span whose tracking is provably continuous (no fuzzy resolve, no boundary-straddled ranges).
- INV-12: accept/reject stay human-only gestures; no new mutation paths.
- Keep `✓ Keep` (`finalizeInPlace`) behavior byte-identical — its lookup-by-id bypass of resolution is correct by design (issue "Contrast" note).
- Existing test suites must stay green: 265+ unit, full host E2E (notably `proposals.test.ts` INV-11 stale-accept, `f12InlineDiff.test.ts`, `fullLoop.test.ts`).
- Wiggleverse hygiene: no inline trailing comments in CLI blocks; commits cite the issue and carry the `Co-Authored-By` trailer.

---

### Task 1: `appliedSpans` bookkeeping + `revertInPlace` tracked-range fallback (the INV-5 repro)

**Files:**
- Modify: `src/proposalController.ts` (DocState ~line 35, `ensureState` ~127, `optimisticApply` ~336, `finalizeInPlace` ~417, `revertInPlace` ~434, `renderAll` ~495, `onDidChange` ~529)
- Test: `test/e2e/suite/f12InlineDiff.test.ts` (new suite appended)

**Interfaces:**
- Consumes: `shift(range, edit)` / `resolve(text, fp)` from `src/anchorer.ts` (existing); `DocState.applied: Set<string>` (existing).
- Produces: `DocState.appliedSpans: Map<string, OffsetRange>` (private bookkeeping; Tasks 2–3 rely on its distrust + ordering semantics); `revertInPlace(docPath, proposalId, opts?: { silent?: boolean }): Promise<boolean>` — signature gains the optional `opts` used by Task 3.

- [ ] **Step 1: Write the failing E2E test — the issue's repro sketch**

Append to `test/e2e/suite/f12InlineDiff.test.ts`:

```typescript
// #70 (INV-5): rejecting a proposal AFTER typing inside its pending range must
// still restore the retained original. The exact-substring anchor is orphaned by
// the interior tweak (INV-1/INV-11) — the revert falls back to the F12
// applied-range bookkeeping (appliedSpans), which shift-tracks the span through
// interior edits.
suite("F12 inline diff — #70 reject after interior edit (INV-5)", () => {
  test("revertInPlace restores the original after a tweak inside the pending range", async () => {
    const ORIGINAL = "The quick brown fox jumps.";
    const { doc } = await freshDoc("docs/s70-reject-tweaked.md", `# T\n\n${ORIGINAL}\n`);
    const api = await getApi();
    const p = api.proposalController;
    const docKey = p.keyFor(doc);
    const fp = { text: ORIGINAL, before: "", after: "", lineHint: 2 };
    const id = await p.propose(doc, fp, "The rapid brown fox jumps.",
      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
    await p.optimisticApply(doc, id!);
    await settle();
    assert.ok(doc.getText().includes("The rapid brown fox jumps."), "optimistically applied");
    // Human types INSIDE the pending range → orphans the exact anchor (INV-11).
    const at = doc.getText().indexOf("rapid");
    const we = new vscode.WorkspaceEdit();
    we.replace(doc.uri, new vscode.Range(doc.positionAt(at), doc.positionAt(at + "rapid".length)), "RAPID-ish");
    assert.ok(await vscode.workspace.applyEdit(we), "interior tweak applied");
    await settle();
    assert.strictEqual(p.listProposals(doc).find((v) => v.id === id)!.anchorStart, null, "anchor orphaned by the tweak");
    // ✗ Reject: must restore the retained original EXACTLY (INV-5), not skip.
    assert.ok(await p.revertInPlace(docKey, id!), "reject reports success");
    await settle();
    assert.strictEqual(doc.getText(), `# T\n\n${ORIGINAL}\n`, "original restored exactly (INV-5)");
    assert.strictEqual(p.listProposals(doc).length, 0, "proposal cleared");
  });

  test("rejectByIdInPlace routes the tweaked-applied case the same way", async () => {
    const ORIGINAL = "A steady closing line.";
    const { doc } = await freshDoc("docs/s70-reject-route.md", `# T\n\n${ORIGINAL}\n`);
    const api = await getApi();
    const p = api.proposalController;
    const docKey = p.keyFor(doc);
    const fp = { text: ORIGINAL, before: "", after: "", lineHint: 2 };
    const id = await p.propose(doc, fp, "A wobbly closing line.",
      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
    await p.optimisticApply(doc, id!);
    await settle();
    const at = doc.getText().indexOf("wobbly");
    const we = new vscode.WorkspaceEdit();
    we.replace(doc.uri, new vscode.Range(doc.positionAt(at), doc.positionAt(at)), "very-");
    assert.ok(await vscode.workspace.applyEdit(we), "interior insertion applied");
    await settle();
    assert.ok(await p.rejectByIdInPlace(docKey, id!), "gesture-level reject succeeds");
    await settle();
    assert.strictEqual(doc.getText(), `# T\n\n${ORIGINAL}\n`, "original restored exactly (INV-5)");
  });
});
```

- [ ] **Step 2: Run the new suite to verify it fails**

```bash
npm run test:e2e 2>&1 | grep -A 3 "#70"
```

Expected: both tests FAIL — first on `doc.getText()` still holding the tweaked replacement (`RAPID-ish`) after a `true` return (the silent-skip bug), i.e. the "original restored exactly" assertion.

- [ ] **Step 3: Implement `appliedSpans` + the fallback**

In `src/proposalController.ts`:

(1) `DocState` gains the map (after `applied`):

```typescript
  /** ids already optimistically applied to the buffer (so the trigger doesn't re-apply). */
  applied: Set<string>;
  /**
   * #70 (INV-5): the F12 applied-range bookkeeping — proposal id -> the applied
   * span's CURRENT buffer range. Written at optimistic-apply, re-synced whenever
   * the exact anchor resolves (renderAll), shifted through interior-safe edits,
   * and DELETED (distrusted) when an edit straddles a span boundary — a clamped
   * range is a guess, and stale text is never applied by guess (INV-11). Lets
   * Reject restore the original after the human types INSIDE the pending range
   * (which orphans the exact-substring anchor).
   */
  appliedSpans: Map<string, OffsetRange>;
```

(2) `ensureState` initializes it: `appliedSpans: new Map(),` after `applied: new Set(),`.

(3) `optimisticApply` records the span where it already re-anchors (after `state.applied.add(proposalId);` and the `appliedStart`/`appliedEnd` computation — move the `add` down beside it or record right after the existing lines):

```typescript
    state.applied.add(proposalId);
    // Re-anchor to the applied text now in the buffer (its start is unchanged; its
    // end shifts by the net length delta of the replacement).
    const appliedStart = resolved.start;
    const appliedEnd = appliedStart + proposal.replacement.length;
    state.appliedSpans.set(proposalId, { start: appliedStart, end: appliedEnd });
```

(4) `renderAll`'s resolved branch re-syncs (covers the prior-session-applied reload, where the in-memory map starts empty):

```typescript
      } else {
        this.recordProposal(state, proposal, resolved, true);
        if (state.applied.has(proposal.id)) state.appliedSpans.set(proposal.id, resolved);
      }
```

(5) `onDidChange` maintains it — interior-safe edits shift, boundary-straddling edits distrust. Replace the method body:

```typescript
  private onDidChange(e: vscode.TextDocumentChangeEvent): void {
    const state = this.docs.get(this.keyOf(e.document));
    if (!state || (state.live.size === 0 && state.appliedSpans.size === 0)) return;
    for (const change of e.contentChanges) {
      const edit = { start: change.rangeOffset, end: change.rangeOffset + change.rangeLength, newLength: change.text.length };
      for (const [id, range] of state.live) state.live.set(id, shift(range, edit));
      // #70: an edit fully inside a tracked applied span (or fully outside it)
      // keeps the span meaningful; one straddling a boundary — e.g. a whole-buffer
      // external replace — makes the shifted range a clamped guess, so the span
      // is distrusted (deleted) rather than reverted-to by guess (INV-11).
      for (const [id, range] of state.appliedSpans) {
        const outside = edit.end <= range.start || edit.start >= range.end;
        const inside = edit.start >= range.start && edit.end <= range.end;
        if (outside || inside) state.appliedSpans.set(id, shift(range, edit));
        else state.appliedSpans.delete(id);
      }
    }
  }
```

(6) `revertInPlace` — the fix itself. Replace the method (keep its position; doc comment updated to describe the layered lookup; `opts` is consumed by Task 3):

```typescript
  /**
   * F12/#64 (INV-51): REJECT an optimistically-applied proposal — replace its live
   * applied span with the stored `original`, then clear it. Reverts the whole block
   * regardless of any in-place edits the human made to the inserted text: when an
   * interior tweak has orphaned the exact anchor (INV-11), the revert falls back to
   * the shift-tracked applied span (#70, INV-5). When neither locates the span
   * (e.g. a boundary-straddling external rewrite distrusted it), the reject FAILS
   * loudly — warning shown, proposal kept, `false` returned — instead of silently
   * leaving the proposed text in the buffer. Undo (or ✓ Keep) remains the way out.
   */
  async revertInPlace(docPath: string, proposalId: string, opts?: { silent?: boolean }): Promise<boolean> {
    const hit = this.byId(docPath, proposalId);
    if (!hit) return false;
    const document = this.openDoc(hit.state);
    if (!document) return false;
    // Never optimistically applied → nothing of ours is in the buffer; clearing
    // the record IS the reject (the legacy pending-only path).
    if (hit.proposal.original === undefined) {
      this.store.update(docPath, (a) => removeProposal(a, proposalId));
      hit.state.applied.delete(proposalId);
      hit.state.appliedSpans.delete(proposalId);
      this.renderAll(document);
      return true;
    }
    const fp = hit.state.artifact.anchors[hit.proposal.anchorId]?.fingerprint;
    const resolved = fp ? resolve(document.getText(), fp) : "orphaned";
    const span = resolved !== "orphaned" ? resolved : hit.state.appliedSpans.get(proposalId);
    if (!span) {
      if (!opts?.silent) {
        void vscode.window.showWarningMessage(
          "Cowriting: this proposal's applied text can't be located (it changed or moved) — undo your edits, or Keep it to leave the buffer as-is (it is never reverted by guess).",
        );
      }
      return false;
    }
    const we = new vscode.WorkspaceEdit();
    we.replace(
      document.uri,
      new vscode.Range(document.positionAt(span.start), document.positionAt(span.end)),
      hit.proposal.original,
    );
    if (!(await vscode.workspace.applyEdit(we))) return false;
    this.store.update(docPath, (a) => removeProposal(a, proposalId));
    hit.state.applied.delete(proposalId);
    hit.state.appliedSpans.delete(proposalId);
    this.renderAll(document);
    return true;
  }
```

(7) `finalizeInPlace` cleans the map beside its existing `applied.delete`:

```typescript
    hit.state.applied.delete(proposalId);
    hit.state.appliedSpans.delete(proposalId);
```

- [ ] **Step 4: Typecheck + unit tests + the new E2E**

```bash
npm run typecheck && npm test
npm run test:e2e
```

Expected: typecheck clean; all unit tests PASS (no unit test touches `ProposalController`); host E2E PASS including the two new #70 tests and all pre-existing F12/proposals/fullLoop suites.

- [ ] **Step 5: Commit**

```bash
git add src/proposalController.ts test/e2e/suite/f12InlineDiff.test.ts
git commit -m "fix(#70): reject after an interior tweak restores the original via tracked applied span (INV-5)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
```

---

### Task 2: The honest hard-failure path (fix direction (b) for the residual orphan)

**Files:**
- Modify: `src/proposalController.ts` (only if Step 2 exposes a gap — the Task 1 code already implements the path)
- Test: `test/e2e/suite/f12InlineDiff.test.ts` (extend the #70 suite)

**Interfaces:**
- Consumes: Task 1's `appliedSpans` distrust semantics and `revertInPlace` failure contract.
- Produces: nothing new — locks the contract with a regression test.

- [ ] **Step 1: Write the failing/locking E2E test**

Append inside the `#70` suite from Task 1:

> **Execution note:** the first cut of this test used a whole-buffer rewrite as the
> distrusting edit and FAILED — VS Code minimizes workspace edits before change
> events fire, so a rewrite sharing a prefix/suffix with the old text decomposes
> into interior hunks the span legitimately survives (and the revert then correctly
> restores the original in place). The distrusting edit must straddle a span
> boundary even after minimization — a deletion from outside the span into its
> interior, as below.

```typescript
  // Fix direction (b): when the tracked span itself is distrusted (an edit
  // straddled its boundary — here a deletion running from the heading into the
  // span's interior), the reject FAILS honestly: warning path, proposal kept,
  // buffer untouched. Silent-skip-and-report-success (the #70 bug) must not come
  // back; reverting at a clamped guessed offset (INV-11) must not either.
  // (A boundary-straddling DELETION is used because VS Code minimizes workspace
  // edits before change events fire — a wholesale rewrite sharing a prefix/suffix
  // decomposes into interior hunks the span legitimately survives.)
  test("reject fails loudly — proposal kept, buffer untouched — when the span is distrusted", async () => {
    const ORIGINAL = "Sentence one stands here.";
    const { doc } = await freshDoc("docs/s70-reject-distrust.md", `# T\n\n${ORIGINAL}\n`);
    const api = await getApi();
    const p = api.proposalController;
    const docKey = p.keyFor(doc);
    const fp = { text: ORIGINAL, before: "", after: "", lineHint: 2 };
    const id = await p.propose(doc, fp, "Sentence ONE stands here.",
      { kind: "agent", id: "claude", agent: { sdk: "x", model: "m", sessionId: "s" } }, { granularity: "block" });
    await p.optimisticApply(doc, id!);
    await settle();
    // Delete from inside the heading through the middle of the applied span:
    // the edit straddles the span's start boundary → the tracked span is
    // distrusted AND the exact anchor no longer resolves.
    const mid = doc.getText().indexOf("ONE");
    const we = new vscode.WorkspaceEdit();
    we.replace(doc.uri, new vscode.Range(doc.positionAt(2), doc.positionAt(mid + 1)), "");
    assert.ok(await vscode.workspace.applyEdit(we), "boundary-straddling deletion applied");
    await settle();
    const before = doc.getText();
    assert.strictEqual(await p.revertInPlace(docKey, id!), false, "reject reports failure (no silent success)");
    await settle();
    assert.strictEqual(doc.getText(), before, "buffer untouched — never reverted by guess (INV-11)");
    assert.ok(p.listProposals(doc).some((v) => v.id === id), "proposal kept (not silently dropped)");
    // Cleanup for later tests: the never-locatable husk is discarded via the
    // plain record-only reject.
    assert.strictEqual(p.rejectById(docKey, id!), true);
  });
```

- [ ] **Step 2: Run it**

```bash
npm run test:e2e 2>&1 | grep -B 2 -A 5 "distrusted"
```

Expected: PASS if Task 1's implementation is complete (this is the locking regression); if it FAILS, the failure pinpoints which leg (distrust bookkeeping vs. failure return vs. proposal retention) is wrong — fix `src/proposalController.ts` accordingly, not the test.

- [ ] **Step 3: Commit**

```bash
git add test/e2e/suite/f12InlineDiff.test.ts src/proposalController.ts
git commit -m "test(#70): lock the honest hard-failure reject path (distrusted span → warn, keep, false)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
```

---

### Task 3: `rejectAll` parity — tweaked proposals revert too, skips are reported

**Files:**
- Modify: `src/proposalController.ts` (`rejectAll` ~line 461), `src/extension.ts` (`cowriting.rejectAllProposals` handler ~line 220)
- Test: `test/e2e/suite/f12InlineDiff.test.ts` (extend the #70 suite)

**Interfaces:**
- Consumes: Task 1's `revertInPlace(docPath, id, opts?: { silent?: boolean })` and `appliedSpans`.
- Produces: `rejectAll(document): Promise<{ reverted: number; skipped: number }>` — additive `skipped` field (existing `{ reverted }` destructurings stay valid).

- [ ] **Step 1: Write the failing E2E test**

Append inside the `#70` suite:

```typescript
  // rejectAll must revert a tweaked (orphaned-anchor) proposal via the same
  // tracked-span fallback, ordered descending by that span so earlier reverts
  // never shift later ones — and must count what it could not revert.
  test("rejectAll reverts tweaked proposals via the tracked span and reports skips", async () => {
    const { doc } = await freshDoc("docs/s70-rejall-tweak.md", "# T\n\nOne aaa.\n\nTwo bbb.\n");
    const api = await getApi();
    const p = api.proposalController;
    const editFlow = api.editFlow;
    editFlow.setEditTurnForTest(async () => ({ replacement: "# T\n\nOne AAA.\n\nTwo BBB.\n", model: "m", sessionId: "s" }));
    const ids = await editFlow.runEditAndPropose(doc, { kind: "document" }, "up");
    await settle();
    for (const id of ids) await p.optimisticApply(doc, id);
    await settle();
    // Tweak INSIDE the first applied block → its exact anchor orphans.
    const at = doc.getText().indexOf("AAA");
    const we = new vscode.WorkspaceEdit();
    we.replace(doc.uri, new vscode.Range(doc.positionAt(at), doc.positionAt(at + 3)), "AAAZ");
    assert.ok(await vscode.workspace.applyEdit(we), "interior tweak applied");
    await settle();
    const { reverted, skipped } = await p.rejectAll(doc);
    await settle();
    assert.strictEqual(reverted, ids.length, "ALL proposals reverted, tweaked one included");
    assert.strictEqual(skipped, 0, "nothing skipped");
    assert.strictEqual(doc.getText(), "# T\n\nOne aaa.\n\nTwo bbb.\n", "document fully restored (INV-5)");
    assert.strictEqual(p.listProposals(doc).length, 0, "all cleared");
  });
```

- [ ] **Step 2: Run it to verify the current gap**

```bash
npm run test:e2e 2>&1 | grep -B 2 -A 5 "rejectAll reverts tweaked"
```

Expected: FAIL — today the tweaked proposal sorts as an orphan (`start: -1`, reverted last), and after the first successful revert's `renderAll` the old code silently removes it without restoring (`document fully restored` assertion fails), and `skipped` does not exist on the return type (typecheck catches first — that is the same failure).

- [ ] **Step 3: Implement — order by the fallback span, count skips, report them**

Replace `rejectAll` in `src/proposalController.ts`:

```typescript
  /**
   * F12/#64 (INV-53): reject EVERY pending proposal on a document — revert each in
   * DESCENDING span order (so an earlier revert never shifts a later one's
   * offsets), symmetric with #46's accept-all. #70: a tweaked proposal whose exact
   * anchor is orphaned orders (and reverts) by its shift-tracked applied span;
   * one with no locatable span is SKIPPED — counted, never guessed (INV-11) —
   * and the per-proposal warning is suppressed in favor of the batch report.
   */
  async rejectAll(document: vscode.TextDocument): Promise<{ reverted: number; skipped: number }> {
    if (!this.isTracked(document)) return { reverted: 0, skipped: 0 };
    const docPath = this.keyOf(document);
    const state = this.ensureState(document);
    state.artifact = this.store.load(docPath) ?? emptyArtifact(docPath);
    const text = document.getText();
    const ordered = state.artifact.proposals
      .map((p) => {
        const fp = state.artifact.anchors[p.anchorId]?.fingerprint;
        const r = fp ? resolve(text, fp) : "orphaned";
        const start = r !== "orphaned" ? r.start : state.appliedSpans.get(p.id)?.start ?? -1;
        return { id: p.id, start };
      })
      .sort((a, b) => b.start - a.start);
    let reverted = 0;
    let skipped = 0;
    for (const it of ordered) {
      if (await this.revertInPlace(docPath, it.id, { silent: true })) reverted++;
      else skipped++;
    }
    return { reverted, skipped };
  }
```

And in `src/extension.ts`, the `cowriting.rejectAllProposals` handler mirrors accept-all's skip note:

```typescript
      const { reverted, skipped } = await proposalController.rejectAll(doc);
      if (reverted === 0 && skipped === 0) return;
      const skipNote = skipped > 0 ? `, ${skipped} skipped (applied text not locatable — undo your edits or Keep)` : "";
      void vscode.window.showInformationMessage(
        `Cowriting: rejected ${reverted} proposal${reverted === 1 ? "" : "s"}${skipNote}.`,
      );
```

- [ ] **Step 4: Typecheck + full test run**

```bash
npm run typecheck && npm test
npm run test:e2e
```

Expected: all PASS — including the pre-existing `rejectAll` E2E tests (`f12InlineDiff` "rejectAll reverts every pending proposal", "control parity", `proposals.test.ts` cleanup calls), whose `{ reverted }` destructuring is unaffected by the additive field.

- [ ] **Step 5: Commit**

```bash
git add src/proposalController.ts src/extension.ts test/e2e/suite/f12InlineDiff.test.ts
git commit -m "fix(#70): rejectAll reverts tweaked proposals via the tracked span; skips are counted and reported

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
```

---

### Task 4: Close the loop — fullLoop E2E rejects a tweaked proposal (the deliberate avoidance falls)

**Files:**
- Modify: `test/e2e/suite/fullLoop.test.ts` (the PUC-2 reject section, ~line 144)

**Interfaces:**
- Consumes: the shipped Task 1 behavior; existing fullLoop fixtures (`rejectId`, `REJECT_REPLACEMENT`, `ORIG_REJECT`).
- Produces: nothing — upgrades the flagship E2E so the gap can't silently regress.

- [ ] **Step 1: Tweak inside the reject proposal's range before rejecting**

In `test/e2e/suite/fullLoop.test.ts`, immediately before the existing line
`assert.ok(await api.proposalController.revertInPlace(docKey, rejectId), "reject reverts in place");`,
insert:

```typescript
    // #70 (INV-5): the reject leg now ALSO takes an interior tweak first — the
    // original deliberately rejected only an un-tweaked proposal because the
    // pre-fix revert silently skipped an orphaned anchor. The tweak orphans the
    // exact anchor; the revert must restore ORIG_REJECT via the tracked span.
    const rejAt = doc.getText().indexOf(REJECT_REPLACEMENT);
    assert.ok(rejAt >= 0, "reject proposal's applied text present");
    const rejTweak = new vscode.WorkspaceEdit();
    rejTweak.replace(doc.uri, new vscode.Range(doc.positionAt(rejAt + 2), doc.positionAt(rejAt + 2)), "x");
    assert.ok(await vscode.workspace.applyEdit(rejTweak), "human tweak inside the reject proposal's range");
    await settle();
    assert.strictEqual(
      api.proposalController.listProposals(doc).find((v) => v.id === rejectId)!.anchorStart,
      null,
      "tweak orphans the reject proposal's exact anchor (INV-11)",
    );
```

(The existing assertions right after — proposal cleared, `ORIG_REJECT` restored, `REJECT_REPLACEMENT` gone — now verify the #70 path. If `REJECT_REPLACEMENT` is a multi-word string whose slice at `+2` splits a word the later `!doc.getText().includes(REJECT_REPLACEMENT)` assertion still holds; the `includes(ORIG_REJECT)` restore assertion is the INV-5 check.)

- [ ] **Step 2: Run the fullLoop suite**

```bash
npm run test:e2e 2>&1 | grep -B 2 -A 8 "fullLoop\|full-loop\|full loop"
```

Expected: PASS end-to-end (would FAIL on unfixed code: the buffer would keep the tweaked `REJECT_REPLACEMENT`, so `includes(ORIG_REJECT)` fails).

- [ ] **Step 3: Full verification sweep**

```bash
npm run typecheck && npm test && npm run test:e2e
```

Expected: everything green.

- [ ] **Step 4: Commit**

```bash
git add test/e2e/suite/fullLoop.test.ts
git commit -m "test(#70): fullLoop reject leg now tweaks inside the pending range first (INV-5 end-to-end)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
```

---

## Post-execution review wave (not in the original tasks)

A high-effort multi-agent branch review after Task 4 confirmed 10 findings; all
but one were fixed in a follow-up commit on this branch ("harden the
tracked-span revert per branch review"): pure `shiftTracked` in `anchorer.ts`
(+11 unit tests; insertion-at-span-start lands before the span), tracked spans
cleared on document close, rebuild-only resync at `renderAll`, `guard.isReadOnly`
on `revertInPlace`/`finalizeInPlace`, a "Discard proposal (leave text)" action on
the hard-fail warning, CodeLens pair anchored at the tracked span (+1 E2E),
QuickPick batch menu routed through the reporting commands, and one
`clearProposal` helper (also fixes `reject()`'s stale `applied`/`appliedSpans`).
The remaining finding — `resolve()` accepts a single exact occurrence without a
context check, so a duplicated block can hijack any anchor consumer — pre-dates
this fix and is filed as its own issue.

## Self-review notes

- **Issue coverage:** direction (a) → Task 1 (`appliedSpans` fallback); direction (b) → Task 2 (hard failure, warn, keep); direction (c) explicitly rejected (guessing violates INV-11). The issue's repro sketch is Task 1's test verbatim; the "full-loop E2E deliberately rejects only an un-tweaked proposal" note is retired by Task 4; `rejectAll` (same `revertInPlace` seam) is covered by Task 3.
- **Type consistency:** `revertInPlace(docPath, proposalId, opts?: { silent?: boolean })` defined in Task 1, consumed in Task 3; `rejectAll` returns `{ reverted, skipped }` (additive); `appliedSpans: Map<string, OffsetRange>` used in Tasks 1 and 3.
- **Contrast guard:** `finalizeInPlace` untouched except symmetric `appliedSpans.delete` cleanup — the Keep bypass stays.