@miller-tech/uap 1.26.5 → 1.27.0

package/dist/delivery/convergence-loop.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Convergence Loop
+ *
+ * Phase 1 of the Fable-parity delivery harness: drives an underlying model
+ * through execute → apply → verify → feedback iterations until the project's
+ * completion gates (verifier ladder) pass or the turn budget is exhausted.
+ *
+ * The loop owns four pluggable seams so later phases extend without breaking
+ * changes:
+ *  - executor: how a prompt becomes model output
+ *  - applier: how model output is materialized into the project tree
+ *  - promptBuilder: how instruction/feedback/prior output compose a prompt
+ *    (Phase 3 structured critique and Phase 4 memory injection plug in here)
+ *  - ladderRunner: how gates are verified (tests inject stubs; Phase 2 runs
+ *    candidates in isolated worktrees)
+ */
+import type { GateRung, LadderResult, LadderOptions } from './verifier-ladder.js';
+import type { Applier } from './applier.js';
+export type LoopExecutor = (prompt: string) => Promise<string>;
+/** Pluggable ladder runner — production uses runLadder, tests inject a stub. */
+export type LadderRunner = (rungs: GateRung[], projectRoot: string, options?: LadderOptions) => LadderResult | Promise<LadderResult>;
+export interface PromptContext {
+    instruction: string;
+    /** 1-based turn about to execute */
+    turn: number;
+    /** Model output from the previous turn (full, untruncated) */
+    previousOutput?: string;
+    /** Gate feedback from the previous turn's ladder run */
+    feedback?: string;
+    /** Apply-stage error from the previous turn (e.g. no file blocks found) */
+    applyError?: string;
+    /** Files written by the previous turn */
+    previousFiles?: string[];
+}
+export type PromptBuilder = (context: PromptContext) => string;
+export interface IterationRecord {
+    /** Real 1-based loop turn (executor-error turns are recorded too) */
+    turn: number;
+    passed: boolean;
+    /** Fraction of gates passed this iteration (0 when the turn never reached verification) */
+    score: number;
+    gateResults: LadderResult['results'];
+    /** Files the applier wrote this turn */
+    filesApplied: string[];
+    /** Executor failure, if the model call itself errored */
+    executorError?: string;
+    /** Apply failure, if output could not be materialized */
+    applyError?: string;
+    durationMs: number;
+}
+export interface DeliveryResult {
+    success: boolean;
+    /** True when the baseline check found all gates already green (no turns ran) */
+    alreadyDelivered: boolean;
+    turns: number;
+    /** Highest gate score observed across iterations */
+    bestScore: number;
+    /** Turn that achieved bestScore (0 when no iterations reached verification) */
+    bestTurn: number;
+    history: IterationRecord[];
+    /** Feedback from the final ladder run (or apply/executor error context) */
+    finalFeedback: string;
+    /** Raw model output from the final turn */
+    finalOutput: string;
+    totalDurationMs: number;
+}
+export interface ConvergenceConfig {
+    /** Maximum execute→apply→verify iterations (default 5) */
+    maxTurns?: number;
+    /** Project whose gates define "delivered" */
+    projectRoot: string;
+    /** Override auto-detected gates (e.g. subset via CLI --gates) */
+    rungs?: GateRung[];
+    /** Ladder options forwarded to the runner */
+    ladderOptions?: LadderOptions;
+    /**
+     * Run the ladder once before turn 1 (default true). When the baseline is
+     * already green there is nothing to converge on — the loop returns
+     * alreadyDelivered without calling the model, preventing false-success
+     * outcomes from polluting adaptive routing.
+     */
+    baselineCheck?: boolean;
+    /** Max characters of prior model output included in retry prompts (default 3000) */
+    previousOutputChars?: number;
+    /**
+     * Called after every iteration. Return 'stop' to abort the loop early
+     * (Phase 5 escalation controllers hook in here).
+     */
+    onIteration?: (record: IterationRecord) => void | 'stop';
+}
+/** Default prompt strategy: lean contract + structured retry context. */
+export declare const defaultPromptBuilder: PromptBuilder;
+export declare class ConvergenceLoop {
+    private readonly config;
+    private readonly executor;
+    private readonly ladderRunner;
+    private readonly applier;
+    private readonly promptBuilder;
+    constructor(config: ConvergenceConfig, executor: LoopExecutor, seams?: {
+        ladderRunner?: LadderRunner;
+        applier?: Applier;
+        promptBuilder?: PromptBuilder;
+    });
+    /**
+     * Run the loop for an instruction until all required gates pass or the
+     * turn budget is exhausted. Returns the full iteration history so callers
+     * can record outcomes and inspect convergence behavior.
+     */
+    deliver(instruction: string): Promise<DeliveryResult>;
+}
+//# sourceMappingURL=convergence-loop.d.ts.map

