@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -167,6 +167,45 @@ test("checkEngineHealth keeps PLAN checkbox divergence after stale projection fl
   assert.match(readFileSync(plan.planPath, "utf-8"), /- \[ \] \*\*T01\*\*:/);
 });
 
+test("checkEngineHealth ignores stale suffixed flat-phase duplicate when bare milestone exists", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-flat-duplicate-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "M003-vaz73w: New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  insertMilestone({ id: "M003-vaz73w", title: "New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003-vaz73w", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003-vaz73w", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  const canonicalPlan = await renderPlanFromDb(base, "M003", "S01");
+  const staleDir = join(gsdDir, "phases", "03-vaz73w-new-milestone-m003-vaz73w");
+  mkdirSync(staleDir, { recursive: true });
+  writeFileSync(
+    join(staleDir, "03-01-PLAN.md"),
+    canonicalPlan.content.replace("- [x] **T03**:", "- [ ] **T03**:"),
+    "utf-8",
+  );
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "stale suffixed duplicate phase projection must not compete with the bare milestone projection",
+  );
+});
+
 test("checkEngineHealth reads task checkboxes from the <tasks> block, not a stray line above it", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-task-section-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -428,6 +467,50 @@ test("checkEngineHealth repair prunes stale phases artifact rows with present mi
   assert.deepEqual(rows.map((row) => row.path), []);
 });
 
+test("checkEngineHealth repair prunes stale phases artifact rows with renamed flat-phase files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-renamed-flat-phase-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const stalePath = "phases/01-new-milestone-m001/01-01-PLAN.md";
+  const replacementPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-lokably-brand-foundation-and-welcome-pag"), { recursive: true });
+  writeFileSync(join(gsdDir, replacementPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: stalePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# stale plan\n",
+  });
+
+  const beforeIssues: any[] = [];
+  await checkEngineHealth(base, beforeIssues, []);
+
+  const beforeIssue = beforeIssues.find((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath);
+  assert.ok(beforeIssue, "stale renamed phases row should be reported when repair is off");
+  assert.equal(beforeIssue.fixable, true, "renamed phases rows with a flat replacement should be fixable");
+
+  const repairIssues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, repairIssues, fixes, { repair: true });
+
+  assert.equal(
+    repairIssues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
+    false,
+    "repair should not report stale rows it pruned",
+  );
+  assert.ok(fixes.includes(`pruned stale flat-phase artifact row ${stalePath}`));
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.deepEqual(rows.map((row) => row.path), []);
+});
+
 test("checkEngineHealth repair keeps phases rows whose own file is still present", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-keep-present-phase-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/evidence-cross-ref.test.ts

@@ -54,6 +54,87 @@ test("passing retry evidence is not invalidated by an earlier failed run of the
   assert.deepEqual(mismatches, []);
 });
 
