gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.0aaa4fc17

package/src/resources/extensions/gsd/tests/workflow-unit-dispatch.test.ts

@@ -0,0 +1,160 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode unit dispatch contract adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { SidecarItem } from "../auto/session.ts";
+import type { IterationContext, IterationData, LoopState } from "../auto/types.ts";
+import type { UokGraphNode } from "../uok/contracts.ts";
+import {
+  runUnitPhaseViaContract,
+  type UnitDispatchScheduler,
+  type UnitPhaseResult,
+} from "../auto/workflow-unit-dispatch.ts";
+
+function makeIterData(overrides?: Partial<IterationData>): IterationData {
+  return {
+    unitType: "execute-task",
+    unitId: "M001/S001/T001",
+    prompt: "Run task",
+    finalPrompt: "Run task",
+    pauseAfterUatDispatch: false,
+    state: {} as IterationData["state"],
+    mid: "M001",
+    midTitle: "Milestone 1",
+    isRetry: false,
+    previousTier: undefined,
+    ...overrides,
+  };
+}
+
+function makeSidecarItem(kind: SidecarItem["kind"]): SidecarItem {
+  return {
+    kind,
+    unitType: `sidecar/${kind}`,
+    unitId: kind,
+    prompt: `Run ${kind}`,
+  };
+}
+
+class FakeScheduler implements UnitDispatchScheduler {
+  readonly handlers = new Map<UokGraphNode["kind"], (node: UokGraphNode) => Promise<void>>();
+  nodes: UokGraphNode[] = [];
+  options: unknown;
+  runHandler = true;
+
+  registerHandler(kind: UokGraphNode["kind"], handler: (node: UokGraphNode) => Promise<void>): void {
+    this.handlers.set(kind, handler);
+  }
+
+  async run(nodes: UokGraphNode[], options: { parallel: false; maxWorkers: 1 }): Promise<void> {
+    this.nodes = nodes;
+    this.options = options;
+    if (this.runHandler) {
+      await this.handlers.get(nodes[0]!.kind)?.(nodes[0]!);
+    }
+  }
+}
+
+test("runUnitPhaseViaContract calls legacy runner directly", async () => {
+  const result: UnitPhaseResult = { action: "next", data: { unitStartedAt: 1 } };
+  const calls: unknown[] = [];
+  const sidecarItem = makeSidecarItem("hook");
+
+  const outcome = await runUnitPhaseViaContract(
+    "legacy-direct",
+    { iteration: 3 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    sidecarItem,
+    {
+      runUnitPhase: async (...args) => {
+        calls.push(args);
+        return result;
+      },
+      createScheduler: () => assert.fail("createScheduler should not be called"),
+    },
+  );
+
+  assert.equal(outcome, result);
+  assert.equal(calls.length, 1);
+  assert.equal((calls[0] as unknown[])[3], sidecarItem);
+});
+
+test("runUnitPhaseViaContract dispatches through scheduler in uok mode", async () => {
+  const scheduler = new FakeScheduler();
+  const result: UnitPhaseResult = { action: "next", data: { requestDispatchedAt: 2 } };
+
+  const outcome = await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 4 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    undefined,
+    {
+      runUnitPhase: async () => result,
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.equal(outcome, result);
+  assert.deepEqual(Array.from(scheduler.handlers.keys()), [
+    "unit",
+    "hook",
+    "subagent",
+    "team-worker",
+    "verification",
+    "reprocess",
+  ]);
+  assert.deepEqual(scheduler.nodes, [{
+    id: "dispatch:4:execute-task:M001/S001/T001",
+    kind: "unit",
+    dependsOn: [],
+    metadata: {
+      unitType: "execute-task",
+      unitId: "M001/S001/T001",
+    },
+  }]);
+  assert.deepEqual(scheduler.options, { parallel: false, maxWorkers: 1 });
+});
+
+test("runUnitPhaseViaContract maps sidecar kind to scheduler node kind", async () => {
+  const scheduler = new FakeScheduler();
+
+  await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 1 } as IterationContext,
+    makeIterData({ unitType: "sidecar/triage", unitId: "triage-1" }),
+    {} as LoopState,
+    makeSidecarItem("triage"),
+    {
+      runUnitPhase: async () => ({ action: "next", data: {} }),
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.equal(scheduler.nodes[0]?.kind, "verification");
+});
+
+test("runUnitPhaseViaContract breaks when scheduler never runs a handler", async () => {
+  const scheduler = new FakeScheduler();
+  scheduler.runHandler = false;
+
+  const outcome = await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 1 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    undefined,
+    {
+      runUnitPhase: async () => assert.fail("runUnitPhase should not be called"),
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.deepEqual(outcome, {
+    action: "break",
+    reason: "scheduler-dispatch-missing-result",
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-worker-heartbeat.test.ts

@@ -0,0 +1,123 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode worker heartbeat adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  maintainWorkerHeartbeat,
+  type MaintainWorkerHeartbeatDeps,
+  type WorkerHeartbeatSession,
+} from "../auto/workflow-worker-heartbeat.ts";
+
+function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
+  deps: MaintainWorkerHeartbeatDeps;
+  calls: unknown[];
+  errors: unknown[];
+} {
+  const calls: unknown[] = [];
+  const errors: unknown[] = [];
+  const deps: MaintainWorkerHeartbeatDeps = {
+    heartbeatAutoWorker: workerId => calls.push(["heartbeat", workerId]),
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      return true;
+    },
+    logHeartbeatFailure: err => errors.push(err),
+    ...overrides,
+  };
+  return { deps, calls, errors };
+}
+
+test("maintainWorkerHeartbeat no-ops without a worker id", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({}, deps);
+
+  assert.deepEqual(calls, []);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat refreshes worker heartbeat without active lease", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({ workerId: "worker-1" }, deps);
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat refreshes active milestone lease when token exists", () => {
+  const { deps, calls, errors } = makeDeps();
+  const session: WorkerHeartbeatSession = {
+    workerId: "worker-1",
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: 7,
+  };
+
+  maintainWorkerHeartbeat(session, deps);
+
+  assert.deepEqual(calls, [
+    ["heartbeat", "worker-1"],
+    ["refresh", "worker-1", "M001", 7],
+  ]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat skips lease refresh when token is null", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({
+    workerId: "worker-1",
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: null,
+  }, deps);
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat logs and suppresses heartbeat failures", () => {
+  const failure = new Error("db unavailable");
+  const { deps, calls, errors } = makeDeps({
+    heartbeatAutoWorker: workerId => {
+      calls.push(["heartbeat", workerId]);
+      throw failure;
+    },
+  });
+
+  assert.doesNotThrow(() => {
+    maintainWorkerHeartbeat({
+      workerId: "worker-1",
+      currentMilestoneId: "M001",
+      milestoneLeaseToken: 7,
+    }, deps);
+  });
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, [failure]);
+});
+
+test("maintainWorkerHeartbeat logs and suppresses lease refresh failures", () => {
+  const failure = new Error("lease stale");
+  const { deps, calls, errors } = makeDeps({
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      throw failure;
+    },
+  });
+
+  assert.doesNotThrow(() => {
+    maintainWorkerHeartbeat({
+      workerId: "worker-1",
+      currentMilestoneId: "M001",
+      milestoneLeaseToken: 7,
+    }, deps);
+  });
+
+  assert.deepEqual(calls, [
+    ["heartbeat", "worker-1"],
+    ["refresh", "worker-1", "M001", 7],
+  ]);
+  assert.deepEqual(errors, [failure]);
+});

