gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

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-session-lock.test.ts

@@ -0,0 +1,135 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode session-lock validation adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { SessionLockStatus } from "../session-lock.ts";
+import {
+  validateWorkflowSessionLock,
+  type WorkflowSessionLockDeps,
+} from "../auto/workflow-session-lock.ts";
+
+function makeDeps(overrides?: Partial<WorkflowSessionLockDeps>): {
+  deps: WorkflowSessionLockDeps;
+  calls: string[];
+  invalidDetails: unknown[];
+  exitDetails: unknown[];
+  handledStatuses: SessionLockStatus[];
+} {
+  const calls: string[] = [];
+  const invalidDetails: unknown[] = [];
+  const exitDetails: unknown[] = [];
+  const handledStatuses: SessionLockStatus[] = [];
+  const deps: WorkflowSessionLockDeps = {
+    lockBase: () => "/tmp/gsd-lock",
+    validateSessionLock: () => ({ valid: true }),
+    handleLostSessionLock: status => {
+      calls.push("handleLostSessionLock");
+      handledStatuses.push(status);
+    },
+    logInvalidSessionLock: details => {
+      calls.push("logInvalidSessionLock");
+      invalidDetails.push(details);
+    },
+    logSessionLockExit: details => {
+      calls.push("logSessionLockExit");
+      exitDetails.push(details);
+    },
+    ...overrides,
+  };
+  return { deps, calls, invalidDetails, exitDetails, handledStatuses };
+}
+
+test("validateWorkflowSessionLock skips validation when no lock base exists", () => {
+  const { deps, calls } = makeDeps({
+    lockBase: () => "",
+    validateSessionLock: () => assert.fail("validateSessionLock should not be called"),
+  });
+
+  const outcome = validateWorkflowSessionLock({
+    active: true,
+    iteration: 1,
+    maxIterations: 10,
+    deps,
+  });
+
+  assert.deepEqual(outcome, { action: "continue" });
+  assert.deepEqual(calls, []);
+});
+
+test("validateWorkflowSessionLock continues when the current lock is valid", () => {
+  const { deps, calls } = makeDeps({
+    validateSessionLock: () => ({ valid: true }),
+  });
+
+  const outcome = validateWorkflowSessionLock({
+    active: true,
+    iteration: 1,
+    maxIterations: 10,
+    deps,
+  });
+
+  assert.deepEqual(outcome, { action: "continue" });
+  assert.deepEqual(calls, []);
+});
+
+test("validateWorkflowSessionLock handles lost lock with structured details", () => {
+  const status: SessionLockStatus = {
+    valid: false,
+    failureReason: "compromised",
+    existingPid: 123,
+    expectedPid: 456,
+  };
+  const { deps, calls, invalidDetails, exitDetails, handledStatuses } = makeDeps({
+    validateSessionLock: () => status,
+  });
+
+  const outcome = validateWorkflowSessionLock({
+    active: true,
+    iteration: 1,
+    maxIterations: 10,
+    deps,
+  });
+
+  assert.deepEqual(outcome, { action: "stop", reason: "session-lock-lost" });
+  assert.deepEqual(calls, [
+    "logInvalidSessionLock",
+    "handleLostSessionLock",
+    "logSessionLockExit",
+  ]);
+  assert.deepEqual(invalidDetails, [{
+    reason: "compromised",
+    existingPid: 123,
+    expectedPid: 456,
+  }]);
+  assert.deepEqual(handledStatuses, [status]);
+  assert.deepEqual(exitDetails, [{
+    reason: "session-lock-lost",
+    detail: "compromised",
+  }]);
+});
+
+test("validateWorkflowSessionLock uses unknown detail for invalid lock without reason", () => {
+  const { deps, invalidDetails, exitDetails } = makeDeps({
+    validateSessionLock: () => ({ valid: false }),
+  });
+
+  const outcome = validateWorkflowSessionLock({
+    active: true,
+    iteration: 1,
+    maxIterations: 10,
+    deps,
+  });
+
+  assert.deepEqual(outcome, { action: "stop", reason: "session-lock-lost" });
+  assert.deepEqual(invalidDetails, [{
+    reason: "unknown",
+    existingPid: undefined,
+    expectedPid: undefined,
+  }]);
+  assert.deepEqual(exitDetails, [{
+    reason: "session-lock-lost",
+    detail: "unknown",
+  }]);
+});

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