package/dist/delivery/convergence-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convergence-loop.d.ts","sourceRoot":"","sources":["../../src/delivery/convergence-loop.ts"],"names":[],"mappings":"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"}

package/dist/delivery/convergence-loop.js

@@ -0,0 +1,199 @@
+/**
+ * Convergence Loop
+ *
+ * Phase 1 of the Fable-parity delivery harness: drives an underlying model
+ * through execute → apply → verify → feedback iterations until the project's
+ * completion gates (verifier ladder) pass or the turn budget is exhausted.
+ *
+ * The loop owns four pluggable seams so later phases extend without breaking
+ * changes:
+ *  - executor: how a prompt becomes model output
+ *  - applier: how model output is materialized into the project tree
+ *  - promptBuilder: how instruction/feedback/prior output compose a prompt
+ *    (Phase 3 structured critique and Phase 4 memory injection plug in here)
+ *  - ladderRunner: how gates are verified (tests inject stubs; Phase 2 runs
+ *    candidates in isolated worktrees)
+ */
+import { detectRungs, runLadder } from './verifier-ladder.js';
+import { applyFileBlocks } from './applier.js';
+const DEFAULT_MAX_TURNS = 5;
+const DEFAULT_PREVIOUS_OUTPUT_CHARS = 3_000;
+const OUTPUT_CONTRACT = [
+    'You are an autonomous software delivery agent. Complete the task by emitting complete file contents.',
+    '',
+    'OUTPUT FORMAT — emit every file you create or modify as a fenced block:',
+    '```file:relative/path/from/project/root',
+    '<entire file content>',
+    '```',
+    'Use a longer fence (````file:path) when the file itself contains ``` sequences.',
+    'Files are written to disk verbatim, then real gates (build, type-check, tests) run.',
+    'Emit only file blocks plus brief reasoning.',
+].join('\n');
+function truncateHead(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n…(truncated)…`;
+}
+/** Default prompt strategy: lean contract + structured retry context. */
+export const defaultPromptBuilder = (ctx) => {
+    if (ctx.turn === 1) {
+        return [OUTPUT_CONTRACT, '', `TASK: ${ctx.instruction}`].join('\n');
+    }
+    const sections = [OUTPUT_CONTRACT, '', `TASK: ${ctx.instruction}`, ''];
+    sections.push(`PREVIOUS ATTEMPT (turn ${ctx.turn - 1}):`);
+    if (ctx.previousFiles && ctx.previousFiles.length > 0) {
+        sections.push(`Files you emitted: ${ctx.previousFiles.join(', ')}`);
+    }
+    if (ctx.applyError) {
+        sections.push(`Your output could not be applied: ${ctx.applyError}`);
+    }
+    if (ctx.feedback) {
+        sections.push(ctx.feedback);
+    }
+    if (ctx.previousOutput) {
+        sections.push('');
+        sections.push('Your previous output (truncated):');
+        sections.push(truncateHead(ctx.previousOutput, DEFAULT_PREVIOUS_OUTPUT_CHARS));
+    }
+    sections.push('');
+    sections.push('Fix the issues and emit corrected file blocks.');
+    return sections.join('\n');
+};
+export class ConvergenceLoop {
+    config;
+    executor;
+    ladderRunner;
+    applier;
+    promptBuilder;
+    constructor(config, executor, seams = {}) {
+        this.config = config;
+        this.executor = executor;
+        this.ladderRunner = seams.ladderRunner ?? runLadder;
+        this.applier = seams.applier ?? applyFileBlocks;
+        this.promptBuilder = seams.promptBuilder ?? defaultPromptBuilder;
+    }
+    /**
+     * Run the loop for an instruction until all required gates pass or the
+     * turn budget is exhausted. Returns the full iteration history so callers
+     * can record outcomes and inspect convergence behavior.
+     */
+    async deliver(instruction) {
+        const start = Date.now();
+        const maxTurns = this.config.maxTurns ?? DEFAULT_MAX_TURNS;
+        const rungs = this.config.rungs && this.config.rungs.length > 0
+            ? this.config.rungs
+            : detectRungs(this.config.projectRoot);
+        if (rungs.length === 0) {
+            throw new Error(`No verifiable gates for ${this.config.projectRoot} — pass explicit rungs or add package.json scripts.`);
+        }
+        if (!Number.isInteger(maxTurns) || maxTurns < 1) {
+            throw new Error(`maxTurns must be a positive integer, got ${String(this.config.maxTurns)}`);
+        }
+        const history = [];
+        const previousOutputChars = this.config.previousOutputChars ?? DEFAULT_PREVIOUS_OUTPUT_CHARS;
+        // Baseline: a green tree means there is nothing for the loop to deliver.
+        if (this.config.baselineCheck ?? true) {
+            const baseline = await this.ladderRunner(rungs, this.config.projectRoot, this.config.ladderOptions);
+            if (baseline.passed) {
+                return {
+                    success: true,
+                    alreadyDelivered: true,
+                    turns: 0,
+                    bestScore: baseline.score,
+                    bestTurn: 0,
+                    history,
+                    finalFeedback: baseline.feedback,
+                    finalOutput: '',
+                    totalDurationMs: Date.now() - start,
+                };
+            }
+        }
+        let success = false;
+        let finalOutput = '';
+        let finalFeedback = '';
+        let prevContext = {};
+        for (let turn = 1; turn <= maxTurns; turn++) {
+            const turnStart = Date.now();
+            const prompt = this.promptBuilder({ instruction, turn, ...prevContext });
+            // Execute
+            let output = '';
+            let executorError;
+            try {
+                output = await this.executor(prompt);
+            }
+            catch (err) {
+                executorError = err instanceof Error ? err.message : String(err);
+            }
+            finalOutput = output || finalOutput;
+            // Apply
+            let applyResult = null;
+            let applyError;
+            if (!executorError) {
+                applyResult = await this.applier(output, this.config.projectRoot);
+                if (applyResult.error) {
+                    applyError = applyResult.error;
+                }
+                else if (applyResult.rejected.length > 0) {
+                    applyError = `Rejected blocks: ${applyResult.rejected
+                        .map((r) => `${r.path} (${r.reason})`)
+                        .join('; ')}`;
+                }
+            }
+            // Verify — only when something was applied; otherwise the tree is
+            // unchanged and re-running gates would waste minutes for no signal.
+            const filesApplied = applyResult?.filesWritten ?? [];
+            let ladder = null;
+            if (!executorError && filesApplied.length > 0) {
+                ladder = await this.ladderRunner(rungs, this.config.projectRoot, this.config.ladderOptions);
+                finalFeedback = ladder.feedback;
+            }
+            const record = {
+                turn,
+                passed: ladder?.passed ?? false,
+                score: ladder?.score ?? 0,
+                gateResults: ladder?.results ?? [],
+                filesApplied,
+                executorError,
+                applyError,
+                durationMs: Date.now() - turnStart,
+            };
+            history.push(record);
+            const directive = this.config.onIteration?.(record);
+            if (ladder?.passed) {
+                success = true;
+                break;
+            }
+            if (directive === 'stop') {
+                break;
+            }
+            prevContext = {
+                previousOutput: executorError
+                    ? undefined
+                    : truncateHead(output, previousOutputChars),
+                feedback: executorError ? `Model call failed: ${executorError}` : ladder?.feedback,
+                applyError,
+                previousFiles: filesApplied.length > 0 ? filesApplied : undefined,
+            };
+        }
+        let bestScore = 0;
+        let bestTurn = 0;
+        for (const record of history) {
+            if (record.score > bestScore) {
+                bestScore = record.score;
+                bestTurn = record.turn;
+            }
+        }
+        return {
+            success,
+            alreadyDelivered: false,
+            turns: history.length,
+            bestScore,
+            bestTurn,
+            history,
+            finalFeedback,
+            finalOutput,
+            totalDurationMs: Date.now() - start,
+        };
+    }
+}
+//# sourceMappingURL=convergence-loop.js.map

package/dist/delivery/convergence-loop.js.map

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

package/dist/delivery/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Delivery harness — Fable-parity convergence loop.
+ *
+ * Drives underlying models through execute → apply → verify → feedback
+ * iterations against the project's real completion gates until delivery
+ * is achieved.
+ */
+export { ConvergenceLoop, defaultPromptBuilder, type ConvergenceConfig, type DeliveryResult, type IterationRecord, type LoopExecutor, type LadderRunner, type PromptBuilder, type PromptContext, } from './convergence-loop.js';
+export { detectRungs, runLadder, runRung, formatFeedback, type GateRung, type RungResult, type RungFailureReason, type LadderResult, type LadderOptions, } from './verifier-ladder.js';
+export { applyFileBlocks, parseFileBlocks, type Applier, type ApplyResult, type FileBlock, } from './applier.js';
+export { OpenAICompatClient, type OpenAICompatClientOptions } from '../models/openai-compat-client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/delivery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/delivery/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,WAAW,EACX,SAAS,EACT,OAAO,EACP,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,eAAe,EACf,eAAe,EACf,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,SAAS,GACf,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/delivery/index.js

@@ -0,0 +1,12 @@
+/**
+ * Delivery harness — Fable-parity convergence loop.
+ *
+ * Drives underlying models through execute → apply → verify → feedback
+ * iterations against the project's real completion gates until delivery
+ * is achieved.
+ */
+export { ConvergenceLoop, defaultPromptBuilder, } from './convergence-loop.js';
+export { detectRungs, runLadder, runRung, formatFeedback, } from './verifier-ladder.js';
+export { applyFileBlocks, parseFileBlocks, } from './applier.js';
+export { OpenAICompatClient } from '../models/openai-compat-client.js';
+//# sourceMappingURL=index.js.map

package/dist/delivery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/delivery/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,eAAe,EACf,oBAAoB,GAQrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,WAAW,EACX,SAAS,EACT,OAAO,EACP,cAAc,GAMf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,eAAe,EACf,eAAe,GAIhB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,kBAAkB,EAAkC,MAAM,mCAAmC,CAAC"}

package/dist/delivery/verifier-ladder.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Verifier Ladder
+ *
+ * Turns the repository's completion gates (build, type-check, test, lint)
+ * into a programmatic verifier that the convergence loop can call after each
+ * model iteration. Each rung runs a real command in the project root; the
+ * ladder reports a pass/fail per rung, an aggregate score (fraction of rungs
+ * passed), and structured feedback sized for small-model context budgets.
+ *
+ * Detection is npm-centric (package.json scripts); callers targeting other
+ * ecosystems can pass explicit rungs.
+ */
+export interface GateRung {
+    /** Stable identifier, e.g. 'build', 'typecheck', 'test', 'lint' */
+    id: string;
+    /** Human-readable name shown in feedback */
+    name: string;
+    /** Executable to run (no shell interpolation) */
+    command: string;
+    /** Arguments passed verbatim */
+    args: string[];
+    /**
+     * Required rungs gate delivery: the ladder only passes when all required
+     * rungs pass, and a required failure stops later rungs (fail-fast).
+     * Optional rungs are reported but never block delivery.
+     */
+    required: boolean;
+    /** Per-rung timeout in milliseconds */
+    timeoutMs: number;
+}
+export type RungFailureReason = 'exit' | 'timeout' | 'signal' | 'spawn-error';
+export interface RungResult {
+    id: string;
+    name: string;
+    passed: boolean;
+    /** True when the rung never ran because an earlier required rung failed */
+    skipped: boolean;
+    exitCode: number | null;
+    /** Why the rung failed; undefined when it passed or was skipped */
+    failureReason?: RungFailureReason;
+    durationMs: number;
+    /** Tail of combined stdout+stderr, truncated for prompt injection */
+    outputTail: string;
+}
+export interface LadderResult {
+    /** True when every required rung passed */
+    passed: boolean;
+    /** Fraction of all rungs that passed (skipped rungs count as not passed) */
+    score: number;
+    results: RungResult[];
+    /** Structured feedback for the next loop iteration */
+    feedback: string;
+}
+export interface LadderOptions {
+    /** Stop at the first failing required rung (default true — cheaper feedback) */
+    failFast?: boolean;
+    /** Max characters of command output included per failing rung (default 2000) */
+    outputTailChars?: number;
+    /** Default per-rung timeout in ms (default 300000) */
+    timeoutMs?: number;
+}
+/**
+ * Detect the gate rungs available in a project from its package.json scripts.
+ * Order matters: cheap/structural gates run before expensive ones so failure
+ * feedback arrives fast.
+ */
+export declare function detectRungs(projectRoot: string, timeoutMs?: number): GateRung[];
+/** Run a single rung synchronously in the project root. */
+export declare function runRung(rung: GateRung, projectRoot: string, tailChars?: number): RungResult;
+/**
+ * Build feedback text from rung results. Only the first failing required
+ * rung's output is included in detail — small models do better with one
+ * concrete problem at a time than with a wall of every failure.
+ */
+export declare function formatFeedback(results: RungResult[], rungs: GateRung[]): string;
+/** Run the full ladder, honoring fail-fast for required rungs. */
+export declare function runLadder(rungs: GateRung[], projectRoot: string, options?: LadderOptions): LadderResult;
+//# sourceMappingURL=verifier-ladder.d.ts.map

package/dist/delivery/verifier-ladder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier-ladder.d.ts","sourceRoot":"","sources":["../../src/delivery/verifier-ladder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE9E,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,mEAAmE;IACnE,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,2CAA2C;IAC3C,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAmBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,GAAE,MAA2B,GAAG,QAAQ,EAAE,CAmEnG;AAQD,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAE,MAA2B,GAAG,UAAU,CA+C/G;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAqB/E;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,EAAE,EACjB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,aAAkB,GAC1B,YAAY,CA8Cd"}

package/dist/delivery/verifier-ladder.js

@@ -0,0 +1,213 @@
+/**
+ * Verifier Ladder
+ *
+ * Turns the repository's completion gates (build, type-check, test, lint)
+ * into a programmatic verifier that the convergence loop can call after each
+ * model iteration. Each rung runs a real command in the project root; the
+ * ladder reports a pass/fail per rung, an aggregate score (fraction of rungs
+ * passed), and structured feedback sized for small-model context budgets.
+ *
+ * Detection is npm-centric (package.json scripts); callers targeting other
+ * ecosystems can pass explicit rungs.
+ */
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_TAIL_CHARS = 2_000;
+/** Env vars matching these patterns are stripped before running gate
+ * commands — project scripts (and npm lifecycle hooks) in arbitrary
+ * --project-root checkouts must not inherit provider credentials. */
+const SECRET_ENV_RE = /(API_KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)/i;
+function sanitizedEnv() {
+    const env = { CI: 'true' };
+    for (const [key, value] of Object.entries(process.env)) {
+        if (SECRET_ENV_RE.test(key))
+            continue;
+        env[key] = value;
+    }
+    return env;
+}
+/**
+ * Detect the gate rungs available in a project from its package.json scripts.
+ * Order matters: cheap/structural gates run before expensive ones so failure
+ * feedback arrives fast.
+ */
+export function detectRungs(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const pkgPath = join(projectRoot, 'package.json');
+    if (!existsSync(pkgPath)) {
+        return [];
+    }
+    let scripts = {};
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        scripts = pkg.scripts ?? {};
+    }
+    catch {
+        return [];
+    }
+    const rungs = [];
+    if (scripts['build']) {
+        rungs.push({
+            id: 'build',
+            name: 'Build (npm run build)',
+            command: 'npm',
+            args: ['run', 'build'],
+            required: true,
+            timeoutMs,
+        });
+    }
+    // Type-check is meaningful for TypeScript projects even when build exists
+    // (build may use a bundler that skips type errors). --no-install fails
+    // closed instead of letting npx fetch the registry package named 'tsc'.
+    if (existsSync(join(projectRoot, 'tsconfig.json')) &&
+        existsSync(join(projectRoot, 'node_modules', '.bin', 'tsc'))) {
+        rungs.push({
+            id: 'typecheck',
+            name: 'Type-check (tsc --noEmit)',
+            command: 'npx',
+            args: ['--no-install', 'tsc', '--noEmit'],
+            required: true,
+            timeoutMs,
+        });
+    }
+    if (scripts['test']) {
+        rungs.push({
+            id: 'test',
+            name: 'Tests (npm test)',
+            command: 'npm',
+            args: ['test'],
+            required: true,
+            timeoutMs,
+        });
+    }
+    if (scripts['lint']) {
+        rungs.push({
+            id: 'lint',
+            name: 'Lint (npm run lint)',
+            command: 'npm',
+            args: ['run', 'lint'],
+            required: false,
+            timeoutMs,
+        });
+    }
+    return rungs;
+}
+function truncateTail(text, maxChars) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `…(truncated)…\n${trimmed.slice(-maxChars)}`;
+}
+/** Run a single rung synchronously in the project root. */
+export function runRung(rung, projectRoot, tailChars = DEFAULT_TAIL_CHARS) {
+    const start = Date.now();
+    const res = spawnSync(rung.command, rung.args, {
+        cwd: projectRoot,
+        encoding: 'utf-8',
+        timeout: rung.timeoutMs,
+        maxBuffer: 16 * 1024 * 1024,
+        env: sanitizedEnv(),
+    });
+    const durationMs = Date.now() - start;
+    const exitCode = res.status;
+    const passed = exitCode === 0;
+    // spawnSync reports timeouts/missing binaries via res.error (+ res.signal),
+    // with status null and empty output — without this the model would get a
+    // bare "FAIL" and burn its turn budget against an unexplained gate.
+    let failureReason;
+    let diagnostic = '';
+    if (!passed) {
+        const errCode = res.error?.code;
+        if (errCode === 'ETIMEDOUT' || (res.error && res.signal === 'SIGTERM')) {
+            failureReason = 'timeout';
+            diagnostic = `Gate timed out after ${rung.timeoutMs}ms.`;
+        }
+        else if (res.error) {
+            failureReason = 'spawn-error';
+            diagnostic = `Gate could not run: ${res.error.message}`;
+        }
+        else if (res.signal) {
+            failureReason = 'signal';
+            diagnostic = `Gate was killed by signal ${res.signal}.`;
+        }
+        else {
+            failureReason = 'exit';
+        }
+    }
+    const combined = `${diagnostic}\n${res.stdout ?? ''}\n${res.stderr ?? ''}`;
+    return {
+        id: rung.id,
+        name: rung.name,
+        passed,
+        skipped: false,
+        exitCode,
+        failureReason,
+        durationMs,
+        outputTail: passed ? '' : truncateTail(combined, tailChars),
+    };
+}
+/**
+ * Build feedback text from rung results. Only the first failing required
+ * rung's output is included in detail — small models do better with one
+ * concrete problem at a time than with a wall of every failure.
+ */
+export function formatFeedback(results, rungs) {
+    const requiredIds = new Set(rungs.filter((r) => r.required).map((r) => r.id));
+    const lines = ['Gate results:'];
+    for (const r of results) {
+        const status = r.skipped ? 'SKIPPED (earlier gate failed)' : r.passed ? 'PASS' : 'FAIL';
+        const optional = requiredIds.has(r.id) ? '' : ' (optional)';
+        lines.push(`- ${r.name}${optional}: ${status}`);
+    }
+    const firstFailure = results.find((r) => !r.passed && !r.skipped && requiredIds.has(r.id)) ??
+        results.find((r) => !r.passed && !r.skipped);
+    if (firstFailure && firstFailure.outputTail) {
+        lines.push('');
+        lines.push(`Fix this gate first — ${firstFailure.name} output:`);
+        lines.push('```');
+        lines.push(firstFailure.outputTail);
+        lines.push('```');
+    }
+    return lines.join('\n');
+}
+/** Run the full ladder, honoring fail-fast for required rungs. */
+export function runLadder(rungs, projectRoot, options = {}) {
+    const failFast = options.failFast ?? true;
+    const tailChars = options.outputTailChars ?? DEFAULT_TAIL_CHARS;
+    const results = [];
+    let stop = false;
+    for (const rung of rungs) {
+        if (stop) {
+            results.push({
+                id: rung.id,
+                name: rung.name,
+                passed: false,
+                skipped: true,
+                exitCode: null,
+                durationMs: 0,
+                outputTail: '',
+            });
+            continue;
+        }
+        const result = runRung(rung, projectRoot, tailChars);
+        results.push(result);
+        if (!result.passed && rung.required && failFast) {
+            stop = true;
+        }
+    }
+    const passedCount = results.filter((r) => r.passed).length;
+    const score = rungs.length > 0 ? passedCount / rungs.length : 1;
+    // Delivery is gated on required rungs only; optional gates (lint) are
+    // reported but never block convergence.
+    const requiredRungs = rungs.filter((r) => r.required);
+    const requiredPassed = results.filter((r) => r.passed && requiredRungs.some((rung) => rung.id === r.id)).length;
+    const passed = requiredPassed === requiredRungs.length;
+    return {
+        passed,
+        score,
+        results,
+        feedback: formatFeedback(results, rungs),
+    };
+}
+//# sourceMappingURL=verifier-ladder.js.map