gsd-pi 2.80.0-dev.710c06e97 → 2.80.0-dev.7582bf37a

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -361,74 +361,95 @@ test("resolveModelId: bare ID with claude-code as only provider still resolves",
 
 // ─── selectAndApplyModel verbose-gating tests ──────────────────────────
 
-test("model change notify in selectAndApplyModel is gated behind verbose flag", () => {
-  // The Model [phase] [tier] notification should only fire when verbose=true.
-  // The dashboard header already shows the active model, so the notification
-  // is redundant noise during auto-mode (#3719).
-  const gsdDir = join(__dirname, "..");
-  const src = readFileSync(join(gsdDir, "auto-model-selection.ts"), "utf-8");
-
-  // Find the block where setModel succeeds (appliedModel = model) and
-  // verify notify is inside an `if (verbose)` guard.
-  const setModelBlock = src.match(
-    /const ok = await pi\.setModel\(model[\s\S]*?appliedModel = model;([\s\S]*?)break;/,
-  );
-  assert.ok(setModelBlock, "should find the setModel success block");
+test("model change notify in selectAndApplyModel is gated behind verbose flag", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-verbose-project-");
+  const notifications: Array<{ message: string; level: string }> = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
 
-  const blockBody = setModelBlock![1];
-  // The notify call must be inside an if (verbose) block
-  assert.ok(
-    blockBody.includes("if (verbose)"),
-    "Model change ctx.ui.notify must be gated behind if (verbose) to avoid auto-mode notification noise",
-  );
-  assert.ok(
-    blockBody.includes("ctx.ui.notify"),
-    "notify call should still exist (just verbose-gated)",
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
   );
-});
+  process.chdir(tempProject);
 
-test("model policy resolves candidates from the policy-eligible pool", () => {
-  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
-  assert.ok(
-    src.includes("const resolutionPool = uokFlags.modelPolicy ? routingEligibleModels : availableModels"),
-    "selectAndApplyModel should resolve model IDs against policy-eligible models when model policy is enabled",
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: (message: string, level: string) => notifications.push({ message, level }) },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
   );
-});
 
-test("model policy receives task metadata for requirement-vector decisions", () => {
-  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
-  assert.ok(
-    src.includes("taskMetadata: taskMetadataForPolicy"),
-    "applyModelPolicyFilter should receive task metadata so requirement vectors are unit-aware",
-  );
-  assert.ok(
-    src.includes("extractTaskMetadata(unitId, basePath)"),
-    "execute-task dispatch should derive metadata before policy filtering",
-  );
+  assert.deepEqual(notifications, []);
 });
 
-test("dynamic routing passes provider-qualified model keys to the router", () => {
-  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
-  assert.ok(
-    src.includes("routingEligibleModels.map(m => `${m.provider}/${m.id}`)"),
-    "selectAndApplyModel should preserve provider prefixes for dynamic routing candidates",
-  );
-  assert.ok(
-    !src.includes("routingEligibleModels.map(m => m.id)"),
-    "selectAndApplyModel must not strip providers before resolving tier_models",
-  );
-});
+test("selectAndApplyModel re-applies captured thinking level after setModel success", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-project-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
 
-test("selectAndApplyModel re-applies captured thinking level after setModel success", () => {
-  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
-  assert.ok(
-    src.includes("autoModeStartThinkingLevel?: ReturnType<ExtensionAPI[\"getThinkingLevel\"]> | null"),
-    "selectAndApplyModel should accept an autoModeStartThinkingLevel parameter",
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
   );
-  assert.ok(
-    src.includes("reapplyThinkingLevel(pi, autoModeStartThinkingLevel)"),
-    "selectAndApplyModel should re-apply captured thinking level after model changes",
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    { effort: "high" } as any,
   );
+
+  assert.deepEqual(thinkingLevels, [{ effort: "high" }]);
 });
 
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -2,63 +2,19 @@
  * auto-paused-session-validation.test.ts — Validates milestone existence
  * before restoring from paused-session.json (#1664).
  *
- * Two layers:
- * 1. Source-code regression: ensures auto.ts validates the milestone before
- *    trusting paused-session.json (guards against accidental removal).
- * 2. Filesystem unit: confirms resolveMilestonePath / resolveMilestoneFile
- *    correctly detect missing and completed milestones.
+ * Filesystem unit coverage confirms resolveMilestonePath / resolveMilestoneFile
+ * correctly detect missing and completed milestones.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
 
 import { resolveMilestonePath, resolveMilestoneFile } from "../paths.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
-
-// ─── Source-code regression guard ───────────────────────────────────────────
-
-test("auto.ts validates milestone before restoring paused session (#1664)", () => {
-  const source = readFileSync(AUTO_TS_PATH, "utf-8");
-
-  // The resume block must call resolveMilestonePath to verify the milestone dir exists
-  assert.ok(
-    source.includes('resolveMilestonePath(base, meta.milestoneId)'),
-    "auto.ts must call resolveMilestonePath to verify paused milestone exists",
-  );
-
-  // The resume block must check for a SUMMARY file to detect completed milestones
-  assert.ok(
-    source.includes('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
-    "auto.ts must check for SUMMARY file to detect completed milestones",
-  );
-
-  assert.ok(
-    source.includes("await ensureDbOpen(base)") &&
-      source.indexOf("await ensureDbOpen(base)") < source.indexOf('resolveMilestoneFile(base, meta.milestoneId, "SUMMARY")'),
-    "auto.ts must open the canonical DB before using SUMMARY as a paused-session fallback",
-  );
-
-  // Resume path must sanitize paused session file metadata before unlink/recovery.
-  assert.ok(
-    source.includes("normalizeSessionFilePath(meta.sessionFile ?? null)"),
-    "auto.ts must sanitize paused-session metadata sessionFile before using it",
-  );
-
-  // Pause path must sanitize live session file path before persisting metadata.
-  assert.ok(
-    source.includes("normalizeSessionFilePath(ctx?.sessionManager?.getSessionFile() ?? null)"),
-    "auto.ts must sanitize sessionManager getSessionFile output before persisting",
-  );
-});
-
 // ─── Filesystem validation unit tests ───────────────────────────────────────
 
 function makeTmpBase(): string {

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -1,27 +1,85 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for auto-loop cleanup after paused provider exits.
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoSource = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+import { cleanupAfterLoopExit, rerootCommandSession } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 
-test("#3370: cleanupAfterLoopExit preserves paused auto badge after provider pause", () => {
-  const cleanupIdx = autoSource.indexOf("function cleanupAfterLoopExit");
-  assert.ok(cleanupIdx > -1, "auto.ts should define cleanupAfterLoopExit");
+test("cleanupAfterLoopExit preserves paused auto badge after provider pause", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-cleanup-"));
+  const previousCwd = process.cwd();
+  const statuses: Array<[string, string | undefined]> = [];
 
-  const dispatchIdx = autoSource.indexOf("export async function dispatchHookUnit", cleanupIdx);
-  assert.ok(dispatchIdx > cleanupIdx, "cleanupAfterLoopExit body should be bounded by the next export");
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = true;
+  autoSession.basePath = join(base, ".gsd", "worktrees", "M001");
+  autoSession.originalBasePath = base;
 
-  const cleanupBody = autoSource.slice(cleanupIdx, dispatchIdx);
-  const pausedGuardIdx = cleanupBody.indexOf("if (!s.paused) {");
-  const clearStatusIdx = cleanupBody.indexOf('ctx.ui.setStatus("gsd-auto", undefined);');
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: (key: string, value: string | undefined) => {
+          statuses.push([key, value]);
+        },
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
 
-  assert.ok(pausedGuardIdx > -1, "loop-exit cleanup must guard UI clearing when auto is paused");
-  assert.ok(clearStatusIdx > pausedGuardIdx, "status clearing must live behind the paused guard");
-  assert.ok(
-    autoSource.includes('ctx?.ui.setStatus("gsd-auto", "paused");'),
-    "pauseAuto must still set the paused badge for transient provider pauses",
+    assert.equal(statuses.some(([key]) => key === "gsd-auto"), false);
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.paused, true);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit clears status and widget when auto is not paused", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: false,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
+    assert.deepEqual(widgetCalls, [["gsd-progress", undefined]]);
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.paused, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("rerootCommandSession refreshes command workspace to project root", async () => {
+  const calls: string[] = [];
+  const result = await rerootCommandSession(
+    {
+      newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+        calls.push(workspaceRoot);
+        return { cancelled: false };
+      },
+    } as any,
+    "/project/root",
   );
+
+  assert.deepEqual(result, { status: "ok" });
+  assert.deepEqual(calls, ["/project/root"]);
 });

package/src/resources/extensions/gsd/tests/auto-phases-lifecycle.test.ts

@@ -1,18 +1,75 @@
+// Project/App: GSD-2
+// File Purpose: Auto-loop phase lifecycle regression tests.
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { runFinalize } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
+import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
-test("runFinalize clears currentUnit after successful finalize", async () => {
-  const s = new AutoSession();
-  s.basePath = "/tmp/gsd-finalize-current-unit";
-  s.currentUnit = {
-    type: "execute-task",
-    id: "M001/S01/T01",
-    startedAt: Date.now(),
+async function runSuccessfulFinalize(s: AutoSession) {
+  const unit = s.currentUnit;
+  assert.ok(unit, "test setup must provide currentUnit");
+
+  writeUnitRuntimeRecord(s.basePath, unit.type, unit.id, unit.startedAt, {
+    phase: "dispatched",
+  });
+
+  const deps = {
+    clearUnitTimeout() {},
+    buildSnapshotOpts() {
+      return {};
+    },
+    stopAuto: async () => {},
+    pauseAuto: async () => {},
+    updateProgressWidget() {},
+    postUnitPreVerification: async () => "continue",
+    runPostUnitVerification: async () => "continue",
+    postUnitPostVerification: async () => "continue",
   };
 
+  return runFinalize(
+    {
+      ctx: { ui: { notify() {} } },
+      pi: {},
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "flow-1",
+      nextSeq: () => 1,
+    } as any,
+    {
+      unitType: unit.type,
+      unitId: unit.id,
+      prompt: "",
+      finalPrompt: "",
+      pauseAfterUatDispatch: false,
+      state: {} as any,
+      mid: "M001",
+      midTitle: "Milestone",
+      isRetry: false,
+      previousTier: undefined,
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+}
+
+async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string, unknown>) {
+  const unit = s.currentUnit;
+  assert.ok(unit, "test setup must provide currentUnit");
+
+  writeUnitRuntimeRecord(s.basePath, unit.type, unit.id, unit.startedAt, {
+    phase: "dispatched",
+  });
+
   const deps = {
     clearUnitTimeout() {},
     buildSnapshotOpts() {
@@ -24,9 +81,10 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
     postUnitPreVerification: async () => "continue",
     runPostUnitVerification: async () => "continue",
     postUnitPostVerification: async () => "continue",
+    ...depsOverrides,
   };
 
-  const result = await runFinalize(
+  return runFinalize(
     {
       ctx: { ui: { notify() {} } },
       pi: {},
@@ -38,8 +96,8 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
       nextSeq: () => 1,
     } as any,
     {
-      unitType: "execute-task",
-      unitId: "M001/S01/T01",
+      unitType: unit.type,
+      unitId: unit.id,
       prompt: "",
       finalPrompt: "",
       pauseAfterUatDispatch: false,
@@ -55,7 +113,98 @@ test("runFinalize clears currentUnit after successful finalize", async () => {
       consecutiveFinalizeTimeouts: 0,
     },
   );
+}
+
+test("runFinalize clears currentUnit after successful finalize", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-current-unit-"));
+  const s = new AutoSession();
+  s.basePath = base;
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  try {
+    const result = await runSuccessfulFinalize(s);
+
+    assert.equal(result.action, "next");
+    assert.equal(s.currentUnit, null);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("runFinalize marks unit runtime finalized after successful finalize", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-runtime-"));
+  const s = new AutoSession();
+  const startedAt = Date.now();
+  s.basePath = base;
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt,
+  };
+
+  try {
+    const result = await runSuccessfulFinalize(s);
+    const runtime = readUnitRuntimeRecord(base, "complete-milestone", "M001");
+
+    assert.equal(result.action, "next");
+    assert.equal(runtime?.phase, "finalized");
+    assert.equal(runtime?.lastProgressKind, "finalize-success");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("runFinalize merges a verified complete-milestone immediately and only once", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-merge-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  const startedAt = Date.now();
+  let mergeCalls = 0;
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt,
+  };
+
+  const result = await runFinalizeWithDeps(s, {
+    preflightCleanRoot: () => ({ stashPushed: false }),
+    postflightPopStash: () => ({ needsManualRecovery: false }),
+    resolver: {
+      mergeAndExit() {
+        mergeCalls++;
+      },
+    },
+  });
 
   assert.equal(result.action, "next");
-  assert.equal(s.currentUnit, null);
+  assert.equal(mergeCalls, 1);
+  assert.equal(s.milestoneMergedInPhases, true);
+
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: startedAt + 1,
+  };
+  const second = await runFinalizeWithDeps(s, {
+    preflightCleanRoot: () => ({ stashPushed: false }),
+    postflightPopStash: () => ({ needsManualRecovery: false }),
+    resolver: {
+      mergeAndExit() {
+        mergeCalls++;
+      },
+    },
+  });
+
+  assert.equal(second.action, "next");
+  assert.equal(mergeCalls, 1);
 });