gsd-pi 2.79.0 → 2.80.0-dev.c5f2443b3

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

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

@@ -0,0 +1,49 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for workflow journal event emission adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createWorkflowJournalReporter } from "../auto/workflow-journal-reporter.ts";
+
+test("workflow journal reporter emits timestamped sequenced journal entries", () => {
+  const entries: unknown[] = [];
+  let seq = 0;
+  const reporter = createWorkflowJournalReporter({
+    emitJournalEvent: entry => entries.push(entry),
+    flowId: "flow-1",
+    nextSeq: () => {
+      seq += 1;
+      return seq;
+    },
+    now: () => "2026-05-04T00:00:00.000Z",
+  });
+
+  reporter.emit("iteration-start", { iteration: 1 });
+  reporter.emit("unit-end", {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    status: "blocked",
+  });
+
+  assert.deepEqual(entries, [
+    {
+      ts: "2026-05-04T00:00:00.000Z",
+      flowId: "flow-1",
+      seq: 1,
+      eventType: "iteration-start",
+      data: { iteration: 1 },
+    },
+    {
+      ts: "2026-05-04T00:00:00.000Z",
+      flowId: "flow-1",
+      seq: 2,
+      eventType: "unit-end",
+      data: {
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        status: "blocked",
+      },
+    },
+  ]);
+});