gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

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

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

@@ -0,0 +1,158 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode dispatch claim adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { AutoSession } from "../auto/session.ts";
+import type { IterationData } from "../auto/types.ts";
+import {
+  openDispatchClaim,
+  type OpenDispatchClaimDeps,
+} from "../auto/workflow-dispatch-claim.ts";
+
+function makeSession(overrides?: Partial<AutoSession>): AutoSession {
+  return {
+    workerId: "worker-1",
+    milestoneLeaseToken: 7,
+    ...overrides,
+  } as AutoSession;
+}
+
+function makeIterationData(overrides?: Partial<IterationData>): IterationData {
+  return {
+    unitType: "execute-task",
+    unitId: "M001/S001/T001",
+    prompt: "Run task",
+    finalPrompt: "Run task",
+    pauseAfterUatDispatch: false,
+    mid: "M001",
+    midTitle: "Milestone",
+    isRetry: false,
+    previousTier: undefined,
+    state: {
+      activeSlice: { id: "S001" },
+      activeTask: { id: "T001" },
+    },
+    ...overrides,
+  } as IterationData;
+}
+
+function makeDeps(overrides?: Partial<OpenDispatchClaimDeps>): OpenDispatchClaimDeps {
+  return {
+    getRecentDispatchesForUnit: () => [],
+    recordDispatchClaim: () => ({ ok: true, dispatchId: 42 }),
+    markDispatchRunning: () => {},
+    logClaimRejected: () => {},
+    logClaimFailed: () => {},
+    ...overrides,
+  };
+}
+
+test("openDispatchClaim degrades when worker identity or lease token is missing", () => {
+  assert.deepEqual(
+    openDispatchClaim(makeSession({ workerId: null }), "flow", "turn", makeIterationData(), makeDeps({
+      recordDispatchClaim: () => assert.fail("recordDispatchClaim should not be called"),
+    })),
+    { kind: "degraded" },
+  );
+
+  assert.deepEqual(
+    openDispatchClaim(makeSession({ milestoneLeaseToken: null }), "flow", "turn", makeIterationData(), makeDeps({
+      recordDispatchClaim: () => assert.fail("recordDispatchClaim should not be called"),
+    })),
+    { kind: "degraded" },
+  );
+});
+
+test("openDispatchClaim degrades when iteration has no milestone id", () => {
+  assert.deepEqual(
+    openDispatchClaim(makeSession(), "flow", "turn", makeIterationData({ mid: undefined }), makeDeps({
+      recordDispatchClaim: () => assert.fail("recordDispatchClaim should not be called"),
+    })),
+    { kind: "degraded" },
+  );
+});
+
+test("openDispatchClaim records attempts and marks successful claims running", () => {
+  const running: number[] = [];
+  const claimInputs: unknown[] = [];
+
+  const outcome = openDispatchClaim(makeSession(), "flow-1", "turn-1", makeIterationData(), makeDeps({
+    getRecentDispatchesForUnit: (unitId, limit) => {
+      assert.equal(unitId, "M001/S001/T001");
+      assert.equal(limit, 1);
+      return [{ attempt_n: 2 }];
+    },
+    recordDispatchClaim: input => {
+      claimInputs.push(input);
+      return { ok: true, dispatchId: 99 };
+    },
+    markDispatchRunning: dispatchId => running.push(dispatchId),
+  }));
+
+  assert.deepEqual(outcome, { kind: "opened", dispatchId: 99 });
+  assert.deepEqual(running, [99]);
+  assert.deepEqual(claimInputs, [{
+    traceId: "flow-1",
+    turnId: "turn-1",
+    workerId: "worker-1",
+    milestoneLeaseToken: 7,
+    milestoneId: "M001",
+    sliceId: "S001",
+    taskId: "T001",
+    unitType: "execute-task",
+    unitId: "M001/S001/T001",
+    attemptN: 3,
+  }]);
+});
+
+test("openDispatchClaim skips already-active claims with existing dispatch details", () => {
+  const rejected: unknown[] = [];
+
+  const outcome = openDispatchClaim(makeSession(), "flow", "turn", makeIterationData(), makeDeps({
+    recordDispatchClaim: () => ({
+      ok: false,
+      error: "already_active",
+      existingId: 12,
+      existingWorker: "worker-2",
+    }),
+    logClaimRejected: details => rejected.push(details),
+  }));
+
+  assert.deepEqual(outcome, {
+    kind: "skip",
+    reason: "already-active",
+    existingId: 12,
+    existingWorker: "worker-2",
+  });
+  assert.deepEqual(rejected, [{
+    unitId: "M001/S001/T001",
+    reason: "already_active",
+    existingId: 12,
+    existingWorker: "worker-2",
+  }]);
+});
+
+test("openDispatchClaim maps non-active claim rejections to stale lease skips", () => {
+  const outcome = openDispatchClaim(makeSession(), "flow", "turn", makeIterationData(), makeDeps({
+    recordDispatchClaim: () => ({ ok: false, error: "stale_lease" }),
+  }));
+
+  assert.deepEqual(outcome, { kind: "skip", reason: "stale-lease" });
+});
+
+test("openDispatchClaim degrades on claim write failures", () => {
+  const writeError = new Error("db unavailable");
+  const logged: unknown[] = [];
+
+  const outcome = openDispatchClaim(makeSession(), "flow", "turn", makeIterationData(), makeDeps({
+    recordDispatchClaim: () => {
+      throw writeError;
+    },
+    logClaimFailed: err => logged.push(err),
+  }));
+
+  assert.deepEqual(outcome, { kind: "degraded" });
+  assert.deepEqual(logged, [writeError]);
+});

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

