gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.c5f2443b3

package/src/resources/extensions/gsd/tests/pr-evidence.test.ts

@@ -0,0 +1,79 @@
+// Project/App: GSD-2
+// File Purpose: Tests for the shared GSD pull request evidence generator.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildPrEvidence, type PrChangeType } from "../pr-evidence.ts";
+
+test("pr-evidence: generated body includes contribution-required sections", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Authentication",
+    linkedIssue: "Closes #123",
+    summaries: ["### S01\nImplemented login."],
+    roadmapItems: ["- [x] **S01: Login**"],
+    metrics: ["**Units executed:** 3"],
+    testsRun: ["npm test"],
+    rollbackNotes: ["Revert the merge commit."],
+  });
+
+  assert.equal(evidence.title, "feat: Authentication");
+  for (const section of [
+    "## TL;DR",
+    "## What",
+    "## Why",
+    "## How",
+    "## Linked Issue",
+    "## Tests Run",
+    "## Change Type",
+    "## Rollback And Compatibility",
+    "## AI Assistance Disclosure",
+  ]) {
+    assert.ok(evidence.body.includes(section), `missing section: ${section}`);
+  }
+  assert.ok(evidence.body.includes("Closes #123"));
+  assert.ok(evidence.body.includes("npm test"));
+  assert.ok(evidence.body.includes("This PR was prepared with AI assistance."));
+});
+
+test("pr-evidence: every change type selects exactly one checklist row", () => {
+  const changeTypes: PrChangeType[] = ["feat", "fix", "refactor", "test", "docs", "chore"];
+
+  for (const changeType of changeTypes) {
+    const evidence = buildPrEvidence({ milestoneId: "M001", changeType });
+    const checkedRows = evidence.body.split("\n").filter((line) => line.startsWith("- [x] `"));
+    assert.deepEqual(checkedRows, [
+      `- [x] \`${changeType}\` - ${{
+        feat: "New feature or capability",
+        fix: "Bug fix",
+        refactor: "Code restructuring",
+        test: "Adding or updating tests",
+        docs: "Documentation only",
+        chore: "Build, CI, or tooling changes",
+      }[changeType]}`,
+    ]);
+  }
+});
+
+test("pr-evidence: missing issue, tests, and rollback data are explicit", () => {
+  const evidence = buildPrEvidence({ milestoneId: "M001", aiAssisted: false });
+
+  assert.ok(evidence.body.includes("Not specified. Add an issue link"));
+  assert.ok(evidence.body.includes("Not specified. Add exact verification commands"));
+  assert.ok(evidence.body.includes("No behavior-changing rollback notes recorded."));
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+});
+
+test("pr-evidence: subject metadata supports non-milestone PRs", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    subjectId: "S01",
+    subjectKind: "slice",
+    milestoneTitle: "Auth Slice",
+  });
+
+  assert.equal(evidence.title, "feat: Auth Slice");
+  assert.ok(evidence.body.includes("Ship slice S01 - Auth Slice"));
+  assert.ok(evidence.body.includes("Slice work is complete and ready for review."));
+});

package/src/resources/extensions/gsd/tests/process-task-path.test.ts

@@ -0,0 +1,51 @@
+// Project/App: GSD-2
+// File Purpose: Tests for canonical process recommendations by task size.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatRecommendedProcessPaths,
+  listRecommendedProcessPaths,
+  recommendProcessPath,
+  type ProcessTaskSize,
+} from "../process-task-path.ts";
+
+test("process task paths cover every Phase 7 task size with one command", () => {
+  const expected: ProcessTaskSize[] = [
+    "hotfix",
+    "bugfix",
+    "small-feature",
+    "large-feature",
+    "architecture-change",
+  ];
+
+  const paths = listRecommendedProcessPaths();
+  assert.deepEqual(paths.map((path) => path.taskSize), expected);
+
+  for (const taskSize of expected) {
+    const path = recommendProcessPath(taskSize);
+    assert.equal(path.taskSize, taskSize);
+    assert.ok(path.templateId.length > 0);
+    assert.match(path.command, /^\/gsd /);
+    assert.ok(path.phases.length > 0);
+    assert.ok(path.guidance.length > 0);
+  }
+});
+
+test("process task paths route large work to the DB-backed milestone flow", () => {
+  const largeFeature = recommendProcessPath("large-feature");
+  assert.equal(largeFeature.templateId, "full-project");
+  assert.match(largeFeature.command, /\/gsd discuss/);
+  assert.match(largeFeature.command, /\/gsd auto/);
+  assert.match(largeFeature.guidance, /DB-backed milestone flow/);
+});
+
+test("formatted process paths are stable for command help", () => {
+  const formatted = formatRecommendedProcessPaths();
+  assert.match(formatted, /hotfix\s+\/gsd start hotfix/);
+  assert.match(formatted, /bugfix\s+\/gsd start bugfix/);
+  assert.match(formatted, /small-feature\s+\/gsd start small-feature/);
+  assert.match(formatted, /large-feature\s+\/gsd discuss/);
+  assert.match(formatted, /architecture-change\s+\/gsd start refactor/);
+});

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -2,7 +2,7 @@
  * Regression test for #3696 — prompt step ordering and runtime fixes
  *
  * 1. complete-milestone.md: gsd_requirement_update (step 9) before
