@cat-factory/orchestration 0.6.0

package/dist/modules/execution/advance.d.ts

@@ -0,0 +1,84 @@
+import type { AgentFailureKind } from '@cat-factory/kernel';
+export type AdvanceResult = 
+/** The step completed; the run is still running and has more steps. */
+{
+    kind: 'continue';
+}
+/** The step raised a decision; the run is parked until it is resolved. */
+ | {
+    kind: 'awaiting_decision';
+    decisionId: string;
+}
+/**
+ * The step dispatched an asynchronous agent job (a container run). The run is
+ * parked: the durable driver polls {@link ExecutionService.pollAgentJob} between
+ * sleeps until the job finishes, then records its result and continues.
+ */
+ | {
+    kind: 'awaiting_job';
+    jobId: string;
+    stepIndex: number;
+}
+/**
+ * A polling **gate** step (`ci` / `conflicts`) is gating the PR on its precheck.
+ * The run is parked: the durable driver sleeps, then polls
+ * {@link ExecutionService.pollGate} to re-run the precheck (which gate is resolved
+ * from the current step's `agentKind`). Polling stops the moment `pollGate` returns
+ * anything else — a passing precheck yields `continue`, a dispatched helper agent
+ * (ci-fixer / conflict-resolver) yields `awaiting_job`, exhaustion fails the run.
+ */
+ | {
+    kind: 'awaiting_gate';
+    stepIndex: number;
+}
+/**
+ * A step finished in a terminal failure; the driver records it via the single
+ * `failRun` funnel and stops. `error` is the human-readable message. An inline
+ * gate that already knows the precise classification sets `failureKind` (e.g. an
+ * unparseable companion verdict → `'companion_rejected'`, a Tester gate that
+ * exhausted its fixer budget → `'agent'`) and may attach extended `detail` (e.g.
+ * the companion's raw reply); the driver records those instead of the generic
+ * `'job_failed'` container-failure framing. Defaults: `failureKind` →
+ * `'job_failed'`, `detail` → none. Inline gates MUST NOT call `failRun`
+ * themselves — returning this is the single path so the driver can't double-write
+ * and clobber the rich record.
+ */
+ | {
+    kind: 'job_failed';
+    error: string;
+    failureKind?: AgentFailureKind;
+    detail?: string;
+}
+/**
+ * A polled async job's container was evicted/crashed and the single automatic
+ * recovery (a fresh-container re-dispatch of the same step) has been spent, so the
+ * eviction is treated as deterministic. The driver fails the run as `evicted`.
+ * (A first eviction is recovered silently inside {@link ExecutionService.pollAgentJob}
+ * by re-dispatching and returning `continue`, so it never reaches the driver.)
+ */
+ | {
+    kind: 'job_evicted';
+    error: string;
+}
+/** The final step completed; the run is finished. */
+ | {
+    kind: 'done';
+}
+/** The spend budget is exhausted; the run is paused until it frees up. */
+ | {
+    kind: 'paused';
+}
+/** Nothing to do — the run is absent or not running (replay/idempotent). */
+ | {
+    kind: 'noop';
+};
+/** Options controlling how a single advance behaves. */
+export interface AdvanceOptions {
+    /**
+     * When true, an agent failure is rethrown instead of being swallowed into the
+     * step output. The durable driver sets this so a failed `step.do` retries; tests
+     * leave it false to preserve the "never wedge" behaviour.
+     */
+    rethrowAgentErrors?: boolean;
+}
+//# sourceMappingURL=advance.d.ts.map

package/dist/modules/execution/advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/advance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAK3D,MAAM,MAAM,aAAa;AACvB,uEAAuE;AACrE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE;AACtB,0EAA0E;GACxE;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE;AACnD;;;;GAIG;GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAC5D;;;;;;;GAOG;GACD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAC9C;;;;;;;;;;;GAWG;GACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;AACxF;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACxC,qDAAqD;GACnD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB,0EAA0E;GACxE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;AACpB,4EAA4E;GAC1E;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpB,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B"}

package/dist/modules/execution/advance.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=advance.js.map

package/dist/modules/execution/advance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.js","sourceRoot":"","sources":["../../../src/modules/execution/advance.ts"],"names":[],"mappings":""}

package/dist/modules/execution/artifact-review.logic.d.ts