@@ -0,0 +1,82 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for best-effort auto-mode dispatch ledger helpers.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  settleDispatchCompleted,
+  settleDispatchFailed,
+} from "../auto/workflow-dispatch-ledger.ts";
+
+test("settleDispatchFailed writes failures and reports settled state", () => {
+  const calls: Array<{ dispatchId: number; errorSummary: string }> = [];
+
+  const settled = settleDispatchFailed(42, "unit-break", {
+    markFailed: (dispatchId, details) => calls.push({ dispatchId, ...details }),
+    logWriteFailure: () => assert.fail("logWriteFailure should not be called"),
+  });
+
+  assert.equal(settled, true);
+  assert.deepEqual(calls, [{ dispatchId: 42, errorSummary: "unit-break" }]);
+});
+
+test("settleDispatchFailed skips null dispatch ids", () => {
+  const settled = settleDispatchFailed(null, "unit-break", {
+    markFailed: () => assert.fail("markFailed should not be called"),
+    logWriteFailure: () => assert.fail("logWriteFailure should not be called"),
+  });
+
+  assert.equal(settled, false);
+});
+
+test("settleDispatchFailed logs failed ledger writes without throwing", () => {
+  const logged: unknown[] = [];
+  const writeError = new Error("db locked");
+
+  const settled = settleDispatchFailed(42, "unit-break", {
+    markFailed: () => {
+      throw writeError;
+    },
+    logWriteFailure: err => logged.push(err),
+  });
+
+  assert.equal(settled, false);
+  assert.deepEqual(logged, [writeError]);
+});
+
+test("settleDispatchCompleted writes completion and reports settled state", () => {
+  const calls: number[] = [];
+
+  const settled = settleDispatchCompleted(42, {
+    markCompleted: dispatchId => calls.push(dispatchId),
+    logWriteFailure: () => assert.fail("logWriteFailure should not be called"),
+  });
+
+  assert.equal(settled, true);
+  assert.deepEqual(calls, [42]);
+});
+
+test("settleDispatchCompleted skips null dispatch ids", () => {
+  const settled = settleDispatchCompleted(null, {
+    markCompleted: () => assert.fail("markCompleted should not be called"),
+    logWriteFailure: () => assert.fail("logWriteFailure should not be called"),
+  });
+
+  assert.equal(settled, false);
+});
+
+test("settleDispatchCompleted logs failed ledger writes without throwing", () => {
+  const logged: unknown[] = [];
+  const writeError = new Error("db locked");
+
+  const settled = settleDispatchCompleted(42, {
+    markCompleted: () => {
+      throw writeError;
+    },
+    logWriteFailure: err => logged.push(err),
+  });
+
+  assert.equal(settled, false);
+  assert.deepEqual(logged, [writeError]);
+});

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

@@ -0,0 +1,44 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for successful auto-mode iteration cleanup.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  completeWorkflowIteration,
+  type WorkflowIterationRecoveryState,
+} from "../auto/workflow-iteration-completion.ts";
+
+test("completeWorkflowIteration resets recovery counters and clears recent errors", () => {
+  const state: WorkflowIterationRecoveryState = {
+    consecutiveErrors: 2,
+    consecutiveCooldowns: 1,
+    recentErrorMessages: ["first", "second"],
+  };
+
+  completeWorkflowIteration(state, {
+    emitIterationEnd: () => {},
+    saveStuckState: () => {},
+    logIterationComplete: () => {},
+  });
+
+  assert.equal(state.consecutiveErrors, 0);
+  assert.equal(state.consecutiveCooldowns, 0);
+  assert.deepEqual(state.recentErrorMessages, []);
+});
+
+test("completeWorkflowIteration runs completion side effects in loop order", () => {
+  const calls: string[] = [];
+
+  completeWorkflowIteration({
+    consecutiveErrors: 1,
+    consecutiveCooldowns: 1,
+    recentErrorMessages: ["temporary"],
+  }, {
+    emitIterationEnd: () => calls.push("emit"),
+    saveStuckState: () => calls.push("save"),
+    logIterationComplete: () => calls.push("log"),
+  });
+
+  assert.deepEqual(calls, ["emit", "save", "log"]);
+});