- *    gsd_complete_milestone (step 10)
+ *    gsd_complete_milestone, and completion remains the final durable write
  * 2. complete-slice.md: uses gsd_requirement_update
  * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
  * 4. register-hooks.ts: session_before_compact only checks isAutoActive
@@ -50,6 +50,21 @@ describe('prompt step ordering (#3696)', () => {
     );
   });
 
+  test('project and learnings writes appear before gsd_complete_milestone', () => {
+    const projectMatch = completeMilestoneMd.match(/^\d+\.\s.*PROJECT\.md/m);
+    const learningsMatch = completeMilestoneMd.match(/^\d+\.\s.*Extract structured learnings/m);
+    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
+    assert.ok(projectMatch, 'PROJECT.md update should appear in a numbered step');
+    assert.ok(learningsMatch, 'learnings extraction should appear in a numbered step');
+    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
+
+    const projectIdx = completeMilestoneMd.indexOf(projectMatch![0]);
+    const learningsIdx = completeMilestoneMd.indexOf(learningsMatch![0]);
+    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
+    assert.ok(projectIdx < completeMilestoneIdx, 'PROJECT.md update must happen before gsd_complete_milestone');
+    assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
+  });
+
   test('complete-slice.md uses gsd_requirement_update', () => {
     assert.match(completeSliceMd, /gsd_requirement_update/,
       'complete-slice.md should reference gsd_requirement_update');

package/src/resources/extensions/gsd/tests/queue-prompt-rendering.test.ts

@@ -0,0 +1,37 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the queue prompt renders compact discussion and write-gate guidance.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("queue prompt renders compact draft, verification, and persistence guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-queue-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("queue", {
+    preamble: "Queue preamble.",
+    existingMilestonesContext: "No existing milestones.",
+    commitInstruction: "Commit queued milestone artifacts.",
+    inlinedTemplates: "## Context Template\n\nUse standard GSD context.",
+  });
+
+  assert.match(prompt, /Draft Awareness/);
+  assert.match(prompt, /What do you want to add\?/);
+  assert.match(prompt, /Investigate between question rounds/);
+  assert.match(prompt, /Pre-Write Verification/);
+  assert.match(prompt, /depth_verification/);
+  assert.match(prompt, /gsd_milestone_generate_id/);
+  assert.match(prompt, /gsd_summary_save/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

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

@@ -1,12 +1,10 @@
-// tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
-//
-// Each DB tool must register under its canonical gsd_concept_action name
-// AND under a backward-compatible alias name.
-// The alias must share the exact same execute function reference as the canonical tool.
+// Project/App: GSD-2
+// File Purpose: Verifies canonical and alias DB tool registration plus legacy alias telemetry.
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
+import { getLegacyTelemetry, resetLegacyTelemetry } from '../legacy-telemetry.ts';
 
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
@@ -66,9 +64,9 @@ for (const { canonical, alias } of RENAME_MAP) {
   assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
 }
 
-// ─── Execute function identity ───────────────────────────────────────────────
+// ─── Execute function wrapping ───────────────────────────────────────────────
 
-console.log('\n── Tool naming: execute function identity (===) ──');
+console.log('\n── Tool naming: alias execute wrapper ──');
 
 for (const { canonical, alias } of RENAME_MAP) {
   const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
@@ -76,12 +74,37 @@ for (const { canonical, alias } of RENAME_MAP) {
 
   if (canonicalTool && aliasTool) {
     assert.ok(
-      canonicalTool.execute === aliasTool.execute,
-      `"${canonical}" and "${alias}" should share the same execute function reference`,
+      canonicalTool.execute !== aliasTool.execute,
+      `"${alias}" should wrap "${canonical}" so alias usage can be counted`,
     );
   }
 }
 
+test("alias execute increments legacy MCP alias telemetry before delegating", async () => {
+  const canonicalTool = pi.tools.find((t: any) => t.name === "gsd_decision_save");
+  const aliasTool = pi.tools.find((t: any) => t.name === "gsd_save_decision");
+  assert.ok(canonicalTool);
+  assert.ok(aliasTool);
+
+  const originalCanonicalExecute = canonicalTool.execute;
+  try {
+    resetLegacyTelemetry();
+    let delegated = false;
+    canonicalTool.execute = async () => {
+      delegated = true;
+      return { content: [{ type: "text", text: "ok" }], details: { ok: true } };
+    };
+
+    await aliasTool.execute("call-1", {}, undefined, undefined, undefined);
+
+    assert.equal(delegated, true);
+    assert.equal(getLegacyTelemetry()["legacy.mcpAliasUsed"], 1);
+  } finally {
+    canonicalTool.execute = originalCanonicalExecute;
+    resetLegacyTelemetry();
+  }
+});
+
 // ─── Alias descriptions include "(alias for ...)" ───────────────────────────
 
 console.log('\n── Tool naming: alias descriptions ──');

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -1,6 +1,5 @@
-// GSD-2 — #4782 phase 2 composer tests. Pure-function tests using mock
-// resolvers plus an integration check that reassess-roadmap's migrated
-// builder produces a prompt matching expectations.
+// Project/App: GSD-2
+// File Purpose: Tests unit context composer rendering, budgets, and reassess-roadmap prompt integration.
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -122,9 +121,9 @@ test("Context Mode composer: standalone output starts with heading and includes
   assert.ok(out.startsWith("## Context Mode"));
   assert.match(out, /execution lane/i);
   assert.match(out, /`gsd_exec`/);
-  assert.match(out, /noisy scans, builds, and tests/);
+  assert.match(out, /noisy commands/);
   assert.match(out, /`gsd_exec_search`/);
-  assert.match(out, /before repeating prior runs/);
+  assert.match(out, /before reruns/);
   assert.match(out, /`gsd_resume`/);
   assert.match(out, /after compaction or resume/);
 });
@@ -137,6 +136,7 @@ test("Context Mode composer: nested output is compact single sentence", () => {
   assert.match(out, /`gsd_exec`/);
   assert.match(out, /`gsd_exec_search`/);
   assert.match(out, /`gsd_resume`/);
+  assert.ok(out.length < 180, `nested guidance should stay compact, got ${out.length} chars`);
 });
 
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
@@ -224,7 +224,7 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
 
 const fakeBase: BaseResolverContext = {
   unitType: "reassess-roadmap",
-  basePath: "/tmp/fake",
+  basePath: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
   milestoneId: "M001",
   sliceId: "S01",
 };

package/src/resources/extensions/gsd/tests/uok-kernel-path.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Verifies UOK kernel path selection and legacy fallback telemetry.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
@@ -11,6 +13,7 @@ import type { AutoSession } from "../auto/session.ts";
 import type { LoopDeps } from "../auto/loop-deps.ts";
 import { gsdRoot } from "../paths.ts";
 import type { GSDPreferences } from "../preferences.ts";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.ts";
 
 function makeBasePath(): string {
   return mkdtempSync(join(tmpdir(), "gsd-uok-kernel-"));
@@ -86,6 +89,7 @@ function readParityEvents(basePath: string): Array<Record<string, unknown>> {
 test("runAutoLoopWithUok uses kernel path by default and records uok-kernel parity", async () => {
   const basePath = makeBasePath();
   try {
+    resetLegacyTelemetry();
     const args = makeArgs(basePath, {
       uok: {
         enabled: true,
@@ -109,7 +113,9 @@ test("runAutoLoopWithUok uses kernel path by default and records uok-kernel pari
     assert.equal(events[1]?.path, "uok-kernel");
     assert.equal(events[1]?.phase, "exit");
     assert.equal(events[1]?.status, "ok");
+    assert.equal(getLegacyTelemetry()["legacy.uokFallbackUsed"], 0);
   } finally {
+    resetLegacyTelemetry();
     rmSync(basePath, { recursive: true, force: true });
   }
 });
@@ -117,6 +123,7 @@ test("runAutoLoopWithUok uses kernel path by default and records uok-kernel pari
 test("runAutoLoopWithUok uses legacy path when explicit legacy fallback is enabled", async () => {
   const basePath = makeBasePath();
   try {
+    resetLegacyTelemetry();
     const args = makeArgs(basePath, {
       uok: {
         enabled: true,
@@ -134,7 +141,9 @@ test("runAutoLoopWithUok uses legacy path when explicit legacy fallback is enabl
     assert.equal(events[0]?.path, "legacy-fallback");
     assert.equal(events[1]?.path, "legacy-fallback");
     assert.equal(events[1]?.status, "ok");
+    assert.equal(getLegacyTelemetry()["legacy.uokFallbackUsed"], 1);
   } finally {
+    resetLegacyTelemetry();
     rmSync(basePath, { recursive: true, force: true });
   }
 });
@@ -144,6 +153,7 @@ test("runAutoLoopWithUok respects GSD_UOK_FORCE_LEGACY emergency switch", async
   const previous = process.env.GSD_UOK_FORCE_LEGACY;
   process.env.GSD_UOK_FORCE_LEGACY = "1";
   try {
+    resetLegacyTelemetry();
     const args = makeArgs(basePath, {
       uok: {
         enabled: true,
@@ -158,7 +168,9 @@ test("runAutoLoopWithUok respects GSD_UOK_FORCE_LEGACY emergency switch", async
     assert.equal(events.length, 2);
     assert.equal(events[0]?.path, "legacy-fallback");
     assert.equal(events[1]?.path, "legacy-fallback");
+    assert.equal(getLegacyTelemetry()["legacy.uokFallbackUsed"], 1);
   } finally {
+    resetLegacyTelemetry();
     if (previous === undefined) delete process.env.GSD_UOK_FORCE_LEGACY;
     else process.env.GSD_UOK_FORCE_LEGACY = previous;
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/workflow-custom-engine-dispatch-outcome.test.ts

@@ -0,0 +1,55 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for custom-engine dispatch outcome side-effect adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { handleCustomEngineDispatchOutcome } from "../auto/workflow-custom-engine-dispatch-outcome.ts";
+
+test("handleCustomEngineDispatchOutcome stops auto on stop decision", async () => {
+  const calls: unknown[] = [];
+
+  const flow = await handleCustomEngineDispatchOutcome({
+    decision: { action: "stop", reason: "done" },
+    deps: {
+      stopAuto: async reason => {
+        calls.push(["stopAuto", reason]);
+      },
+    },
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [["stopAuto", "done"]]);
+});
+
+test("handleCustomEngineDispatchOutcome continues on skip decision", async () => {
+  const calls: unknown[] = [];
+
+  const flow = await handleCustomEngineDispatchOutcome({
+    decision: { action: "skip" },
+    deps: {
+      stopAuto: async reason => {
+        calls.push(["stopAuto", reason]);
+      },
+    },
+  });
+
+  assert.deepEqual(flow, { action: "continue" });
+  assert.deepEqual(calls, []);
+});
+
+test("handleCustomEngineDispatchOutcome dispatches without side effects", async () => {
+  const calls: unknown[] = [];
+
+  const flow = await handleCustomEngineDispatchOutcome({
+    decision: { action: "dispatch" },
+    deps: {
+      stopAuto: async reason => {
+        calls.push(["stopAuto", reason]);
+      },
+    },
+  });
+
+  assert.deepEqual(flow, { action: "dispatch" });
+  assert.deepEqual(calls, []);
+});

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

@@ -0,0 +1,93 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode custom-engine iteration-data adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { GSDState } from "../types.ts";
+import { buildCustomEngineIterationData } from "../auto/workflow-custom-engine-iteration.ts";
+
+test("buildCustomEngineIterationData derives state from canonical project root", async () => {
+  const roots: string[] = [];
+
+  await buildCustomEngineIterationData({
+    step: { unitType: "engine-task", unitId: "E001", prompt: "Run engine task" },
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    currentMilestoneId: "M001",
+    deriveState: async root => {
+      roots.push(root);
+      return { phase: "executing" } as GSDState;
+    },
+    logPostDerive: () => {},
+  });
+
+  assert.deepEqual(roots, ["/project"]);
+});
+
+test("buildCustomEngineIterationData maps engine step into iteration data", async () => {
+  const state = {
+    phase: "executing",
+    activeMilestone: { id: "M001", title: "Milestone 1" },
+  } as GSDState;
+
+  const iterData = await buildCustomEngineIterationData({
+    step: { unitType: "engine-task", unitId: "E001", prompt: "Run engine task" },
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    currentMilestoneId: "M001",
+    deriveState: async () => state,
+    logPostDerive: () => {},
+  });
+
+  assert.equal(iterData.unitType, "engine-task");
+  assert.equal(iterData.unitId, "E001");
+  assert.equal(iterData.prompt, "Run engine task");
+  assert.equal(iterData.finalPrompt, "Run engine task");
+  assert.equal(iterData.pauseAfterUatDispatch, false);
+  assert.equal(iterData.state, state);
+  assert.equal(iterData.mid, "M001");
+  assert.equal(iterData.midTitle, "Workflow");
+  assert.equal(iterData.isRetry, false);
+  assert.equal(iterData.previousTier, undefined);
+});
+
+test("buildCustomEngineIterationData defaults milestone id to workflow", async () => {
+  const iterData = await buildCustomEngineIterationData({
+    step: { unitType: "engine-task", unitId: "E001", prompt: "Run engine task" },
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    currentMilestoneId: null,
+    deriveState: async () => ({ phase: "executing" }) as GSDState,
+    logPostDerive: () => {},
+  });
+
+  assert.equal(iterData.mid, "workflow");
+  assert.equal(iterData.midTitle, "Workflow");
+});
+
+test("buildCustomEngineIterationData logs active unit details", async () => {
+  const logs: unknown[] = [];
+
+  await buildCustomEngineIterationData({
+    step: { unitType: "engine-task", unitId: "E001", prompt: "Run engine task" },
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    currentMilestoneId: "M001",
+    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: "custom-engine-gsd-state",
+    basePath: "/worktree",
+    canonicalProjectRoot: "/project",
+    derivedPhase: "planning",
+    activeUnit: "T01",
+  }]);
+});

package/src/resources/extensions/gsd/tests/workflow-custom-engine-reconcile-outcome.test.ts

@@ -0,0 +1,108 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for custom-engine reconcile outcome side-effect adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  handleCustomEngineReconcileOutcome,
+  type HandleCustomEngineReconcileOutcomeDeps,
+} from "../auto/workflow-custom-engine-reconcile-outcome.ts";
+
+function makeDeps(): {
+  deps: HandleCustomEngineReconcileOutcomeDeps;
+  calls: unknown[];
+} {
+  const calls: unknown[] = [];
+  const deps: HandleCustomEngineReconcileOutcomeDeps = {
+    stopAuto: async reason => {
+      calls.push(["stopAuto", reason]);
+    },
+    pauseAuto: async () => {
+      calls.push(["pauseAuto"]);
+    },
+    report: (action, details) => calls.push(["report", action, details]),
+    finishTurn: (status, failureClass, error) => calls.push(["finishTurn", status, failureClass, error]),
+  };
+  return { deps, calls };
+}
+
+test("handleCustomEngineReconcileOutcome stops completed workflow", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineReconcileOutcome({
+    outcome: {
+      decision: { action: "complete-workflow", stopReason: "Workflow complete" },
+    },
+    unitType: "execute-task",
+    unitId: "T01",
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["stopAuto", "Workflow complete"],
+    ["report", "milestone-complete", { unitType: "execute-task", unitId: "T01" }],
+    ["finishTurn", "completed", undefined, undefined],
+  ]);
+});
+
+test("handleCustomEngineReconcileOutcome pauses for manual attention", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineReconcileOutcome({
+    outcome: {
+      decision: { action: "pause" },
+    },
+    unitType: "verify-slice",
+    unitId: "S01",
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["pauseAuto"],
+    ["report", "pause", { unitType: "verify-slice", unitId: "S01" }],
+    ["finishTurn", "paused", "manual-attention", undefined],
+  ]);
+});
+
+test("handleCustomEngineReconcileOutcome stops with reconcile reason", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineReconcileOutcome({
+    outcome: {
+      decision: { action: "stop", reason: "blocked" },
+      reason: "blocked",
+    },
+    unitType: "complete-slice",
+    unitId: "S01",
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["stopAuto", "blocked"],
+    ["report", "stop", { unitType: "complete-slice", unitId: "S01", reason: "blocked" }],
+    ["finishTurn", "stopped", "manual-attention", "blocked"],
+  ]);
+});
+
+test("handleCustomEngineReconcileOutcome continues after completed unit", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineReconcileOutcome({
+    outcome: {
+      decision: { action: "continue" },
+    },
+    unitType: "research-slice",
+    unitId: "S01",
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "continue" });
+  assert.deepEqual(calls, [
+    ["report", "continue", { unitType: "research-slice", unitId: "S01" }],
+    ["finishTurn", "completed", undefined, undefined],
+  ]);
+});