agent-bober 0.12.0 → 0.17.0

package/dist/orchestrator/workflow/scheduler.js

@@ -0,0 +1,158 @@
+/**
+ * Concurrency scheduler for the local-model workflow runtime.
+ *
+ * Mirrors the execution model of Claude Code's dynamic-workflow runtime:
+ *   - `parallel(thunks)` — barrier; runs all thunks with bounded concurrency
+ *     and awaits them all (order-preserving). Use for lens panels / N skeptics.
+ *   - `pipeline(items, ...stages)` — per-item, NO barrier between stages; each
+ *     item flows through every stage independently, so item A can be in stage 3
+ *     while item B is still in stage 1. Total concurrent stage executions are
+ *     bounded by the same cap.
+ *
+ * Concurrency is enforced by a hand-off semaphore (true bounded concurrency,
+ * unlike chunk-batching which idles fast tasks waiting on a slow one). A live
+ * agent counter caps total executions over the scheduler's lifetime (the
+ * runaway guard — Claude Code uses 1000/run).
+ */
+import * as os from "node:os";
+// ── Errors ──────────────────────────────────────────────────────────
+/** Raised when a scheduler exceeds its lifetime agent-execution cap. */
+export class AgentCapError extends Error {
+    cap;
+    constructor(message, 
+    /** The cap that was hit. */
+    cap) {
+        super(message);
+        this.cap = cap;
+        this.name = "AgentCapError";
+    }
+}
+// ── Default concurrency ─────────────────────────────────────────────
+/**
+ * The default concurrency cap: `min(16, cores - 2)`, floored at 1. Matches the
+ * Claude Code dynamic-workflow runtime. For local model servers the real bound
+ * is usually the server's slot count (e.g. Ollama's OLLAMA_NUM_PARALLEL), so
+ * callers should override `maxConcurrent` to match their backend.
+ */
+export function defaultConcurrency() {
+    const cores = os.cpus().length;
+    return Math.max(1, Math.min(16, cores - 2));
+}
+// ── Hand-off semaphore ──────────────────────────────────────────────
+/**
+ * A counting semaphore with FIFO hand-off: when a holder releases and a waiter
+ * is queued, the slot transfers directly to that waiter (the active count never
+ * dips), giving true peak-concurrency === cap regardless of task duration.
+ */
+export class Semaphore {
+    cap;
+    active = 0;
+    waiters = [];
+    constructor(cap) {
+        this.cap = cap;
+        if (cap < 1)
+            throw new Error(`Semaphore cap must be >= 1 (got ${String(cap)}).`);
+    }
+    async acquire() {
+        if (this.active < this.cap) {
+            this.active += 1;
+            return;
+        }
+        // Full: queue and wait. release() hands us the slot (active stays at cap),
+        // so we do NOT increment when resumed.
+        await new Promise((resolve) => this.waiters.push(resolve));
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next) {
+            next(); // hand the slot over; active unchanged
+        }
+        else {
+            this.active -= 1;
+        }
+    }
+    /** Number of currently-held slots (for tests / introspection). */
+    get inFlight() {
+        return this.active;
+    }
+}
+export class Scheduler {
+    maxConcurrent;
+    maxAgents;
+    sem;
+    agentsStarted = 0;
+    constructor(opts = {}) {
+        this.maxConcurrent = opts.maxConcurrent ?? defaultConcurrency();
+        this.maxAgents = opts.maxAgents ?? 1000;
+        this.sem = new Semaphore(Math.max(1, this.maxConcurrent));
+    }
+    /** Total task executions started over this scheduler's lifetime. */
+    get agentsRun() {
+        return this.agentsStarted;
+    }
+    /** Acquire a slot, run, release — counting the execution against the cap. */
+    async run(thunk) {
+        if (this.agentsStarted >= this.maxAgents) {
+            throw new AgentCapError(`Scheduler agent cap exceeded (${String(this.maxAgents)} executions).`, this.maxAgents);
+        }
+        this.agentsStarted += 1;
+        await this.sem.acquire();
+        try {
+            return await thunk();
+        }
+        finally {
+            this.sem.release();
+        }
+    }
+    /**
+     * Run all thunks concurrently (bounded by the cap) and await them all.
+     * Results are index-aligned with `thunks`. A thunk that throws rejects the
+     * whole call (use try/catch inside the thunk for {@link Promise.allSettled}-style
+     * tolerance).
+     */
+    async parallel(thunks) {
+        return Promise.all(thunks.map((t) => this.run(t)));
+    }
+    /**
+     * Run each item through every stage independently — no barrier between
+     * stages. Returns an array index-aligned with `items`. A stage that throws
+     * (other than {@link AgentCapError}) drops that item to `null` and skips its
+     * remaining stages; the runaway-cap error propagates.
+     */
+    async pipeline(items, ...stages) {
+        return Promise.all(items.map(async (item, index) => {
+            let acc = item;
+            for (const stage of stages) {
+                try {
+                    acc = await this.run(() => stage(acc, item, index));
+                }
+                catch (e) {
+                    if (e instanceof AgentCapError)
+                        throw e;
+                    return null;
+                }
+            }
+            return acc;
+        }));
+    }
+}
+// ── mapBounded (drop-in for the legacy panel helper) ────────────────
+/**
+ * Map over `items` applying `fn` with at most `cap` concurrent calls, preserving
+ * input order. Backed by a hand-off {@link Semaphore} (true bounded concurrency,
+ * superseding the chunk-batching copies previously duplicated in the evaluator
+ * and architect agents).
+ */
+export async function mapBounded(items, cap, fn) {
+    const sem = new Semaphore(Math.max(1, cap));
+    return Promise.all(items.map(async (item) => {
+        await sem.acquire();
+        try {
+            return await fn(item);
+        }
+        finally {
+            sem.release();
+        }
+    }));
+}
+//# sourceMappingURL=scheduler.js.map

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

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

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

