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

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

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

@@ -0,0 +1,146 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode custom-engine reconcile adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { EngineState, ReconcileResult } from "../engine-types.ts";
+import type { IterationData } from "../auto/types.ts";
+import {
+  handleCustomEngineReconcile,
+  type HandleCustomEngineReconcileDeps,
+} from "../auto/workflow-custom-engine-reconcile.ts";
+
+function makeIterData(): IterationData {
+  return {
+    unitType: "execute-task",
+    unitId: "T01",
+    prompt: "Run task",
+    finalPrompt: "Run task",
+    pauseAfterUatDispatch: false,
+    state: {} as IterationData["state"],
+    mid: "M001",
+    midTitle: "Milestone 1",
+    isRetry: false,
+    previousTier: undefined,
+  };
+}
+
+function makeEngineState(): EngineState {
+  return {
+    phase: "executing",
+    currentMilestoneId: "M001",
+    activeSliceId: "S01",
+    activeTaskId: "T01",
+    isComplete: false,
+    raw: {},
+  };
+}
+
+function makeDeps(reconcileResult: ReconcileResult): {
+  deps: HandleCustomEngineReconcileDeps;
+  calls: unknown[];
+} {
+  const calls: unknown[] = [];
+  const deps: HandleCustomEngineReconcileDeps = {
+    saveRetryCounts: () => calls.push(["save"]),
+    logReconcile: details => calls.push(["log", details]),
+    reconcile: async (state, completedStep) => {
+      calls.push(["reconcile", state, completedStep]);
+      return reconcileResult;
+    },
+    now: () => 200,
+    clearUnitTimeout: () => calls.push(["clearUnitTimeout"]),
+    completeIteration: () => calls.push(["completeIteration"]),
+  };
+  return { deps, calls };
+}
+
+test("handleCustomEngineReconcile clears retry count and reconciles completed step", async () => {
+  const retryCounts = new Map([["execute-task/T01", 2]]);
+  const { deps, calls } = makeDeps({ outcome: "continue" });
+  const engineState = makeEngineState();
+
+  const outcome = await handleCustomEngineReconcile({
+    session: {
+      currentUnit: { startedAt: 100 },
+      verificationRetryCount: retryCounts,
+    },
+    engineState,
+    iterData: makeIterData(),
+    iteration: 5,
+    deps,
+  });
+
+  assert.equal(retryCounts.has("execute-task/T01"), false);
+  assert.deepEqual(outcome, {
+    decision: { action: "continue" },
+    reason: undefined,
+  });
+  assert.deepEqual(calls, [
+    ["save"],
+    ["log", { iteration: 5, unitId: "T01" }],
+    ["reconcile", engineState, {
+      unitType: "execute-task",
+      unitId: "T01",
+      startedAt: 100,
+      finishedAt: 200,
+    }],
+    ["clearUnitTimeout"],
+    ["completeIteration"],
+  ]);
+});
+
+test("handleCustomEngineReconcile falls back startedAt to finishedAt", async () => {
+  const { deps, calls } = makeDeps({ outcome: "pause" });
+
+  const outcome = await handleCustomEngineReconcile({
+    session: {},
+    engineState: makeEngineState(),
+    iterData: makeIterData(),
+    iteration: 1,
+    deps,
+  });
+
+  assert.deepEqual(outcome.decision, { action: "pause" });
+  assert.deepEqual((calls[2] as unknown[])[2], {
+    unitType: "execute-task",
+    unitId: "T01",
+    startedAt: 200,
+    finishedAt: 200,
+  });
+});
+
+test("handleCustomEngineReconcile maps stop reason through kernel decision", async () => {
+  const { deps } = makeDeps({ outcome: "stop", reason: "blocked" });
+
+  const outcome = await handleCustomEngineReconcile({
+    session: { verificationRetryCount: new Map() },
+    engineState: makeEngineState(),
+    iterData: makeIterData(),
+    iteration: 1,
+    deps,
+  });
+
+  assert.deepEqual(outcome, {
+    decision: { action: "stop", reason: "blocked" },
+    reason: "blocked",
+  });
+});
+
+test("handleCustomEngineReconcile maps milestone completion", async () => {
+  const { deps } = makeDeps({ outcome: "milestone-complete" });
+
+  const outcome = await handleCustomEngineReconcile({
+    session: { verificationRetryCount: new Map() },
+    engineState: makeEngineState(),
+    iterData: makeIterData(),
+    iteration: 1,
+    deps,
+  });
+
+  assert.deepEqual(outcome.decision, {
+    action: "complete-workflow",
+    stopReason: "Workflow complete",
+  });
+});

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

