gsd-pi 2.81.0-dev.72a81bdf3 → 2.82.0-dev.20138ae42

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

@@ -14,7 +14,9 @@ import {
   generatePreview,
   writeGSDDirectory,
 } from '../../migrate/index.ts';
+import { importWrittenMigrationToDb } from '../../migrate/command.ts';
 import { deriveState } from '../../state.ts';
+import { closeDatabase, getDecisionById, getRequirementCounts } from '../../gsd-db.ts';
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -52,6 +54,16 @@ const SAMPLE_REQUIREMENTS = `# Requirements
 - Description: Output matches GSD format.
 `;
 
+const SAMPLE_REQUIREMENTS_LEGACY_IDS = `# Requirements
+
+## Active
+
+- [ ] **CORE-PIPELINE**: Pipeline must work end-to-end.
+- [ ] **OUTPUT-FORMAT**: Output matches GSD format.
+- [ ] **IMPORT-DB**: Migration imports requirements into the DB.
+- [ ] **STATUS-WIDGET**: Status can query migrated requirements.
+`;
+
 const SAMPLE_STATE = `# State
 
 **Current Phase:** 20-features
@@ -166,14 +178,14 @@ Depends on foundation work.
 </context>
 `;
 
-function createCompleteFixture(): string {
+function createCompleteFixture(requirementsContent: string = SAMPLE_REQUIREMENTS): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-test-'));
   const planning = join(base, '.planning');
   mkdirSync(planning, { recursive: true });
 
   writeFileSync(join(planning, 'PROJECT.md'), SAMPLE_PROJECT);
   writeFileSync(join(planning, 'ROADMAP.md'), SAMPLE_ROADMAP);
-  writeFileSync(join(planning, 'REQUIREMENTS.md'), SAMPLE_REQUIREMENTS);
+  writeFileSync(join(planning, 'REQUIREMENTS.md'), requirementsContent);
   writeFileSync(join(planning, 'STATE.md'), SAMPLE_STATE);
   writeFileSync(join(planning, 'config.json'), SAMPLE_CONFIG);
 
@@ -303,6 +315,7 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
       const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
       assert.deepStrictEqual(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
       assert.deepStrictEqual(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+      assert.deepStrictEqual(preview.decisions.total, 1, 'pipeline: preview decisions total');
 
       // Requirements in preview
       assert.deepStrictEqual(preview.requirements.active, 1, 'pipeline: preview requirements active');
@@ -342,6 +355,39 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
     }
 });
 
+test('Full pipeline: legacy requirement IDs import into DB with canonical IDs', async () => {
+    const base = createCompleteFixture(SAMPLE_REQUIREMENTS_LEGACY_IDS);
+    const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-legacy-reqs-'));
+    try {
+      const parsed = await parsePlanningDirectory(join(base, '.planning'));
+      const project = transformToGSD(parsed);
+      const preview = generatePreview(project);
+
+      assert.deepStrictEqual(
+        project.requirements.map((req) => req.id),
+        ['R001', 'R002', 'R003', 'R004'],
+        'legacy-reqs: transform assigns canonical R IDs',
+      );
+      assert.ok(
+        project.requirements[0]?.description.includes('Legacy ID: CORE-PIPELINE'),
+        'legacy-reqs: original ID survives in migrated requirement content',
+      );
+
+      await writeGSDDirectory(project, writeTarget);
+      const imported = await importWrittenMigrationToDb(writeTarget, preview);
+      const counts = getRequirementCounts();
+
+      assert.deepStrictEqual(imported.decisions, 1, 'legacy-reqs: DB import includes migrated decisions');
+      assert.deepStrictEqual(imported.requirements, 4, 'legacy-reqs: DB import count matches preview');
+      assert.ok(getDecisionById('D001') !== null, 'legacy-reqs: migrated decision is queryable');
+      assert.deepStrictEqual(counts.total, 4, 'legacy-reqs: DB stores all migrated requirements');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+      rmSync(writeTarget, { recursive: true, force: true });
+    }
+});
+
   // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
 
 test('.gsd/ exists detection', () => {
@@ -357,4 +403,3 @@ test('.gsd/ exists detection', () => {
       rmSync(base, { recursive: true, force: true });
     }
 });
-

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/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);
+  }
+});

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