@@ -0,0 +1,26 @@
+import type { BoberConfig } from "../../config/schema.js";
+import type { PipelineEngine, PipelineEngineName } from "./engine.js";
+/**
+ * Pure resolver — returns the engine name without instantiating an engine.
+ *
+ * Resolution branches:
+ *   - engine unset                        → 'ts'
+ *   - engine === 'workflow' && ineligible  → 'ts'  (one downgrade log line)
+ *   - engine === 'workflow' && mode === 'careful' → 'ts'  (one downgrade log line)
+ *   - else                                → engine verbatim ('ts' | 'skill' | 'workflow')
+ *
+ * Mirrors the pure-resolver pattern of resolveCheckpointMechanismName
+ * (src/orchestrator/checkpoints/registry.ts:65).
+ */
+export declare function resolveEngineName(config: BoberConfig): PipelineEngineName;
+/**
+ * Resolve config.pipeline.engine to a PipelineEngine instance.
+ *
+ * Belt-and-suspenders per ADR-6:
+ *   - resolveEngineName (above) ALREADY downgrades workflow→ts when ineligible/careful.
+ *   - In the eligible case, WorkflowEngine is returned; its run() has a second guard
+ *     that catches WorkflowUnavailableError from the dormant invoke and re-dispatches TS.
+ *   - 'skill' remains on TsPipelineEngine (no skill engine this sprint — non-goal).
+ */
+export declare function selectPipelineEngine(config: BoberConfig): PipelineEngine;
+//# sourceMappingURL=selector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selector.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/selector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAOtE;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,kBAAkB,CAezE;AAID;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,CAaxE"}

package/dist/orchestrator/workflow/selector.js