@@ -0,0 +1,25 @@
+import type { AgentRunResult } from '@cat-factory/kernel';
+/**
+ * The text a companion (and the SPA reader, and downstream steps via `priorOutputs`)
+ * should review for a finished producer step, or `undefined` when the step's own
+ * `output` already IS the work product.
+ *
+ * A producer that emits a STRUCTURED ARTIFACT (the spec doc, the blueprint tree, …)
+ * runs as a container agent: it commits the artifact to the repo and returns its raw
+ * Pi transcript summary as `result.output`. That summary is a useless thing to grade
+ * — it was what made the spec-companion declare every pass "unreviewable" and loop the
+ * producer to its rework cap on every spec task. So whenever a known artifact is
+ * present, the reviewable output is a deterministic rendering of the ARTIFACT itself.
+ *
+ * This is the universal seam: it is keyed off WHICH artifact the result carries, not
+ * off a specific `agentKind`, so every artifact-producing agent with a companion —
+ * today's spec-writer, and any future one — is covered by rendering its artifact here
+ * rather than by another per-agent special case. A producer whose work product is
+ * already prose (architect, researcher, the coder's PR summary) carries no artifact
+ * field and falls through to `undefined`, keeping its own `output`.
+ *
+ * Falls back to `undefined` when the artifact is present but won't parse (the in-repo
+ * files are committed regardless, so the raw summary is kept rather than nothing).
+ */
+export declare function reviewableArtifactOutput(result: AgentRunResult): string | undefined;
+//# sourceMappingURL=artifact-review.logic.d.ts.map

package/dist/modules/execution/artifact-review.logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-review.logic.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/artifact-review.logic.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAcnF"}

package/dist/modules/execution/artifact-review.logic.js

@@ -0,0 +1,39 @@
+import { renderBlueprintForReview, renderSpecForReview, safeParseBlueprintService, safeParseSpecDoc, } from '@cat-factory/contracts';
+/**
+ * The text a companion (and the SPA reader, and downstream steps via `priorOutputs`)
+ * should review for a finished producer step, or `undefined` when the step's own
+ * `output` already IS the work product.
+ *
+ * A producer that emits a STRUCTURED ARTIFACT (the spec doc, the blueprint tree, …)
+ * runs as a container agent: it commits the artifact to the repo and returns its raw
+ * Pi transcript summary as `result.output`. That summary is a useless thing to grade
+ * — it was what made the spec-companion declare every pass "unreviewable" and loop the
+ * producer to its rework cap on every spec task. So whenever a known artifact is
+ * present, the reviewable output is a deterministic rendering of the ARTIFACT itself.
+ *
+ * This is the universal seam: it is keyed off WHICH artifact the result carries, not
+ * off a specific `agentKind`, so every artifact-producing agent with a companion —
+ * today's spec-writer, and any future one — is covered by rendering its artifact here
+ * rather than by another per-agent special case. A producer whose work product is
+ * already prose (architect, researcher, the coder's PR summary) carries no artifact
+ * field and falls through to `undefined`, keeping its own `output`.
+ *
+ * Falls back to `undefined` when the artifact is present but won't parse (the in-repo
+ * files are committed regardless, so the raw summary is kept rather than nothing).
+ */
+export function reviewableArtifactOutput(result) {
+    if (result.spec !== undefined) {
+        const doc = safeParseSpecDoc(result.spec);
+        return doc ? renderSpecForReview(doc) : undefined;
+    }
+    if (result.blueprintService !== undefined) {
+        const service = safeParseBlueprintService(result.blueprintService);
+        return service ? renderBlueprintForReview(service) : undefined;
+    }
+    // `testReport` / `mergeAssessment` carry their own dedicated structured surfaces
+    // (the tester result view; the merger is the final step) and no prose companion
+    // grades them today. If one ever gains a companion, render it here — the seam, not
+    // the call sites, is where a new artifact type is taught to be reviewable.
+    return undefined;
+}
+//# sourceMappingURL=artifact-review.logic.js.map

package/dist/modules/execution/artifact-review.logic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-review.logic.js","sourceRoot":"","sources":["../../../src/modules/execution/artifact-review.logic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,wBAAwB,CAAA;AAG/B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAsB;IAC7D,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACzC,OAAO,GAAG,CAAC,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IACnD,CAAC;IACD,IAAI,MAAM,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,yBAAyB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;QAClE,OAAO,OAAO,CAAC,CAAC,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAChE,CAAC;IACD,iFAAiF;IACjF,gFAAgF;IAChF,mFAAmF;IACnF,2EAA2E;IAC3E,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/dist/modules/execution/ci.logic.d.ts