@@ -0,0 +1,242 @@
+// ADR-013 Stage 2c — /gsd knowledge write-side redirect tests.
+//
+// Locks in four properties of captureKnowledgeEntry / nextKnowledgeId:
+//   1. Pattern entries write a memory row with category="pattern" and a
+//      sourceKnowledgeId marker — but do NOT touch KNOWLEDGE.md.
+//   2. Lesson entries write a memory row with category="gotcha" — same
+//      file-vs-memory split.
+//   3. Next-ID is monotonic across both surfaces: a P004 in the file plus a
+//      P007 in memories yields P008 next.
+//   4. The legacy appendKnowledge stays the canonical path for Rules
+//      (covered indirectly via no-memory side effect on type="rule").
+
+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 { captureKnowledgeEntry, nextKnowledgeId } from "../knowledge-capture.ts";
+import { knowledgeMdPath } from "../knowledge-parser.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-knowledge-capture-"));
+  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 readMemoriesWithMarker(prefix: "P" | "L"): Array<{ category: string; sf: Record<string, unknown> }> {
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+  const rows = adapter
+    .prepare(
+      "SELECT category, structured_fields FROM memories WHERE structured_fields LIKE :pattern ORDER BY seq",
+    )
+    .all({ ":pattern": `%"sourceKnowledgeId":"${prefix}%` }) as Array<{
+    category: string;
+    structured_fields: string;
+  }>;
+  return rows.map((r) => ({ category: r.category, sf: JSON.parse(r.structured_fields) }));
+}
+
+// ─── Pattern path ───────────────────────────────────────────────────────────
+
+test("pattern entry creates a memory and assigns the next P### id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "pattern", "Repository pattern at the seam", "M001");
+    assert.equal(result.id, "P001", "first pattern on a fresh project should be P001");
+    assert.equal(result.written, true);
+
+    const memories = readMemoriesWithMarker("P");
+    assert.equal(memories.length, 1);
+    assert.equal(memories[0]?.category, "pattern");
+    assert.equal(memories[0]?.sf.sourceKnowledgeId, "P001");
+    assert.equal(memories[0]?.sf.pattern, "Repository pattern at the seam");
+    assert.equal(memories[0]?.sf.where, "");
+    assert.equal(memories[0]?.sf.notes, "");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("pattern entry does NOT write to KNOWLEDGE.md (memory-only)", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "Adapter at the seam", "project");
+    assert.equal(
+      existsSync(knowledgeMdPath(base)),
+      false,
+      "KNOWLEDGE.md should remain untouched — projection re-renders on next session start",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("repeated pattern captures advance the ID monotonically", () => {
+  const base = makeTmpBase();
+  try {
+    const a = captureKnowledgeEntry(base, "pattern", "First", "project");
+    const b = captureKnowledgeEntry(base, "pattern", "Second", "project");
+    const c = captureKnowledgeEntry(base, "pattern", "Third", "project");
+    assert.deepEqual([a.id, b.id, c.id], ["P001", "P002", "P003"]);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Lesson path ────────────────────────────────────────────────────────────
+
+test("lesson entry creates a memory with category=gotcha and L### id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "lesson", "Cache poisoning via reused key", "M001/S01");
+    assert.equal(result.id, "L001");
+    assert.equal(result.written, true);
+
+    const memories = readMemoriesWithMarker("L");
+    assert.equal(memories.length, 1);
+    assert.equal(memories[0]?.category, "gotcha");
+    assert.equal(memories[0]?.sf.sourceKnowledgeId, "L001");
+    assert.equal(memories[0]?.sf.whatHappened, "Cache poisoning via reused key");
+    assert.equal(memories[0]?.sf.scopeText, "M001/S01");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Empty input ────────────────────────────────────────────────────────────
+
+test("empty entry text does NOT create a memory but still assigns an id", () => {
+  const base = makeTmpBase();
+  try {
+    const result = captureKnowledgeEntry(base, "pattern", "   ", "project");
+    assert.equal(result.written, false);
+    assert.equal(readMemoriesWithMarker("P").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── nextKnowledgeId — cross-surface monotonicity ───────────────────────────
+
+test("nextKnowledgeId takes max of file and memory surfaces", () => {
+  const base = makeTmpBase();
+  try {
+    // Pre-existing patterns in KNOWLEDGE.md and one new pattern in memories.
+    // The legacy appendKnowledge format starts P at 001 — we simulate higher
+    // existing IDs to verify the take-max-then-+1 rule.
+    writeFileSync(
+      knowledgeMdPath(base),
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P004 | Legacy pattern | services/ | preserved |
+`,
+      "utf-8",
+    );
+
+    // Capture jumps the memory ID forward.
+    captureKnowledgeEntry(base, "pattern", "Memory-only pattern", "project");
+    captureKnowledgeEntry(base, "pattern", "Another memory-only pattern", "project");
+    captureKnowledgeEntry(base, "pattern", "And another", "project");
+
+    // After: file has P004 (max=4); memories have P005, P006, P007 (max=7).
+    // Next must be P008.
+    assert.equal(nextKnowledgeId(base, "P"), "P008");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("nextKnowledgeId works per-prefix without cross-talk", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "P entry", "project");
+    captureKnowledgeEntry(base, "pattern", "P entry 2", "project");
+    captureKnowledgeEntry(base, "lesson", "L entry", "project");
+
+    assert.equal(nextKnowledgeId(base, "P"), "P003");
+    assert.equal(nextKnowledgeId(base, "L"), "L002");
+    // K has no entries on this project — first one should be K001.
+    assert.equal(nextKnowledgeId(base, "K"), "K001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("nextKnowledgeId pads to three digits even at the rollover", () => {
+  const base = makeTmpBase();
+  try {
+    writeFileSync(
+      knowledgeMdPath(base),
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P099 | high water mark | — | — |
+`,
+      "utf-8",
+    );
+    assert.equal(nextKnowledgeId(base, "P"), "P100");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Sanity: file-side reads still see existing rows after capture ─────────
+
+test("after pattern capture, KNOWLEDGE.md untouched but next id reflects memory state", () => {
+  const base = makeTmpBase();
+  try {
+    captureKnowledgeEntry(base, "pattern", "First", "project");
+    // KNOWLEDGE.md still absent.
+    assert.equal(existsSync(knowledgeMdPath(base)), false);
+    // Next-ID logic sees the new memory.
+    assert.equal(nextKnowledgeId(base, "P"), "P002");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("rule writes still flow through appendKnowledge (file-canonical) — memory unchanged", async () => {
+  const base = makeTmpBase();
+  try {
+    // We invoke the legacy file path directly here; the command handler
+    // dispatch is verified separately at the integration level. The point
+    // of this test is to lock in that captureKnowledgeEntry is NOT the
+    // rule path — rules must go through appendKnowledge.
+    const { appendKnowledge } = await import("../files.ts");
+    await appendKnowledge(base, "rule", "Always pin SQLite version", "project");
+
+    const md = readFileSync(knowledgeMdPath(base), "utf-8");
+    assert.match(md, /\| K001 \| project \| Always pin SQLite version /);
+
+    // No pattern/lesson memories should exist as a side effect.
+    assert.equal(readMemoriesWithMarker("P").length, 0);
+    assert.equal(readMemoriesWithMarker("L").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});