@@ -0,0 +1,54 @@
+import { logger } from "../../utils/logger.js";
+import { isWorkflowEligible } from "./eligibility.js";
+import { TsPipelineEngine } from "./ts-engine.js";
+import { WorkflowEngine } from "./workflow-engine.js";
+// ── Resolver ───────────────────────────────────────────────────────
+/**
+ * Pure resolver — returns the engine name without instantiating an engine.
+ *
+ * Resolution branches:
+ *   - engine unset                        → 'ts'
+ *   - engine === 'workflow' && ineligible  → 'ts'  (one downgrade log line)
+ *   - engine === 'workflow' && mode === 'careful' → 'ts'  (one downgrade log line)
+ *   - else                                → engine verbatim ('ts' | 'skill' | 'workflow')
+ *
+ * Mirrors the pure-resolver pattern of resolveCheckpointMechanismName
+ * (src/orchestrator/checkpoints/registry.ts:65).
+ */
+export function resolveEngineName(config) {
+    const requested = config.pipeline?.engine ?? "ts";
+    if (requested === "workflow") {
+        const eligible = isWorkflowEligible(config);
+        const careful = config.pipeline?.mode === "careful";
+        if (!eligible || careful) {
+            logger.info(`Workflow engine requested but ${!eligible ? "ineligible" : "mode='careful'"}; downgrading to 'ts'.`);
+            return "ts";
+        }
+    }
+    return requested;
+}
+// ── Selector ───────────────────────────────────────────────────────
+/**
+ * Resolve config.pipeline.engine to a PipelineEngine instance.
+ *
+ * Belt-and-suspenders per ADR-6:
+ *   - resolveEngineName (above) ALREADY downgrades workflow→ts when ineligible/careful.
+ *   - In the eligible case, WorkflowEngine is returned; its run() has a second guard
+ *     that catches WorkflowUnavailableError from the dormant invoke and re-dispatches TS.
+ *   - 'skill' remains on TsPipelineEngine (no skill engine this sprint — non-goal).
+ */
+export function selectPipelineEngine(config) {
+    const name = resolveEngineName(config);
+    switch (name) {
+        case "ts":
+            return new TsPipelineEngine();
+        case "skill":
+            // Skill engine deferred (non-goal this sprint); falls through to TS.
+            return new TsPipelineEngine();
+        case "workflow":
+            // Reachable only when resolveEngineName returns 'workflow' (eligible + not careful).
+            // WorkflowEngine.run has a belt-and-suspenders catch for WorkflowUnavailableError.
+            return new WorkflowEngine();
+    }
+}
+//# sourceMappingURL=selector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selector.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/selector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,sEAAsE;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAmB;IACnD,MAAM,SAAS,GAAuB,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI,IAAI,CAAC;IAEtE,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,IAAI,KAAK,SAAS,CAAC;QACpD,IAAI,CAAC,QAAQ,IAAI,OAAO,EAAE,CAAC;YACzB,MAAM,CAAC,IAAI,CACT,iCAAiC,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,wBAAwB,CACrG,CAAC;YACF,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,sEAAsE;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAmB;IACtD,MAAM,IAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,IAAI;YACP,OAAO,IAAI,gBAAgB,EAAE,CAAC;QAChC,KAAK,OAAO;YACV,qEAAqE;YACrE,OAAO,IAAI,gBAAgB,EAAE,CAAC;QAChC,KAAK,UAAU;YACb,qFAAqF;YACrF,mFAAmF;YACnF,OAAO,IAAI,cAAc,EAAE,CAAC;IAChC,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,52 @@
+/**
+ * SynthesisResult: the ranked output of synthesize() (ranking shape, not
+ * pass/fail — contrast with EvalResult returned by reconcile()).
+ */
+export interface SynthesisResult {
+    /** The approach with the highest aggregate score across all lenses. */
+    winner: string;
+    /**
+     * All approaches ordered descending by total score.
+     * Deterministic tie-break: lower original index in `approaches` wins
+     * when two approaches have equal totals (i.e. the approach that appeared
+     * earlier in the caller's list is ranked higher).
+     */
+    ranking: Array<{
+        approach: string;
+        perLensScores: Record<string, number>;
+        total: number;
+    }>;
+    /**
+     * Placeholder collection slot for cross-approach ideas worth grafting into
+     * the winner. This sprint uses runner-up approach names as a simple default;
+     * future sprints may populate this with extracted proposal fragments.
+     */
+    graftedIdeas: string[];
+    /**
+     * Lenses whose individual top-scored approach differs from the overall winner.
+     * Each entry is a human-readable string identifying the lens and its preferred
+     * approach, e.g. "scalability: prefers approach-B".
+     */
+    dissent: string[];
+}
+/**
+ * Pure ranking reducer over per-lens approach scores (sibling of reconcile()).
+ * No Date.now / new Date / Math.random / fs — this function is deterministic
+ * given the same inputs.
+ *
+ * Tie-break rule (documented): when two approaches have equal aggregate totals,
+ * the approach whose index is LOWER in the original `approaches` array wins.
+ * This is achieved by capturing original indices before sorting and using them
+ * as a stable comparator secondary key.
+ *
+ * @param approaches - Ordered list of approach identifiers to rank.
+ * @param lensScores - Per-lens score maps: each entry has a lens name and a
+ *   `scores` record mapping approach → numeric score. Missing approach keys
+ *   contribute 0 for that lens.
+ * @throws {Error} if `approaches` is empty (mirrors reconcile() guard).
+ */
+export declare function synthesize(approaches: string[], lensScores: Array<{
+    lens: string;
+    scores: Record<string, number>;
+}>): SynthesisResult;
+//# sourceMappingURL=synthesizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"synthesizer.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/synthesizer.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,OAAO,EAAE,KAAK,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH;;;;OAIG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC,GAClE,eAAe,CA4EjB"}