@@ -0,0 +1,101 @@
+import type { CiCheck } from '@cat-factory/kernel';
+/** The agent kind of the special CI-gate step (polls checks, loops the ci-fixer). */
+export declare const CI_AGENT_KIND = "ci";
+/**
+ * The agent kind of the special requirements-review gate step. It is NOT a container /
+ * prose agent: the engine runs the inline reviewer (via the requirements module), parks
+ * the run for the dedicated review window, and drives the iterative answer → incorporate →
+ * re-review loop until it converges (or the human resolves a hit iteration cap). Passes
+ * through when the requirements module / reviewer model is not wired.
+ */
+export declare const REQUIREMENTS_REVIEW_AGENT_KIND = "requirements-review";
+/**
+ * The agent kind of the special clarity-review gate step. Like the requirements reviewer
+ * it is an INLINE engine step (not a container/prose agent): the engine runs the inline
+ * clarity reviewer (via the clarity module), parks the run for the dedicated review
+ * window, and drives the iterative answer → incorporate → re-review loop until it
+ * converges. It triages a BUG REPORT for fixability rather than reviewing requirements
+ * completeness. Passes through when the clarity module / reviewer model is not wired.
+ */
+export declare const CLARITY_REVIEW_AGENT_KIND = "clarity-review";
+/**
+ * The agent kind of the read-only `bug-investigator` container agent. It clones the repo,
+ * reads the codebase from the raw bug report, and returns a prose report: an enriched bug
+ * report plus an OPTIONAL working hypothesis (omitted unless reasonably confident). It
+ * makes no commits and opens no PR — it runs the shared read-only `/explore` harness path
+ * (like `architect`/`analysis`). Its prose output feeds the downstream clarity reviewer
+ * (as the triage subject) and the coder (via `priorOutputs`, as a non-binding lead).
+ */
+export declare const BUG_INVESTIGATOR_AGENT_KIND = "bug-investigator";
+/**
+ * The agent kind of the container agent that writes the service's unified, in-repo
+ * specification (`spec.json`). It runs BEFORE the coder and aggregates the collected
+ * requirements of every task under the service frame — including their acceptance
+ * scenarios — onto the implementation branch.
+ */
+export declare const SPEC_WRITER_AGENT_KIND = "spec-writer";
+/** The agent kind of the container agent that fixes failing CI on the PR branch. */
+export declare const CI_FIXER_AGENT_KIND = "ci-fixer";
+/** The agent kind of the container agent that scores a PR for the merge decision. */
+export declare const MERGER_AGENT_KIND = "merger";
+/**
+ * The agent kind of the special `tester` gate step: a container agent that runs the
+ * project's tests (local docker-compose infra or an ephemeral env) and returns a
+ * structured report. On a withheld greenlight the engine loops the `fixer` agent
+ * with the report and re-tests — mirroring the CI gate / ci-fixer loop.
+ */
+export declare const TESTER_AGENT_KIND = "tester";
+/**
+ * The agent kind of the container agent that applies fixes from a Tester's report to
+ * the PR head branch and pushes them back (no new PR), looping with the Tester.
+ */
+export declare const FIXER_AGENT_KIND = "fixer";
+/**
+ * The agent kind of the special pre-merge gate step: it checks whether the PR can
+ * be merged and, on a conflict, loops the conflict-resolver — mirroring the CI gate.
+ */
+export declare const CONFLICTS_AGENT_KIND = "conflicts";
+/**
+ * The agent kind of the container agent that resolves merge conflicts: it merges
+ * the base into the PR branch, fixes the conflicts and pushes back onto the branch.
+ */
+export declare const CONFLICT_RESOLVER_AGENT_KIND = "conflict-resolver";
+/**
+ * The agent kind of the read-only code-analysis agent that opens the tech-debt
+ * recurring pipeline: it inspects the repo and emits a prioritized markdown report
+ * (no commits). Reuses the generic container run path — no special engine handling.
+ */
+export declare const ANALYSIS_AGENT_KIND = "analysis";
+/**
+ * The agent kind of the special `tracker` step: a non-LLM step that files a GitHub
+ * issue / Jira ticket from the preceding `analysis` output before implementation,
+ * mirroring the special handling of the `ci` gate. Passes through when no tracker
+ * is configured for the workspace.
+ */
+export declare const TRACKER_AGENT_KIND = "tracker";
+/**
+ * The aggregate CI verdict for a PR head commit, derived from its check runs:
+ *  - `none`    — no checks reported (nothing to gate; treated as green).
+ *  - `pending` — at least one check is still queued/in-progress and none failed.
+ *  - `success` — every completed check succeeded (or was neutral/skipped) and none pending.
+ *  - `failure` — at least one check concluded in a non-success terminal state.
+ */
+export type CiVerdict = 'none' | 'pending' | 'success' | 'failure';
+/**
+ * Reduce a set of check runs to a single verdict. A failure dominates (one red
+ * check fails the gate); otherwise a still-running check keeps it pending; with
+ * everything completed-and-passing it is green; with no checks at all it is
+ * `none` (the engine treats `none` as green so a repo with no CI configured isn't
+ * blocked forever).
+ */
+export declare function aggregateCi(checks: CiCheck[]): CiVerdict;
+/** Whether a verdict means the gate may advance (green or nothing to gate). */
+export declare function isCiGreen(verdict: CiVerdict): boolean;
+/** The completed-and-non-passing checks behind a `failure` verdict. */
+export declare function listFailingChecks(checks: CiCheck[]): {
+    name: string;
+    conclusion: string | null;
+}[];
+/** A short, human-readable summary of the failing checks, for the step output / notification. */
+export declare function describeFailingChecks(checks: CiCheck[]): string;
+//# sourceMappingURL=ci.logic.d.ts.map