@@ -0,0 +1,136 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode custom-engine verification retry adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  handleCustomEngineVerifyRetry,
+  type CustomEngineRecoverResult,
+  type HandleCustomEngineVerifyRetryDeps,
+} from "../auto/workflow-custom-engine-retry.ts";
+
+function makeHarness(options?: {
+  initialAttempts?: number;
+  recoverResult?: CustomEngineRecoverResult;
+}): {
+  session: { verificationRetryCount: Map<string, number> };
+  deps: HandleCustomEngineVerifyRetryDeps;
+  calls: unknown[];
+} {
+  const retryCounts = new Map<string, number>();
+  if (options?.initialAttempts !== undefined) {
+    retryCounts.set("execute-task/T01", options.initialAttempts);
+  }
+  const session = { verificationRetryCount: retryCounts };
+  const calls: unknown[] = [];
+  const deps: HandleCustomEngineVerifyRetryDeps = {
+    hydrateRetryCounts: () => {
+      calls.push(["hydrate"]);
+      return retryCounts;
+    },
+    saveRetryCounts: () => calls.push(["save"]),
+    recover: async (unitType, unitId, recoverOptions) => {
+      calls.push(["recover", unitType, unitId, recoverOptions]);
+      return options?.recoverResult ?? { outcome: "pause", reason: "needs human" };
+    },
+    logRetry: details => calls.push(["log", details]),
+    reportRetry: details => calls.push(["report", details]),
+  };
+  return { session, deps, calls };
+}
+
+test("handleCustomEngineVerifyRetry increments and persists retry attempts", async () => {
+  const { session, deps, calls } = makeHarness();
+
+  const outcome = await handleCustomEngineVerifyRetry({
+    session,
+    unitType: "execute-task",
+    unitId: "T01",
+    basePath: "/project",
+    iteration: 2,
+    maxRetries: 3,
+    deps,
+  });
+
+  assert.deepEqual(outcome, { action: "retry", attempts: 1 });
+  assert.equal(session.verificationRetryCount.get("execute-task/T01"), 1);
+  assert.deepEqual(calls, [
+    ["hydrate"],
+    ["save"],
+    ["log", { iteration: 2, unitId: "T01", attempts: 1 }],
+    ["report", { unitType: "execute-task", unitId: "T01", attempts: 1 }],
+  ]);
+});
+
+test("handleCustomEngineVerifyRetry requests recovery after retry budget is exceeded", async () => {
+  const { deps, calls } = makeHarness({
+    initialAttempts: 3,
+    recoverResult: { outcome: "pause", reason: "manual review" },
+  });
+
+  const outcome = await handleCustomEngineVerifyRetry({
+    session: { verificationRetryCount: new Map([["execute-task/T01", 3]]) },
+    unitType: "execute-task",
+    unitId: "T01",
+    basePath: "/project",
+    iteration: 4,
+    maxRetries: 3,
+    deps,
+  });
+
+  assert.deepEqual(outcome, {
+    action: "pause",
+    attempts: 4,
+    turnError: "manual review",
+  });
+  assert.deepEqual(calls.at(-1), ["recover", "execute-task", "T01", { basePath: "/project" }]);
+});
+
+test("handleCustomEngineVerifyRetry maps stop recovery to stop outcome", async () => {
+  const { session, deps } = makeHarness({
+    initialAttempts: 3,
+    recoverResult: { outcome: "stop", reason: "engine stopped" },
+  });
+
+  const outcome = await handleCustomEngineVerifyRetry({
+    session,
+    unitType: "execute-task",
+    unitId: "T01",
+    basePath: "/project",
+    iteration: 4,
+    maxRetries: 3,
+    deps,
+  });
+
+  assert.deepEqual(outcome, {
+    action: "stop",
+    attempts: 4,
+    stopMessage: "engine stopped",
+    turnError: "custom-engine-verify-retry-exhausted",
+  });
+});
+
+test("handleCustomEngineVerifyRetry maps skip recovery to incompatible skip stop", async () => {
+  const { session, deps } = makeHarness({
+    initialAttempts: 3,
+    recoverResult: { outcome: "skip" },
+  });
+
+  const outcome = await handleCustomEngineVerifyRetry({
+    session,
+    unitType: "execute-task",
+    unitId: "T01",
+    basePath: "/project",
+    iteration: 4,
+    maxRetries: 3,
+    deps,
+  });
+
+  assert.equal(outcome.action, "stop");
+  assert.equal(outcome.attempts, 4);
+  assert.match(
+    outcome.action === "stop" ? outcome.stopMessage : "",
+    /cannot reconcile skipped steps/,
+  );
+});

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