package/dist/orchestrator/workflow/synthesizer.js

@@ -0,0 +1,75 @@
+// ── Synthesizer ─────────────────────────────────────────────────────
+// ── synthesize ──────────────────────────────────────────────────────
+/**
+ * Pure ranking reducer over per-lens approach scores (sibling of reconcile()).
+ * No Date.now / new Date / Math.random / fs — this function is deterministic
+ * given the same inputs.
+ *
+ * Tie-break rule (documented): when two approaches have equal aggregate totals,
+ * the approach whose index is LOWER in the original `approaches` array wins.
+ * This is achieved by capturing original indices before sorting and using them
+ * as a stable comparator secondary key.
+ *
+ * @param approaches - Ordered list of approach identifiers to rank.
+ * @param lensScores - Per-lens score maps: each entry has a lens name and a
+ *   `scores` record mapping approach → numeric score. Missing approach keys
+ *   contribute 0 for that lens.
+ * @throws {Error} if `approaches` is empty (mirrors reconcile() guard).
+ */
+export function synthesize(approaches, lensScores) {
+    if (approaches.length === 0) {
+        throw new Error("synthesize: approaches must be non-empty");
+    }
+    // ── Build per-approach aggregates ───────────────────────────────────
+    // Capture original indices for deterministic tie-breaking before sort
+    const indexed = approaches.map((approach, originalIndex) => {
+        const perLensScores = {};
+        let total = 0;
+        for (const { lens, scores } of lensScores) {
+            const s = scores[approach] ?? 0;
+            perLensScores[lens] = s;
+            total = total + s;
+        }
+        return { approach, perLensScores, total, originalIndex };
+    });
+    // ── Sort descending by total; tie-break: lower original index wins ──
+    const sorted = indexed.slice().sort((a, b) => {
+        if (b.total !== a.total) {
+            return b.total - a.total; // higher total ranks first
+        }
+        return a.originalIndex - b.originalIndex; // lower index ranks first on tie
+    });
+    const ranking = sorted.map(({ approach, perLensScores, total }) => ({
+        approach,
+        perLensScores,
+        total,
+    }));
+    const winner = ranking[0].approach;
+    // ── Compute dissent ─────────────────────────────────────────────────
+    // A lens dissents when its own top-scored approach differs from winner.
+    // Tie-break within a single lens also uses lower original index.
+    const approachToIndex = new Map(approaches.map((a, i) => [a, i]));
+    const dissent = [];
+    for (const { lens, scores } of lensScores) {
+        let lensWinner;
+        let lensMax = -Infinity;
+        for (const approach of approaches) {
+            const s = scores[approach] ?? 0;
+            const idx = approachToIndex.get(approach) ?? 0;
+            if (s > lensMax ||
+                (s === lensMax &&
+                    lensWinner !== undefined &&
+                    idx < (approachToIndex.get(lensWinner) ?? 0))) {
+                lensMax = s;
+                lensWinner = approach;
+            }
+        }
+        if (lensWinner !== undefined && lensWinner !== winner) {
+            dissent.push(`${lens}: prefers ${lensWinner}`);
+        }
+    }
+    // ── Compute graftedIdeas (runner-up approaches as placeholder) ──────
+    const graftedIdeas = ranking.slice(1).map((r) => r.approach);
+    return { winner, ranking, graftedIdeas, dissent };
+}
+//# sourceMappingURL=synthesizer.js.map

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

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

