@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

package/src/resources/extensions/gsd/tests/phases-terminal-complete-idempotent.test.ts

@@ -0,0 +1,242 @@
+/**
+ * phases-terminal-complete-idempotent.test.ts — Regression test for the
+ * milestone-completion double-closeout guard in `runPreDispatch`.
+ *
+ * When `runPreDispatch` observes that the active milestone (or the last one
+ * the session was working on) has already been closed by another session,
+ * the loop must exit cleanly with `{ action: "break", reason:
+ * "milestone-complete" }` and must NOT replay merge, desktop / cmux
+ * notifications, unit closeout, or `stopAuto`.
+ *
+ * There are two `deriveState` shapes the guard must cover, and both are
+ * exercised below because the canonical one is easy to miss:
+ *
+ *   1. `state.phase === "complete"` with `activeMilestone` set, so the
+ *      loop computes a non-null `mid` from `state.activeMilestone.id`.
+ *
+ *   2. `state.phase === "complete"` with `activeMilestone: null` — the
+ *      canonical "all milestones complete" return from `deriveState`
+ *      (state.ts:613, state.ts:1293). `mid` is undefined here, so the
+ *      guard must consult `s.currentMilestoneId` (the milestone this
+ *      session was working on) instead. Without coverage for this case,
+ *      a guard that only inspects `mid` is unreachable in production and
+ *      the loop replays `_runMilestoneMergeOnceWithStashRestore`,
+ *      `sendDesktopNotification("All milestones complete!")`,
+ *      `logCmuxEvent`, and `stopAuto` — exactly the duplicate side
+ *      effects this fix exists to prevent.
+ *
+ * Both fire-paths of the guard (`completionStopInProgress` and a
+ * DB-already-closed milestone) are exercised against each shape.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  isDbAvailable,
+} from "../gsd-db.ts";
+
+const { assertTrue, report } = createTestContext();
+
+type SideEffect = string;
+
+interface ScenarioOverrides {
+  completionStopInProgress: boolean;
+  sideEffects: SideEffect[];
+  notifications: Array<{ message: string; level?: string }>;
+  // When `null`, deriveState returns activeMilestone: null (canonical
+  // all-complete path). Otherwise, returns an activeMilestone with this id.
+  activeMilestone: { id: string; title: string } | null;
+}
+
+function makeIterationContext(overrides: ScenarioOverrides): any {
+  const basePath = "/tmp/gsd-test-terminal-complete";
+  const recordSideEffect = (label: string) => {
+    overrides.sideEffects.push(label);
+  };
+  return {
+    ctx: {
+      ui: {
+        notify(message: string, level?: string) {
+          overrides.notifications.push({ message, level });
+        },
+      },
+    },
+    pi: {},
+    s: {
+      basePath,
+      originalBasePath: basePath,
+      canonicalProjectRoot: basePath,
+      resourceVersionOnStart: "test",
+      // Critical for the `!mid` canonical path: even when deriveState returns
+      // activeMilestone: null, the session still remembers the milestone it
+      // was working on, and we use that to look up DB status.
+      currentMilestoneId: "M001",
+      currentUnit: null,
+      milestoneMergedInPhases: false,
+      completionStopInProgress: overrides.completionStopInProgress,
+    },
+    prefs: undefined,
+    iteration: 1,
+    flowId: "test-flow",
+    nextSeq: () => 1,
+    deps: {
+      checkResourcesStale() {
+        return null;
+      },
+      invalidateAllCaches() {},
+      async preDispatchHealthGate() {
+        return { proceed: true, fixesApplied: [] };
+      },
+      async deriveState() {
+        return {
+          phase: "complete",
+          activeMilestone: overrides.activeMilestone,
+          activeSlice: null,
+          activeTask: null,
+          // Registry says M001 is complete and no other milestones exist, so
+          // `incomplete.length === 0 && state.registry.length > 0` evaluates
+          // true in the `!mid` branch.
+          registry: [{ id: "M001", status: "complete" }],
+          nextAction: "complete",
+        };
+      },
+      syncCmuxSidebar() {},
+      setActiveMilestoneId() {},
+      reconcileMergeState() {
+        return "clean";
+      },
+      // Anything below this point MUST NOT be reached when the guard fires.
+      preflightCleanRoot() {
+        recordSideEffect("preflight");
+        return { ok: true, stashPushed: false, stashMarker: null };
+      },
+      postflightPopStash() {
+        recordSideEffect("postflight");
+        return { ok: true, needsManualRecovery: false };
+      },
+      lifecycle: {
+        exitMilestone() {
+          recordSideEffect("merge");
+          return { ok: true };
+        },
+      },
+      sendDesktopNotification() {
+        recordSideEffect("desktop-notify");
+      },
+      logCmuxEvent() {
+        recordSideEffect("cmux-event");
+      },
+      async closeoutUnit() {
+        recordSideEffect("closeout-unit");
+      },
+      buildSnapshotOpts() {
+        return {};
+      },
+      async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {
+        recordSideEffect(`stop:${reason ?? ""}`);
+      },
+      async pauseAuto() {
+        recordSideEffect("pause");
+      },
+      emitJournalEvent() {
+        recordSideEffect("journal-event");
+      },
+    },
+  };
+}
+
+async function runScenario(opts: {
+  label: string;
+  completionStopInProgress: boolean;
+  activeMilestone: { id: string; title: string } | null;
+  // When true, the test opens an in-memory DB and inserts M001 with status
+  // "complete" so the DB-closed branch of the guard can fire.
+  dbAlreadyClosed: boolean;
+}): Promise<void> {
+  if (isDbAvailable()) {
+    closeDatabase();
+  }
+  if (opts.dbAlreadyClosed) {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Milestone one", status: "complete" });
+  }
+
+  try {
+    const sideEffects: SideEffect[] = [];
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const ic = makeIterationContext({
+      completionStopInProgress: opts.completionStopInProgress,
+      sideEffects,
+      notifications,
+      activeMilestone: opts.activeMilestone,
+    });
+
+    const result = await runPreDispatch(ic, {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assertTrue(
+      result.action === "break",
+      `${opts.label}: returns break instead of next`,
+    );
+    if (result.action === "break") {
+      assertTrue(
+        result.reason === "milestone-complete",
+        `${opts.label}: reason is milestone-complete (got "${result.reason}")`,
+      );
+    }
+    assertTrue(
+      sideEffects.length === 0,
+      `${opts.label}: no closeout side effects replayed (saw [${sideEffects.join(", ")}])`,
+    );
+    assertTrue(
+      notifications.length === 0,
+      `${opts.label}: no user notifications emitted (saw ${notifications.length})`,
+    );
+  } finally {
+    if (isDbAvailable()) {
+      closeDatabase();
+    }
+  }
+}
+
+console.log("\n=== Terminal complete is idempotent across both observer paths ===");
+
+// ── state.phase === "complete" branch (activeMilestone non-null) ────────────
+await runScenario({
+  label: "phase=complete + mid set + completionStopInProgress",
+  completionStopInProgress: true,
+  activeMilestone: { id: "M001", title: "Milestone one" },
+  dbAlreadyClosed: false,
+});
+
+await runScenario({
+  label: "phase=complete + mid set + DB closed",
+  completionStopInProgress: false,
+  activeMilestone: { id: "M001", title: "Milestone one" },
+  dbAlreadyClosed: true,
+});
+
+// ── Canonical !mid "all milestones complete" sub-branch ────────────────────
+// deriveState returns phase: "complete" with activeMilestone: null. The
+// session's s.currentMilestoneId (M001) is what the guard consults.
+await runScenario({
+  label: "phase=complete + activeMilestone=null + completionStopInProgress",
+  completionStopInProgress: true,
+  activeMilestone: null,
+  dbAlreadyClosed: false,
+});
+
+await runScenario({
+  label: "phase=complete + activeMilestone=null + DB closed",
+  completionStopInProgress: false,
+  activeMilestone: null,
+  dbAlreadyClosed: true,
+});
+
+report();

package/src/resources/extensions/gsd/tests/plan-gate-failed-doctor-heal-hint.test.ts

@@ -18,12 +18,12 @@ function readSrc(file: string): string {
   return readFileSync(join(gsdDir, file), "utf-8");
 }
 
-test("#4620: auto/phases plan gate failed message includes doctor heal hint", () => {
-  const src = readSrc("auto/phases.ts");
+test("#4620: auto/pre-dispatch plan gate failed message includes doctor heal hint", () => {
+  const src = readSrc("auto/pre-dispatch.ts");
   assert.match(
     src,
     /Plan gate failed-closed:[\s\S]*\/gsd doctor heal/,
-    "auto/phases.ts should include /gsd doctor heal in plan gate failed notification",
+    "auto/pre-dispatch.ts should include /gsd doctor heal in plan gate failed notification",
   );
 });
 

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -145,7 +145,7 @@ function createBasicTask(): void {
   });
 }
 
-function createTaskWithoutVerify(): void {
+function createTaskWithoutVerify(status = "pending"): void {
   insertMilestone({ id: "M001" });
   insertSlice({
     id: "S01",
@@ -159,7 +159,7 @@ function createTaskWithoutVerify(): void {
     sliceId: "S01",
     milestoneId: "M001",
     title: "Task without host verification",
-    status: "pending",
+    status,
     planning: {
       description: "Task intentionally missing runnable verification",
       estimate: "1h",
@@ -558,6 +558,32 @@ describe("Post-execution blocking failure retry bypass", () => {
     assert.equal(pauseAutoMock.mock.callCount(), 1);
     assert.equal(s.pendingVerificationRetry, null);
 
+    const notifyMessages = ctx.ui.notify.mock.calls.map((c: { arguments: unknown[] }) =>
+      String(c.arguments[0])
+    );
+    assert.ok(
+      notifyMessages.some(
+        (m: string) =>
+          m.includes(".gsd/PREFERENCES.md") &&
+          m.includes("task-plan Verify command") &&
+          m.includes("/gsd next")
+      ),
+      "no-host-checks notification should guide the user to add verification and resume",
+    );
+
+    const pauseCalls = pauseAutoMock.mock.calls as Array<{ arguments: unknown[] }>;
+    const pauseCallArgs = pauseCalls[0]?.arguments[2] as
+      | { message?: string }
+      | undefined;
+    assert.ok(
+      pauseCallArgs?.message?.includes(".gsd/PREFERENCES.md"),
+      "pause reason should include the project verification configuration path",
+    );
+    assert.ok(
+      pauseCallArgs?.message?.includes("/gsd next"),
+      "pause reason should tell the user how to resume",
+    );
+
     const evidencePath = join(tempDir, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-VERIFY.json");
     const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
     assert.equal(evidence.passed, false);
@@ -566,6 +592,41 @@ describe("Post-execution blocking failure retry bypass", () => {
     assert.ok(!("maxRetries" in evidence), "no-host-checks evidence must not include maxRetries");
   });
 
+  test("completed browser-facing execute-task with no host-owned verification continues toward browser UAT", async () => {
+    createTaskWithoutVerify("complete");
+    writeFileSync(join(tempDir, "index.html"), "<!doctype html><button>Import</button>", "utf-8");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.equal(s.pendingVerificationRetry, null);
+
+    const notifyMessages = ctx.ui.notify.mock.calls.map((c: { arguments: unknown[] }) =>
+      String(c.arguments[0])
+    );
+    assert.ok(
+      notifyMessages.some(
+        (m: string) =>
+          m.includes("browser-facing task") &&
+          m.includes("slice UAT") &&
+          m.includes("browser tools")
+      ),
+      "completed web tasks without task-level commands should explain browser UAT handoff",
+    );
+
+    const evidencePath = join(tempDir, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-VERIFY.json");
+    const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
+    assert.equal(evidence.passed, false);
+    assert.equal(evidence.discoverySource, "none");
+    assert.ok(!("retryAttempt" in evidence), "browser-UAT handoff evidence must not request a task retry");
+  });
+
   test("auto-discovered package.json verification failure retries instead of continuing", async () => {
     createTaskWithoutVerify();
     writeFileSync(

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -21,6 +21,7 @@ import { join } from "node:path";
 import {
   extractPackageReferences,
   checkFilePathConsistency,
+  checkPlanningArtifactReferences,
   checkTaskOrdering,
   checkInterfaceContracts,
   checkVerificationCommands,
@@ -973,7 +974,12 @@ describe("runPreExecutionChecks", () => {
     }
   });
 
-  test("resolves .gsd metadata inputs from canonical project root in worktree mode (#5492)", async () => {
+  // Supersedes #5492: .gsd metadata inputs used to be accepted in worktree mode
+  // by resolving from the canonical project root. Task inputs are source files
+  // only (CONTEXT.md "Task Input") — planning artifacts are now blocked with a
+  // removal message regardless of where they resolve. The canonical-root
+  // resolution itself remains for merged-but-unsynced source files.
+  test("blocks .gsd metadata inputs even when resolvable from canonical project root in worktree mode", async () => {
     const projectRoot = join(tmpdir(), `pre-exec-project-root-${Date.now()}`);
     const worktreeRoot = join(tmpdir(), `pre-exec-worktree-root-${Date.now()}`);
     mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
@@ -990,6 +996,35 @@ describe("runPreExecutionChecks", () => {
         }),
       ];
 
+      const result = await runPreExecutionChecks(tasks, worktreeRoot, {
+        canonicalProjectRoot: projectRoot,
+      });
+      assert.equal(result.status, "fail");
+      assert.equal(result.checks.length, 1);
+      assert.ok(result.checks[0].message.includes("preloaded as context"));
+    } finally {
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(worktreeRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("resolves source-file inputs from canonical project root in worktree mode (#5492)", async () => {
+    const projectRoot = join(tmpdir(), `pre-exec-project-root-src-${Date.now()}`);
+    const worktreeRoot = join(tmpdir(), `pre-exec-worktree-root-src-${Date.now()}`);
+    mkdirSync(join(projectRoot, "src"), { recursive: true });
+    mkdirSync(worktreeRoot, { recursive: true });
+    writeFileSync(join(projectRoot, "src", "merged.ts"), "// merged upstream");
+
+    try {
+      const tasks = [
+        createTask({
+          id: "T01",
+          files: [],
+          inputs: ["src/merged.ts"],
+          expected_output: [],
+        }),
+      ];
+
       const result = await runPreExecutionChecks(tasks, worktreeRoot, {
         canonicalProjectRoot: projectRoot,
       });
@@ -2263,3 +2298,160 @@ describe("checkFilePathConsistency quote-wrapped annotation (#3747)", () => {
     );
   });
 });
+
+// ─── Planning Artifact Reference Tests ───────────────────────────────────────
+
+describe("checkPlanningArtifactReferences", () => {
+  function withTempDir(run: (tempDir: string) => void): void {
+    const tempDir = join(tmpdir(), `pre-exec-artifact-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+      run(tempDir);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  test("blocks .gsd/ paths in inputs even when the file exists", () => {
+    withTempDir((tempDir) => {
+      const artifactDir = join(tempDir, ".gsd", "milestones", "M001");
+      mkdirSync(artifactDir, { recursive: true });
+      writeFileSync(join(artifactDir, "M001-CONTEXT.md"), "# context");
+
+      const tasks = [
+        createTask({ id: "T01", inputs: [".gsd/milestones/M001/M001-CONTEXT.md"] }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.equal(results[0].blocking, true);
+      assert.ok(results[0].message.includes("preloaded as context"));
+    });
+  });
+
+  test("blocks bare artifact names that do not resolve to a real file, with the truthful message", () => {
+    withTempDir((tempDir) => {
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.ok(results[0].message.includes("preloaded as context"));
+      assert.ok(!results[0].message.includes("doesn't exist"));
+
+      // The consistency check must not double-report the same entry with the
+      // misleading "doesn't exist" message.
+      const consistency = checkFilePathConsistency(tasks, tempDir);
+      assert.deepEqual(consistency, []);
+    });
+  });
+
+  test("allows a bare artifact-style name that exists as a real source file", () => {
+    withTempDir((tempDir) => {
+      writeFileSync(join(tempDir, "M001-CONTEXT.md"), "# tracked source file");
+
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+    });
+  });
+
+  test("leaves artifact-style names with directory components to the existence checks", () => {
+    withTempDir((tempDir) => {
+      const tasks = [createTask({ id: "T01", inputs: ["tests/fixtures/M001-CONTEXT.md"] })];
+
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+      const consistency = checkFilePathConsistency(tasks, tempDir);
+      assert.equal(consistency.length, 1);
+      assert.ok(consistency[0].message.includes("doesn't exist"));
+    });
+  });
+
+  test("blocks .planning/ and .audits/ paths in files", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({ id: "T01", files: [".planning/codebase/STACK.md", ".audits/security.md"] }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 2);
+      assert.ok(results.every((r) => r.blocking && r.message.includes("never task files")));
+    });
+  });
+
+  test("blocks .gsd/ paths in expectedOutput with the workflow-tools message and no ordering duplicate", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({
+          id: "T01",
+          sequence: 0,
+          expected_output: [".gsd/milestones/M001/M001-SUMMARY.md"],
+        }),
+        createTask({
+          id: "T02",
+          sequence: 1,
+          inputs: [".gsd/milestones/M001/M001-SUMMARY.md"],
+        }),
+      ];
+
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 2);
+      const outputFinding = results.find((r) => r.message.includes("expectedOutput"));
+      assert.ok(outputFinding);
+      assert.ok(outputFinding.message.includes("written by workflow tools"));
+
+      assert.deepEqual(checkTaskOrdering(tasks, tempDir), []);
+    });
+  });
+
+  test("skips prose, sentinels, and runtime-only entries", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({
+          id: "T01",
+          inputs: ["none", "Current enum shape", "server logs (runtime)"],
+        }),
+      ];
+
+      assert.deepEqual(checkPlanningArtifactReferences(tasks, tempDir), []);
+    });
+  });
+
+  test("runPreExecutionChecks surfaces artifact findings as blocking failures", async () => {
+    const tempDir = join(tmpdir(), `pre-exec-artifact-run-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+      const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+      const result: PreExecutionResult = await runPreExecutionChecks(tasks, tempDir);
+      assert.equal(result.status, "fail");
+      assert.ok(
+        result.checks.some((c) => !c.passed && c.blocking && c.message.includes("preloaded as context")),
+      );
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("allows a bare artifact-style name that exists only at canonicalProjectRoot (not at worktree basePath)", () => {
+    withTempDir((canonicalRoot) => {
+      withTempDir((worktreeRoot) => {
+        writeFileSync(join(canonicalRoot, "M001-CONTEXT.md"), "# tracked source file");
+        const tasks = [createTask({ id: "T01", inputs: ["M001-CONTEXT.md"] })];
+        assert.deepEqual(
+          checkPlanningArtifactReferences(tasks, worktreeRoot, { canonicalProjectRoot: canonicalRoot }),
+          [],
+        );
+      });
+    });
+  });
+
+  test("blocks .GSD/ paths with mixed casing (case-insensitive metadata dir match)", () => {
+    withTempDir((tempDir) => {
+      const tasks = [
+        createTask({ id: "T01", inputs: [".GSD/milestones/M001/M001-CONTEXT.md"] }),
+      ];
+      const results = checkPlanningArtifactReferences(tasks, tempDir);
+      assert.equal(results.length, 1);
+      assert.equal(results[0].blocking, true);
+      assert.ok(results[0].message.includes("preloaded as context"));
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -55,14 +55,20 @@ const PHASE_PROMPT_TOOL_CALLS: Record<string, readonly string[]> = {
   "plan-slice": ["gsd_reassess_roadmap", "gsd_plan_slice", "gsd_decision_save"],
   "refine-slice": ["gsd_plan_slice", "gsd_decision_save"],
   "replan-slice": ["gsd_replan_slice"],
-  "execute-task": ["gsd_task_complete"],
+  "execute-task": [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ],
   "reactive-execute": ["gsd_summary_save"],
   "complete-slice": [
     "gsd_exec",
     "gsd_task_reopen",
     "gsd_replan_slice",
     "gsd_requirement_update",
-    "capture_thought",
+    "gsd_capture_thought",
     "gsd_slice_complete",
     "gsd_summary_save",
   ],
@@ -240,6 +246,8 @@ test("workflow-start prompt defaults to autonomy instead of per-phase confirmati
   const prompt = readPrompt("workflow-start");
   assert.match(prompt, /Keep moving by default/i);
   assert.match(prompt, /Decision gates, not ceremony/i);
+  assert.match(prompt, /Persist workflow state/i);
+  assert.match(prompt, /completedAt/i);
   assert.doesNotMatch(prompt, /confirm with the user before proceeding/i);
   assert.doesNotMatch(prompt, /Gate between phases/i);
 });