+test("newer script-wrapped pass is not shadowed by a stale exact failing run", () => {
+  const command = "npm test";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed after retry" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "failed",
+        timestamp: 1,
+      },
+      {
+        kind: "bash",
+        toolCallId: "call-2",
+        command: `cd /work && ${command}`,
+        exitCode: 0,
+        outputSnippet: "passed",
+        timestamp: 2,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.deepEqual(mismatches, []);
+});
+
+test("later containing script does not override an exact successful run", () => {
+  const command = "npm test";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 0,
+        outputSnippet: "passed",
+        timestamp: 1,
+      },
+      {
+        kind: "bash",
+        toolCallId: "call-2",
+        command: `cd /work && ${command} && npm run lint`,
+        exitCode: 1,
+        outputSnippet: "lint failed",
+        timestamp: 2,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.deepEqual(mismatches, []);
+});
+
+test("same-timestamp retry evidence prefers the later recorded run", () => {
+  const command = "npm test";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed after retry" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "failed",
+        timestamp: 1,
+      },
+      {
+        kind: "bash",
+        toolCallId: "call-2",
+        command,
+        exitCode: 0,
+        outputSnippet: "passed",
+        timestamp: 1,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.deepEqual(mismatches, []);
+});
+
 test("stale verification evidence batches are ignored when a newer completion batch exists", () => {
   const command = "node todo.js add 'Task A' && node todo.js add 'Task B' && node todo.js done 1";
   const resetCommand = `rm -f "$HOME/.config/todo/data.json" && ${command}`;

package/src/resources/extensions/gsd/tests/evidence-xref-gsd-exec.test.ts

@@ -60,6 +60,28 @@ test("evidence-xref: verification run through gsd_exec script matches the claime
   assert.deepEqual(mismatches, [], "gsd_exec-executed verification must not be flagged as missing");
 });
 
+test("evidence-xref: gsd_exec runtime-purpose label matches the recorded sandbox run", () => {
+  resetEvidence();
+
+  recordToolCall("tc-exec-label", "gsd_exec", {
+    runtime: "node",
+    code: "const plan = 'T02-PLAN'; if (!plan.includes('T02')) process.exit(1);",
+    purpose: "validate T02-PLAN contains canonical Cargo command, state seam, d",
+  });
+  recordToolResult("tc-exec-label", "gsd_exec", gsdExecResult(0), false);
+
+  const mismatches = crossReferenceEvidence(
+    [{
+      command: "gsd_exec node: validate T02-PLAN contains canonical Cargo command, state seam, d",
+      exitCode: 0,
+      verdict: "passed",
+    }],
+    getEvidence(),
+  );
+
+  assert.deepEqual(mismatches, [], "gsd_exec purpose labels must match sandbox evidence");
+});
+
 test("evidence-xref: multi-line gsd_exec script matches claims for each embedded command", () => {
   resetEvidence();
 

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -3,7 +3,7 @@
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -152,6 +152,38 @@ test('runExecSandbox: node runtime executes JS', async () => {
   }
 });
 
+test('runExecSandbox: node runtime forwards NODE_PATH for GSD-installed dependencies', async () => {
+  const base = freshBase();
+  try {
+    const dependencyRoot = join(base, 'parent-node_modules');
+    const packageDir = join(dependencyRoot, 'fake-gsd-dep');
+    const worktree = join(base, 'project', '.gsd', 'worktrees', 'M003');
+    mkdirSync(packageDir, { recursive: true });
+    mkdirSync(worktree, { recursive: true });
+    writeFileSync(
+      join(packageDir, 'package.json'),
+      JSON.stringify({ name: 'fake-gsd-dep', version: '1.0.0', main: 'index.js' }),
+    );
+    writeFileSync(join(packageDir, 'index.js'), "module.exports = 'resolved-via-node-path';\n");
+
+    const result = await runExecSandbox(
+      { runtime: 'node', script: "console.log(require('fake-gsd-dep'))" },
+      baseOpts(worktree, {
+        env: {
+          PATH: '/usr/bin:/bin',
+          HOME: '/tmp',
+          NODE_PATH: dependencyRoot,
+        },
+      }),
+    );
+
+    assert.equal(result.exit_code, 0, readFileSync(result.stderr_path, 'utf-8'));
+    assert.ok(result.digest.includes('resolved-via-node-path'));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: rewrites NUL redirects for bash on Windows', async () => {
   const originalPlatform = process.platform;
   Object.defineProperty(process, 'platform', { value: 'win32' });

package/src/resources/extensions/gsd/tests/external-edit-scoped-import.test.ts

@@ -0,0 +1,262 @@
+// Project/App: gsd-pi
+// File Purpose: #027 regression — external-edit drift repair must scope status
+// authority to the drifted milestone(s) so a stale checkbox in an unrelated
+// projection can't revert a reopened slice/milestone in the DB.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  closeDatabase,
+  getSliceTasks,
+  getSlice,
+  openDatabase,
+  updateTaskStatus,
+  updateSliceStatus,
+} from "../gsd-db.ts";
+import { migrateHierarchyToDb, milestoneIdsFromEntities } from "../md-importer.ts";
+import { externalMarkdownEditHandler } from "../state-reconciliation/drift/external-markdown-edit.ts";
+import {
+  computeProjectionSha,
+  writeCompatMarker,
+} from "../compat/compat-marker.ts";
+import type { DriftContext } from "../state-reconciliation/types.ts";
+import type { GSDState } from "../types.ts";
+
+const stubState = { phase: "idle" } as unknown as GSDState;
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-scoped-import-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  rmSync(base, { recursive: true, force: true });
+}
+
+const roadmapRel = (mid: string): string => join("milestones", mid, `${mid}-ROADMAP.md`);
+
+/** Render a single-slice roadmap whose one slice is checked (`done`). */
+function roadmapContent(mid: string, sliceTitle: string, done: boolean): string {
+  return [
+    `# ${mid}: ${mid} Milestone`,
+    "",
+    `**Vision:** ${mid} vision`,
+    "",
+    "## Slices",
+    `- [${done ? "x" : " "}] **S01: ${sliceTitle}** \`risk:low\` \`depends:[]\``,
+    "",
+  ].join("\n");
+}
+
+function writeRoadmap(base: string, mid: string, sliceTitle: string, done: boolean): string {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  const content = roadmapContent(mid, sliceTitle, done);
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content, "utf-8");
+  return content;
+}
+
+function planContent(taskDone: boolean): string {
+  return [
+    "# S01: Slice Plan",
+    "",
+    "**Goal:** Exercise scoped task status imports.",
+    "",
+    "## Tasks",
+    "",
+    `- [${taskDone ? "x" : " "}] **T01: Scoped Task** \`est:10m\``,
+    "  Task body.",
+    "",
+  ].join("\n");
+}
+
+function writePlan(base: string, mid: string, taskDone: boolean): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", "S01");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "S01-PLAN.md"), planContent(taskDone), "utf-8");
+}
+
+function taskStatus(mid: string): string | undefined {
+  return getSliceTasks(mid, "S01").find((task) => task.id === "T01")?.status;
+}
+
+/**
+ * Build two legacy-layout milestones (M001, M002) each with one checked slice,
+ * import them so both slices land `complete`, then reopen M002/S01 to `pending`
+ * while leaving M002's roadmap checkbox checked (a stale projection).
+ */
+function seedTwoMilestonesWithReopenedB(base: string): void {
+  writeRoadmap(base, "M001", "Alpha Slice", true);
+  writeRoadmap(base, "M002", "Beta Slice", true);
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  assert.equal(getSlice("M001", "S01")?.status, "complete");
+  assert.equal(getSlice("M002", "S01")?.status, "complete");
+  updateSliceStatus("M002", "S01", "pending");
+  assert.equal(getSlice("M002", "S01")?.status, "pending", "precondition: B/S01 reopened");
+}
+
+/**
+ * Same as seedTwoMilestonesWithReopenedB, but with checked task boxes too. The
+ * reopened DB task is the authority for out-of-scope milestones.
+ */
+function seedTwoMilestonesWithReopenedBTask(base: string): void {
+  writeRoadmap(base, "M001", "Alpha Slice", true);
+  writePlan(base, "M001", true);
+  writeRoadmap(base, "M002", "Beta Slice", true);
+  writePlan(base, "M002", true);
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  assert.equal(getSlice("M002", "S01")?.status, "complete");
+  assert.equal(taskStatus("M002"), "complete");
+  updateSliceStatus("M002", "S01", "pending");
+  updateTaskStatus("M002", "S01", "T01", "pending");
+  assert.equal(getSlice("M002", "S01")?.status, "pending", "precondition: B/S01 reopened");
+  assert.equal(taskStatus("M002"), "pending", "precondition: B/S01/T01 reopened");
+}
+
+test("milestoneIdsFromEntities derives milestone ids from DB entity ids (layout-independent)", () => {
+  assert.deepEqual(
+    [...milestoneIdsFromEntities(["M001", "M001/S01", "M001/S01/T01"])],
+    ["M001"],
+  );
+  assert.deepEqual(
+    [...milestoneIdsFromEntities(["M001/S01", "M002/S03/T02"])].sort(),
+    ["M001", "M002"],
+  );
+  // Entity-less / blank entries yield an empty set → repair preserves DB status.
+  assert.equal(milestoneIdsFromEntities([]).size, 0);
+  assert.equal(milestoneIdsFromEntities([""]).size, 0);
+});
+
+test("scoped import preserves a reopened out-of-scope slice (the #027 bug, direct)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  seedTwoMilestonesWithReopenedB(base);
+
+  // Only M001 drifted; M002 keeps DB status authority.
+  migrateHierarchyToDb(base, { statusAuthoritativeMilestones: new Set(["M001"]) });
+
+  assert.equal(
+    getSlice("M002", "S01")?.status,
+    "pending",
+    "reopened out-of-scope slice must NOT be reverted to complete by a stale checkbox",
+  );
+});
+
+test("scoped import preserves reopened tasks in an out-of-scope slice", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  seedTwoMilestonesWithReopenedBTask(base);
+
+  // Only M001 drifted; M002's stale checked roadmap and plan boxes must not
+  // re-complete either its reopened slice or its reopened task.
+  migrateHierarchyToDb(base, { statusAuthoritativeMilestones: new Set(["M001"]) });
+
+  assert.equal(
+    getSlice("M002", "S01")?.status,
+    "pending",
+    "reopened out-of-scope slice must stay pending",
+  );
+  assert.equal(
+    taskStatus("M002"),
+    "pending",
+    "reopened out-of-scope task must NOT be reverted to complete by a stale plan checkbox",
+  );
+});
+
+test("scoped import keeps markdown authority for the in-scope (drifted) milestone", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  seedTwoMilestonesWithReopenedB(base);
+
+  // Sanctioned interop: M002's own roadmap was externally edited — the checked
+  // box IS authoritative for the drifted milestone.
+  migrateHierarchyToDb(base, { statusAuthoritativeMilestones: new Set(["M002"]) });
+
+  assert.equal(
+    getSlice("M002", "S01")?.status,
+    "complete",
+    "the drifted milestone's checkbox must close its slice (markdown authority)",
+  );
+});
+
+test("no-opts import is unchanged: markdown checkbox wins (pins the default)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  seedTwoMilestonesWithReopenedB(base);
+
+  // No scope → full markdown authority, exactly as before #027. Initial-migration
+  // and gsd-core full-import semantics must not silently change.
+  migrateHierarchyToDb(base);
+
+  assert.equal(
+    getSlice("M002", "S01")?.status,
+    "complete",
+    "without a scope, the stale checkbox closes the slice — today's behavior",
+  );
+});
+
+test("scoped import still imports NEW out-of-scope content with its parsed status", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  // Both milestones are on disk but neither is in the DB yet. M002 is out of the
+  // authority scope, but a row that does not exist yet takes the parsed status
+  // regardless of scope (new content is new content).
+  writeRoadmap(base, "M001", "Alpha Slice", true);
+  writeRoadmap(base, "M002", "Beta Slice", true);
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  migrateHierarchyToDb(base, { statusAuthoritativeMilestones: new Set(["M001"]) });
+
+  assert.equal(getSlice("M002", "S01")?.status, "complete", "new out-of-scope slice imports as parsed");
+});
+
+test("external-markdown-edit repair scopes authority to the drifted milestone (end-to-end)", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  seedTwoMilestonesWithReopenedB(base);
+
+  // Externally edit M001's roadmap (change the slice title) so its sha drifts;
+  // leave M002's roadmap byte-identical to its marker baseline (not drifted).
+  writeRoadmap(base, "M001", "Alpha Slice EDITED", true);
+  const m002Content = roadmapContent("M002", "Beta Slice", true);
+
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-07T00:00:00.000Z",
+    projections: {
+      [roadmapRel("M001")]: { sha: "stale000000000000", entities: ["M001"] },
+      [roadmapRel("M002")]: { sha: computeProjectionSha(m002Content), entities: ["M002"] },
+    },
+    piVersion: "1.8.1",
+  });
+
+  const ctx: DriftContext = { basePath: base, state: stubState };
+  const drift = await externalMarkdownEditHandler.detect(stubState, ctx);
+  assert.equal(drift.length, 1, "only M001's roadmap should be detected as drifted");
+  assert.deepEqual(drift[0].entities, ["M001"]);
+
+  await externalMarkdownEditHandler.repair(drift[0], ctx);
+
+  // B was NOT the drifted file — its reopened slice must survive the repair.
+  assert.equal(
+    getSlice("M002", "S01")?.status,
+    "pending",
+    "repair of an unrelated file must not revert B/S01",
+  );
+  // A WAS drifted — its edit is imported (title updated, status stays complete).
+  assert.equal(getSlice("M001", "S01")?.title, "Alpha Slice EDITED", "A's external edit is imported");
+  assert.equal(getSlice("M001", "S01")?.status, "complete");
+});