package/dist/orchestrator/workflow/ts-engine.d.ts

@@ -0,0 +1,13 @@
+import type { BoberConfig } from "../../config/schema.js";
+import type { PipelineResult } from "../pipeline.js";
+import type { PipelineEngine, PipelineEngineName } from "./engine.js";
+/**
+ * Engine adapter that wraps the original TypeScript pipeline implementation.
+ * Delegates to runTsPipeline — the extracted former runPipeline body — with
+ * ZERO behaviour change on the default 'ts' path.
+ */
+export declare class TsPipelineEngine implements PipelineEngine {
+    readonly name: PipelineEngineName;
+    run(userPrompt: string, projectRoot: string, config: BoberConfig): Promise<PipelineResult>;
+}
+//# sourceMappingURL=ts-engine.d.ts.map

package/dist/orchestrator/workflow/ts-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-engine.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/ts-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItE;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,cAAc;IACrD,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAQ;IAEzC,GAAG,CACD,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,cAAc,CAAC;CAG3B"}

package/dist/orchestrator/workflow/ts-engine.js

@@ -0,0 +1,14 @@
+import { runTsPipeline } from "../pipeline.js";
+// ── TsPipelineEngine ───────────────────────────────────────────────
+/**
+ * Engine adapter that wraps the original TypeScript pipeline implementation.
+ * Delegates to runTsPipeline — the extracted former runPipeline body — with
+ * ZERO behaviour change on the default 'ts' path.
+ */
+export class TsPipelineEngine {
+    name = "ts";
+    run(userPrompt, projectRoot, config) {
+        return runTsPipeline(userPrompt, projectRoot, config);
+    }
+}
+//# sourceMappingURL=ts-engine.js.map

package/dist/orchestrator/workflow/ts-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-engine.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/ts-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C,sEAAsE;AAEtE;;;;GAIG;AACH,MAAM,OAAO,gBAAgB;IAClB,IAAI,GAAuB,IAAI,CAAC;IAEzC,GAAG,CACD,UAAkB,EAClB,WAAmB,EACnB,MAAmB;QAEnB,OAAO,aAAa,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;CACF"}

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