package/src/resources/extensions/gsd/tests/working-output-messages.test.ts

@@ -0,0 +1,93 @@
+// GSD-2 + src/resources/extensions/gsd/tests/working-output-messages.test.ts - Regression coverage for user-facing working-state message quality.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  evaluateWorkingOutputMessage,
+  evaluateWorkingOutputMessages,
+  formatAutoUnitWorkingMessage,
+} from "../working-output-messages.ts";
+
+test("auto unit loader messages name the active work", () => {
+  assert.equal(
+    formatAutoUnitWorkingMessage("research-milestone", "M001"),
+    "Researching M001: waiting for provider response",
+  );
+  assert.equal(
+    evaluateWorkingOutputMessage({
+      surface: "loader",
+      message: formatAutoUnitWorkingMessage("research-milestone", "M001"),
+      context: { unitType: "research-milestone", unitId: "M001", health: "waiting" },
+    }).length,
+    0,
+  );
+});
+
+test("generic working messages are flagged", () => {
+  const findings = evaluateWorkingOutputMessage({
+    surface: "loader",
+    message: "Working...",
+    context: { health: "waiting" },
+  });
+
+  assert.deepEqual(findings.map(f => f.code), ["generic-working-message"]);
+});
+
+test("dashboard messages cannot claim healthy progress while recovering", () => {
+  const findings = evaluateWorkingOutputMessage({
+    surface: "dashboard",
+    message: "GSD AUTO Progressing well",
+    context: { health: "recovering", recoveryAttempts: 1 },
+  });
+
+  assert.deepEqual(findings.map(f => f.code), ["misleading-healthy-message"]);
+});
+
+test("pre-roadmap zero-slice counters are flagged", () => {
+  const findings = evaluateWorkingOutputMessage({
+    surface: "dashboard",
+    message: "0/0 slices",
+    context: { health: "waiting" },
+  });
+
+  assert.deepEqual(findings.map(f => f.code), ["fake-zero-progress"]);
+});
+
+test("stalled/provider-error/timeout messages need an action", () => {
+  const noAction = evaluateWorkingOutputMessage({
+    surface: "notification",
+    message: "Provider stalled after 2m",
+    context: { health: "stalled" },
+  });
+  assert.deepEqual(noAction.map(f => f.code), ["missing-action"]);
+
+  const withAction = evaluateWorkingOutputMessage({
+    surface: "notification",
+    message: "Provider stalled after 2m. Type /gsd stop or wait for retry.",
+    context: { health: "stalled" },
+  });
+  assert.equal(withAction.length, 0);
+});
+
+test("current fixed research working surfaces pass the audit", () => {
+  const findings = evaluateWorkingOutputMessages([
+    {
+      surface: "loader",
+      message: "Researching M001: waiting for provider response",
+      context: { unitType: "research-milestone", unitId: "M001", health: "waiting" },
+    },
+    {
+      surface: "dashboard",
+      message: "Recovering\nretry 1 after idle stall",
+      context: { unitType: "research-milestone", unitId: "M001", health: "recovering", recoveryAttempts: 1 },
+    },
+    {
+      surface: "notification",
+      message: "Auto-mode stopped - User requested stop.",
+      context: { health: "stopped" },
+    },
+  ]);
+
+  assert.equal(findings.length, 0);
+});