@@ -0,0 +1,110 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode sidecar iteration-data adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { GSDState } from "../types.ts";
+import type { SidecarItem } from "../auto/session.ts";
+import { buildSidecarIterationData } from "../auto/workflow-sidecar-iteration.ts";
+
+function makeSidecarItem(overrides?: Partial<SidecarItem>): SidecarItem {
+  return {
+    kind: "hook",
+    unitType: "sidecar/hook",
+    unitId: "hook-1",
+    prompt: "Run hook",
+    ...overrides,
+  };
+}
+
+test("buildSidecarIterationData derives state from canonical project root", async () => {
+  const roots: string[] = [];
+  const state = {
+    phase: "executing",
+    activeMilestone: { id: "M001", title: "Milestone 1" },
+    activeSlice: { id: "S01" },
+    activeTask: { id: "T01" },
+  } as GSDState;
+
+  await buildSidecarIterationData({
+    sidecarItem: makeSidecarItem(),
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    deriveState: async root => {
+      roots.push(root);
+      return state;
+    },
+    logPostDerive: () => {},
+  });
+
+  assert.deepEqual(roots, ["/project"]);
+});
+
+test("buildSidecarIterationData maps sidecar item and milestone state into iteration data", async () => {
+  const state = {
+    phase: "executing",
+    activeMilestone: { id: "M001", title: "Milestone 1" },
+  } as GSDState;
+
+  const iterData = await buildSidecarIterationData({
+    sidecarItem: makeSidecarItem({
+      unitType: "sidecar/quick-task",
+      unitId: "capture-1",
+      prompt: "Do captured task",
+    }),
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    deriveState: async () => state,
+    logPostDerive: () => {},
+  });
+
+  assert.equal(iterData.unitType, "sidecar/quick-task");
+  assert.equal(iterData.unitId, "capture-1");
+  assert.equal(iterData.prompt, "Do captured task");
+  assert.equal(iterData.finalPrompt, "Do captured task");
+  assert.equal(iterData.pauseAfterUatDispatch, false);
+  assert.equal(iterData.state, state);
+  assert.equal(iterData.mid, "M001");
+  assert.equal(iterData.midTitle, "Milestone 1");
+  assert.equal(iterData.isRetry, false);
+  assert.equal(iterData.previousTier, undefined);
+});
+
+test("buildSidecarIterationData logs task, slice, or milestone active unit", async () => {
+  const logs: unknown[] = [];
+
+  await buildSidecarIterationData({
+    sidecarItem: makeSidecarItem(),
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    deriveState: async () => ({
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Milestone 1" },
+      activeSlice: { id: "S01" },
+      activeTask: { id: "T01" },
+    }) as GSDState,
+    logPostDerive: details => logs.push(details),
+  });
+
+  assert.deepEqual(logs, [{
+    site: "sidecar",
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    derivedPhase: "planning",
+    activeUnit: "T01",
+  }]);
+});
+
+test("buildSidecarIterationData handles missing active milestone", async () => {
+  const iterData = await buildSidecarIterationData({
+    sidecarItem: makeSidecarItem(),
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    deriveState: async () => ({ phase: "blocked" }) as GSDState,
+    logPostDerive: () => {},
+  });
+
+  assert.equal(iterData.mid, undefined);
+  assert.equal(iterData.midTitle, undefined);
+});

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

