gsd-pi 2.80.0 → 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-logger.test.ts

@@ -21,6 +21,11 @@ import {
   setStderrLoggingEnabled,
   _resetLogs,
 } from "../workflow-logger.ts";
+import {
+  initNotificationStore,
+  readNotifications,
+  _resetNotificationStore,
+} from "../notification-store.ts";
 
 const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 
@@ -250,6 +255,7 @@ describe("workflow-logger", () => {
 
     afterEach(() => {
       setLogBasePath("");
+      _resetNotificationStore();
       cleanup(dir);
     });
 
@@ -343,16 +349,26 @@ describe("workflow-logger", () => {
   });
 
   describe("stderr output", () => {
-    test("writes WARN prefix to stderr for warnings", (t) => {
+    test("keeps warnings out of stderr but persists them to notifications", (t) => {
+      const dir = makeTempDir("wl-notify-");
       const written: string[] = [];
       const orig = process.stderr.write.bind(process.stderr);
       // @ts-ignore — patching for test
       process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
-      t.after(() => { process.stderr.write = orig; });
+      t.after(() => {
+        process.stderr.write = orig;
+        _resetNotificationStore();
+        cleanup(dir);
+      });
 
+      initNotificationStore(dir);
       logWarning("engine", "test warn");
-      assert.equal(written.length, 1);
-      assert.ok(written[0].includes("[gsd:engine] WARN: test warn"));
+      assert.deepEqual(written, []);
+
+      const notifications = readNotifications(dir);
+      assert.equal(notifications.length, 1);
+      assert.equal(notifications[0].severity, "warning");
+      assert.equal(notifications[0].message, "[engine] test warn");
     });
 
     test("writes ERROR prefix to stderr for errors", (t) => {

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-memory-pressure.test.ts

@@ -0,0 +1,71 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode memory-pressure measurement adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+
+const mb = 1024 * 1024;
+
+test("measureMemoryPressure reports heap usage against the injected heap limit", () => {
+  const snapshot = measureMemoryPressure({
+    threshold: 0.85,
+    deps: {
+      memoryUsage: () => ({ heapUsed: 512 * mb }),
+      heapLimitBytes: () => 1024 * mb,
+    },
+  });
+
+  assert.deepEqual(snapshot, {
+    pressured: false,
+    heapMB: 512,
+    limitMB: 1024,
+    pct: 0.5,
+  });
+});
+
+test("measureMemoryPressure marks pressure only above the threshold", () => {
+  const snapshot = measureMemoryPressure({
+    threshold: 0.85,
+    deps: {
+      memoryUsage: () => ({ heapUsed: 900 * mb }),
+      heapLimitBytes: () => 1000 * mb,
+    },
+  });
+
+  assert.equal(snapshot.pressured, true);
+  assert.equal(snapshot.pct, 0.9);
+});
+
+test("measureMemoryPressure treats exact threshold as not pressured", () => {
+  const snapshot = measureMemoryPressure({
+    threshold: 0.85,
+    deps: {
+      memoryUsage: () => ({ heapUsed: 850 * mb }),
+      heapLimitBytes: () => 1000 * mb,
+    },
+  });
+
+  assert.equal(snapshot.pressured, false);
+  assert.equal(snapshot.pct, 0.85);
+});
+
+test("measureMemoryPressure falls back when heap limit cannot be read", () => {
+  const snapshot = measureMemoryPressure({
+    fallbackLimitMB: 4096,
+    deps: {
+      memoryUsage: () => ({ heapUsed: 1024 * mb }),
+      heapLimitBytes: () => {
+        throw new Error("v8 unavailable");
+      },
+    },
+  });
+
+  assert.deepEqual(snapshot, {
+    pressured: false,
+    heapMB: 1024,
+    limitMB: 4096,
+    pct: 0.25,
+  });
+});

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

@@ -0,0 +1,40 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for workflow phase-result reporting adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createWorkflowPhaseReporter } from "../auto/workflow-phase-reporter.ts";
+
+test("workflow phase reporter forwards phase results to observer", () => {
+  const phases: unknown[] = [];
+  const reporter = createWorkflowPhaseReporter({
+    observer: {
+      onTurnStart: () => {},
+      onPhaseResult: (phase, action, data) => phases.push({ phase, action, data }),
+      onTurnResult: () => {},
+    },
+  });
+
+  reporter.report("dispatch", "sidecar", {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    sidecarKind: "quick-task",
+  });
+
+  assert.deepEqual(phases, [{
+    phase: "dispatch",
+    action: "sidecar",
+    data: {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      sidecarKind: "quick-task",
+    },
+  }]);
+});
+
+test("workflow phase reporter tolerates missing observer", () => {
+  const reporter = createWorkflowPhaseReporter({});
+
+  assert.doesNotThrow(() => reporter.report("finalize", "next"));
+});

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);
+});