@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tests/orchestrator-logs.test.ts

@@ -0,0 +1,335 @@
+// gsd-pi — Orchestrator advance() log coverage.
+//
+// The orchestrator's private methods (findPriorSliceCompletionBlocker,
+// emitUokGate, mergePendingCompleteMilestone) each emit `engine` warnings on
+// their failure paths (orchestrator.ts:660 / :538 / :637). They are only
+// reachable by driving advance() through a real AutoOrchestrator constructed
+// via createAutoOrchestrator. This file builds a minimal fixture (git repo +
+// seeded DB + session lock + registry dispatch rule, modelled on
+// auto-orchestrator.test.ts's makeFixture) and drives advance() into each
+// branch, asserting the log output.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import {
+  createAutoOrchestrator,
+  _setProjectionRebuildFnForTests,
+  type OrchestratorContext,
+} from "../auto/orchestrator.ts";
+import type { AutoSessionContext } from "../auto/contracts.ts";
+import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.ts";
+import type { UnifiedRule } from "../rule-types.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import { AutoSession } from "../auto/session.ts";
+import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { invalidateStateCache } from "../state.ts";
+import {
+  drainLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+
+const SESSION_CONTEXT: AutoSessionContext = { basePath: "/tmp/project", trigger: "manual" };
+
+function gitInit(base: string): void {
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, ".gitkeep"), "");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base, stdio: "ignore" });
+}
+
+interface FixtureOptions {
+  /** Override the session's originalBasePath (used by findPriorSliceCompletionBlocker's guard). */
+  originalBasePath?: string;
+  /** The dispatch decision the registry rule returns. */
+  dispatch?: UnifiedRule["where"];
+  /** Drop the gate_runs table after seeding so emitUokGate's insertGateRun throws (:538 path). */
+  dropGateRuns?: boolean;
+}
+
+interface Fixture {
+  base: string;
+  session: AutoSession;
+  orchestrator: ReturnType<typeof createAutoOrchestrator>;
+  cleanup(): void;
+}
+
+function makeFixture(opts: FixtureOptions = {}): Fixture {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orch-logs-"));
+  gitInit(base);
+
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+
+  invalidateAllCaches();
+  invalidateStateCache();
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "low", depends: [], demo: "", sequence: 1 });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "active" });
+  if (opts.dropGateRuns) {
+    // Break the gate_runs sink so UokGateRunner.run → insertGateRun throws,
+    // exercising emitUokGate's catch (orchestrator.ts:538).
+    _getAdapter()!.exec("DROP TABLE gate_runs");
+  }
+
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    ["# M001: Milestone", "", "**Vision:** Fixture", "", "## Slices", "", "- [ ] **S01: Slice** `risk:low` `depends:[]`", ""].join("\n"),
+  );
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    ["# S01: Slice", "", "**Goal:** g", "**Demo:** d", "", "## Tasks", "", "- [ ] **T01: Task** `est:1h`", ""].join("\n"),
+  );
+
+  acquireSessionLock(base);
+
+  const session = new AutoSession();
+  session.basePath = base;
+  // originalBasePath feeds resolveWorktreeProjectRoot inside
+  // findPriorSliceCompletionBlocker → getMainBranch(guardBasePath). Pointing it
+  // at a non-git directory makes branch discovery throw → :660 warning.
+  session.originalBasePath = opts.originalBasePath ?? base;
+  session.currentMilestoneId = "M001";
+  session.resourceVersionOnStart = null;
+
+  const ctx: OrchestratorContext = {
+    ctx: { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] }, ui: { notify() {} } } as never,
+    pi: { getActiveTools: () => [] } as never,
+    dispatchBasePath: base,
+    runtimeBasePath: base,
+    session,
+  };
+
+  const rule: UnifiedRule = {
+    name: "fixture-dispatch",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: opts.dispatch ?? (async () => ({
+      action: "dispatch",
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "fixture-prompt",
+    })),
+    then: (r) => r,
+  };
+  setRegistry(new RuleRegistry([rule]));
+
+  const orchestrator = createAutoOrchestrator(ctx);
+
+  return {
+    base,
+    session,
+    orchestrator,
+    cleanup() {
+      resetRegistry();
+      try { releaseSessionLock(base); } catch { /* */ }
+      try { closeDatabase(); } catch { /* */ }
+      try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+    },
+  };
+}
+
+/** Capture log entries emitted during fn, with stderr suppressed. */
+async function captureLogs<T>(fn: () => Promise<T>): Promise<{ result: T; logs: LogEntry[] }> {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = await fn();
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+// orchestrator.ts:660 — findPriorSliceCompletionBlocker catches a getMainBranch
+// failure and logs `branch discovery failed, falling back to main`. Triggered
+// by pointing session.originalBasePath at a non-git directory.
+test("advance() logs an engine warning when branch discovery fails (orchestrator.ts:660)", async (t) => {
+  // A second temp dir that is deliberately NOT a git repo.
+  const nonGit = mkdtempSync(join(tmpdir(), "gsd-orch-logs-nongit-"));
+  const f = makeFixture({ originalBasePath: nonGit });
+  t.after(() => {
+    f.cleanup();
+    rmSync(nonGit, { recursive: true, force: true });
+  });
+
+  const { logs } = await captureLogs(() => f.orchestrator.advance());
+
+  const branchWarn = logs.find(
+    (e) => e.component === "engine" && e.severity === "warn" && /branch discovery failed/u.test(e.message),
+  );
+  assert.ok(
+    branchWarn,
+    "an engine warning must be logged when getMainBranch fails (got: " +
+      logs.filter((e) => e.component === "engine").map((e) => e.message).join(" | ") + ")",
+  );
+  assert.match(branchWarn!.message, /branch discovery failed, falling back to main/u);
+});
+
+// orchestrator.ts:538 — emitUokGate catches a UokGateRunner.run failure and logs
+// `uok gate emit failed`. Gates are enabled by default (uok.gates.enabled ?? true),
+// and runner.run persists via insertGateRun; dropping the gate_runs table makes
+// that persistence throw, surfacing through the catch.
+test("advance() logs an engine warning when the uok gate emit fails (orchestrator.ts:538)", async (t) => {
+  const f = makeFixture({ dropGateRuns: true });
+  t.after(() => f.cleanup());
+
+  const { logs } = await captureLogs(() => f.orchestrator.advance());
+
+  const uokFail = logs.find(
+    (e) => e.component === "engine" && e.severity === "warn" && /uok gate emit failed/u.test(e.message),
+  );
+  assert.ok(
+    uokFail,
+    "an engine warning must be logged when UokGateRunner.run fails (got: " +
+      logs.filter((e) => e.component === "engine").map((e) => e.message).join(" | ") + ")",
+  );
+  assert.match(uokFail!.message, /uok gate emit failed/u);
+  assert.equal(uokFail!.context?.file, "orchestrator.ts");
+  assert.ok(uokFail!.context?.gateId, "the failing gate id must be captured in context");
+});
+
+// orchestrator.ts:637 — mergePendingCompleteMilestone catches a
+// rebuildMarkdownProjectionsFromDb failure after the system-owned milestone
+// merge and logs `markdown projection rebuild after settlement merge failed`.
+// Reached only when advance() hits a merge-pending settlement (auto-worktree,
+// complete milestone, proven closeout, no remaining units). We build that state
+// (real git worktree + closed milestone + SUMMARY artifact, modelled on
+// milestone-settlement.test.ts), inject a throwing rebuild via the test seam,
+// and assert the engine warning.
+test("advance() logs an engine warning when the post-settlement projection rebuild fails (orchestrator.ts:637)", async (t) => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-orch-logs-settle-"));
+  // Real git repo at the project root.
+  execFileSync("git", ["init", "-b", "main"], { cwd: projectRoot, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: projectRoot, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: projectRoot, stdio: "ignore" });
+  writeFileSync(join(projectRoot, "README.md"), "# fixture\n");
+  execFileSync("git", ["add", "."], { cwd: projectRoot, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "chore: init"], { cwd: projectRoot, stdio: "ignore" });
+
+  // Auto-worktree for M001 — required so evaluateAllCompleteSettlement returns
+  // merge-pending (isActiveUnmergedWorktree must be true).
+  const worktree = join(projectRoot, ".gsd", "worktrees", "M001");
+  mkdirSync(dirname(worktree), { recursive: true });
+  execFileSync("git", ["worktree", "add", "-b", "milestone/M001", worktree, "HEAD"], { cwd: projectRoot, stdio: "ignore" });
+
+  // Seed a closed milestone + proven closeout SUMMARY so proveMilestoneCloseout
+  // passes and the settlement resolves to merge-pending.
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  invalidateAllCaches();
+  invalidateStateCache();
+  openDatabase(join(projectRoot, ".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",
+  });
+  // Create the milestone projection dir in the worktree BEFORE resolving the
+  // summary artifact path (resolveExpectedArtifactPath needs the dir to exist).
+  const milestoneProjDir = join(worktree, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneProjDir, { recursive: true });
+  const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
+  assert.ok(summaryPath, "complete-milestone summary path must resolve");
+  mkdirSync(dirname(summaryPath), { recursive: true });
+  writeFileSync(summaryPath, "# Milestone One\n\nComplete.\n");
+
+  acquireSessionLock(projectRoot);
+
+  const session = new AutoSession();
+  session.basePath = worktree;
+  session.originalBasePath = projectRoot;
+  session.currentMilestoneId = "M001";
+  session.resourceVersionOnStart = null;
+
+  const ctx: OrchestratorContext = {
+    ctx: { model: {}, modelRegistry: { getAll: () => [], getAvailable: () => [] }, ui: { notify() {} } } as never,
+    pi: { getActiveTools: () => [] } as never,
+    dispatchBasePath: worktree,
+    runtimeBasePath: worktree,
+    session,
+  };
+
+  // Registry rule returns skip (no remaining units) so advance() reaches the
+  // no-remaining-units settlement branch and calls mergePendingCompleteMilestone.
+  const rule: UnifiedRule = {
+    name: "settle-no-units",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async () => ({ action: "skip", matchedRule: "settle-no-units" }),
+    then: (r) => r,
+  };
+  setRegistry(new RuleRegistry([rule]));
+
+  const orchestrator = createAutoOrchestrator(ctx);
+
+  // Inject a throwing projection rebuild so :637 fires after exitMilestone
+  // completes the system-owned merge. restoreDefault() in finally keeps the
+  // seam production-neutral for every other test in the process.
+  const restoreDefault = _setProjectionRebuildFnForTests(async () => {
+    throw new Error("forced projection rebuild failure");
+  });
+
+  t.after(() => {
+    restoreDefault();
+    resetRegistry();
+    try { releaseSessionLock(projectRoot); } catch { /* */ }
+    try { closeDatabase(); } catch { /* */ }
+    try { execFileSync("git", ["worktree", "remove", "--force", worktree], { cwd: projectRoot, stdio: "ignore" }); } catch { /* */ }
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* */ }
+  });
+
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  let logs: LogEntry[] = [];
+  try {
+    await orchestrator.advance();
+    logs = drainLogs();
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+
+  const rebuildWarn = logs.find(
+    (e) => e.component === "engine" && e.severity === "warn" &&
+      /markdown projection rebuild after settlement merge failed/u.test(e.message),
+  );
+  assert.ok(
+    rebuildWarn,
+    "an engine warning must be logged when the post-settlement projection rebuild fails (got: " +
+      logs.filter((e) => e.component === "engine").map((e) => e.message).join(" | ") + ")",
+  );
+  assert.match(rebuildWarn!.message, /forced projection rebuild failure/u);
+});

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