@@ -0,0 +1,95 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for custom-engine verification outcome side-effect adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  handleCustomEngineVerifyPause,
+  handleCustomEngineVerifyRetryOutcome,
+  type HandleCustomEngineVerifyOutcomeDeps,
+} from "../auto/workflow-custom-engine-verify-outcome.ts";
+
+function makeDeps(): {
+  deps: HandleCustomEngineVerifyOutcomeDeps;
+  calls: unknown[];
+} {
+  const calls: unknown[] = [];
+  const deps: HandleCustomEngineVerifyOutcomeDeps = {
+    pauseAuto: async () => {
+      calls.push(["pauseAuto"]);
+    },
+    stopAuto: async reason => {
+      calls.push(["stopAuto", reason]);
+    },
+    reportPause: details => calls.push(["reportPause", details]),
+    finishTurn: (status, failureClass, error) => calls.push(["finishTurn", status, failureClass, error]),
+  };
+  return { deps, calls };
+}
+
+test("handleCustomEngineVerifyPause pauses and reports unit details", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineVerifyPause({
+    unitType: "execute-task",
+    unitId: "T01",
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["pauseAuto"],
+    ["reportPause", { unitType: "execute-task", unitId: "T01" }],
+    ["finishTurn", "paused", "manual-attention", "custom-engine-verify-pause"],
+  ]);
+});
+
+test("handleCustomEngineVerifyRetryOutcome pauses after recovery pause", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineVerifyRetryOutcome({
+    outcome: { action: "pause", attempts: 4, turnError: "recovery-pause" },
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["pauseAuto"],
+    ["finishTurn", "paused", "manual-attention", "recovery-pause"],
+  ]);
+});
+
+test("handleCustomEngineVerifyRetryOutcome stops after recovery stop", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineVerifyRetryOutcome({
+    outcome: {
+      action: "stop",
+      attempts: 4,
+      stopMessage: "Recovery failed",
+      turnError: "recovery-stop",
+    },
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "break" });
+  assert.deepEqual(calls, [
+    ["stopAuto", "Recovery failed"],
+    ["finishTurn", "stopped", "manual-attention", "recovery-stop"],
+  ]);
+});
+
+test("handleCustomEngineVerifyRetryOutcome continues for retry", async () => {
+  const { deps, calls } = makeDeps();
+
+  const flow = await handleCustomEngineVerifyRetryOutcome({
+    outcome: { action: "retry", attempts: 1 },
+    deps,
+  });
+
+  assert.deepEqual(flow, { action: "continue" });
+  assert.deepEqual(calls, [
+    ["finishTurn", "retry", undefined, undefined],
+  ]);
+});