@@ -0,0 +1,116 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode sidecar queue scheduling and dequeue adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { SidecarItem } from "../auto/session.ts";
+import {
+  dequeueSidecarItem,
+  type SidecarDequeuePayload,
+} from "../auto/workflow-sidecar-queue.ts";
+
+function makeSidecarItem(kind: SidecarItem["kind"], unitId: string): SidecarItem {
+  return {
+    kind,
+    unitType: `sidecar/${kind}`,
+    unitId,
+    prompt: `Run ${unitId}`,
+  };
+}
+
+test("dequeueSidecarItem returns undefined for an empty queue", async () => {
+  const queue: SidecarItem[] = [];
+
+  const item = await dequeueSidecarItem({
+    queue,
+    executionGraphEnabled: true,
+    scheduleQueue: async () => assert.fail("scheduleQueue should not be called"),
+    warnSchedulingFailure: () => assert.fail("warnSchedulingFailure should not be called"),
+    logDequeue: () => assert.fail("logDequeue should not be called"),
+    emitDequeue: () => assert.fail("emitDequeue should not be called"),
+  });
+
+  assert.equal(item, undefined);
+  assert.deepEqual(queue, []);
+});
+
+test("dequeueSidecarItem schedules multi-item queues when execution graph is enabled", async () => {
+  const first = makeSidecarItem("hook", "first");
+  const second = makeSidecarItem("triage", "second");
+  const queue = [first, second];
+  const payloads: SidecarDequeuePayload[] = [];
+
+  const item = await dequeueSidecarItem({
+    queue,
+    executionGraphEnabled: true,
+    scheduleQueue: async scheduled => [scheduled[1]!, scheduled[0]!],
+    warnSchedulingFailure: () => assert.fail("warnSchedulingFailure should not be called"),
+    logDequeue: payload => payloads.push(payload),
+    emitDequeue: payload => payloads.push(payload),
+  });
+
+  assert.equal(item, second);
+  assert.deepEqual(queue, [first]);
+  assert.deepEqual(payloads, [
+    { kind: "triage", unitType: "sidecar/triage", unitId: "second" },
+    { kind: "triage", unitType: "sidecar/triage", unitId: "second" },
+  ]);
+});
+
+test("dequeueSidecarItem skips scheduling for single-item queues", async () => {
+  const first = makeSidecarItem("quick-task", "only");
+  const queue = [first];
+
+  const item = await dequeueSidecarItem({
+    queue,
+    executionGraphEnabled: true,
+    scheduleQueue: async () => assert.fail("scheduleQueue should not be called"),
+    warnSchedulingFailure: () => assert.fail("warnSchedulingFailure should not be called"),
+    logDequeue: () => {},
+    emitDequeue: () => {},
+  });
+
+  assert.equal(item, first);
+  assert.deepEqual(queue, []);
+});
+
+test("dequeueSidecarItem warns and preserves queue order when scheduling fails", async () => {
+  const first = makeSidecarItem("hook", "first");
+  const second = makeSidecarItem("triage", "second");
+  const queue = [first, second];
+  const warnings: string[] = [];
+
+  const item = await dequeueSidecarItem({
+    queue,
+    executionGraphEnabled: true,
+    scheduleQueue: async () => {
+      throw new Error("scheduler unavailable");
+    },
+    warnSchedulingFailure: message => warnings.push(message),
+    logDequeue: () => {},
+    emitDequeue: () => {},
+  });
+
+  assert.equal(item, first);
+  assert.deepEqual(queue, [second]);
+  assert.deepEqual(warnings, ["scheduler unavailable"]);
+});
+
+test("dequeueSidecarItem skips scheduling when execution graph is disabled", async () => {
+  const first = makeSidecarItem("hook", "first");
+  const second = makeSidecarItem("triage", "second");
+  const queue = [first, second];
+
+  const item = await dequeueSidecarItem({
+    queue,
+    executionGraphEnabled: false,
+    scheduleQueue: async () => assert.fail("scheduleQueue should not be called"),
+    warnSchedulingFailure: () => assert.fail("warnSchedulingFailure should not be called"),
+    logDequeue: () => {},
+    emitDequeue: () => {},
+  });
+
+  assert.equal(item, first);
+  assert.deepEqual(queue, [second]);
+});

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for workflow template registry loading, matching, and display.
+//
 // GSD Workflow Templates — Unit Tests
 //
 // Tests registry loading, template resolution, auto-detection, and listing.
@@ -8,6 +11,7 @@ import {
   loadRegistry,
   resolveByName,
   autoDetect,
+  isLegacyWorkflowMode,
   listTemplates,
   getTemplateInfo,
   loadWorkflowTemplate,
@@ -48,6 +52,20 @@ console.log('\n── Registry Loading ──');
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Workflow Mode Classification
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Workflow Mode Classification ──');
+
+{
+  assert.equal(isLegacyWorkflowMode(undefined), true, 'missing mode defaults to markdown-phase legacy engine');
+  assert.equal(isLegacyWorkflowMode('markdown-phase'), true, 'markdown-phase is legacy engine telemetry');
+  assert.equal(isLegacyWorkflowMode('yaml-step'), true, 'yaml-step is legacy engine telemetry');
+  assert.equal(isLegacyWorkflowMode('oneshot'), true, 'oneshot is legacy engine telemetry');
+  assert.equal(isLegacyWorkflowMode('auto-milestone'), false, 'auto-milestone is the DB-backed milestone path');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Resolve by Name
 // ═══════════════════════════════════════════════════════════════════════════
@@ -134,6 +152,9 @@ console.log('\n── List Templates ──');
   assert.ok(output.includes('spike'), 'Should list spike');
   assert.ok(output.includes('hotfix'), 'Should list hotfix');
   assert.ok(output.includes('/gsd start'), 'Should include usage hint');
+  assert.ok(output.includes('Recommended Task Paths'), 'Should include process path guidance');
+  assert.ok(output.includes('large-feature'), 'Should include large feature process path');
+  assert.ok(output.includes('/gsd discuss'), 'Should route large features to milestone flow');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -391,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 {

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