@opengsd/gsd-pi 1.2.0-dev.e8563f58 → 1.2.0-dev.fbdca60b

package/src/resources/extensions/gsd/tests/milestone-settlement.test.ts

@@ -0,0 +1,92 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for milestone closeout settlement guidance.
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { evaluateAllCompleteSettlement } from "../milestone-settlement.ts";
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+
+let base = "";
+
+function runGit(cwd: string, args: string[]): void {
+  execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+function initRepo(root: string): void {
+  runGit(root, ["init", "-b", "main"]);
+  runGit(root, ["config", "user.email", "test@example.com"]);
+  runGit(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "README.md"), "# fixture\n");
+  runGit(root, ["add", "."]);
+  runGit(root, ["commit", "-m", "chore: init"]);
+}
+
+function seedClosedMilestone(root: string, worktree: string): void {
+  mkdirSync(join(root, ".gsd"), { recursive: true });
+  openDatabase(join(root, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice One", status: "complete" });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task One",
+    status: "complete",
+    verificationResult: "passed",
+  });
+  insertAssessment({
+    path: ".gsd/milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass\n",
+  });
+
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
+  assert.ok(summaryPath, "complete-milestone summary path should resolve");
+  mkdirSync(dirname(summaryPath), { recursive: true });
+  writeFileSync(summaryPath, "# Milestone One\n\nComplete.\n");
+}
+
+afterEach(() => {
+  try { closeDatabase(); } catch { /* ignore */ }
+  if (base) rmSync(base, { recursive: true, force: true });
+  base = "";
+});
+
+test("merge-pending settlement routes back to complete-milestone dispatch without manual merge guidance", () => {
+  base = mkdtempSync(join(tmpdir(), "gsd-milestone-settlement-"));
+  initRepo(base);
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(dirname(worktree), { recursive: true });
+  runGit(base, ["worktree", "add", "-b", "milestone/M001", worktree, "HEAD"]);
+  seedClosedMilestone(base, worktree);
+
+  const result = evaluateAllCompleteSettlement({
+    milestoneId: "M001",
+    statePhase: "complete",
+    basePath: worktree,
+    originalBasePath: base,
+    milestoneMerged: false,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "merge-pending");
+  assert.equal(result.nextAction, "Retry `/gsd dispatch complete-milestone M001`.");
+  assert.doesNotMatch(result.message, /merge manually/i);
+  assert.doesNotMatch(result.nextAction, /merge manually/i);
+});

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -14,7 +14,7 @@ import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { AutoSession } from "../auto/session.ts";
-import { runPreDispatch } from "../auto/phases.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 
 test("milestone transition archives completed units and rebuilds state", async () => {
   const tempDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cu-reset-")));

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

@@ -1,7 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
+import { playQuestionBell } from "../../ask-user-questions.js";
+import { stopAuto } from "../auto.js";
+import { autoSession } from "../auto-runtime-state.js";
 import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
@@ -58,18 +63,68 @@ test("playNotificationBell is silent when disabled", () => {
   assert.equal(output, "");
 });
 
-test("ask_user_questions plays local bell before waiting for an answer", () => {
-  const source = readFileSync(new URL("../../ask-user-questions.ts", import.meta.url), "utf-8");
+test("playQuestionBell writes a terminal bell when local bell is enabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
 
-  assert.match(source, /playNotificationBell\("question"\)/);
-  assert.match(source, /await playQuestionBell\(\)/);
+  await playQuestionBell({ enabled: true, local_bell: true }, stream);
+
+  assert.equal(output, "\u0007");
 });
 
-test("stopAuto plays local bell for auto-mode stop notifications", () => {
-  const source = readFileSync(new URL("../auto.ts", import.meta.url), "utf-8");
+test("playQuestionBell is silent when local bell is disabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
 
-  assert.match(source, /import \{[^}]*playNotificationBell[^}]*\} from "\.\/notifications\.js"/);
-  assert.match(source, /playNotificationBell\("stop", loadedPreferences\?\.notifications\)/);
+  await playQuestionBell({ enabled: true, local_bell: false }, stream);
+
+  assert.equal(output, "");
+});
+
+test("stopAuto plays local bell for auto-mode stop notifications", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stop-bell-"));
+  const previousCwd = process.cwd();
+  const previousStderrWrite = process.stderr.write;
+  const previousStderrIsTTY = process.stderr.isTTY;
+  let bellOutput = "";
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nnotifications:\n  enabled: true\n  local_bell: true\n---\n",
+    "utf-8",
+  );
+
+  process.stderr.isTTY = true;
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    if (typeof chunk === "string") {
+      bellOutput += chunk;
+    }
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    await stopAuto(
+      { hasUI: false, ui: { notify: () => {}, setStatus: () => {}, setWidget: () => {}, setHeader: () => {} } } as any,
+      undefined,
+      "test stop",
+    );
+
+    assert.ok(
+      bellOutput.includes("\u0007"),
+      "stopAuto must write a terminal bell to stderr when the local bell preference is enabled",
+    );
+  } finally {
+    process.stderr.write = previousStderrWrite;
+    process.stderr.isTTY = previousStderrIsTTY;
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 test("buildDesktopNotificationCommand falls back to osascript on macOS when terminal-notifier is absent", () => {

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -29,8 +29,8 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${COMPLETE_SLICE_SKILL_NAME}' })`;
+const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
+const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;

package/src/resources/extensions/gsd/tests/parsers-legacy-importers.test.ts

@@ -28,6 +28,11 @@ const BANNED_DECISION_PATHS = new Set([
   "gsd/auto-post-unit.ts",
   "gsd/milestone-closeout.ts",
   "gsd/auto/phases.ts",
+  "gsd/auto/pre-dispatch.ts",
+  "gsd/auto/dispatch.ts",
+  "gsd/auto/unit-phase.ts",
+  "gsd/auto/finalize.ts",
+  "gsd/auto/closeout.ts",
   "gsd/auto/orchestrator.ts",
   "gsd/auto/loop.ts",
   "gsd/tools/complete-slice.ts",

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -10,7 +10,7 @@
  */
 
 import { createTestContext } from "./test-helpers.ts";
-import { runPreDispatch } from "../auto/phases.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 
 const { assertTrue, report } = createTestContext();
 

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

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,10 +17,8 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import {
-  _buildCancelledUnitStopReason,
-  _classifyZeroToolProviderMessageForTest,
-} from "../auto/phases.ts";
+import { _buildCancelledUnitStopReason } from "../auto/phase-helpers.ts";
+import { _classifyZeroToolProviderMessageForTest } from "../auto/unit-phase.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package