package/src/resources/extensions/gsd/tests/external-markdown-edit.test.ts

@@ -8,7 +8,8 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { externalMarkdownEditHandler } from "../state-reconciliation/drift/external-markdown-edit.ts";
-import { writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { closeDatabase, insertArtifact, openDatabase } from "../gsd-db.ts";
 import type { DriftContext } from "../state-reconciliation/types.ts";
 import type { GSDState } from "../types.ts";
 
@@ -28,6 +29,11 @@ function ctx(base: string): DriftContext {
 }
 
 afterEach(() => {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
   for (const dir of tmpDirs) {
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
   }
@@ -71,6 +77,37 @@ test("detect returns drift when file content differs from marker", async () => {
   assert.deepEqual(drift[0].entities, ["m1"]);
 });
 
+test("detect refreshes stale marker when current file already matches DB artifact", async () => {
+  const base = makeTmpBase();
+  const rel = "milestones/M001/M001-ROADMAP.md";
+  const dbRel = "phases/01-alpha/01-ROADMAP.md";
+  const content = "# M001: Alpha\n\n## Slices\n\n- [ ] **S01: Work** `risk:low` `depends:[]`\n";
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", rel), content, "utf-8");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertArtifact({
+    path: dbRel,
+    artifact_type: "ROADMAP",
+    milestone_id: "M001",
+    slice_id: null,
+    task_id: null,
+    full_content: content,
+  });
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: { [rel]: { sha: "stale000000000000", entities: ["M001"] } },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.9.0",
+  });
+
+  const drift = await externalMarkdownEditHandler.detect(stubState, ctx(base));
+  assert.equal(drift.length, 0);
+  const marker = readCompatMarker(base);
+  assert.equal(marker.projections[rel]?.sha, computeProjectionSha(content));
+});
+
 test("detect treats missing marker as drift on every tracked projection file", async () => {
   const base = makeTmpBase();
   const rel = "m1/roadmap.md";