gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -11,7 +11,9 @@ import {
   _getAdapter,
   insertGateRow,
   upsertRequirement,
+  getAllMilestones,
 } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
 import { markApprovalGateVerified, markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot, setPendingGate } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
@@ -389,6 +391,38 @@ test("executeCompleteMilestone sanitizes raw params and writes milestone summary
   }
 });
 
+test("executeCompleteMilestone returns success for already-complete milestones without overwriting the existing summary", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M003", "Milestone Three", "complete");
+    seedSlice("M003", "S03", "complete");
+    writeRoadmap(base, "M003", ["S03"]);
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    mkdirSync(milestoneDir, { recursive: true });
+    const summaryPath = join(milestoneDir, "M003-SUMMARY.md");
+    writeFileSync(summaryPath, "# Existing Summary\n");
+
+    const result = await inProjectDir(base, () => executeCompleteMilestone({
+      milestoneId: "M003",
+      title: "Milestone Three",
+      oneLiner: "Completed milestone",
+      narrative: "Everything shipped.",
+      verificationPassed: true,
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    assert.equal(result.details.operation, "complete_milestone");
+    assert.equal(result.details.alreadyComplete, true);
+    assert.match(result.content[0].text, /already complete/);
+    assert.doesNotMatch(result.content[0].text, /Summary written to/);
+    assert.equal(readFileSync(summaryPath, "utf-8"), "# Existing Summary\n");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeReassessRoadmap writes assessment and updates roadmap projection", async () => {
   const base = makeTmpBase();
   try {
@@ -690,7 +724,18 @@ test("executeSummarySave supports root-level deep planning artifacts", async ()
 
     const project = await inProjectDir(base, () => executeSummarySave({
       artifact_type: "PROJECT",
-      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+      content: [
+        "# Project",
+        "",
+        "## What This Is",
+        "",
+        "A root project artifact.",
+        "",
+        "## Milestone Sequence",
+        "",
+        "- [ ] M001: Foundation - Establish the first runnable slice.",
+        "",
+      ].join("\n"),
     }, base));
     assert.equal(project.isError, undefined);
     assert.equal(project.details.path, "PROJECT.md");
@@ -737,6 +782,109 @@ test("executeSummarySave supports root-level deep planning artifacts", async ()
   }
 });
 
+test("executeSummarySave registers PROJECT milestone sequence for the next run", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: [
+        "# Project",
+        "",
+        "## What This Is",
+        "",
+        "Deep project setup output.",
+        "",
+        "## Project Shape",
+        "",
+        "**Complexity:** complex",
+        "**Why:** It spans multiple delivery steps.",
+        "",
+        "## Capability Contract",
+        "",
+        "See .gsd/REQUIREMENTS.md.",
+        "",
+        "## Milestone Sequence",
+        "",
+        "- [ ] M001: Foundation - Establish the first runnable slice.",
+        "- [ ] M002: Polish - Follow-up experience work.",
+        "",
+      ].join("\n"),
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    assert.deepEqual(result.details.registeredMilestones, ["M001", "M002"]);
+
+    const milestones = getAllMilestones();
+    assert.deepEqual(
+      milestones.map((m) => [m.id, m.title, m.status]),
+      [
+        ["M001", "Foundation", "queued"],
+        ["M002", "Polish", "queued"],
+      ],
+    );
+
+    invalidateStateCache();
+    const state = await deriveState(base);
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(state.phase, "pre-planning");
+    assert.equal(state.registry[0]?.status, "active");
+    assert.equal(state.registry[1]?.status, "pending");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave hard-fails when milestone registration throws so silent No-Active-Milestone is impossible", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    const db = _getAdapter();
+    assert.ok(db, "DB should be open");
+    const originalPrepare = db.prepare.bind(db);
+    (db as any).prepare = (sql: string) => {
+      if (sql.includes("INSERT OR IGNORE INTO milestones")) {
+        throw new Error("simulated milestone registration failure");
+      }
+      return originalPrepare(sql);
+    };
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: [
+        "# Project",
+        "",
+        "## What This Is",
+        "",
+        "Deep project setup output.",
+        "",
+        "## Milestone Sequence",
+        "",
+        "- [ ] M001: Foundation - Establish the first runnable slice.",
+        "",
+      ].join("\n"),
+    }, base));
+
+    // The artifact is persisted before registration runs, but registration must
+    // surface as isError so the LLM retries (INSERT OR IGNORE makes it idempotent)
+    // instead of announcing "ready" while the DB has zero milestone rows.
+    assert.equal(result.isError, true);
+    assert.equal(result.details.path, "PROJECT.md");
+    assert.equal(result.details.error, "milestone_registration_threw");
+    assert.match(String(result.details.registration_error), /simulated milestone registration failure/);
+    assert.match(result.content[0].text, /milestone registration failed/);
+    assert.match(result.content[0].text, /idempotent/);
+    assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
+    const artifact = originalPrepare("SELECT path FROM artifacts WHERE path = ?").get("PROJECT.md");
+    assert.equal(artifact?.path, "PROJECT.md");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSummarySave blocks final root artifacts while approval gate is pending", async () => {
   const base = makeTmpBase();
   try {
@@ -772,9 +920,22 @@ test("executeSummarySave requires verified root approval in deep mode", async ()
     writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: deep\n---\n");
     openTestDb(base);
 
+    const projectFixture = [
+      "# Project",
+      "",
+      "## What This Is",
+      "",
+      "A root project artifact.",
+      "",
+      "## Milestone Sequence",
+      "",
+      "- [ ] M001: Foundation - Establish the first runnable slice.",
+      "",
+    ].join("\n");
+
     const blocked = await inProjectDir(base, () => executeSummarySave({
       artifact_type: "PROJECT",
-      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+      content: projectFixture,
     }, base));
 
     assert.equal(blocked.isError, true);
@@ -786,7 +947,7 @@ test("executeSummarySave requires verified root approval in deep mode", async ()
 
     const unblocked = await inProjectDir(base, () => executeSummarySave({
       artifact_type: "PROJECT",
-      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+      content: projectFixture,
     }, base));
 
     assert.equal(unblocked.isError, undefined);

package/src/resources/extensions/gsd/tests/workflow-turn-reporter.test.ts

@@ -0,0 +1,87 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for workflow turn observer reporting adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createWorkflowTurnReporter } from "../auto/workflow-turn-reporter.ts";
+
+test("workflow turn reporter emits start and finish contracts", () => {
+  const starts: unknown[] = [];
+  const results: unknown[] = [];
+  let clearCount = 0;
+  const reporter = createWorkflowTurnReporter({
+    observer: {
+      onTurnStart: contract => starts.push(contract),
+      onPhaseResult: () => {},
+      onTurnResult: result => results.push(result),
+    },
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    basePath: "/repo",
+    startedAt: "2026-05-04T00:00:00.000Z",
+    clearCurrentTurn: () => {
+      clearCount += 1;
+    },
+    now: () => "2026-05-04T00:00:01.000Z",
+  });
+
+  reporter.start();
+  reporter.finish({
+    status: "stopped",
+    failureClass: "manual-attention",
+    error: "blocked",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+  });
+
+  assert.deepEqual(starts, [{
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    basePath: "/repo",
+    startedAt: "2026-05-04T00:00:00.000Z",
+  }]);
+  assert.deepEqual(results, [{
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    status: "stopped",
+    failureClass: "manual-attention",
+    phaseResults: [],
+    error: "blocked",
+    startedAt: "2026-05-04T00:00:00.000Z",
+    finishedAt: "2026-05-04T00:00:01.000Z",
+  }]);
+  assert.equal(clearCount, 1);
+});
+
+test("workflow turn reporter finishes only once", () => {
+  const results: unknown[] = [];
+  let clearCount = 0;
+  const reporter = createWorkflowTurnReporter({
+    observer: {
+      onTurnStart: () => {},
+      onPhaseResult: () => {},
+      onTurnResult: result => results.push(result),
+    },
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    basePath: "/repo",
+    startedAt: "start",
+    clearCurrentTurn: () => {
+      clearCount += 1;
+    },
+    now: () => "done",
+  });
+
+  reporter.finish({ status: "retry" });
+  reporter.finish({ status: "completed" });
+
+  assert.equal(results.length, 1);
+  assert.equal(clearCount, 1);
+});

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-path-injection.test.ts

@@ -229,6 +229,9 @@ test("worktree-aware prompt builders include the explicit working directory", as
     ),
   ]);
 
+  assert.ok(prompts[0].includes("## Context Mode"), "discuss-milestone should include standalone Context Mode guidance");
+  assert.ok(prompts[0].includes("interview lane"), "discuss-milestone should render the interview lane");
+
   for (const prompt of prompts) {
     assert.match(prompt, /working directory/i);
     assert.ok(prompt.includes(base), "prompt should include the provided working directory");