package/dist/modules/execution/ci.logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci.logic.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/ci.logic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,qFAAqF;AACrF,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,wBAAwB,CAAA;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,mBAAmB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,qBAAqB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAA;AAEnD,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,aAAa,CAAA;AAE7C,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,WAAW,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,WAAW,CAAA;AAEzC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,UAAU,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,4BAA4B,sBAAsB,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,aAAa,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;AAKlE;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,SAAS,CAYxD;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAErD;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,OAAO,EAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,CAI/C;AAED,iGAAiG;AACjG,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAK/D"}

package/dist/modules/execution/ci.logic.js

@@ -0,0 +1,117 @@
+/** The agent kind of the special CI-gate step (polls checks, loops the ci-fixer). */
+export const CI_AGENT_KIND = 'ci';
+/**
+ * The agent kind of the special requirements-review gate step. It is NOT a container /
+ * prose agent: the engine runs the inline reviewer (via the requirements module), parks
+ * the run for the dedicated review window, and drives the iterative answer → incorporate →
+ * re-review loop until it converges (or the human resolves a hit iteration cap). Passes
+ * through when the requirements module / reviewer model is not wired.
+ */
+export const REQUIREMENTS_REVIEW_AGENT_KIND = 'requirements-review';
+/**
+ * The agent kind of the special clarity-review gate step. Like the requirements reviewer
+ * it is an INLINE engine step (not a container/prose agent): the engine runs the inline
+ * clarity reviewer (via the clarity module), parks the run for the dedicated review
+ * window, and drives the iterative answer → incorporate → re-review loop until it
+ * converges. It triages a BUG REPORT for fixability rather than reviewing requirements
+ * completeness. Passes through when the clarity module / reviewer model is not wired.
+ */
+export const CLARITY_REVIEW_AGENT_KIND = 'clarity-review';
+/**
+ * The agent kind of the read-only `bug-investigator` container agent. It clones the repo,
+ * reads the codebase from the raw bug report, and returns a prose report: an enriched bug
+ * report plus an OPTIONAL working hypothesis (omitted unless reasonably confident). It
+ * makes no commits and opens no PR — it runs the shared read-only `/explore` harness path
+ * (like `architect`/`analysis`). Its prose output feeds the downstream clarity reviewer
+ * (as the triage subject) and the coder (via `priorOutputs`, as a non-binding lead).
+ */
+export const BUG_INVESTIGATOR_AGENT_KIND = 'bug-investigator';
+/**
+ * The agent kind of the container agent that writes the service's unified, in-repo
+ * specification (`spec.json`). It runs BEFORE the coder and aggregates the collected
+ * requirements of every task under the service frame — including their acceptance
+ * scenarios — onto the implementation branch.
+ */
+export const SPEC_WRITER_AGENT_KIND = 'spec-writer';
+/** The agent kind of the container agent that fixes failing CI on the PR branch. */
+export const CI_FIXER_AGENT_KIND = 'ci-fixer';
+/** The agent kind of the container agent that scores a PR for the merge decision. */
+export const MERGER_AGENT_KIND = 'merger';
+/**
+ * The agent kind of the special `tester` gate step: a container agent that runs the
+ * project's tests (local docker-compose infra or an ephemeral env) and returns a
+ * structured report. On a withheld greenlight the engine loops the `fixer` agent
+ * with the report and re-tests — mirroring the CI gate / ci-fixer loop.
+ */
+export const TESTER_AGENT_KIND = 'tester';
+/**
+ * The agent kind of the container agent that applies fixes from a Tester's report to
+ * the PR head branch and pushes them back (no new PR), looping with the Tester.
+ */
+export const FIXER_AGENT_KIND = 'fixer';
+/**
+ * The agent kind of the special pre-merge gate step: it checks whether the PR can
+ * be merged and, on a conflict, loops the conflict-resolver — mirroring the CI gate.
+ */
+export const CONFLICTS_AGENT_KIND = 'conflicts';
+/**
+ * The agent kind of the container agent that resolves merge conflicts: it merges
+ * the base into the PR branch, fixes the conflicts and pushes back onto the branch.
+ */
+export const CONFLICT_RESOLVER_AGENT_KIND = 'conflict-resolver';
+/**
+ * The agent kind of the read-only code-analysis agent that opens the tech-debt
+ * recurring pipeline: it inspects the repo and emits a prioritized markdown report
+ * (no commits). Reuses the generic container run path — no special engine handling.
+ */
+export const ANALYSIS_AGENT_KIND = 'analysis';
+/**
+ * The agent kind of the special `tracker` step: a non-LLM step that files a GitHub
+ * issue / Jira ticket from the preceding `analysis` output before implementation,
+ * mirroring the special handling of the `ci` gate. Passes through when no tracker
+ * is configured for the workspace.
+ */
+export const TRACKER_AGENT_KIND = 'tracker';
+/** Conclusions GitHub reports for a *completed* check that are NOT failures. */
+const PASSING_CONCLUSIONS = new Set(['success', 'neutral', 'skipped']);
+/**
+ * Reduce a set of check runs to a single verdict. A failure dominates (one red
+ * check fails the gate); otherwise a still-running check keeps it pending; with
+ * everything completed-and-passing it is green; with no checks at all it is
+ * `none` (the engine treats `none` as green so a repo with no CI configured isn't
+ * blocked forever).
+ */
+export function aggregateCi(checks) {
+    if (checks.length === 0)
+        return 'none';
+    let pending = false;
+    for (const check of checks) {
+        if (check.status !== 'completed') {
+            pending = true;
+            continue;
+        }
+        const conclusion = check.conclusion ?? '';
+        if (!PASSING_CONCLUSIONS.has(conclusion))
+            return 'failure';
+    }
+    return pending ? 'pending' : 'success';
+}
+/** Whether a verdict means the gate may advance (green or nothing to gate). */
+export function isCiGreen(verdict) {
+    return verdict === 'success' || verdict === 'none';
+}
+/** The completed-and-non-passing checks behind a `failure` verdict. */
+export function listFailingChecks(checks) {
+    return checks
+        .filter((c) => c.status === 'completed' && !PASSING_CONCLUSIONS.has(c.conclusion ?? ''))
+        .map((c) => ({ name: c.name, conclusion: c.conclusion }));
+}
+/** A short, human-readable summary of the failing checks, for the step output / notification. */
+export function describeFailingChecks(checks) {
+    const failing = listFailingChecks(checks);
+    if (failing.length === 0)
+        return 'CI reported a failure.';
+    const names = failing.map((c) => `${c.name} (${c.conclusion ?? 'failure'})`).join(', ');
+    return `Failing checks: ${names}`;
+}
+//# sourceMappingURL=ci.logic.js.map

