agent-bober 0.15.0 → 0.17.0

package/dist/orchestrator/workflow/flusher.js

@@ -0,0 +1,81 @@
+// ── RunResultFlusher ─────────────────────────────────────────────────
+//
+// Host-side flusher: commits a WorkflowRunResult from the JS workflow script
+// to durable .bober/ state. This class is the ONLY clock source for the
+// workflow engine — new Date() is called here, never in the script.
+//
+// Flush strategy:
+//   - Per-contract: update status + write contract, then updateProgress (crash-safe).
+//   - pendingHistory: appended ONCE after all contracts have been flushed
+//     (history entries are not per-contract; the list is global to the run).
+//     Re-flushing the same result appends the same entries again — callers
+//     must ensure idempotency at the orchestration layer (skip-completed cursor).
+import { updateContractStatus } from "../../contracts/sprint-contract.js";
+import { updateContract, loadContract, listContracts } from "../../state/sprint-state.js";
+import { appendHistory, updateProgress } from "../../state/history.js";
+import { ensureBoberDir, saveSpec } from "../../state/index.js";
+export class RunResultFlusher {
+    /**
+     * Commit a WorkflowRunResult to durable .bober/ state.
+     *
+     * Write sequence (mirrors pipeline.ts:381-394):
+     *   1. For each sprint: updateContractStatus → updateContract (crash-safe per-contract).
+     *   2. updateProgress after each contract (cumulative list, crash-safe).
+     *   3. After all contracts: appendHistory for each pendingHistory entry (stamped).
+     *   4. Save the spec.
+     *   5. Return PipelineResult.
+     */
+    async flush(projectRoot, _config, result) {
+        const startTime = Date.now();
+        await ensureBoberDir(projectRoot);
+        const completedSprints = [];
+        const failedSprints = [];
+        // ── Per-contract loop (crash-safe: flush after each) ────────────────
+        for (const sprint of result.perSprint) {
+            const contractStatus = sprint.outcome === "passed"
+                ? "passed"
+                : sprint.outcome === "needs-rework"
+                    ? "needs-rework"
+                    : "failed";
+            // Stamp updatedAt / completedAt (host is the only clock)
+            const stamped = updateContractStatus(sprint.contract, contractStatus);
+            // Persist — atomic per file (updateContract = saveContract with same id)
+            await updateContract(projectRoot, stamped);
+            // Accumulate before updateProgress so the progress file always reflects
+            // all contracts flushed so far
+            if (contractStatus === "passed") {
+                completedSprints.push(stamped);
+            }
+            else {
+                failedSprints.push(stamped);
+            }
+            // updateProgress with cumulative list (crash-safe checkpoint after each contract)
+            await updateProgress(projectRoot, [...completedSprints, ...failedSprints], result.spec);
+        }
+        // ── History: append all pendingHistory entries with stamped timestamps ──
+        //
+        // Appended once after the per-contract loop. Each entry receives a fresh
+        // new Date().toISOString() stamp here — the script passed Omit<HistoryEntry,"timestamp">.
+        for (const partial of result.pendingHistory) {
+            await appendHistory(projectRoot, {
+                ...partial,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        // ── Persist the spec ────────────────────────────────────────────────
+        await saveSpec(projectRoot, result.spec);
+        // ── Return PipelineResult (pipeline.ts:809-810 success formula) ─────
+        return {
+            success: failedSprints.length === 0 && completedSprints.length > 0,
+            spec: result.spec,
+            completedSprints,
+            failedSprints,
+            duration: Date.now() - startTime,
+            needsClarification: result.needsClarification,
+        };
+    }
+}
+// Re-export for test convenience (allows tests to load contracts back without
+// importing sprint-state directly if they already import flusher).
+export { loadContract, listContracts };
+//# sourceMappingURL=flusher.js.map

package/dist/orchestrator/workflow/flusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flusher.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/flusher.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,EAAE;AACF,6EAA6E;AAC7E,wEAAwE;AACxE,oEAAoE;AACpE,EAAE;AACF,kBAAkB;AAClB,sFAAsF;AACtF,0EAA0E;AAC1E,6EAA6E;AAC7E,2EAA2E;AAC3E,kFAAkF;AAIlF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhE,MAAM,OAAO,gBAAgB;IAC3B;;;;;;;;;OASG;IACH,KAAK,CAAC,KAAK,CACT,WAAmB,EACnB,OAAoB,EACpB,MAAyB;QAEzB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,MAAM,cAAc,CAAC,WAAW,CAAC,CAAC;QAElC,MAAM,gBAAgB,GAAqB,EAAE,CAAC;QAC9C,MAAM,aAAa,GAAqB,EAAE,CAAC;QAE3C,uEAAuE;QAEvE,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACtC,MAAM,cAAc,GAClB,MAAM,CAAC,OAAO,KAAK,QAAQ;gBACzB,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,MAAM,CAAC,OAAO,KAAK,cAAc;oBACjC,CAAC,CAAC,cAAc;oBAChB,CAAC,CAAC,QAAQ,CAAC;YAEjB,yDAAyD;YACzD,MAAM,OAAO,GAAG,oBAAoB,CAAC,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YAEtE,yEAAyE;YACzE,MAAM,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAE3C,wEAAwE;YACxE,+BAA+B;YAC/B,IAAI,cAAc,KAAK,QAAQ,EAAE,CAAC;gBAChC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACjC,CAAC;iBAAM,CAAC;gBACN,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;YAED,kFAAkF;YAClF,MAAM,cAAc,CAClB,WAAW,EACX,CAAC,GAAG,gBAAgB,EAAE,GAAG,aAAa,CAAC,EACvC,MAAM,CAAC,IAAI,CACZ,CAAC;QACJ,CAAC;QAED,2EAA2E;QAC3E,EAAE;QACF,yEAAyE;QACzE,0FAA0F;QAE1F,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;YAC5C,MAAM,aAAa,CAAC,WAAW,EAAE;gBAC/B,GAAG,OAAO;gBACV,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC,CAAC,CAAC;QACL,CAAC;QAED,uEAAuE;QAEvE,MAAM,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAEzC,uEAAuE;QAEvE,OAAO;YACL,OAAO,EAAE,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC;YAClE,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,gBAAgB;YAChB,aAAa;YACb,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YAChC,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;SAC9C,CAAC;IACJ,CAAC;CACF;AAED,8EAA8E;AAC9E,mEAAmE;AACnE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/orchestrator/workflow/interpreter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Workflow interpreter — the live body of the (currently dormant) WorkflowEngine
+ * invoke() seam.
+ *
+ * Reproduces the TS pipeline's plan → sprint-loop orchestration as PURE
+ * computation: it produces a {@link WorkflowRunResult} and writes nothing.
+ * `RunResultFlusher.flush()` commits the result afterward (the sole clock/commit
+ * source). Plan / contract-derivation / sprint-cycle are injected
+ * ({@link WorkflowDeps}) so the interpreter is hermetically testable; the real
+ * agent wiring (default deps) and the invoke() rewire + eligibility flip land in
+ * Sprint 5.
+ *
+ * Resume: contracts whose `sprintNumber` is in `args.resumeCursor.completed-
+ * SprintNumbers` are filtered out BEFORE dispatch, so the result only contains
+ * newly-run sprints — the flusher then appends only their history (no
+ * double-write on re-run).
+ */
+import type { WorkflowArgs, WorkflowRunResult } from "./types.js";
+import type { PlanSpec } from "../../contracts/spec.js";
+import type { SprintContract } from "../../contracts/sprint-contract.js";
+import { Scheduler } from "./scheduler.js";
+import type { SprintInput, SprintOutcome } from "./pure-sprint.js";
+export interface PlanResult {
+    spec: PlanSpec;
+    needsClarification: boolean;
+}
+export interface WorkflowDeps {
+    /** Produce or load the plan spec for the run. */
+    plan: (args: WorkflowArgs, projectRoot: string) => Promise<PlanResult>;
+    /** Derive sprint contracts from a spec (used when preloadedContracts is empty). */
+    buildContracts: (spec: PlanSpec, args: WorkflowArgs) => SprintContract[];
+    /** Run one sprint's pure (side-effect-free) generate→evaluate cycle. */
+    runSprint: (input: SprintInput) => Promise<SprintOutcome>;
+}
+export interface RunWorkflowOptions {
+    /**
+     * Scheduler used to run the sprint loop. Defaults to a sequential scheduler
+     * (maxConcurrent 1) for TS-pipeline parity. Sprint 5 raises the cap and adds
+     * dependsOn-aware ordering for true cross-sprint parallelism.
+     */
+    scheduler?: Scheduler;
+}
+/**
+ * Run the workflow: plan → derive contracts → (skip completed) → sprint loop →
+ * aggregate into a {@link WorkflowRunResult}. Writes nothing.
+ */
+export declare function runWorkflow(args: WorkflowArgs, projectRoot: string, deps: WorkflowDeps, opts?: RunWorkflowOptions): Promise<WorkflowRunResult>;
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/orchestrator/workflow/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/interpreter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAInE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,IAAI,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACvE,mFAAmF;IACnF,cAAc,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,KAAK,cAAc,EAAE,CAAC;IACzE,wEAAwE;IACxE,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,YAAY,EAClB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,iBAAiB,CAAC,CAsF5B"}

package/dist/orchestrator/workflow/interpreter.js

@@ -0,0 +1,92 @@
+/**
+ * Workflow interpreter — the live body of the (currently dormant) WorkflowEngine
+ * invoke() seam.
+ *
+ * Reproduces the TS pipeline's plan → sprint-loop orchestration as PURE
+ * computation: it produces a {@link WorkflowRunResult} and writes nothing.
+ * `RunResultFlusher.flush()` commits the result afterward (the sole clock/commit
+ * source). Plan / contract-derivation / sprint-cycle are injected
+ * ({@link WorkflowDeps}) so the interpreter is hermetically testable; the real
+ * agent wiring (default deps) and the invoke() rewire + eligibility flip land in
+ * Sprint 5.
+ *
+ * Resume: contracts whose `sprintNumber` is in `args.resumeCursor.completed-
+ * SprintNumbers` are filtered out BEFORE dispatch, so the result only contains
+ * newly-run sprints — the flusher then appends only their history (no
+ * double-write on re-run).
+ */
+import { Scheduler } from "./scheduler.js";
+/**
+ * Run the workflow: plan → derive contracts → (skip completed) → sprint loop →
+ * aggregate into a {@link WorkflowRunResult}. Writes nothing.
+ */
+export async function runWorkflow(args, projectRoot, deps, opts = {}) {
+    const scheduler = opts.scheduler ?? new Scheduler({ maxConcurrent: 1 });
+    const pendingHistory = [];
+    // ── Plan (or reuse preloaded spec on resume) ───────────────────────
+    let spec;
+    let needsClarification = false;
+    if (args.preloadedSpec) {
+        spec = args.preloadedSpec;
+    }
+    else {
+        const planned = await deps.plan(args, projectRoot);
+        spec = planned.spec;
+        needsClarification = planned.needsClarification;
+    }
+    pendingHistory.push({
+        event: "workflow-planning-complete",
+        phase: "planning",
+        details: { specId: spec.specId },
+    });
+    if (needsClarification) {
+        pendingHistory.push({
+            event: "planning-needs-clarification",
+            phase: "planning",
+            details: { specId: spec.specId },
+        });
+        return { spec, perSprint: [], needsClarification: true, pendingHistory };
+    }
+    // ── Contracts (preloaded on resume, else derived from the spec) ────
+    const allContracts = args.preloadedContracts.length > 0
+        ? args.preloadedContracts
+        : deps.buildContracts(spec, args);
+    const capped = allContracts.slice(0, Math.min(allContracts.length, args.knobs.maxSprints));
+    // ── Skip-completed (resume) — filter BEFORE dispatch ───────────────
+    const completed = new Set(args.resumeCursor.completedSprintNumbers);
+    const pending = capped.filter((c) => !completed.has(c.sprintNumber));
+    // ── Sprint loop (scheduler-bounded; results index-aligned) ─────────
+    const outcomes = await scheduler.parallel(pending.map((contract) => () => deps.runSprint({
+        contract,
+        spec,
+        maxIterations: args.knobs.maxIterations,
+        priorPassed: [],
+    })));
+    const perSprint = outcomes.map((o) => ({
+        contract: o.contract,
+        finalVerdict: o.finalVerdict,
+        iterationsUsed: o.iterationsUsed,
+        outcome: o.outcome,
+        lensVerdicts: o.lensVerdicts,
+    }));
+    for (const o of outcomes) {
+        pendingHistory.push({
+            event: "workflow-sprint-evaluated",
+            phase: o.outcome === "passed" ? "complete" : "evaluating",
+            sprintId: o.contract.contractId,
+            details: { outcome: o.outcome, iterations: o.iterationsUsed },
+        });
+    }
+    const allPassed = perSprint.length > 0 && perSprint.every((p) => p.outcome === "passed");
+    pendingHistory.push({
+        event: "workflow-complete",
+        phase: allPassed ? "complete" : "failed",
+        details: {
+            total: perSprint.length,
+            passed: perSprint.filter((p) => p.outcome === "passed").length,
+            failed: perSprint.filter((p) => p.outcome !== "passed").length,
+        },
+    });
+    return { spec, perSprint, needsClarification: false, pendingHistory };
+}
+//# sourceMappingURL=interpreter.js.map

package/dist/orchestrator/workflow/interpreter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/interpreter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA4B3C;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,IAAkB,EAClB,WAAmB,EACnB,IAAkB,EAClB,OAA2B,EAAE;IAE7B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;IACxE,MAAM,cAAc,GAAqB,EAAE,CAAC;IAE5C,sEAAsE;IACtE,IAAI,IAAc,CAAC;IACnB,IAAI,kBAAkB,GAAG,KAAK,CAAC;IAC/B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;SAAM,CAAC;QACN,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QACnD,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACpB,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAClD,CAAC;IAED,cAAc,CAAC,IAAI,CAAC;QAClB,KAAK,EAAE,4BAA4B;QACnC,KAAK,EAAE,UAAU;QACjB,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;KACjC,CAAC,CAAC;IAEH,IAAI,kBAAkB,EAAE,CAAC;QACvB,cAAc,CAAC,IAAI,CAAC;YAClB,KAAK,EAAE,8BAA8B;YACrC,KAAK,EAAE,UAAU;YACjB,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;SACjC,CAAC,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;IAC3E,CAAC;IAED,sEAAsE;IACtE,MAAM,YAAY,GAChB,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC;QAChC,CAAC,CAAC,IAAI,CAAC,kBAAkB;QACzB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAEtC,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAC/B,CAAC,EACD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CACrD,CAAC;IAEF,sEAAsE;IACtE,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;IACpE,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;IAErE,sEAAsE;IACtE,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,QAAQ,CACvC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,GAAG,EAAE,CAC7B,IAAI,CAAC,SAAS,CAAC;QACb,QAAQ;QACR,IAAI;QACJ,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa;QACvC,WAAW,EAAE,EAAE;KAChB,CAAC,CACH,CACF,CAAC;IAEF,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACrC,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,YAAY,EAAE,CAAC,CAAC,YAAY;QAC5B,cAAc,EAAE,CAAC,CAAC,cAAc;QAChC,OAAO,EAAE,CAAC,CAAC,OAAO;QAClB,YAAY,EAAE,CAAC,CAAC,YAAY;KAC7B,CAAC,CAAC,CAAC;IAEJ,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,cAAc,CAAC,IAAI,CAAC;YAClB,KAAK,EAAE,2BAA2B;YAClC,KAAK,EAAE,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY;YACzD,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,UAAU;YAC/B,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,cAAc,EAAE;SAC9D,CAAC,CAAC;IACL,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC;IACzF,cAAc,CAAC,IAAI,CAAC;QAClB,KAAK,EAAE,mBAAmB;QAC1B,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ;QACxC,OAAO,EAAE;YACP,KAAK,EAAE,SAAS,CAAC,MAAM;YACvB,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,MAAM;YAC9D,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,MAAM;SAC/D;KACF,CAAC,CAAC;IAEH,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,kBAAkB,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC;AACxE,CAAC"}

package/dist/orchestrator/workflow/pure-sprint.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure (side-effect-free) sprint cycle for the workflow interpreter.
+ *
+ * The TS pipeline's `runSprintCycle` (pipeline.ts:131) writes contracts, history,
+ * and audit checkpoints to `.bober/` inline. The workflow engine makes
+ * `RunResultFlusher` the SOLE clock/commit source — so the interpreter needs a
+ * sprint cycle that produces a result WITHOUT touching disk. This is that cycle:
+ * a generate→evaluate retry loop that returns a {@link SprintOutcome} and writes
+ * nothing. The flusher commits it afterward.
+ *
+ * The curate / generate / evaluate steps are INJECTED ({@link PureSprintDeps}):
+ * Sprint 3 ships the loop + its tests with fakes; the real wiring (runCurator /
+ * runGenerator / panel evaluator) is attached in the interpreter's default deps
+ * (Sprint 5, when eligibility flips). EvalResult timestamps come from the
+ * evaluator (real evaluation data) — never synthesized here — so this stays
+ * clock-free for the host's history stamping.
+ */
+import type { SprintContract } from "../../contracts/sprint-contract.js";
+import type { EvalResult } from "../../contracts/eval-result.js";
+import type { PlanSpec } from "../../contracts/spec.js";
+export type SprintOutcomeKind = "passed" | "needs-rework" | "failed";
+export interface SprintInput {
+    contract: SprintContract;
+    spec: PlanSpec;
+    /** Max generate→evaluate iterations for this sprint. */
+    maxIterations: number;
+    /** Contracts that already passed — context for the generator/curator. */
+    priorPassed: SprintContract[];
+}
+export interface SprintOutcome {
+    contract: SprintContract;
+    finalVerdict: EvalResult;
+    iterationsUsed: number;
+    outcome: SprintOutcomeKind;
+    /** The per-lens verdicts from the final iteration (length >= 1). */
+    lensVerdicts: EvalResult[];
+}
+/** One generation attempt's result (provider-agnostic, side-effect-free). */
+export interface GenerationResult {
+    /** True if the generator hit a hard blocker it could not resolve. */
+    blocked: boolean;
+    /** Free-form summary, threaded into the next iteration's feedback. */
+    summary: string;
+}
+export type ReconcileFn = (contractId: string, iteration: number, verdicts: EvalResult[], timestamp: string) => EvalResult;
+export interface PureSprintDeps {
+    /** Optional one-shot context curation; returns a briefing string. */
+    curate?: (input: SprintInput) => Promise<string>;
+    /** Run one generation attempt. `feedback` is empty on the first iteration. */
+    generate: (input: SprintInput, briefing: string, feedback: string) => Promise<GenerationResult>;
+    /** Evaluate current state → one or more lens verdicts for this iteration. */
+    evaluate: (input: SprintInput, iteration: number) => Promise<EvalResult[]>;
+    /** Reduce lens verdicts to one verdict. Defaults to the majority-vote reconciler. */
+    reconcile?: ReconcileFn;
+}
+/**
+ * Run a single sprint's generate→evaluate retry loop, side-effect-free.
+ *
+ * Each iteration: (curate once) → generate → evaluate → reconcile. Returns
+ * `passed` as soon as a verdict passes (and the generator isn't blocked);
+ * `failed` if the generator reports a hard blocker; `needs-rework` if the
+ * iteration budget is exhausted without passing.
+ */
+export declare function runPureSprint(input: SprintInput, deps: PureSprintDeps): Promise<SprintOutcome>;
+//# sourceMappingURL=pure-sprint.d.ts.map

package/dist/orchestrator/workflow/pure-sprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-sprint.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/pure-sprint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,cAAc,GAAG,QAAQ,CAAC;AAErE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,wDAAwD;IACxD,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,WAAW,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,YAAY,EAAE,UAAU,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,oEAAoE;IACpE,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,WAAW,GAAG,CACxB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,UAAU,EAAE,EACtB,SAAS,EAAE,MAAM,KACd,UAAU,CAAC;AAEhB,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,8EAA8E;IAC9E,QAAQ,EAAE,CACR,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC3E,qFAAqF;IACrF,SAAS,CAAC,EAAE,WAAW,CAAC;CACzB;AAaD;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,aAAa,CAAC,CAqDxB"}

package/dist/orchestrator/workflow/pure-sprint.js

@@ -0,0 +1,82 @@
+/**
+ * Pure (side-effect-free) sprint cycle for the workflow interpreter.
+ *
+ * The TS pipeline's `runSprintCycle` (pipeline.ts:131) writes contracts, history,
+ * and audit checkpoints to `.bober/` inline. The workflow engine makes
+ * `RunResultFlusher` the SOLE clock/commit source — so the interpreter needs a
+ * sprint cycle that produces a result WITHOUT touching disk. This is that cycle:
+ * a generate→evaluate retry loop that returns a {@link SprintOutcome} and writes
+ * nothing. The flusher commits it afterward.
+ *
+ * The curate / generate / evaluate steps are INJECTED ({@link PureSprintDeps}):
+ * Sprint 3 ships the loop + its tests with fakes; the real wiring (runCurator /
+ * runGenerator / panel evaluator) is attached in the interpreter's default deps
+ * (Sprint 5, when eligibility flips). EvalResult timestamps come from the
+ * evaluator (real evaluation data) — never synthesized here — so this stays
+ * clock-free for the host's history stamping.
+ */
+import { reconcile } from "./reconciler.js";
+/** Use a verdict's own timestamp (evaluation data); epoch fallback if none. */
+function pickTimestamp(verdicts) {
+    return verdicts[0]?.timestamp ?? new Date(0).toISOString();
+}
+function buildFeedback(verdict, gen) {
+    return [verdict.feedback, gen.summary]
+        .filter((s) => s.length > 0)
+        .join("\n");
+}
+/**
+ * Run a single sprint's generate→evaluate retry loop, side-effect-free.
+ *
+ * Each iteration: (curate once) → generate → evaluate → reconcile. Returns
+ * `passed` as soon as a verdict passes (and the generator isn't blocked);
+ * `failed` if the generator reports a hard blocker; `needs-rework` if the
+ * iteration budget is exhausted without passing.
+ */
+export async function runPureSprint(input, deps) {
+    const reduce = deps.reconcile ?? reconcile;
+    const contractId = input.contract.contractId;
+    const briefing = deps.curate ? await deps.curate(input) : "";
+    const maxIter = Math.max(1, input.maxIterations);
+    let feedback = "";
+    let lastVerdict;
+    let lastLensVerdicts = [];
+    for (let iter = 1; iter <= maxIter; iter += 1) {
+        const gen = await deps.generate(input, briefing, feedback);
+        const lensVerdicts = await deps.evaluate(input, iter);
+        lastLensVerdicts = lensVerdicts;
+        const verdict = lensVerdicts.length === 1 && lensVerdicts[0] !== undefined
+            ? lensVerdicts[0]
+            : reduce(contractId, iter, lensVerdicts, pickTimestamp(lensVerdicts));
+        lastVerdict = verdict;
+        if (verdict.passed && !gen.blocked) {
+            return {
+                contract: input.contract,
+                finalVerdict: verdict,
+                iterationsUsed: iter,
+                outcome: "passed",
+                lensVerdicts,
+            };
+        }
+        if (gen.blocked) {
+            return {
+                contract: input.contract,
+                finalVerdict: verdict,
+                iterationsUsed: iter,
+                outcome: "failed",
+                lensVerdicts,
+            };
+        }
+        feedback = buildFeedback(verdict, gen);
+    }
+    // Iteration budget exhausted without passing → retryable rework.
+    const finalVerdict = lastVerdict ?? reduce(contractId, maxIter, [], new Date(0).toISOString());
+    return {
+        contract: input.contract,
+        finalVerdict,
+        iterationsUsed: maxIter,
+        outcome: "needs-rework",
+        lensVerdicts: lastLensVerdicts,
+    };
+}
+//# sourceMappingURL=pure-sprint.js.map

package/dist/orchestrator/workflow/pure-sprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-sprint.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/pure-sprint.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator/workflow/reconciler.d.ts

@@ -0,0 +1,15 @@
+import type { EvalResult } from "../../contracts/eval-result.js";
+/**
+ * Pure majority-vote reducer over per-lens EvalResult[] (ADR-4).
+ * No Date.now / new Date / Math.random / fs — timestamp is a caller arg.
+ *
+ * Rules:
+ *   - empty lensVerdicts → throws
+ *   - passed = passCount > failCount (strict majority, fail-closed on tie)
+ *   - details = union of all failing details, de-duped by (criterion, message)
+ *   - feedback = failing lenses' feedback joined with newlines, or "All lenses passed."
+ *   - evaluator = "panel"
+ *   - timestamp = the injected timestamp argument (echoed verbatim)
+ */
+export declare function reconcile(_sprintId: string, _round: number, lensVerdicts: EvalResult[], timestamp: string): EvalResult;
+//# sourceMappingURL=reconciler.d.ts.map

package/dist/orchestrator/workflow/reconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciler.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/reconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,gCAAgC,CAAC;AAI7E;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,UAAU,EAAE,EAC1B,SAAS,EAAE,MAAM,GAChB,UAAU,CA4DZ"}

package/dist/orchestrator/workflow/reconciler.js

@@ -0,0 +1,65 @@
+// ── Reconciler ─────────────────────────────────────────────────────
+/**
+ * Pure majority-vote reducer over per-lens EvalResult[] (ADR-4).
+ * No Date.now / new Date / Math.random / fs — timestamp is a caller arg.
+ *
+ * Rules:
+ *   - empty lensVerdicts → throws
+ *   - passed = passCount > failCount (strict majority, fail-closed on tie)
+ *   - details = union of all failing details, de-duped by (criterion, message)
+ *   - feedback = failing lenses' feedback joined with newlines, or "All lenses passed."
+ *   - evaluator = "panel"
+ *   - timestamp = the injected timestamp argument (echoed verbatim)
+ */
+export function reconcile(_sprintId, _round, lensVerdicts, timestamp) {
+    if (lensVerdicts.length === 0) {
+        throw new Error("reconcile: lensVerdicts must be non-empty");
+    }
+    const n = lensVerdicts.length;
+    // Count passing lenses
+    let passCount = 0;
+    for (const lens of lensVerdicts) {
+        if (lens.passed === true) {
+            passCount = passCount + 1;
+        }
+    }
+    const failCount = n - passCount;
+    // Strict majority: passCount must exceed failCount (fail-closed on tie)
+    const passed = passCount > failCount;
+    // Union failing details, de-duped by criterion + message
+    const seenKeys = new Set();
+    const details = [];
+    for (const lens of lensVerdicts) {
+        for (const detail of lens.details) {
+            if (detail.passed === false) {
+                const key = `${detail.criterion}␟${detail.message}`;
+                if (!seenKeys.has(key)) {
+                    seenKeys.add(key);
+                    details.push(detail);
+                }
+            }
+        }
+    }
+    // Build summary
+    const summary = `Panel verdict: ${passCount}/${n} lenses passed`;
+    // Build feedback from failing lenses
+    const feedbackParts = [];
+    for (const lens of lensVerdicts) {
+        if (!lens.passed && lens.feedback) {
+            feedbackParts.push(lens.feedback);
+        }
+    }
+    const feedback = feedbackParts.length > 0 ? feedbackParts.join("\n") : "All lenses passed.";
+    // Compute optional score
+    const score = Math.round((100 * passCount) / n);
+    return {
+        evaluator: "panel",
+        passed,
+        score,
+        details,
+        summary,
+        feedback,
+        timestamp,
+    };
+}
+//# sourceMappingURL=reconciler.js.map

package/dist/orchestrator/workflow/reconciler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciler.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/reconciler.ts"],"names":[],"mappings":"AAEA,sEAAsE;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CACvB,SAAiB,EACjB,MAAc,EACd,YAA0B,EAC1B,SAAiB;IAEjB,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC;IAE9B,uBAAuB;IACvB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACzB,SAAS,GAAG,SAAS,GAAG,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;IAEhC,wEAAwE;IACxE,MAAM,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IAErC,yDAAyD;IACzD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,OAAO,GAAiB,EAAE,CAAC;IAEjC,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;gBAC5B,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBACvB,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAClB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACvB,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,gBAAgB;IAChB,MAAM,OAAO,GAAG,kBAAkB,SAAS,IAAI,CAAC,gBAAgB,CAAC;IAEjE,qCAAqC;IACrC,MAAM,aAAa,GAAa,EAAE,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IACD,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC;IAE5F,yBAAyB;IACzB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;IAEhD,OAAO;QACL,SAAS,EAAE,OAAO;QAClB,MAAM;QACN,KAAK;QACL,OAAO;QACP,OAAO;QACP,QAAQ;QACR,SAAS;KACV,CAAC;AACJ,CAAC"}

package/dist/orchestrator/workflow/resume-cursor.d.ts

@@ -0,0 +1,10 @@
+import type { ResumeCursor } from "./types.js";
+/**
+ * Reconstructs a ResumeCursor from durable contract status and history.
+ * Contract status is the source of truth — history is corroboration only.
+ * When history and contract status conflict, contract status wins.
+ */
+export declare class ResumeCursorReconstructor {
+    reconstruct(projectRoot: string, specId: string): Promise<ResumeCursor>;
+}
+//# sourceMappingURL=resume-cursor.d.ts.map

package/dist/orchestrator/workflow/resume-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-cursor.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/resume-cursor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;GAIG;AACH,qBAAa,yBAAyB;IAC9B,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAoB9E"}

package/dist/orchestrator/workflow/resume-cursor.js

@@ -0,0 +1,25 @@
+// ── ResumeCursorReconstructor ───────────────────────────────────────
+import { listContracts } from "../../state/sprint-state.js";
+import { loadHistory } from "../../state/history.js";
+/**
+ * Reconstructs a ResumeCursor from durable contract status and history.
+ * Contract status is the source of truth — history is corroboration only.
+ * When history and contract status conflict, contract status wins.
+ */
+export class ResumeCursorReconstructor {
+    async reconstruct(projectRoot, specId) {
+        const contracts = (await listContracts(projectRoot)).filter((c) => c.specId === specId);
+        // Corroborate with history, but contract status WINS on conflict
+        await loadHistory(projectRoot);
+        const completed = contracts
+            .filter((c) => c.status === "passed" || c.status === "completed")
+            .map((c) => c.sprintNumber);
+        const allNumbers = contracts.map((c) => c.sprintNumber);
+        return {
+            specId,
+            completedSprintNumbers: [...completed].sort((a, b) => a - b),
+            lastObservedSprintNumber: allNumbers.length ? Math.max(...allNumbers) : 0,
+        };
+    }
+}
+//# sourceMappingURL=resume-cursor.js.map

package/dist/orchestrator/workflow/resume-cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-cursor.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/resume-cursor.ts"],"names":[],"mappings":"AAAA,uEAAuE;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAGrD;;;;GAIG;AACH,MAAM,OAAO,yBAAyB;IACpC,KAAK,CAAC,WAAW,CAAC,WAAmB,EAAE,MAAc;QACnD,MAAM,SAAS,GAAG,CAAC,MAAM,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CACzD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAC3B,CAAC;QAEF,iEAAiE;QACjE,MAAM,WAAW,CAAC,WAAW,CAAC,CAAC;QAE/B,MAAM,SAAS,GAAG,SAAS;aACxB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC;aAChE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QAE9B,MAAM,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QAExD,OAAO;YACL,MAAM;YACN,sBAAsB,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;YAC5D,wBAAwB,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;SAC1E,CAAC;IACJ,CAAC;CACF"}

package/dist/orchestrator/workflow/retry.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Exponential-backoff retry for transient provider failures.
+ *
+ * Today the agentic loop ends on the first `client.chat()` error
+ * (agentic-loop.ts), which is fragile when hammering a single local model
+ * server (Ollama/vLLM return 429/503 under load). `withRetry` wraps a call in
+ * bounded exponential backoff with jitter, retrying only TRANSIENT failures
+ * (rate limits, overload, timeouts, network resets) and surfacing everything
+ * else immediately.
+ *
+ * The scheduler / interpreter wraps each provider call in this, so every
+ * provider benefits without per-adapter changes. `sleep` and `jitter` are
+ * injectable so tests are deterministic and instant.
+ */
+/**
+ * Heuristic: is this error worth retrying? True for HTTP 408/429 and 5xx,
+ * known transient network codes, and overload/rate-limit/timeout messages.
+ */
+export declare function classifyTransient(err: unknown): boolean;
+export interface RetryOptions {
+    /** Max retries AFTER the first attempt. Default 3 (=> up to 4 calls). */
+    maxRetries?: number;
+    /** Base delay in ms for the first backoff. Default 500. */
+    baseDelayMs?: number;
+    /** Upper bound on a single backoff delay. Default 30_000. */
+    maxDelayMs?: number;
+    /** Exponential growth factor. Default 2. */
+    factor?: number;
+    /** Returns a value in [0, 1) for jitter. Default Math.random. Inject for tests. */
+    jitter?: () => number;
+    /** Sleeps for `ms`. Default setTimeout-backed. Inject for tests. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Decides whether an error is retryable. Default {@link classifyTransient}. */
+    isTransient?: (err: unknown) => boolean;
+    /** Called before each backoff sleep (for logging / telemetry). */
+    onRetry?: (info: {
+        attempt: number;
+        delayMs: number;
+        error: unknown;
+    }) => void;
+}
+/**
+ * Run `fn`, retrying TRANSIENT failures with exponential backoff + jitter.
+ * Non-transient errors and the final exhausted error are rethrown.
+ *
+ * Backoff for retry `n` (0-based): `min(maxDelayMs, baseDelayMs * factor**n)`,
+ * then jittered to 50–100% of that value (decorrelated, avoids thundering herd).
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/orchestrator/workflow/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA2CH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CASvD;AAID,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,gFAAgF;IAChF,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;IACxC,kEAAkE;IAClE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;CAChF;AAKD;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,CAAC,CAAC,CAyBZ"}