gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -1,131 +1,58 @@
-// GSD Extension — workflow-logger wiring regression tests
-//
-// Verifies the plumbing between workflow-logger and the rest of the state
-// system (auto-loop phases, detect-stuck, notification store). Without this
-// wiring, warnings/errors logged during a unit leak across units, never
-// reach the user as a consolidated post-unit alert, and don't enrich
-// stuck-detection reasons.
+// GSD-2 — workflow-logger behavior regression tests.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
 import {
-  logWarning,
+  drainAndSummarize,
+  formatForNotification,
+  hasAnyIssues,
   logError,
+  logWarning,
   peekLogs,
   _resetLogs,
   setStderrLoggingEnabled,
 } from "../workflow-logger.ts";
 import { detectStuck } from "../auto/detect-stuck.ts";
 
-const phasesSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto", "phases.ts"),
-  "utf-8",
-);
-const autoSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto.ts"),
-  "utf-8",
-);
+test("drainAndSummarize summarizes and clears the workflow log buffer", () => {
+  const previous = setStderrLoggingEnabled(false);
+  try {
+    _resetLogs();
+    logWarning("projection", "STATE.md render failed", { file: "STATE.md" });
+    logError("db", "WAL checkpoint failed");
 
-// ─── Source-scan: phases.ts calls the logger lifecycle API ─────────────────
+    assert.equal(hasAnyIssues(), true);
+    const drained = drainAndSummarize();
 
-test("auto/phases.ts imports _resetLogs, drainAndSummarize, formatForNotification, hasAnyIssues", () => {
-  assert.match(
-    phasesSrc,
-    /from\s+"\.\.\/workflow-logger\.js"/,
-    "phases.ts imports from workflow-logger",
-  );
-  for (const name of [
-    "_resetLogs",
-    "drainLogs",
-    "drainAndSummarize",
-    "formatForNotification",
-    "hasAnyIssues",
-  ]) {
-    assert.ok(
-      phasesSrc.includes(name),
-      `phases.ts should reference ${name}`,
-    );
+    assert.equal(drained.logs.length, 2);
+    assert.match(drained.summary ?? "", /STATE\.md render failed/);
+    assert.match(drained.summary ?? "", /WAL checkpoint failed/);
+    assert.equal(peekLogs().length, 0);
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
   }
 });
 
-test("runUnitPhase calls _resetLogs() before assigning s.currentUnit", () => {
-  // Find the "s.currentUnit = { type: unitType" assignment line and check
-  // the preceding ~500 chars contain a _resetLogs() call.
-  const idx = phasesSrc.indexOf("s.currentUnit = { type: unitType");
-  assert.ok(idx > 0, "runUnitPhase should assign s.currentUnit");
-  const before = phasesSrc.slice(Math.max(0, idx - 500), idx);
-  assert.match(
-    before,
-    /_resetLogs\(\)/,
-    "_resetLogs() must be called immediately before s.currentUnit assignment",
-  );
-});
-
-test("runFinalize drains and surfaces logger buffer via ctx.ui.notify", () => {
-  // Locate the runFinalize success path and verify it calls drainAndSummarize
-  // and routes the result through ctx.ui.notify.
-  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
-  assert.ok(runFinalizeIdx > 0, "runFinalize export should exist");
-  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  assert.match(
-    finalizeBody,
-    /hasAnyIssues\(\)/,
-    "runFinalize should gate drain on hasAnyIssues",
-  );
-  assert.match(
-    finalizeBody,
-    /drainAndSummarize\(\)/,
-    "runFinalize should call drainAndSummarize on success",
-  );
-  assert.match(
-    finalizeBody,
-    /formatForNotification\(logs\)/,
-    "runFinalize should format drained logs for the notification",
-  );
-});
-
-test("runFinalize timeout branches drain the buffer to prevent bleed", () => {
-  // Both timeout branches route through failClosedOnFinalizeTimeout; that
-  // helper must drain the buffer so timed-out unit logs do not bleed into
-  // the next unit.
-  const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
-  const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  const timeoutHelperCalls =
-    (finalizeBody.match(/failClosedOnFinalizeTimeout\(/g) ?? []).length;
-  assert.ok(
-    timeoutHelperCalls >= 2,
-    `runFinalize timeout branches should each route through failClosedOnFinalizeTimeout() (found ${timeoutHelperCalls}, expected >= 2)`,
-  );
-
-  const helperMatch = phasesSrc.match(
-    /async function failClosedOnFinalizeTimeout[\s\S]*?drainLogs\(\)/,
-  );
-  assert.ok(
-    helperMatch,
-    "failClosedOnFinalizeTimeout should drain the logger buffer before returning",
-  );
-});
-
-// ─── Source-scan: auto.ts calls setLogBasePath in startAuto ────────────────
-
-test("startAuto calls setLogBasePath(base) so audit log is pinned on resume", () => {
-  const startAutoIdx = autoSrc.indexOf("export async function startAuto");
-  assert.ok(startAutoIdx > 0, "startAuto export should exist");
-  const body = autoSrc.slice(startAutoIdx);
-  assert.match(
-    body,
-    /setLogBasePath\(base\)/,
-    "startAuto must call setLogBasePath(base) to pin the audit log",
-  );
+test("formatForNotification includes component and useful context", () => {
+  const text = formatForNotification([
+    {
+      ts: "2026-01-01T00:00:00.000Z",
+      severity: "warn",
+      component: "projection",
+      message: "render failed",
+      context: { file: "STATE.md", command: "derive" },
+    },
+  ]);
+
+  assert.match(text, /\[projection\] render failed/);
+  assert.match(text, /file: STATE\.md/);
+  assert.match(text, /command: derive/);
 });
 
-// ─── Runtime: detect-stuck enriches reason with summarizeLogs() ────────────
-
 test("detectStuck reason includes workflow-logger summary when logs present", () => {
-  setStderrLoggingEnabled(false);
+  const previous = setStderrLoggingEnabled(false);
   try {
     _resetLogs();
     logWarning("projection", "STATE.md render failed");
@@ -138,37 +65,18 @@ test("detectStuck reason includes workflow-logger summary when logs present", ()
 
     assert.notEqual(result, null);
     assert.equal(result!.stuck, true);
-    assert.match(
-      result!.reason,
-      /Same error repeated:/,
-      "reason should still start with the rule string",
-    );
-    assert.match(
-      result!.reason,
-      /STATE\.md render failed/,
-      "reason should include the accumulated logger warning",
-    );
-    assert.match(
-      result!.reason,
-      /WAL checkpoint failed/,
-      "reason should include the accumulated logger error",
-    );
-
-    // Critical: summarizeLogs must not drain — the auto-loop's finalize
-    // step owns the buffer lifecycle, detect-stuck is read-only.
-    assert.equal(
-      peekLogs().length,
-      2,
-      "detect-stuck must not drain the buffer",
-    );
+    assert.match(result!.reason, /Same error repeated:/);
+    assert.match(result!.reason, /STATE\.md render failed/);
+    assert.match(result!.reason, /WAL checkpoint failed/);
+    assert.equal(peekLogs().length, 2, "detect-stuck must not drain the buffer");
   } finally {
     _resetLogs();
-    setStderrLoggingEnabled(true);
+    setStderrLoggingEnabled(previous);
   }
 });
 
 test("detectStuck reason unchanged when logger buffer is empty", () => {
-  setStderrLoggingEnabled(false);
+  const previous = setStderrLoggingEnabled(false);
   try {
     _resetLogs();
     const result = detectStuck([
@@ -176,62 +84,9 @@ test("detectStuck reason unchanged when logger buffer is empty", () => {
       { key: "A", error: "boom" },
     ]);
     assert.notEqual(result, null);
-    // No trailing " — " suffix when there are no logs to summarize.
-    assert.doesNotMatch(
-      result!.reason,
-      / — \d+ (error|warning)/,
-      "reason should have no logger suffix when buffer is empty",
-    );
+    assert.doesNotMatch(result!.reason, / — \d+ (error|warning)/);
   } finally {
-    setStderrLoggingEnabled(true);
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
   }
 });
-
-// ─── Runtime: readTransaction rollback failure surfaces via logError ────────
-//
-// snapshotState now delegates its transaction to readTransaction() in
-// gsd-db.ts (single-writer refactor in #4198), so the split-brain
-// ROLLBACK-failure log lives there, not in workflow-manifest.ts.
-
-test("readTransaction logs ROLLBACK failures as split-brain signal", () => {
-  const dbSrc = readFileSync(
-    join(import.meta.dirname, "..", "gsd-db.ts"),
-    "utf-8",
-  );
-  assert.match(
-    dbSrc,
-    /logError\("db",\s*"snapshotState ROLLBACK failed"/,
-    "readTransaction ROLLBACK catch should call logError",
-  );
-});
-
-// ─── Runtime: startup/projection diagnostics stay explicit ─────────────────
-
-test("auto-start initializes the DB without implicit markdown migration", () => {
-  const autoStartSrc = readFileSync(
-    join(import.meta.dirname, "..", "auto-start.ts"),
-    "utf-8",
-  );
-  assert.doesNotMatch(
-    autoStartSrc,
-    /migrateFromMarkdown|md-importer/,
-    "auto-start must not import markdown into the runtime DB implicitly",
-  );
-  assert.match(
-    autoStartSrc,
-    /failed to initialize project database/,
-    "DB initialization failures should still be logged",
-  );
-});
-
-test("workflow-projections.ts logs DB probe failures instead of silent return", () => {
-  const projectionsSrc = readFileSync(
-    join(import.meta.dirname, "..", "workflow-projections.ts"),
-    "utf-8",
-  );
-  assert.match(
-    projectionsSrc,
-    /logWarning\("projection",\s*"renderStateProjection: DB handle probe failed/,
-    "renderStateProjection DB probe should log on failure",
-  );
-});

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

@@ -1,9 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -18,29 +17,11 @@ import {
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
-
 type ElicitPayload = {
   message: string;
   requestedSchema: { properties: Record<string, unknown>; required?: string[] };
 };
 
-function readSrc(file: string): string {
-  return readFileSync(join(gsdDir, file), "utf-8");
-}
-
-function listTsFiles(dir: string): string[] {
-  const out: string[] = [];
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    const stat = statSync(full);
-    if (stat.isDirectory()) out.push(...listTsFiles(full));
-    else if (entry.endsWith(".ts")) out.push(full);
-  }
-  return out;
-}
-
 function extractElicitPayload(request: unknown): ElicitPayload {
   const payload = (request as { params?: unknown }).params ?? request;
   return payload as ElicitPayload;
@@ -54,6 +35,12 @@ test("auto execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_task_complete"]);
 });
 
+test("complete-slice requires closeout and execution handoff tools", () => {
+  const expected = ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("complete-slice"), expected);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("complete-slice"), expected);
+});
+
 test("deep project setup units declare required workflow MCP tools", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-project"), [
     "ask_user_questions",
@@ -759,39 +746,3 @@ test("transport compatibility still blocks units whose MCP tools are not exposed
   assert.match(error ?? "", /requires secure_env_collect/);
   assert.match(error ?? "", /currently exposes only/);
 });
-
-test("guided-flow source enforces workflow compatibility preflight", () => {
-  const src = readSrc("guided-flow.ts");
-  assert.match(src, /getRequiredWorkflowToolsForGuidedUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-});
-
-test("auto direct dispatch source enforces workflow compatibility preflight", () => {
-  const src = readSrc("auto-direct-dispatch.ts");
-  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-});
-
-test("auto phases source enforces workflow compatibility preflight", () => {
-  const src = readSrc(join("auto", "phases.ts"));
-  assert.match(src, /getRequiredWorkflowToolsForAutoUnit/);
-  assert.match(src, /getWorkflowTransportSupportError/);
-  assert.match(src, /workflow-capability/);
-});
-
-test("workflow transport error guidance includes /gsd mcp init hint", () => {
-  const src = readSrc("workflow-mcp.ts");
-  assert.match(src, /Please run \/gsd mcp init \./);
-});
-
-test("buildWorkflowMcpServers is only imported by tests or Claude Code MCP boundary code", () => {
-  const offenders: string[] = [];
-  for (const file of listTsFiles(gsdDir)) {
-    const rel = file.slice(gsdDir.length + 1).replace(/\\/g, "/");
-    if (rel === "workflow-mcp.ts" || rel.startsWith("tests/")) continue;
-    const src = readFileSync(file, "utf-8");
-    if (/\bimport\b[\s\S]*\bbuildWorkflowMcpServers\b/.test(src)) offenders.push(rel);
-  }
-
-  assert.deepEqual(offenders, []);
-});

package/src/resources/extensions/gsd/tests/workflow-protocol-excerpt.test.ts

@@ -0,0 +1,99 @@
+// Project/App: GSD-2
+// File Purpose: Tests for capped GSD workflow protocol and doctor-heal payload helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildDoctorHealIssuePayload,
+  buildDoctorHealSummary,
+  buildWorkflowDispatchContent,
+  buildWorkflowProtocolExcerpt,
+} from "../workflow-protocol.ts";
+
+test("workflow protocol helper emits capped excerpt plus source path", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1200 });
+
+  assert.match(excerpt, /Source: `\/tmp\/GSD-WORKFLOW\.md`/);
+  assert.match(excerpt, /\[Workflow Protocol Truncated\]/);
+  assert.ok(excerpt.length < workflow.length);
+  assert.ok(excerpt.length < 1600);
+});
+
+test("workflow dispatch uses excerpt instead of full workflow body", () => {
+  const workflow = `# Protocol\n${"FULL_WORKFLOW_BODY ".repeat(500)}`;
+  const content = buildWorkflowDispatchContent({
+    workflow,
+    workflowPath: "/tmp/GSD-WORKFLOW.md",
+    task: "Run the selected unit.",
+    maxProtocolChars: 1200,
+  });
+
+  assert.match(content, /## GSD Workflow Protocol Excerpt/);
+  assert.match(content, /## Your Task/);
+  assert.match(content, /Run the selected unit/);
+  assert.ok(content.length < workflow.length);
+});
+
+test("workflow protocol excerpt includes late verification and advance rules", () => {
+  const workflow = [
+    "# GSD Workflow",
+    "intro",
+    "## Quick Start",
+    "quick",
+    "## File Format Reference",
+    "format ".repeat(400),
+    "## The Phases",
+    "phase overview",
+    "### Phase 4: Execute",
+    "execute rules",
+    "### Phase 5: Verify",
+    "verification rules",
+    "### Phase 7: Advance",
+    "advance rules",
+  ].join("\n");
+
+  const excerpt = buildWorkflowProtocolExcerpt(workflow, "/tmp/GSD-WORKFLOW.md", { maxChars: 1300 });
+
+  assert.match(excerpt, /Quick Start/);
+  assert.match(excerpt, /Phase 5: Verify/);
+  assert.match(excerpt, /Phase 7: Advance/);
+  assert.doesNotMatch(excerpt, /format format format format format/);
+});
+
+test("doctor heal summary omits duplicated full report body", () => {
+  const report = [
+    "# GSD doctor heal prep.",
+    "Scope: M001",
+    "Status: warning",
+    "Warnings: 9",
+    "",
+    "VERY_LONG_FULL_REPORT_BODY ".repeat(300),
+  ].join("\n");
+
+  const summary = buildDoctorHealSummary(report, { maxChars: 900 });
+
+  assert.match(summary, /GSD doctor heal prep/);
+  assert.match(summary, /Warnings: 9/);
+  assert.ok(summary.length <= 900);
+  assert.doesNotMatch(summary, /VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY VERY_LONG_FULL_REPORT_BODY/);
+});
+
+test("doctor heal issue payload keeps top actionable issues and caps detail", () => {
+  const issues = Array.from({ length: 20 }, (_, index) =>
+    `### Issue ${index + 1}\n${`detail ${index + 1} `.repeat(80)}`,
+  ).join("\n");
+
+  const payload = buildDoctorHealIssuePayload(issues, {
+    maxIssues: 3,
+    maxIssueChars: 180,
+    maxChars: 900,
+  });
+
+  assert.match(payload, /Issue 1/);
+  assert.match(payload, /Issue 3/);
+  assert.doesNotMatch(payload, /Issue 4/);
+  assert.match(payload, /17 additional actionable issue/);
+  assert.ok(payload.length <= 900);
+});

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

@@ -165,6 +165,9 @@ test("executeMilestoneStatus returns milestone metadata and slice counts", async
     assert.equal(parsed.sliceCount, 1);
     assert.equal(parsed.slices[0].id, "S01");
     assert.equal(parsed.slices[0].taskCounts.pending, 1);
+    assert.equal(result.details.status, "active");
+    assert.equal(result.details.title, "Milestone One");
+    assert.deepEqual(result.details.slices, parsed.slices);
   } finally {
     closeDatabase();
     cleanup(base);

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

@@ -14,9 +14,11 @@ function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
   deps: MaintainWorkerHeartbeatDeps;
   calls: unknown[];
   errors: unknown[];
+  misses: unknown[];
 } {
   const calls: unknown[] = [];
   const errors: unknown[] = [];
+  const misses: unknown[] = [];
   const deps: MaintainWorkerHeartbeatDeps = {
     heartbeatAutoWorker: workerId => calls.push(["heartbeat", workerId]),
     refreshMilestoneLease: (workerId, milestoneId, token) => {
@@ -24,9 +26,10 @@ function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
       return true;
     },
     logHeartbeatFailure: err => errors.push(err),
+    logLeaseRefreshMiss: details => misses.push(details),
     ...overrides,
   };
-  return { deps, calls, errors };
+  return { deps, calls, errors, misses };
 }
 
 test("maintainWorkerHeartbeat no-ops without a worker id", () => {
@@ -121,3 +124,31 @@ test("maintainWorkerHeartbeat logs and suppresses lease refresh failures", () =>
   ]);
   assert.deepEqual(errors, [failure]);
 });
+
+test("maintainWorkerHeartbeat clears stale lease tokens when refresh misses", () => {
+  const { deps, calls, errors, misses } = makeDeps({
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      return false;
+    },
+  });
+  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, []);
+  assert.deepEqual(misses, [{
+    workerId: "worker-1",
+    milestoneId: "M001",
+    fencingToken: 7,
+  }]);
+  assert.equal(session.milestoneLeaseToken, null);
+});