@@ -0,0 +1,55 @@
+import type { PlanSpec } from "../../contracts/spec.js";
+import type { SprintContract } from "../../contracts/sprint-contract.js";
+import type { EvalResult } from "../../contracts/eval-result.js";
+import type { HistoryEntry } from "../../state/history.js";
+import type { PipelineEngineName } from "./engine.js";
+export type { PipelineEngineName } from "./engine.js";
+export type WorkflowArgs = {
+    userPrompt: string;
+    knobs: {
+        maxIterations: number;
+        maxSprints: number;
+        researchPhase: boolean;
+        architectPhase: boolean;
+        curatorEnabled: boolean;
+        codeReviewEnabled: boolean;
+        requireContracts: boolean;
+    };
+    models: {
+        planner: string;
+        curator: string;
+        generator: string;
+        evaluator: string;
+    };
+    evaluatorLenses: string[];
+    principles: string;
+    preloadedSpec?: PlanSpec;
+    preloadedContracts: SprintContract[];
+    resumeCursor: ResumeCursor;
+};
+export type WorkflowRunResult = {
+    spec: PlanSpec;
+    perSprint: Array<{
+        contract: SprintContract;
+        finalVerdict: EvalResult;
+        iterationsUsed: number;
+        outcome: "passed" | "needs-rework" | "failed";
+        lensVerdicts: EvalResult[];
+    }>;
+    needsClarification: boolean;
+    pendingHistory: Array<Omit<HistoryEntry, "timestamp">>;
+};
+export type ResumeCursor = {
+    specId: string;
+    completedSprintNumbers: number[];
+    lastObservedSprintNumber: number;
+};
+export type ConformanceReport = {
+    equivalent: boolean;
+    diffs: Array<{
+        artifact: "spec" | "contract" | "eval-result" | "history";
+        path: string;
+        engines: PipelineEngineName[];
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QACL,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,OAAO,CAAC;QACvB,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,EAAE,OAAO,CAAC;QACxB,iBAAiB,EAAE,OAAO,CAAC;QAC3B,gBAAgB,EAAE,OAAO,CAAC;KAC3B,CAAC;IACF,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB,kBAAkB,EAAE,cAAc,EAAE,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAIF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,KAAK,CAAC;QACf,QAAQ,EAAE,cAAc,CAAC;QACzB,YAAY,EAAE,UAAU,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,CAAC;QAC9C,YAAY,EAAE,UAAU,EAAE,CAAC;KAC5B,CAAC,CAAC;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC;CACxD,CAAC;AAIF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAIF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;QACX,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAAC;QAC1D,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,kBAAkB,EAAE,CAAC;KAC/B,CAAC,CAAC;CACJ,CAAC"}

package/dist/orchestrator/workflow/types.js

@@ -0,0 +1,3 @@
+// ── Workflow host types ─────────────────────────────────────────────
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/types.ts"],"names":[],"mappings":"AAAA,uEAAuE"}

package/dist/orchestrator/workflow/workflow-engine.d.ts

@@ -0,0 +1,31 @@
+import type { BoberConfig } from "../../config/schema.js";
+import type { PipelineResult } from "../pipeline.js";
+import type { PipelineEngine, PipelineEngineName } from "./engine.js";
+/**
+ * Pipeline engine that assembles and invokes the Dynamic Workflows runtime.
+ *
+ * Control flow (eligibility FIRST — avoids MissingKnobError on the downgrade path):
+ *   1. if (!isWorkflowEligible(config))  → log once + return tsEngine.run(...)   ← NO args built
+ *   2. cursor = reconstruct(...)         ← read-only (listContracts + loadHistory)
+ *   3. args   = build(...)               ← pure; may throw MissingKnobError (acceptable: eligible)
+ *   4. try { result = invoke(args); return flush(result) }
+ *      catch WorkflowUnavailableError → log once + return tsEngine.run(...)  ← NO partial flush
+ *      catch other → rethrow
+ *
+ * invoke() is DORMANT this release — always throws WorkflowUnavailableError.
+ * The eligible path is only reachable in tests that force eligibility=true via
+ * the injection seam (constructor param + vi.mock).
+ */
+export declare class WorkflowEngine implements PipelineEngine {
+    private readonly tsEngineFactory;
+    readonly name: PipelineEngineName;
+    /**
+     * Injection seam — tsEngineFactory defaults to () => new TsPipelineEngine().
+     * Tests inject a fake factory that returns a sentinel PipelineResult without
+     * spawning real LLM agents.
+     */
+    constructor(tsEngineFactory?: () => PipelineEngine);
+    run(userPrompt: string, projectRoot: string, config: BoberConfig): Promise<PipelineResult>;
+    private invoke;
+}
+//# sourceMappingURL=workflow-engine.d.ts.map

package/dist/orchestrator/workflow/workflow-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-engine.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/workflow/workflow-engine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAWtE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAe,YAAW,cAAc;IASjD,OAAO,CAAC,QAAQ,CAAC,eAAe;IARlC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAc;IAE/C;;;;OAIG;gBAEgB,eAAe,GAAE,MAAM,cAChB;IAGpB,GAAG,CACP,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,cAAc,CAAC;YAwCZ,MAAM;CAKrB"}

package/dist/orchestrator/workflow/workflow-engine.js

@@ -0,0 +1,70 @@
+// ── WorkflowEngine ─────────────────────────────────────────────────
+import { logger } from "../../utils/logger.js";
+import { isWorkflowEligible } from "./eligibility.js";
+import { ResumeCursorReconstructor } from "./resume-cursor.js";
+import { ArgsPayloadBuilder } from "./args-builder.js";
+import { RunResultFlusher } from "./flusher.js";
+import { TsPipelineEngine } from "./ts-engine.js";
+import { WorkflowUnavailableError } from "./errors.js";
+// ── WorkflowEngine ──────────────────────────────────────────────────
+/**
+ * Pipeline engine that assembles and invokes the Dynamic Workflows runtime.
+ *
+ * Control flow (eligibility FIRST — avoids MissingKnobError on the downgrade path):
+ *   1. if (!isWorkflowEligible(config))  → log once + return tsEngine.run(...)   ← NO args built
+ *   2. cursor = reconstruct(...)         ← read-only (listContracts + loadHistory)
+ *   3. args   = build(...)               ← pure; may throw MissingKnobError (acceptable: eligible)
+ *   4. try { result = invoke(args); return flush(result) }
+ *      catch WorkflowUnavailableError → log once + return tsEngine.run(...)  ← NO partial flush
+ *      catch other → rethrow
+ *
+ * invoke() is DORMANT this release — always throws WorkflowUnavailableError.
+ * The eligible path is only reachable in tests that force eligibility=true via
+ * the injection seam (constructor param + vi.mock).
+ */
+export class WorkflowEngine {
+    tsEngineFactory;
+    name = "workflow";
+    /**
+     * Injection seam — tsEngineFactory defaults to () => new TsPipelineEngine().
+     * Tests inject a fake factory that returns a sentinel PipelineResult without
+     * spawning real LLM agents.
+     */
+    constructor(tsEngineFactory = () => new TsPipelineEngine()) {
+        this.tsEngineFactory = tsEngineFactory;
+    }
+    async run(userPrompt, projectRoot, config) {
+        // ── STEP 1: Eligibility check FIRST (avoids MissingKnobError on downgrade path) ──
+        if (!isWorkflowEligible(config)) {
+            logger.info("workflow runtime unavailable — re-dispatching TS engine");
+            return this.tsEngineFactory().run(userPrompt, projectRoot, config);
+        }
+        // ── STEP 2: Reconstruct cursor (read-only — writes nothing) ────────────────
+        // specId is derived from config or empty — invoke is dormant so this is
+        // never persisted. The PipelineEngine.run() signature is frozen (no specId).
+        const specId = config.project?.specId ?? "";
+        const cursor = await new ResumeCursorReconstructor().reconstruct(projectRoot, specId);
+        // ── STEP 3: Build args (pure — throws MissingKnobError if knobs missing) ────
+        const args = new ArgsPayloadBuilder().build(userPrompt, config, cursor, "");
+        // ── STEP 4: Invoke → flush; catch WorkflowUnavailableError → re-dispatch ───
+        try {
+            const result = await this.invoke(args);
+            return await new RunResultFlusher().flush(projectRoot, config, result);
+        }
+        catch (e) {
+            if (e instanceof WorkflowUnavailableError) {
+                logger.info("workflow runtime unavailable — re-dispatching TS engine");
+                return this.tsEngineFactory().run(userPrompt, projectRoot, config);
+            }
+            throw e;
+        }
+    }
+    // ── Dormant invoke (non-goal: no live transport this release) ──────────────
+    //
+    // Always throws WorkflowUnavailableError so the run() catch block re-dispatches
+    // to the TS engine with zero partial flush (flush is only reached post-invoke).
+    async invoke(_args) {
+        throw new WorkflowUnavailableError("Programmatic workflow invoke is not implemented this release.");
+    }
+}
+//# sourceMappingURL=workflow-engine.js.map

package/dist/orchestrator/workflow/workflow-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-engine.js","sourceRoot":"","sources":["../../../src/orchestrator/workflow/workflow-engine.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAItE,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAGvD,uEAAuE;AAEvE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,cAAc;IASN;IARV,IAAI,GAAuB,UAAU,CAAC;IAE/C;;;;OAIG;IACH,YACmB,kBAAwC,GAAG,EAAE,CAC5D,IAAI,gBAAgB,EAAE;QADP,oBAAe,GAAf,eAAe,CACR;IACvB,CAAC;IAEJ,KAAK,CAAC,GAAG,CACP,UAAkB,EAClB,WAAmB,EACnB,MAAmB;QAEnB,oFAAoF;QACpF,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;YAChC,MAAM,CAAC,IAAI,CACT,yDAAyD,CAC1D,CAAC;YACF,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;QACrE,CAAC;QAED,8EAA8E;QAC9E,wEAAwE;QACxE,6EAA6E;QAC7E,MAAM,MAAM,GAAI,MAAM,CAAC,OAA2C,EAAE,MAAM,IAAI,EAAE,CAAC;QACjF,MAAM,MAAM,GAAG,MAAM,IAAI,yBAAyB,EAAE,CAAC,WAAW,CAC9D,WAAW,EACX,MAAM,CACP,CAAC;QAEF,+EAA+E;QAC/E,MAAM,IAAI,GAAG,IAAI,kBAAkB,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;QAE5E,8EAA8E;QAC9E,IAAI,CAAC;YACH,MAAM,MAAM,GAAsB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC1D,OAAO,MAAM,IAAI,gBAAgB,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACzE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,wBAAwB,EAAE,CAAC;gBAC1C,MAAM,CAAC,IAAI,CACT,yDAAyD,CAC1D,CAAC;gBACF,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;YACrE,CAAC;YACD,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED,8EAA8E;IAC9E,EAAE;IACF,gFAAgF;IAChF,gFAAgF;IACxE,KAAK,CAAC,MAAM,CAAC,KAAmB;QACtC,MAAM,IAAI,wBAAwB,CAChC,+DAA+D,CAChE,CAAC;IACJ,CAAC;CACF"}

package/dist/orchestrator/worktree.d.ts

@@ -0,0 +1,18 @@
+import type { BoberConfig } from "../config/schema.js";
+import { type PipelineResult } from "./pipeline.js";
+export declare function deriveWorktreeSlug(task: string): string;
+export interface RunInWorktreeOpts {
+    /** When true, skip the dirty-tree check and allow worktree creation anyway. Default false. */
+    allowDirty?: boolean;
+    /** When true, retain the worktree on success (overrides pipeline.cleanupWorktreeOnSuccess). Default false. */
+    keepOnSuccess?: boolean;
+    /** Injected pipelineFn for testing. Defaults to the real runPipeline. */
+    pipelineFn?: (task: string, projectRoot: string, config: BoberConfig) => Promise<PipelineResult>;
+}
+export interface RunInWorktreeResult {
+    runId: string;
+    branch: string;
+    worktreePath: string;
+}
+export declare function runInWorktree(task: string, projectRoot: string, config: BoberConfig, opts?: RunInWorktreeOpts): Promise<RunInWorktreeResult>;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/orchestrator/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktree.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAajE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD;AAID,MAAM,WAAW,iBAAiB;IAChC,8FAA8F;IAC9F,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8GAA8G;IAC9G,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yEAAyE;IACzE,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,cAAc,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB;AAmBD,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,WAAW,EACnB,IAAI,GAAE,iBAAsB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAoG9B"}