package/src/resources/extensions/gsd/tests/worktree-health-dispatch.test.ts

@@ -9,12 +9,12 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readdirSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { PROJECT_FILES } from "../detection.js";
+import { PROJECT_FILES, classifyProject } from "../detection.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -30,6 +30,14 @@ function createGitRepo(): string {
   return dir;
 }
 
+function createEmptyGitRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-empty-"));
+  execSync("git init", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: dir, stdio: "ignore" });
+  return dir;
+}
+
 /**
  * Simulate the health check logic from auto/phases.ts.
  *
@@ -64,8 +72,6 @@ function hasXcodeBundle(basePath: string): boolean {
   } catch { return false; }
 }
 
-import { existsSync } from "node:fs";
-
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 test("PROJECT_FILES is exported and contains expected multi-ecosystem entries", () => {
@@ -80,6 +86,21 @@ test("PROJECT_FILES is exported and contains expected multi-ecosystem entries",
   assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
 });
 
+test("runUnitPhase fails closed when classification returns invalid-repo", () => {
+  const source = readFileSync(join(process.cwd(), "src/resources/extensions/gsd/auto/phases.ts"), "utf-8");
+  const invalidRepoBranch = source.slice(
+    source.indexOf('projectClassification.kind === "invalid-repo"'),
+    source.indexOf('projectClassification.kind === "greenfield"'),
+  );
+
+  assert.match(invalidRepoBranch, /projectClassification\.reason === "missing \.git" && hasGit/);
+  assert.match(invalidRepoBranch, /project classification could not confirm \.git/);
+  assert.match(invalidRepoBranch, /ctx\.ui\.notify\(msg,\s*"error"\)/);
+  assert.match(invalidRepoBranch, /await deps\.stopAuto\(ctx,\s*pi,\s*msg\)/);
+  assert.match(invalidRepoBranch, /return \{ action: "break", reason: "worktree-invalid" \}/);
+  assert.match(invalidRepoBranch, /classified as invalid-repo/);
+});
+
 describe("health check with git repo", () => {
   let dir: string;
   beforeEach(() => { dir = createGitRepo(); });
@@ -132,8 +153,18 @@ describe("health check with git repo", () => {
   });
 
   test("health check passes for empty git repo (greenfield project)", () => {
-    assert.ok(wouldPassHealthCheck(dir, existsSync), "empty git repo should pass health check (greenfield)");
-    assert.ok(!hasRecognizedProjectFiles(dir, existsSync), "empty git repo has no recognized project files");
+    const empty = createEmptyGitRepo();
+    try {
+      assert.ok(wouldPassHealthCheck(empty, existsSync), "empty git repo should pass health check (greenfield)");
+      assert.equal(classifyProject(empty).kind, "greenfield");
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
+  });
+
+  test("health check classifies README-only repo as untyped existing, not greenfield", () => {
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "README-only repo should pass health check");
+    assert.equal(classifyProject(dir).kind, "untyped-existing");
   });
 });
 

package/src/resources/extensions/gsd/tests/worktree-manager.test.ts

@@ -235,4 +235,11 @@ describe("removeWorktree — missing worktree", () => {
       "should not throw when worktree does not exist",
     );
   });
+
+  test("deleteBranch is quiet when the branch is already gone", () => {
+    assert.doesNotThrow(
+      () => removeWorktree(base, "nonexistent", { deleteBranch: true }),
+      "missing branch should be treated as already cleaned up",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/worktree-nested-git-safety.test.ts

@@ -56,11 +56,11 @@ test("#2616: findNestedGitDirs ignores .git files (worktree pointers)", (t) => {
   );
 });
 
-test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, target)", (t) => {
+test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, .bg-shell, target)", (t) => {
   const root = makeRoot(t);
 
   // All three of these contain a .git *directory*, but the scan must skip them.
-  for (const excluded of ["node_modules", ".gsd", "target"]) {
+  for (const excluded of ["node_modules", ".gsd", ".bg-shell", "target"]) {
     const inside = join(root, excluded, "vendored-pkg");
     mkdirSync(join(inside, ".git"), { recursive: true });
   }
@@ -73,6 +73,13 @@ test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, t
   );
 });
 
+test("#2616: findNestedGitDirs ignores normal missing child .git probes", (t) => {
+  const root = makeRoot(t);
+  mkdirSync(join(root, "plain-dir"), { recursive: true });
+
+  assert.deepEqual(findNestedGitDirs(root), []);
+});
+
 test("#2616: findNestedGitDirs finds deeply nested repos", (t) => {
   const root = makeRoot(t);
   const deep = join(root, "a", "b", "c", "scaffolded");

package/src/resources/extensions/gsd/tests/worktree-submodule-safety.test.ts

@@ -17,8 +17,8 @@
  *
  * This rewrite builds a real git parent repo + local submodule, creates
  * a worktree, dirties a tracked file inside the submodule, then invokes
- * `removeWorktree` and asserts observable behaviour on stderr (where
- * `logWarning` writes) and on the filesystem (the worktree is gone).
+ * `removeWorktree` and asserts observable behaviour through the workflow log
+ * buffer and on the filesystem (the worktree is gone).
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -35,6 +35,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { createWorktree, removeWorktree } from "../worktree-manager.ts";
+import { _resetLogs, peekLogs } from "../workflow-logger.ts";
 
 interface Harness {
   parent: string;
@@ -112,53 +113,38 @@ function makeHarness(): Harness {
   };
 }
 
-/** Capture stderr writes during `fn`. `logWarning` writes to stderr, so
- * this reveals warnings emitted by the worktree-manager. */
-function captureStderr(fn: () => void): string {
-  const streamAny = process.stderr as unknown as {
-    write: (chunk: string | Uint8Array, ...rest: unknown[]) => boolean;
-  };
-  const original = streamAny.write.bind(streamAny);
-  const chunks: string[] = [];
-  streamAny.write = (chunk: string | Uint8Array): boolean => {
-    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
-    return true;
-  };
-  try {
-    fn();
-  } finally {
-    streamAny.write = original;
-  }
-  return chunks.join("");
+function workflowLogMessages(): string {
+  return peekLogs().map((entry) => entry.message).join("\n");
 }
 
 describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
   let h: Harness;
 
   beforeEach(() => {
+    _resetLogs();
     h = makeHarness();
   });
 
   afterEach(() => {
     h.cleanup();
+    _resetLogs();
   });
 
   test("clean submodules: worktree removes without stashing or submodule warnings", () => {
     const wt = createWorktree(h.parent, "cleanwt");
     runGit(wt.path, ["submodule", "update", "--init", "--recursive"]);
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "cleanwt");
-    });
+    removeWorktree(h.parent, "cleanwt");
+    const logs = workflowLogMessages();
 
     assert.ok(!existsSync(wt.path), "worktree directory should be gone");
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch/,
       "clean submodule must not trigger rescue-branch creation",
     );
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Submodule rescue branch creation failed/,
       "clean submodule must not trigger rescue-branch failure warning",
     );
@@ -191,9 +177,8 @@ describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
       `precondition: submodule must be diverged, got: "${subStatus}"`,
     );
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "dirtywt");
-    });
+    removeWorktree(h.parent, "dirtywt");
+    const logs = workflowLogMessages();
 
     // Worktree is gone: force fallback succeeded.
     assert.ok(!existsSync(wt.path), "worktree directory should be removed");
@@ -205,7 +190,7 @@ describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
     // removal. This is the assertion that #4823 demanded in place of
     // the tautological `src.includes("submodule") && src.includes("force")`.
     assert.match(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch|Submodule rescue branch creation failed|Submodule changes detected/,
       "dirty submodule must trigger detection-and-warning path",
     );
@@ -231,12 +216,11 @@ describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
       renameSync(modPath, hiddenPath);
     }
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "no-gitmodules");
-    });
+    removeWorktree(h.parent, "no-gitmodules");
+    const logs = workflowLogMessages();
 
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch/,
       "missing .gitmodules should skip submodule detection entirely",
     );