@opengsd/gsd-pi 1.8.1 → 1.9.0

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -330,6 +330,56 @@ test("dispatch: session milestone mismatch stops before missing-task-plan recove
   assert.match(result.reason, /context mid "M001" does not match session\.currentMilestoneId "M002"/);
 });
 
+test("dispatch: bare context milestone maps to suffixed active session milestone", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-suffixed-session-milestone-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M003-vaz73w");
+  scaffoldLegacyMilestoneContext(worktreeRoot, "M003-vaz73w");
+  scaffoldLegacySlicePlan(worktreeRoot, "M003-vaz73w", "S01");
+  scaffoldLegacyTaskPlan(worktreeRoot, "M003-vaz73w", "S01", "T02");
+
+  const ctx = makeContextFor(tmp, "M003", "S01", "T02", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M003-vaz73w",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M003-vaz73w/S01/T02",
+    `unitId should use suffixed milestone, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
+test("dispatch: suffixed context milestone keeps suffix when scoped alias is bare", async (t) => {
+  // Inverse of the case above: dispatch context carries the suffixed id but the
+  // scoped alias (session.currentMilestoneId) is bare. resolveEffectiveDispatchMilestoneId
+  // must keep the suffixed id so slice/task artifacts resolve under the suffixed
+  // worktree layout (milestones/M003-xxxxxx/) rather than the bare milestones/M003/.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-suffixed-context-bare-scope-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M003-vaz73w");
+  scaffoldLegacyMilestoneContext(worktreeRoot, "M003-vaz73w");
+  scaffoldLegacySlicePlan(worktreeRoot, "M003-vaz73w", "S01");
+  scaffoldLegacyTaskPlan(worktreeRoot, "M003-vaz73w", "S01", "T02");
+
+  const ctx = makeContextFor(tmp, "M003-vaz73w", "S01", "T02", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M003",
+  });
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M003-vaz73w/S01/T02",
+    `unitId should keep suffixed milestone, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
 test("dispatch: worktree path mismatch stops before planning a different milestone", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-path-milestone-mismatch-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/dispatch-rule-coverage.test.ts

@@ -146,6 +146,55 @@ test("dispatch-rule-coverage: pre-planning, no CONTEXT → discuss-milestone", a
   );
 });
 
+test("dispatch-rule-coverage: pre-planning worktree sees project-root CONTEXT", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-wt-context-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  const projectPhaseDir = join(tmp, ".gsd", "phases", "01-foundation");
+  mkdirSync(projectPhaseDir, { recursive: true });
+  writeFileSync(join(projectPhaseDir, "01-CONTEXT.md"), "# Context\n");
+
+  const worktree = join(tmp, ".gsd", "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(worktree, ".gsd", "milestones", "M001", "M001-META.json"),
+    '{"branch":"milestone/M001"}',
+  );
+
+  const rule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(rule, "pre-planning missing-context rule should exist");
+
+  const result = await rule.match(makeCtx(worktree, makeState({ phase: "pre-planning" })));
+  assert.equal(result, null, "project-root CONTEXT must prevent a second discuss-milestone dispatch");
+});
+
+test("dispatch-rule-coverage: pre-planning worktree sees worktree-only CONTEXT", async (t) => {
+  // Mirror image of the project-root test: discuss-milestone mirrors CONTEXT into
+  // the worktree's own .gsd, and it may not yet exist at the project root (the
+  // worktree→root sync deliberately does not flow markdown projections back).
+  // A project-root-only check would miss it and re-fire discuss-milestone.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-wt-only-context-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // No CONTEXT at the project root — only the milestone dir exists there.
+  mkdirSync(join(tmp, ".gsd", "phases"), { recursive: true });
+
+  const worktree = join(tmp, ".gsd", "worktrees", "M001");
+  const worktreePhaseDir = join(worktree, ".gsd", "phases", "01-foundation");
+  mkdirSync(worktreePhaseDir, { recursive: true });
+  writeFileSync(join(worktreePhaseDir, "01-CONTEXT.md"), "# WT Context\n");
+
+  const rule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(rule, "pre-planning missing-context rule should exist");
+
+  const result = await rule.match(makeCtx(worktree, makeState({ phase: "pre-planning" })));
+  assert.equal(result, null, "worktree-only CONTEXT must prevent a second discuss-milestone dispatch");
+});
+
 test("dispatch-rule-coverage: pre-planning, has CONTEXT, no RESEARCH → research-milestone", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-res-"));
   t.after(() => rmSync(tmp, { 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/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");
+});