@opengsd/gsd-pi 1.0.2-dev.235ebf3 → 1.0.2-dev.29398d2

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/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 {

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -344,6 +344,70 @@ describe("Custom engine loop integration", () => {
     );
   });
 
+  it("step mode stops after one custom workflow step", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a" }),
+      makeStep({ id: "step-b", dependsOn: ["step-a"] }),
+      makeStep({ id: "step-c", dependsOn: ["step-b"] }),
+    ], "step-mode-custom");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "step-mode-custom");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+      stepMode: true,
+    });
+
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+    });
+
+    const loopPromise = autoLoop(ctx, pi, s, deps);
+    await resolveNextAgentEnd();
+
+    let timeout: NodeJS.Timeout | undefined;
+    try {
+      await Promise.race([
+        loopPromise,
+        new Promise((_, reject) =>
+          timeout = setTimeout(() => {
+            s.active = false;
+            if (_hasPendingResolveForTest()) {
+              resolveAgentEnd({ messages: [{ role: "assistant" }] });
+            }
+            reject(new Error(
+              `step mode did not stop after one custom workflow step; calls=${pi.calls.length}; log=${deps.callLog.join(",")}`,
+            ));
+          }, 1_000),
+        ),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+
+    const finalGraph = readGraph(runDir);
+    assert.equal(pi.calls.length, 1, "step mode should dispatch exactly one custom step");
+    assert.equal(finalGraph.steps[0]?.status, "complete", "first step should complete");
+    assert.equal(finalGraph.steps[1]?.status, "pending", "second step should wait for the next /gsd next");
+    assert.equal(finalGraph.steps[2]?.status, "pending", "third step should wait for a later step");
+    assert.equal(
+      deps.callLog.some((e: string) => e.startsWith("stopAuto:")),
+      false,
+      "step-mode pause should not complete or stop the whole workflow",
+    );
+    assert.equal(s.preserveStepSurfaceAfterLoopExit, true);
+  });
+
   it("stops when engine reports isComplete on first derive", async () => {
     _resetPendingResolve();