package/dist/modules/execution/ci.logic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci.logic.js","sourceRoot":"","sources":["../../../src/modules/execution/ci.logic.ts"],"names":[],"mappings":"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"}

package/dist/modules/execution/drive.d.ts

@@ -0,0 +1,47 @@
+import type { ExecutionService } from './ExecutionService.js';
+/** Poll cadence + budgets for the gates a parked run waits on. */
+export interface DriveConfig {
+    jobPollIntervalMs: number;
+    jobMaxPolls: number;
+    jobPollFailureTolerance: number;
+    ciPollIntervalMs: number;
+    ciMaxPolls: number;
+}
+/** Minimal structured logger the driver needs (pino is structurally compatible). */
+export interface DriveLogger {
+    info(obj: unknown, msg?: string): void;
+}
+/** Runtime seams the driver loop needs; both have inert defaults. */
+export interface DriveOptions {
+    /**
+     * How to wait between gate polls. Orchestration is runtime-neutral (no timers), so
+     * the default resolves INSTANTLY; the Node service injects a real `setTimeout` sleep
+     * (see its `drive.ts` wrapper), and the conformance harness keeps the instant default
+     * to drive the deterministic fakes without real waiting.
+     */
+    sleep?: (ms: number) => Promise<void>;
+    /** Where to log lifecycle breadcrumbs. Defaults to a no-op. */
+    log?: DriveLogger;
+}
+/** What a drive ended on, so the runner can schedule follow-up work (a decision timeout). */
+export interface DriveOutcome {
+    /** Set when the run parked awaiting a human decision/approval with this id. */
+    parkedDecisionId?: string;
+}
+/**
+ * Drive one run to a standstill. The runtime-neutral driver loop: it contains NO
+ * business logic — every decision lives in {@link ExecutionService} — and uses plain
+ * async sleeps, so it is the exact analogue of the Cloudflare ExecutionWorkflow (which
+ * wraps the same advance/poll calls in durable steps). The Node service's pg-boss
+ * worker runs it with a real sleep + pino logger; the cross-runtime conformance harness
+ * runs the SAME function (instant sleep, no-op log) against each facade's real store, so
+ * the suite exercises the production driver rather than a hand-rolled twin — which is how
+ * the companion-failure clobber (a second `failRun` overwriting the rich record with a
+ * generic one) once slipped past the suite.
+ *
+ * On a human decision it parks (returning the id so the caller can arm a timeout); the
+ * pg-boss runner re-enqueues an advance when the decision is resolved. All run state
+ * lives in the store, so a re-run after a crash simply reads the current state.
+ */
+export declare function driveExecution(exec: ExecutionService, workspaceId: string, executionId: string, cfg: DriveConfig, opts?: DriveOptions): Promise<DriveOutcome>;
+//# sourceMappingURL=drive.d.ts.map