@@ -30,7 +30,7 @@
  */
 
 import { createTestContext } from "./test-helpers.ts";
-import { runPreDispatch } from "../auto/phases.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 import {
   openDatabase,
   closeDatabase,

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/prefs-missing-models-crash.test.ts

@@ -11,7 +11,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -92,11 +92,42 @@ test("resolveModelWithFallbacksForUnit returns undefined when no preferences fil
 });
 
 test("resolveModelWithFallbacksForUnit returns undefined when preferences omit models", () => {
-  withGsdHome("---\nmode: solo\n---\n", () => {
+  withGsdHome("---\nmode: solo\ntoken_profile: burn-max\n---\n", () => {
     assert.equal(resolveModelWithFallbacksForUnit("execute-task"), undefined);
   });
 });
 
+test("resolveModelWithFallbacksForUnit honors project basePath when cwd differs", () => {
+  const oldHome = process.env.GSD_HOME;
+  const oldCwd = process.cwd();
+  const home = mkdtempSync(join(tmpdir(), "gsd-prefs-home-"));
+  const project = mkdtempSync(join(tmpdir(), "gsd-prefs-project-"));
+  const other = mkdtempSync(join(tmpdir(), "gsd-prefs-other-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "PREFERENCES.md"), "---\nmode: solo\ntoken_profile: burn-max\n---\n");
+    const gsdDir = join(project, ".gsd");
+    mkdirSync(gsdDir, { recursive: true });
+    writeFileSync(
+      join(gsdDir, "PREFERENCES.md"),
+      "---\nmodels:\n  execution: anthropic/claude-opus-4-6\n---\n",
+    );
+    process.chdir(other);
+    assert.equal(resolveModelWithFallbacksForUnit("execute-task"), undefined);
+    assert.equal(
+      resolveModelWithFallbacksForUnit("execute-task", project)?.primary,
+      "anthropic/claude-opus-4-6",
+    );
+  } finally {
+    process.chdir(oldCwd);
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+    rmSync(other, { recursive: true, force: true });
+  }
+});
+
 test("resolveDefaultSessionModel returns undefined when no preferences file exists", () => {
   withGsdHome(null, () => {
     assert.equal(resolveDefaultSessionModel("anthropic"), undefined);
@@ -104,13 +135,13 @@ test("resolveDefaultSessionModel returns undefined when no preferences file exis
 });
 
 test("resolveDefaultSessionModel returns undefined when preferences omit models", () => {
-  withGsdHome("---\nmode: solo\n---\n", () => {
+  withGsdHome("---\nmode: solo\ntoken_profile: burn-max\n---\n", () => {
     assert.equal(resolveDefaultSessionModel("anthropic"), undefined);
   });
 });
 
 test("readModelFromPreferences returns 'default' when preferences omit models", () => {
-  withGsdHome("---\nmode: solo\n---\n", () => {
+  withGsdHome("---\nmode: solo\ntoken_profile: burn-max\n---\n", () => {
     assert.equal(readModelFromPreferences(), "default");
   });
 });

package/src/resources/extensions/gsd/tests/progress-strip-test-helpers.ts

@@ -0,0 +1,79 @@
+// Project/App: gsd-pi
+// File Purpose: Shared helpers for GsdStatusWidget progress-strip extension tests.
+
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+import { visibleWidth } from "@gsd/pi-tui";
+import type { GsdProgressState } from "@gsd/pi-coding-agent/core/extensions/index.js";
+import { initTheme } from "@gsd/pi-coding-agent/theme/theme.js";
+import { GsdStatusWidget } from "../../../../../packages/gsd-agent-modes/src/modes/interactive/components/gsd-status-widget.ts";
+
+export type ProgressStripUiMock = {
+  widgetCalls: Array<[string, unknown]>;
+  getProgressState: () => GsdProgressState | undefined;
+  disposeProgress: () => void;
+  ui: {
+    setWidget(key: string, factory: unknown): void;
+    setHeader(): void;
+    setStatus(key: string, value?: string): void;
+    setGsdProgress(state: GsdProgressState | undefined, dispose?: () => void): void;
+  };
+};
+
+export function createProgressStripUiMock(): ProgressStripUiMock {
+  const widgetCalls: Array<[string, unknown]> = [];
+  let progressState: GsdProgressState | undefined;
+  let progressDispose: (() => void) | undefined;
+
+  return {
+    widgetCalls,
+    getProgressState: () => progressState,
+    disposeProgress: () => progressDispose?.(),
+    ui: {
+      setWidget(key: string, factory: unknown) {
+        widgetCalls.push([key, factory]);
+      },
+      setHeader() {},
+      setStatus() {},
+      setGsdProgress(state: GsdProgressState | undefined, dispose?: () => void) {
+        progressState = state;
+        if (dispose) progressDispose = dispose;
+        widgetCalls.push(["setGsdProgress", state]);
+      },
+    },
+  };
+}
+
+export function renderProgressStripLines(
+  progress: GsdProgressState,
+  width: number,
+  options?: { activeToolCount?: number; manuallyExpanded?: boolean; cwd?: string },
+): string[] {
+  initTheme("dark", false);
+  const widget = new GsdStatusWidget(() => ({
+    override: "auto",
+    activeToolCount: options?.activeToolCount ?? 1,
+    cwd: options?.cwd ?? progress.path ?? "/tmp",
+    manuallyExpanded: options?.manuallyExpanded ?? progress.widgetMode !== "min",
+    gsdProgress: progress,
+  }));
+  return widget.render(width);
+}
+
+export function renderProgressStrip(
+  progress: GsdProgressState,
+  width: number,
+  options?: { activeToolCount?: number; manuallyExpanded?: boolean; cwd?: string },
+): string {
+  return renderProgressStripLines(progress, width, options).map((line) => stripAnsi(line)).join("\n");
+}
+
+export function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    const plain = stripAnsi(line);
+    assert.ok(
+      visibleWidth(plain) <= width,
+      `line exceeds width ${width}: "${plain}" (${visibleWidth(plain)})`,
+    );
+  }
+}

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

@@ -620,6 +620,8 @@ describe("prompt-budget: reactive-execute builder", () => {
 
       assert.match(prompt, /\[\.\.\.truncated/);
       assert.ok(prompt.length < hugeSummary.length * 2, "reactive prompt should not include full dependency summaries");
+      assert.match(prompt, /Your working directory is/);
+      assert.doesNotMatch(prompt, /Work only in the repository root/i);
     } finally {
       cleanup(base);
     }

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",
   ],
@@ -113,6 +119,7 @@ test("reactive-execute prompt keeps task summaries with subagents and avoids bat
   const prompt = readPrompt("reactive-execute");
   assert.match(prompt, /subagent-written summary as authoritative/i);
   assert.match(prompt, /Do NOT create a batch commit/i);
+  assert.match(prompt, /cwd:\s*"\{\{workingDirectory\}\}"/);
   assert.doesNotMatch(prompt, /\*\*Write task summaries\*\*/i);
   assert.doesNotMatch(prompt, /\*\*Commit\*\* all changes/i);
 });
@@ -240,6 +247,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-error-guidance.test.ts

@@ -56,6 +56,21 @@ test("unitTypeToPrefsPhaseKey maps research units", () => {
   assert.equal(unitTypeToPrefsPhaseKey("plan-slice"), "planning");
 });
 
+test("resolveProviderErrorGuidance suggests Antigravity migration for deprecated Gemini CLI", () => {
+  const guidance = resolveProviderErrorGuidance({
+    errorMsg:
+      "IneligibleTierError: This client is no longer supported for Gemini Code Assist for individuals. To continue using Gemini, please migrate to the Antigravity suite of products: https://antigravity.google.",
+    provider: "google-gemini-cli",
+    modelId: "gemini-2.5-pro",
+    unitType: "execute-task",
+  });
+
+  assert.match(guidance.summary, /Antigravity CLI/);
+  assert.ok(guidance.steps.some((step) => step.includes("antigravity.google/cli/install.sh")));
+  assert.ok(guidance.steps.some((step) => step.includes("/login")));
+  assert.ok(guidance.steps.some((step) => step.includes("/gsd next")));
+});
+
 test("resolveProviderErrorGuidance suggests gemini-3-flash for antigravity pro-high", () => {
   const guidance = resolveProviderErrorGuidance({
     errorMsg: "Cloud Code Assist API error (400): Request contains an invalid argument.",

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