@opengsd/gsd-pi 1.0.2-dev.5961fbf → 1.0.2-dev.5f7864c

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -52,6 +52,103 @@ function makeRepoWithUnmergedCompletedMilestone(): string {
   return base;
 }
 
+function makeRepoWithStrandedActiveMilestone(options: { deepPlanning?: boolean } = {}): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    options.deepPlanning
+      ? "---\nplanning_depth: deep\ngit:\n  isolation: \"none\"\n---\n"
+      : "---\ngit:\n  isolation: \"none\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M001"]);
+  writeFileSync(join(base, "m001.txt"), "in-progress stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M001 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Active milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
+function makeRepoWithMultipleStrandedMilestones(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-multiple-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"none\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M001"]);
+  writeFileSync(join(base, "m001.txt"), "active stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M001 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "additional stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Active milestone", status: "active" });
+  insertMilestone({ id: "M002", title: "Pending milestone", status: "pending" });
+  closeDatabase();
+
+  return base;
+}
+
+function makeRepoWithRecoveredCleanupAndStrandedMismatch(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-headless-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"none\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["branch", "milestone/M001"]);
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "in-progress stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Completed milestone", status: "complete" });
+  insertMilestone({ id: "M002", title: "Stranded milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
 function makeCtx(notifications: Array<{ message: string; level?: string }>) {
   const model = { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 128000 };
   return {
@@ -159,3 +256,342 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("headless bootstrap checks stranded work before recovered-complete shortcut", async () => {
+  const base = makeRepoWithRecoveredCleanupAndStrandedMismatch();
+  const previousCwd = process.cwd();
+  const previousHeadless = process.env.GSD_HEADLESS;
+  const previousParallelWorker = process.env.GSD_PARALLEL_WORKER;
+  const previousMilestoneLock = process.env.GSD_MILESTONE_LOCK;
+  const s = new AutoSession();
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    process.env.GSD_HEADLESS = "1";
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M001";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, false);
+    assert.match(messages, /Stranded work for M002 blocks auto-mode/);
+    assert.doesNotMatch(messages, /all milestones complete/);
+  } finally {
+    if (previousHeadless === undefined) {
+      delete process.env.GSD_HEADLESS;
+    } else {
+      process.env.GSD_HEADLESS = previousHeadless;
+    }
+    if (previousParallelWorker === undefined) {
+      delete process.env.GSD_PARALLEL_WORKER;
+    } else {
+      process.env.GSD_PARALLEL_WORKER = previousParallelWorker;
+    }
+    if (previousMilestoneLock === undefined) {
+      delete process.env.GSD_MILESTONE_LOCK;
+    } else {
+      process.env.GSD_MILESTONE_LOCK = previousMilestoneLock;
+    }
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("bootstrap blocks active stranded recovery when another open milestone also has stranded work", async () => {
+  const base = makeRepoWithMultipleStrandedMilestones();
+  const previousCwd = process.cwd();
+  const s = new AutoSession();
+  const adoptCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          adoptStrandedMilestone: (milestoneId: string) => {
+            adoptCalls.push(milestoneId);
+            return { ok: true, mode: "branch", path: base };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, false);
+    assert.deepEqual(adoptCalls, []);
+    assert.match(messages, /Stranded work for M002 blocks auto-mode before M001/);
+  } finally {
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("bootstrap adopts stranded active branch even when isolation is none", async () => {
+  const base = makeRepoWithStrandedActiveMilestone();
+  const previousCwd = process.cwd();
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const enterCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: (milestoneId: string) => {
+            enterCalls.push(milestoneId);
+            return { ok: true, mode: "none", path: base };
+          },
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M001", mode: "branch" }]);
+    assert.deepEqual(enterCalls, []);
+    assert.equal(s.currentMilestoneId, "M001");
+    assert.equal(s.strandedRecoveryIsolationMode, "branch");
+    assert.match(
+      notifications.map((entry) => entry.message).join("\n"),
+      /Recovering stranded work for M001/,
+    );
+  } finally {
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("bootstrap adopts stranded active branch before deep project setup", async () => {
+  const base = makeRepoWithStrandedActiveMilestone({ deepPlanning: true });
+  const previousCwd = process.cwd();
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const enterCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: (milestoneId: string) => {
+            enterCalls.push(milestoneId);
+            return { ok: true, mode: "none", path: base };
+          },
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M001", mode: "branch" }]);
+    assert.deepEqual(enterCalls, []);
+    assert.equal(s.currentMilestoneId, "M001");
+    assert.equal(s.strandedRecoveryIsolationMode, "branch");
+    assert.match(
+      notifications.map((entry) => entry.message).join("\n"),
+      /Recovering stranded work for M001/,
+    );
+  } finally {
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/closeout-recovery.test.ts

@@ -9,6 +9,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
+  getCloseoutManualResolveBlocker,
   listUnresolvedCloseoutFailures,
   markLatestCloseoutFailureResolved,
   retryLatestCloseoutFailure,
@@ -99,3 +100,17 @@ test("closeout manual resolve refuses a dirty worktree", () => {
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("closeout manual resolve blocks non-git project roots without throwing", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-closeout-recovery-non-git-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    assert.equal(
+      getCloseoutManualResolveBlocker(base),
+      `Could not inspect git status in ${base}.`,
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/collect-from-manifest.test.ts

@@ -16,8 +16,34 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { visibleWidth } from "@gsd/pi-tui";
 import type { SecretsManifest, SecretsManifestEntry } from "../types.ts";
 
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function stripAnsi(text: string): string {
+	return text.replace(ANSI_PATTERN, "");
+}
+
+function assertFullOuterBorder(lines: string[], width: number): void {
+	assert.ok(lines.length >= 2, "dialog must include top and bottom borders");
+
+	for (const [index, line] of lines.entries()) {
+		assert.equal(visibleWidth(line), width, `line ${index} must fill dialog width`);
+	}
+
+	const top = stripAnsi(lines[0] ?? "");
+	const bottom = stripAnsi(lines.at(-1) ?? "");
+	assert.match(top, /^╭.*╮$/, `top border missing full corners: ${top}`);
+	assert.match(bottom, /^╰.*╯$/, `bottom border missing full corners: ${bottom}`);
+
+	for (let index = 1; index < lines.length - 1; index++) {
+		const line = stripAnsi(lines[index] ?? "");
+		assert.match(line, /^[│├]/, `line ${index} missing left border: ${line}`);
+		assert.match(line, /[│┤]$/, `line ${index} missing right border: ${line}`);
+	}
+}
+
 // Dynamic imports for files.ts functions to avoid cascading failure
 // when paths.js isn't available (files.ts statically imports paths.js)
 async function loadFilesExports(): Promise<{
@@ -300,6 +326,7 @@ test("showSecretsSummary: produces lines with correct status glyphs for each ent
 
 	assert.ok(renderFn, "render function should have been captured from factory");
 	const lines = renderFn!(80);
+	assertFullOuterBorder(lines, 80);
 
 	// Verify each key appears in the output
 	const output = lines.join("\n");
@@ -341,6 +368,7 @@ test("showSecretsSummary: existing keys shown with distinct status indicator", a
 
 	assert.ok(renderFn, "render function should have been captured");
 	const lines = renderFn!(80);
+	assertFullOuterBorder(lines, 80);
 	const output = lines.join("\n");
 
 	assert.ok(output.includes("NEW_KEY"), "should include NEW_KEY");
@@ -380,6 +408,7 @@ test("collectOneSecret: guidance lines appear in render output when guidance is
 
 	assert.ok(renderFn, "render function should have been captured");
 	const lines = renderFn!(80);
+	assertFullOuterBorder(lines, 80);
 	const output = lines.join("\n");
 
 	// Verify guidance steps appear in the output
@@ -417,6 +446,7 @@ test("collectOneSecret: guidance lines wrap long URLs instead of truncating", as
 	assert.ok(renderFn, "render function should have been captured");
 	// Render at narrow width to force wrapping
 	const lines = renderFn!(50);
+	assertFullOuterBorder(lines, 50);
 	const output = lines.join("\n");
 
 	// The full URL should be present (wrapped, not truncated)
@@ -449,6 +479,7 @@ test("collectOneSecret: no guidance provided — render output has no guidance s
 
 	assert.ok(renderFn, "render function should have been captured");
 	const lines = renderFn!(80);
+	assertFullOuterBorder(lines, 80);
 	const output = lines.join("\n");
 
 	// Should include the key name and hint but no numbered guidance steps

package/src/resources/extensions/gsd/tests/commands-context.test.ts

@@ -156,9 +156,11 @@ test("handleContext writes open reports under the command project root", async (
   process.chdir(processProject);
   try {
     const binDir = mkdtempSync(join(tmpdir(), "gsd-context-bin-"));
-    const xdgOpen = join(binDir, "xdg-open");
-    writeFileSync(xdgOpen, "#!/bin/sh\nexit 0\n");
-    chmodSync(xdgOpen, 0o755);
+    for (const opener of ["open", "xdg-open"]) {
+      const openerPath = join(binDir, opener);
+      writeFileSync(openerPath, "#!/bin/sh\nexit 0\n");
+      chmodSync(openerPath, 0o755);
+    }
     process.env.PATH = `${binDir}:${originalPath ?? ""}`;
 
     const notifications: string[] = [];

package/src/resources/extensions/gsd/tests/commands-dispatcher-workspace-git.test.ts

@@ -3,11 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getWorkspaceGitBlockMessageForBase } from "../workspace-git-guard.js";
-import { cleanup, git, makeTempRepo } from "./test-utils.ts";
+import { cleanup, git, makeTempDir, makeTempRepo } from "./test-utils.ts";
 
 function seedProductConflict(base: string): void {
   writeFileSync(join(base, "app.ts"), "root\n");
@@ -41,6 +41,19 @@ test("getWorkspaceGitBlockMessageForBase blocks auto when product conflicts rema
   }
 });
 
+test("getWorkspaceGitBlockMessageForBase does not block project setup in non-git folders", async () => {
+  const base = makeTempDir("gsd-dispatch-ws-git-new-project-");
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    assert.equal(await getWorkspaceGitBlockMessageForBase(base, ""), null);
+    assert.equal(await getWorkspaceGitBlockMessageForBase(base, "init"), null);
+    assert.equal(await getWorkspaceGitBlockMessageForBase(base, "new-project"), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("getWorkspaceGitBlockMessageForBase allows doctor on product conflicts", async () => {
   const base = makeTempRepo("gsd-dispatch-ws-git-doctor-");
   try {