package/dist/modules/execution/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/drive.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,oFAAoF;AACpF,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACvC;AAED,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,+DAA+D;IAC/D,GAAG,CAAC,EAAE,WAAW,CAAA;CAClB;AAED,6FAA6F;AAC7F,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,gBAAgB,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,YAAY,CAAC,CAkHvB"}

package/dist/modules/execution/drive.js

@@ -0,0 +1,112 @@
+const instantSleep = () => Promise.resolve();
+const noopLogger = { info() { } };
+/**
+ * Drive one run to a standstill. The runtime-neutral driver loop: it contains NO
+ * business logic — every decision lives in {@link ExecutionService} — and uses plain
+ * async sleeps, so it is the exact analogue of the Cloudflare ExecutionWorkflow (which
+ * wraps the same advance/poll calls in durable steps). The Node service's pg-boss
+ * worker runs it with a real sleep + pino logger; the cross-runtime conformance harness
+ * runs the SAME function (instant sleep, no-op log) against each facade's real store, so
+ * the suite exercises the production driver rather than a hand-rolled twin — which is how
+ * the companion-failure clobber (a second `failRun` overwriting the rich record with a
+ * generic one) once slipped past the suite.
+ *
+ * On a human decision it parks (returning the id so the caller can arm a timeout); the
+ * pg-boss runner re-enqueues an advance when the decision is resolved. All run state
+ * lives in the store, so a re-run after a crash simply reads the current state.
+ */
+export async function driveExecution(exec, workspaceId, executionId, cfg, opts = {}) {
+    const sleep = opts.sleep ?? instantSleep;
+    const log = opts.log ?? noopLogger;
+    const fail = (message, kind = 'agent', detail = null) => exec.failRun(workspaceId, executionId, message, kind, detail);
+    // Poll a parked gate (job / CI / conflicts) until it yields a non-awaiting result
+    // or the budget is spent. Tolerates a bounded run of status-read failures.
+    const pollUntil = async (awaiting, poll, intervalMs, maxPolls, label, onExhausted) => {
+        let readFailures = 0;
+        for (let p = 0; p < maxPolls; p++) {
+            await sleep(intervalMs);
+            let result;
+            try {
+                result = await poll();
+            }
+            catch {
+                readFailures += 1;
+                if (readFailures >= cfg.jobPollFailureTolerance) {
+                    await fail(`${label} status was unreadable (${readFailures} polls)`, 'timeout');
+                    return null;
+                }
+                continue;
+            }
+            readFailures = 0;
+            if (result.kind !== awaiting)
+                return result;
+        }
+        // Budget spent. A gate may resolve exhaustion itself (a watch gate PASSES rather than
+        // timing out) — let it; otherwise fail the run as a generic timeout.
+        if (onExhausted)
+            return onExhausted();
+        await fail(`${label} did not settle within its polling budget`, 'timeout');
+        return null;
+    };
+    for (;;) {
+        let result;
+        try {
+            result = await exec.advanceInstance(workspaceId, executionId, { rethrowAgentErrors: true });
+        }
+        catch (error) {
+            await fail(error instanceof Error ? error.message : String(error));
+            return {};
+        }
+        // Drain whatever gate the step parked on. A gate poll can resolve to a DIFFERENT
+        // gate — e.g. a `ci` step that finds CI red dispatches a `ci-fixer` and returns
+        // `awaiting_job` — so loop until the result is no longer an awaiting_* gate rather
+        // than relying on the next `advanceInstance` to re-establish the poll (which is why
+        // the order of these checks must not matter). `pollUntil` itself is bounded, so the
+        // outer guard only backstops a pathological gate↔gate ping-pong.
+        let gateHops = 0;
+        const MAX_GATE_HOPS = 64;
+        while (gateHops++ < MAX_GATE_HOPS) {
+            if (result.kind === 'awaiting_job') {
+                const next = await pollUntil('awaiting_job', () => exec.pollAgentJob(workspaceId, executionId), cfg.jobPollIntervalMs, cfg.jobMaxPolls, 'Implementation job');
+                if (!next)
+                    return {};
+                result = next;
+                continue;
+            }
+            // A polling gate step (`ci` / `conflicts`): re-run its precheck between sleeps;
+            // which gate is resolved inside `pollGate` from the current step, so one branch
+            // drives both.
+            if (result.kind === 'awaiting_gate') {
+                const next = await pollUntil('awaiting_gate', () => exec.pollGate(workspaceId, executionId), cfg.ciPollIntervalMs, cfg.ciMaxPolls, 'Gate precheck', () => exec.resolveGatePollExhaustion(workspaceId, executionId));
+                if (!next)
+                    return {};
+                result = next;
+                continue;
+            }
+            break;
+        }
+        if (result.kind === 'job_failed') {
+            // Single `failRun` funnel for a terminal step failure. An inline gate that already
+            // knows the precise classification + diagnostic carries them on the result
+            // (`failureKind`/`detail`) — e.g. an unparseable companion verdict
+            // (`companion_rejected`, with its raw reply as detail) — so the run records the
+            // accurate kind, hint and detail instead of a generic "container reported a
+            // failure". Defaults to `job_failed` for a genuine container-job failure.
+            await fail(result.error, result.failureKind ?? 'job_failed', result.detail ?? null);
+            return {};
+        }
+        if (result.kind === 'job_evicted') {
+            await fail(result.error, 'evicted');
+            return {};
+        }
+        // done / noop / paused: stop. awaiting_decision: park (resumed on signalDecision).
+        if (result.kind === 'done' || result.kind === 'noop' || result.kind === 'paused')
+            return {};
+        if (result.kind === 'awaiting_decision') {
+            log.info({ workspaceId, executionId, decisionId: result.decisionId }, 'run parked on decision');
+            return { parkedDecisionId: result.decisionId };
+        }
+        // 'continue': loop and advance the next step.
+    }
+}
+//# sourceMappingURL=drive.js.map

package/dist/modules/execution/drive.js.map

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