gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -31,6 +31,7 @@ import {
   openDatabase,
   closeDatabase,
   insertMilestone,
+  insertAssessment,
   insertSlice,
   insertTask,
   getTask,
@@ -280,6 +281,16 @@ function makeMilestoneParams(milestoneId: string): Record<string, unknown> {
   };
 }
 
+function insertPassingMilestoneValidation(milestoneId: string): void {
+  insertAssessment({
+    path: `.gsd/milestones/${milestoneId}/${milestoneId}-VALIDATION.md`,
+    milestoneId,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "# Validation\n\nverdict: PASS",
+  });
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -424,6 +435,7 @@ describe("state-machine-live-validation", () => {
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Impl", status: "complete" });
       insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Test", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Impl", status: "complete" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok(!("error" in result), `expected success, got: ${JSON.stringify(result)}`);
@@ -528,6 +540,7 @@ describe("state-machine-live-validation", () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -542,6 +555,7 @@ describe("state-machine-live-validation", () => {
       insertSlice({ id: "S02", milestoneId: "M001", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -555,6 +569,7 @@ describe("state-machine-live-validation", () => {
       // Slice marked complete but task is still pending — simulates inconsistent state
       insertSlice({ id: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -195,6 +195,11 @@ describe("infrastructure error detection", () => {
     assert.equal(isInfrastructureError(err), "EAGAIN");
   });
 
+  test("ENOBUFS (no buffer space available) is detected", () => {
+    const err = Object.assign(new Error("spawnSync git ENOBUFS"), { code: "ENOBUFS" });
+    assert.equal(isInfrastructureError(err), "ENOBUFS");
+  });
+
   test("SQLite WAL corruption is detected via message scan", () => {
     const err = new Error("database disk image is malformed");
     assert.equal(isInfrastructureError(err), "SQLITE_CORRUPT");
@@ -223,7 +228,7 @@ describe("infrastructure error detection", () => {
   test("all INFRA_ERROR_CODES are covered", () => {
     const expectedCodes = [
       "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE",
-      "ENFILE", "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+      "ENFILE", "EAGAIN", "ENOBUFS", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
     ];
     for (const code of expectedCodes) {
       assert.ok(INFRA_ERROR_CODES.has(code), `${code} should be in INFRA_ERROR_CODES`);

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
+import { _handlePausedSessionResumeRecoveryForTest } from "../auto.ts";
 import { assessInterruptedSession } from "../interrupted-session.ts";
 import {
   openDatabase,
@@ -186,6 +187,45 @@ test("direct /gsd auto source only resumes paused-session metadata for recoverab
   assert.ok(source.includes('|| !!freshStartAssessment.lock'));
 });
 
+test("direct /gsd auto skips paused-session replay when recovered unit already completed", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      [
+        "# S01: Test Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [ ] **T01: First task** `est:1h`",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.\n", "utf-8");
+
+    const state = {
+      pausedSessionFile: join(base, ".gsd", "activity", "paused-session.jsonl"),
+      currentUnit: null,
+      pausedUnitType: "plan-slice",
+      pausedUnitId: "M001/S01",
+      pendingCrashRecovery: "stale-recovery-prompt",
+    };
+
+    const result = _handlePausedSessionResumeRecoveryForTest(base, state);
+    assert.equal(result.skippedReplay, true);
+    assert.equal(state.pausedSessionFile, null);
+    assert.equal(state.pendingCrashRecovery, null);
+    assert.equal(state.pausedUnitType, null);
+    assert.equal(state.pausedUnitId, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("auto module imports successfully after interrupted-session changes", async () => {
   const mod = await import(`../auto.ts?ts=${Date.now()}-${Math.random()}`);
   assert.equal(typeof mod.startAuto, "function");

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -22,6 +22,7 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
   insertMilestone,
@@ -160,6 +161,8 @@ function makeIC(
     pi: {
       sendMessage: () => {},
       setModel: async () => true,
+      getThinkingLevel: () => "off",
+      setThinkingLevel: () => {},
     } as any,
     s: makeSession(),
     deps,
@@ -633,7 +636,7 @@ test("runDispatch clears execute-task stuck state when artifacts and DB status a
   assert.equal(stopCalls, 0, "closed DB task should not hard-stop the loop");
   assert.equal(invalidateCalls, 1, "closed DB task recovery should invalidate caches once");
   assert.deepEqual(loopState.recentUnits, [], "closed DB task recovery should clear the stuck window");
-  assert.equal(loopState.stuckRecoveryAttempts, 0, "closed DB task recovery should reset the recovery counter");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "closed DB task recovery should preserve the recovery counter");
 });
 
 test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
@@ -700,7 +703,7 @@ test("runDispatch clears stuck state after Level 1 artifact recovery", async (t)
   assert.equal(invalidateCalls, 1, "Level 1 artifact recovery should invalidate caches");
   assert.equal(stopCalls, 0, "Level 1 artifact recovery should not hard-stop");
   assert.deepEqual(loopState.recentUnits, [], "Level 1 artifact recovery should clear the stuck window");
-  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 1 artifact recovery should reset the recovery counter");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 1 artifact recovery should preserve the recovery counter");
 });
 
 test("runDispatch escapes Level 2 stuck stop when artifact verifies after cache invalidation", async (t) => {
@@ -825,7 +828,7 @@ test("runUnitPhase emits unit-start and unit-end with causedBy reference", async
   assert.equal(endEvents[0].flowId, ic.flowId);
   assert.equal((endEvents[0].data as any).unitType, "execute-task");
   assert.equal((endEvents[0].data as any).unitId, "M001/S01/T01");
-  assert.equal((endEvents[0].data as any).status, "completed");
+  assert.equal((endEvents[0].data as any).status, "no-artifact");
 
   // Verify causedBy: unit-end references unit-start's seq
   assert.ok(endEvents[0].causedBy, "unit-end must have a causedBy reference");
@@ -868,6 +871,49 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
   assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01"), 2);
 });
 
+test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
+  const capture = createEventCapture();
+  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const deps = makeMockDeps(capture, {
+    selectAndApplyModel: async () => {
+      throw new ModelPolicyDispatchBlockedError("execute-task", "M001/S01/T01", []);
+    },
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+    } as any,
+  });
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+
+  const startEvents = capture.events.filter(e => e.eventType === "unit-start");
+  assert.equal(startEvents.length, 0, "pre-dispatch validation failures must not emit unit-start");
+  assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01") ?? 0, 0, "dispatch count must not increment on pre-dispatch validation failure");
+  assert.equal(
+    readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01"),
+    null,
+    "pre-dispatch validation failures must not persist a dispatched runtime record",
+  );
+});
+
 test("all events from a mock iteration have monotonically increasing seq and same flowId", async () => {
   const capture = createEventCapture();
   const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");

package/src/resources/extensions/gsd/tests/journal.test.ts

@@ -206,6 +206,38 @@ describe("queryJournal", () => {
     assert.ok(results.every(e => e.eventType === "dispatch-match"));
   });
 
+  test("keeps auto-orchestrator events separate from auto-loop events", () => {
+    emitJournalEvent(base, makeEntry({ eventType: "iteration-start", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 1 }));
+    emitJournalEvent(
+      base,
+      makeEntry({
+        eventType: "orchestrator-iteration-start",
+        seq: 2,
+        data: { source: "auto-orchestrator", name: "start" },
+      }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({
+        eventType: "orchestrator-dispatch-match",
+        seq: 3,
+        data: { source: "auto-orchestrator", name: "advance" },
+      }),
+    );
+
+    const loopMatches = queryJournal(base, { eventType: "dispatch-match" });
+    const orchestratorMatches = queryJournal(base, { eventType: "orchestrator-dispatch-match" });
+
+    assert.equal(loopMatches.length, 1, "loop dispatch telemetry should not include orchestrator advances");
+    assert.equal(orchestratorMatches.length, 1, "forensics needs orchestrator advances under their own type");
+    assert.equal(orchestratorMatches[0].seq, 3);
+    assert.deepEqual(orchestratorMatches[0].data, {
+      source: "auto-orchestrator",
+      name: "advance",
+    });
+  });
+
   test("filters by unitId (from data.unitId)", () => {
     emitJournalEvent(
       base,

package/src/resources/extensions/gsd/tests/knowledge-backfill-projection.test.ts

@@ -0,0 +1,323 @@
+// ADR-013 Stage 2b — KNOWLEDGE.md backfill + hybrid projection tests.
+//
+// Covers four behaviors:
+//   1. parser: splits cells correctly, skips header/separator rows, respects
+//      section boundaries
+//   2. backfill: Patterns -> memories(category=pattern), Lessons ->
+//      memories(category=gotcha), Rules NOT migrated, idempotent
+//   3. projection: hybrid output preserves manual Rules verbatim while
+//      projecting Patterns + Lessons from memories
+//   4. bootstrap path: backfill + projection round-trip produces a stable
+//      file that re-reading reconstitutes the same memory set
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getAdapter,
+  closeDatabase,
+  openDatabase,
+} from "../gsd-db.ts";
+import { backfillKnowledgeToMemories } from "../knowledge-backfill.ts";
+import {
+  knowledgeMdPath,
+  parseKnowledgeRows,
+  splitPipeRow,
+} from "../knowledge-parser.ts";
+import { renderKnowledgeProjection } from "../knowledge-projection.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-knowledge-stage2b-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function writeKnowledgeMd(base: string, body: string): void {
+  writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), body, "utf-8");
+}
+
+const FIXTURE = `# Project Knowledge
+
+Append-only register of project-specific rules, patterns, and lessons learned.
+Agents read this before every unit. Add entries when you discover something worth remembering.
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | All timestamps in UTC | clarity | 2026-01-01 |
+| K002 | M001 | Never trust user input | safety | 2026-01-02 |
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Repository pattern | services/ | guards |
+| P002 | Adapter at the seam | packages/pi-ai/ | observability |
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|
+| L001 | Cache poisoning | reused key | versioned key | project |
+`;
+
+// ─── splitPipeRow ──────────────────────────────────────────────────────────
+
+test("splitPipeRow extracts cells from a standard table row", () => {
+  const cells = splitPipeRow("| K001 | project | All timestamps in UTC | clarity | 2026-01-01 |");
+  assert.deepEqual(cells, ["K001", "project", "All timestamps in UTC", "clarity", "2026-01-01"]);
+});
+
+test("splitPipeRow preserves escaped pipes inside a cell", () => {
+  const cells = splitPipeRow(`| K001 | project | Use A \\| B operator | safety | 2026-01-01 |`);
+  assert.equal(cells[2], "Use A | B operator");
+});
+
+// ─── parseKnowledgeRows ────────────────────────────────────────────────────
+
+test("parseKnowledgeRows returns rows per section with the correct table tag", () => {
+  const rows = parseKnowledgeRows(FIXTURE);
+  assert.equal(rows.length, 5, "two rules + two patterns + one lesson");
+  const tables = rows.map((r) => r.table);
+  assert.deepEqual(tables, ["rules", "rules", "patterns", "patterns", "lessons"]);
+});
+
+test("parseKnowledgeRows captures cell values aligned with the section schema", () => {
+  const rows = parseKnowledgeRows(FIXTURE);
+  const p1 = rows.find((r) => r.id === "P001");
+  assert.ok(p1);
+  assert.equal(p1.cells[1], "Repository pattern");
+  assert.equal(p1.cells[2], "services/");
+});
+
+// ─── backfillKnowledgeToMemories ───────────────────────────────────────────
+
+test("backfill migrates Patterns + Lessons but skips Rules", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+    const written = backfillKnowledgeToMemories(base);
+    assert.equal(written, 3, "P001 + P002 + L001 should migrate; K rows skipped");
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+
+    const knowledgeMemories = adapter
+      .prepare(
+        "SELECT category, structured_fields FROM memories WHERE structured_fields LIKE '%\"sourceKnowledgeId\":\"%' ORDER BY seq",
+      )
+      .all() as Array<{ category: string; structured_fields: string }>;
+
+    assert.equal(knowledgeMemories.length, 3);
+    const categoriesById: Record<string, string> = {};
+    for (const m of knowledgeMemories) {
+      const sf = JSON.parse(m.structured_fields) as { sourceKnowledgeId: string };
+      categoriesById[sf.sourceKnowledgeId] = m.category;
+    }
+    assert.equal(categoriesById["P001"], "pattern");
+    assert.equal(categoriesById["P002"], "pattern");
+    assert.equal(categoriesById["L001"], "gotcha");
+    assert.equal(categoriesById["K001"], undefined, "K001 must NOT be in memories");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("backfill is idempotent — second run on the same file is a no-op", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+    const first = backfillKnowledgeToMemories(base);
+    assert.equal(first, 3);
+    const second = backfillKnowledgeToMemories(base);
+    assert.equal(second, 0, "already-migrated rows must not be re-inserted");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("backfill returns 0 when KNOWLEDGE.md is absent", () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(backfillKnowledgeToMemories(base), 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── renderKnowledgeProjection ─────────────────────────────────────────────
+
+test("projection preserves the manual Rules section verbatim", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+    backfillKnowledgeToMemories(base);
+    renderKnowledgeProjection(base);
+
+    const rendered = readFileSync(knowledgeMdPath(base), "utf-8");
+    // Both K-rows must appear unchanged.
+    assert.match(rendered, /\| K001 \| project \| All timestamps in UTC \| clarity \| 2026-01-01 \|/);
+    assert.match(rendered, /\| K002 \| M001 \| Never trust user input \| safety \| 2026-01-02 \|/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("projection renders Patterns + Lessons from memories", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+    backfillKnowledgeToMemories(base);
+    // Wipe the original Patterns/Lessons table rows from the file so the
+    // projection's output can ONLY come from memories. Keep Rules intact.
+    writeKnowledgeMd(
+      base,
+      `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | All timestamps in UTC | clarity | 2026-01-01 |
+| K002 | M001 | Never trust user input | safety | 2026-01-02 |
+`,
+    );
+
+    renderKnowledgeProjection(base);
+    const rendered = readFileSync(knowledgeMdPath(base), "utf-8");
+
+    assert.match(rendered, /\| P001 \| Repository pattern \| services\/ \| guards \|/);
+    assert.match(rendered, /\| P002 \| Adapter at the seam \| packages\/pi-ai\/ \| observability \|/);
+    assert.match(rendered, /\| L001 \| Cache poisoning \| reused key \| versioned key \| project \|/);
+
+    // Section structure must still be the canonical three headings, in order.
+    const rulesIdx = rendered.indexOf("## Rules");
+    const patternsIdx = rendered.indexOf("## Patterns");
+    const lessonsIdx = rendered.indexOf("## Lessons Learned");
+    assert.ok(rulesIdx >= 0 && patternsIdx > rulesIdx && lessonsIdx > patternsIdx, "headings must appear in canonical order");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("projection is idempotent when nothing has changed", () => {
+  const base = makeTmpBase();
+  try {
+    // Seed a file the projection will *change* (no canonical headers yet, so
+    // the first render must rewrite to add structure).
+    writeKnowledgeMd(
+      base,
+      `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | manual rule | reason | 2026-01-01 |
+`,
+    );
+
+    const first = renderKnowledgeProjection(base);
+    assert.equal(first.written, true, "first render adds the missing Patterns + Lessons section scaffolding");
+
+    const second = renderKnowledgeProjection(base);
+    assert.equal(second.written, false, "second render is a no-op when content already matches");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("projection emits empty section tables when no rows exist for that category", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(
+      base,
+      `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+`,
+    );
+    renderKnowledgeProjection(base);
+    const rendered = readFileSync(knowledgeMdPath(base), "utf-8");
+
+    assert.match(rendered, /## Patterns/);
+    assert.match(rendered, /## Lessons Learned/);
+    // The empty-table headers must be present.
+    assert.match(rendered, /\| # \| Pattern \| Where \| Notes \|/);
+    assert.match(rendered, /\| # \| What Happened \| Root Cause \| Fix \| Scope \|/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("projection escapes pipes in memory content", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(
+      base,
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Use A \\| B fallback | adapters/ | watch out |
+`,
+    );
+    backfillKnowledgeToMemories(base);
+    renderKnowledgeProjection(base);
+    const rendered = readFileSync(knowledgeMdPath(base), "utf-8");
+
+    // Pipe MUST stay escaped in the rendered output so the table doesn't break.
+    assert.match(rendered, /\| P001 \| Use A \\\| B fallback \| adapters\/ \| watch out \|/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── End-to-end round-trip ─────────────────────────────────────────────────
+
+test("backfill + projection round-trip: re-running backfill on rendered file is a no-op", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+    const initial = backfillKnowledgeToMemories(base);
+    assert.equal(initial, 3);
+
+    renderKnowledgeProjection(base);
+    assert.ok(existsSync(knowledgeMdPath(base)));
+
+    // The rendered file contains the same P/L IDs as the source. A second
+    // backfill pass must NOT re-insert them.
+    const second = backfillKnowledgeToMemories(base);
+    assert.equal(second, 0, "round-trip rendered file must remain idempotent for backfill");
+  } finally {
+    cleanup(base);
+  }
+});