gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

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-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",
     );

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

@@ -0,0 +1,179 @@
+// GSD-2 worktree-isolation write gate (#5199).
+//
+// Regression coverage for shouldBlockWorktreeWrite — the helper that prevents
+// the LLM from authoring code at the project root when `git.isolation: worktree`
+// is configured but auto-mode (and its post-unit commit pipeline) hasn't run.
+// Without this gate, writes silently orphan outside git history.
+//
+// Test setup creates a fresh temp project for each isolation case, writes a
+// `.gsd/PREFERENCES.md` with `isolation: "worktree"`, and exercises the helper
+// against the 9 scenarios listed in the issue. No source-grep tests — every
+// assertion exercises the real predicate.
+
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { shouldBlockWorktreeWrite } from "../bootstrap/write-gate.js";
+import { invalidateAllCaches } from "../cache.js";
+
+function makeProject(isolation: "none" | "worktree" | "branch" | null): string {
+  const root = mkdtempSync(join(tmpdir(), "wt-write-gate-"));
+  if (isolation !== null) {
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(root, ".gsd", "PREFERENCES.md"),
+      `---\ngit:\n  isolation: "${isolation}"\n---\n`,
+    );
+  }
+  invalidateAllCaches();
+  return root;
+}
+
+const PLANNING_WRITE_TOOLS = ["write", "edit", "multi_edit", "notebook_edit"];
+
+describe("shouldBlockWorktreeWrite (#5199)", () => {
+  let projectRoot: string;
+  let prevDisableEnv: string | undefined;
+
+  beforeEach(() => {
+    prevDisableEnv = process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+    delete process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+  });
+
+  afterEach(() => {
+    if (projectRoot) {
+      try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* best-effort */ }
+    }
+    if (prevDisableEnv === undefined) {
+      delete process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+    } else {
+      process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD = prevDisableEnv;
+    }
+    invalidateAllCaches();
+  });
+
+  test("Case 1: every PLANNING_WRITE_TOOLS variant writing to <root>/app.js is blocked", () => {
+    projectRoot = makeProject("worktree");
+    for (const tool of PLANNING_WRITE_TOOLS) {
+      const result = shouldBlockWorktreeWrite(
+        tool,
+        join(projectRoot, "app.js"),
+        projectRoot,
+        /* isAutoLive */ false,
+        /* unitType */ null,
+      );
+      assert.equal(result.block, true, `tool ${tool} should be blocked`);
+      assert.match(result.reason ?? "", /HARD BLOCK/);
+    }
+  });
+
+  test("Case 2: write to <root>/.gsd/PROJECT.md is allowed", () => {
+    projectRoot = makeProject("worktree");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, ".gsd", "PROJECT.md"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 3: write inside <root>/.gsd/worktrees/M001/ is allowed", () => {
+    projectRoot = makeProject("worktree");
+    const target = join(projectRoot, ".gsd", "worktrees", "M001", "src", "app.js");
+    const result = shouldBlockWorktreeWrite("edit", target, projectRoot, false, null);
+    assert.equal(result.block, false);
+  });
+
+  test("Case 4: write to <root>/.gsd/worktrees-extra/M001/app.js (prefix trick) is blocked", () => {
+    projectRoot = makeProject("worktree");
+    const target = join(projectRoot, ".gsd", "worktrees-extra", "M001", "app.js");
+    const result = shouldBlockWorktreeWrite("write", target, projectRoot, false, null);
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /HARD BLOCK/);
+  });
+
+  test("Case 5: isolation=none → allow", () => {
+    projectRoot = makeProject("none");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 6: isolation=worktree, auto active, effectiveBasePath inside worktree → allow", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd", "worktrees", "M001");
+    mkdirSync(inside, { recursive: true });
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(inside, "src", "app.js"),
+      inside,
+      /* isAutoLive */ true,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 7: isolation=worktree, auto active, effectiveBasePath is project root (cwd never flipped) → block", () => {
+    projectRoot = makeProject("worktree");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      /* isAutoLive */ true,
+      null,
+    );
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /HARD BLOCK/);
+  });
+
+  test("Case 8: bootstrap unit type active → allow", () => {
+    projectRoot = makeProject("worktree");
+    for (const unitType of ["discuss-milestone", "plan-milestone", "init"]) {
+      const result = shouldBlockWorktreeWrite(
+        "write",
+        join(projectRoot, "app.js"),
+        projectRoot,
+        false,
+        unitType,
+      );
+      assert.equal(result.block, false, `unit ${unitType} should bypass the guard`);
+    }
+  });
+
+  test("Case 9: GSD_DISABLE_WORKTREE_WRITE_GUARD=1 → allow", () => {
+    projectRoot = makeProject("worktree");
+    process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD = "1";
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("non-planning tools (read/grep/bash) pass through unconditionally", () => {
+    projectRoot = makeProject("worktree");
+    for (const tool of ["read", "grep", "bash", "ls"]) {
+      const result = shouldBlockWorktreeWrite(
+        tool,
+        join(projectRoot, "app.js"),
+        projectRoot,
+        false,
+        null,
+      );
+      assert.equal(result.block, false, `tool ${tool} must not be gated`);
+    }
+  });
+});