@miller-tech/uap 1.163.13 → 1.164.0

package/dist/delivery/graph-safety.js

@@ -0,0 +1,98 @@
+/**
+ * Graph-engineering safety (S7).
+ *
+ * Pure implementations of the three failure modes from the graph-engineering
+ * playbook, so a fan-out/fan-in decomposition is safe at scale:
+ *
+ *  1. FALSE INDEPENDENCE — two nodes with no data dependency but a shared write
+ *     target (same file) have a hidden edge; they must serialize. `syntheticEdges`
+ *     derives those edges from predicted writes (fed by the coordination DB).
+ *  2. SILENT NODE FAILURE — one failed node among many vanishes into a report
+ *     that looks complete. `reconcileFanIn` checks completed-vs-expected and
+ *     surfaces the gap instead of synthesizing partial output.
+ *  3. CONTEXT COLLAPSE — feeding N raw outputs into one consolidation blows the
+ *     context window. `layerFanIn` batches into groups for layered summary.
+ */
+/**
+ * Derive serialization edges between nodes that write the SAME file, even with
+ * zero data dependency (false independence). Deterministic: for each shared
+ * write target, chains the nodes in input order (earlier → later). Pure.
+ */
+export function syntheticEdges(nodes) {
+    const byResource = new Map();
+    for (const n of nodes) {
+        for (const w of n.writes ?? []) {
+            const list = byResource.get(w) ?? [];
+            if (!list.includes(n.id))
+                list.push(n.id);
+            byResource.set(w, list);
+        }
+    }
+    const edges = [];
+    for (const [resource, ids] of byResource) {
+        for (let i = 1; i < ids.length; i++) {
+            edges.push({ from: ids[i - 1], to: ids[i], resource });
+        }
+    }
+    return edges;
+}
+/**
+ * Silent-node-failure guard: compare completed node ids against the expected
+ * set BEFORE synthesizing. `complete` is false when any expected node is
+ * missing, so the caller flags the gap rather than shipping partial output.
+ * Pure.
+ */
+export function reconcileFanIn(expected, completed) {
+    const done = new Set(completed);
+    const missing = expected.filter((id) => !done.has(id));
+    return {
+        complete: missing.length === 0,
+        expectedCount: expected.length,
+        completedCount: expected.length - missing.length,
+        missing,
+    };
+}
+/**
+ * Layer a list into fan-in batches (context-collapse fix). Batches of at most
+ * `batchSize` (default 30) so a consolidation step summarizes group summaries
+ * rather than N raw outputs. Pure.
+ */
+export function layerFanIn(items, batchSize = 30) {
+    const size = Math.max(1, Math.floor(batchSize));
+    const batches = [];
+    for (let i = 0; i < items.length; i += size) {
+        batches.push(items.slice(i, i + size));
+    }
+    return batches;
+}
+/**
+ * Augment DAG phases with false-independence serialization edges: phases
+ * predicted to write the SAME file get their `deps` extended so the scheduler
+ * serializes them, even with zero data dependency. `predictWrites` is injected
+ * (fed by the coordination DB's predicted writes). Pure — returns new phase
+ * objects with a merged `deps`; input order defines the serialization chain.
+ * This is the S7 fix wired at the DeliveryPhase layer.
+ *
+ * PRECONDITION: `phases` must be in an order consistent with their existing
+ * `deps` (topologically ordered, as planDeliveryPhases emits). Synthetic edges
+ * run earlier→later by input order; passing a phase before one it already
+ * depends on could combine with the pre-existing dep to form a cycle. Callers
+ * that don't guarantee topological input order should cycle-check the result.
+ */
+export function augmentPhasesWithWriteEdges(phases, predictWrites) {
+    const nodes = phases.map((p) => ({ id: p.id, writes: predictWrites(p) }));
+    const edges = syntheticEdges(nodes);
+    const extra = new Map();
+    for (const e of edges) {
+        const set = extra.get(e.to) ?? new Set();
+        set.add(e.from);
+        extra.set(e.to, set);
+    }
+    return phases.map((p) => {
+        const merged = new Set(p.deps ?? []);
+        for (const from of extra.get(p.id) ?? [])
+            merged.add(from);
+        return { ...p, deps: [...merged] };
+    });
+}
+//# sourceMappingURL=graph-safety.js.map

package/dist/delivery/graph-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-safety.js","sourceRoot":"","sources":["../../src/delivery/graph-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAiBH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAkB;IAC/C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC/C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;YAC/B,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC1C,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,MAAM,KAAK,GAAoB,EAAE,CAAC;IAClC,KAAK,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,UAAU,EAAE,CAAC;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAUD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,QAAkB,EAAE,SAAmB;IACpE,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACvD,OAAO;QACL,QAAQ,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;QAC9B,aAAa,EAAE,QAAQ,CAAC,MAAM;QAC9B,cAAc,EAAE,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM;QAChD,OAAO;KACR,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAI,KAAmB,EAAE,SAAS,GAAG,EAAE;IAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAChD,MAAM,OAAO,GAAU,EAAE,CAAC;IAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;QAC5C,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAoB,EACpB,aAAqC;IAErC,MAAM,KAAK,GAAgB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACvF,MAAM,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,GAAG,EAAU,CAAC;QACjD,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACvB,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACtB,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QACrC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE;YAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3D,OAAO,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC;IACrC,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/delivery/per-phase-escalation-controller.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Per-phase escalation controller (integration of S5 into the loop).
+ *
+ * A stagnation-driven `onIteration` hook that walks the EXECUTE phase's
+ * escalation chain (S5 `resolveEscalation`) rung by rung, then the capability
+ * ceiling — superseding the single global `escalateModel` with the full
+ * per-(tier, phase) ladder. The single-executor convergence loop can only host
+ * the execute-phase ladder; plan/review/reflect ladders belong at the
+ * orchestrator layer (they run distinct executors). This controller composes via
+ * `composeIterationHooks`, so no loop-core change is needed — it just emits
+ * `switchExecutor` directives, exactly like the existing escalation controller.
+ */
+import type { IterationRecord, IterationDirective, LoopExecutor } from './convergence-loop.js';
+import type { RoutingPreset, TaskComplexity } from '../models/types.js';
+import type { EscalationScope } from '../coordination/effort-profile.js';
+export interface PerPhaseEscalationConfig {
+    preset: RoutingPreset;
+    complexity?: TaskComplexity;
+    /** Effort scope gating whether the execute phase may escalate at all. */
+    scope: EscalationScope;
+    /** Bind a resolved model id to a LoopExecutor (provided by the CLI). */
+    bindExecutor: (modelId: string) => LoopExecutor;
+    stagnationTurns?: number;
+    improvementEpsilon?: number;
+    onEscalate?: (info: {
+        rung: number;
+        model: string;
+        policy: 'fixed' | 'capability';
+    }) => void;
+}
+export interface PerPhaseEscalationController {
+    onIteration: (record: IterationRecord) => IterationDirective;
+    /** Current execute-phase rung (0 = primary, ≥1 = escalated). For tests. */
+    rung: () => number;
+}
+export declare function createPerPhaseEscalationController(cfg: PerPhaseEscalationConfig): PerPhaseEscalationController;
+//# sourceMappingURL=per-phase-escalation-controller.d.ts.map

package/dist/delivery/per-phase-escalation-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-phase-escalation-controller.d.ts","sourceRoot":"","sources":["../../src/delivery/per-phase-escalation-controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE/F,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAKzE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,yEAAyE;IACzE,KAAK,EAAE,eAAe,CAAC;IACvB,wEAAwE;IACxE,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,YAAY,CAAC;IAChD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,GAAG,YAAY,CAAA;KAAE,KAAK,IAAI,CAAC;CAC9F;AAED,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,kBAAkB,CAAC;IAC7D,2EAA2E;IAC3E,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,wBAAgB,kCAAkC,CAChD,GAAG,EAAE,wBAAwB,GAC5B,4BAA4B,CAiD9B"}

package/dist/delivery/per-phase-escalation-controller.js

@@ -0,0 +1,68 @@
+/**
+ * Per-phase escalation controller (integration of S5 into the loop).
+ *
+ * A stagnation-driven `onIteration` hook that walks the EXECUTE phase's
+ * escalation chain (S5 `resolveEscalation`) rung by rung, then the capability
+ * ceiling — superseding the single global `escalateModel` with the full
+ * per-(tier, phase) ladder. The single-executor convergence loop can only host
+ * the execute-phase ladder; plan/review/reflect ladders belong at the
+ * orchestrator layer (they run distinct executors). This controller composes via
+ * `composeIterationHooks`, so no loop-core change is needed — it just emits
+ * `switchExecutor` directives, exactly like the existing escalation controller.
+ */
+import { resolveEscalation, phaseMayEscalate } from './per-phase-escalation.js';
+const DEFAULT_STAGNATION_TURNS = 2;
+const DEFAULT_EPSILON = 0.01;
+export function createPerPhaseEscalationController(cfg) {
+    const stagnationTurns = cfg.stagnationTurns ?? DEFAULT_STAGNATION_TURNS;
+    const epsilon = cfg.improvementEpsilon ?? DEFAULT_EPSILON;
+    let bestScore = -1;
+    let stagnant = 0;
+    let rung = 0; // 0 = the primary model already running; escalate from rung 1
+    let ceilingReached = false;
+    return {
+        rung: () => rung,
+        onIteration: (record) => {
+            if (record.passed)
+                return {};
+            if (!phaseMayEscalate('execute', cfg.scope))
+                return {};
+            // Don't let infra flakiness (an executor error / never-verified turn,
+            // both score 0) count toward stagnation and walk the ladder to the
+            // ceiling — mirror the loop's own `inconclusive` guard.
+            if (record.executorError || record.gateResults.length === 0)
+                return {};
+            // Once at the capability ceiling there is nothing stronger to switch to;
+            // stop re-binding the same model every stagnation window.
+            if (ceilingReached)
+                return {};
+            if (record.score > bestScore + epsilon) {
+                bestScore = record.score;
+                stagnant = 0;
+                return {};
+            }
+            stagnant += 1;
+            if (record.score > bestScore)
+                bestScore = record.score;
+            if (stagnant < stagnationTurns)
+                return {};
+            // Stagnated — advance one execute rung along the chain / to the ceiling.
+            rung += 1;
+            stagnant = 0;
+            const step = resolveEscalation({
+                preset: cfg.preset,
+                complexity: cfg.complexity,
+                phase: 'execute',
+                rung,
+            });
+            if (step.exhausted)
+                ceilingReached = true;
+            cfg.onEscalate?.({ rung, model: step.model, policy: step.policy });
+            return {
+                switchExecutor: cfg.bindExecutor(step.model),
+                note: `per-phase escalate execute → ${step.model} (rung ${rung}, ${step.policy})`,
+            };
+        },
+    };
+}
+//# sourceMappingURL=per-phase-escalation-controller.js.map

package/dist/delivery/per-phase-escalation-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-phase-escalation-controller.js","sourceRoot":"","sources":["../../src/delivery/per-phase-escalation-controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAIhF,MAAM,wBAAwB,GAAG,CAAC,CAAC;AACnC,MAAM,eAAe,GAAG,IAAI,CAAC;AAoB7B,MAAM,UAAU,kCAAkC,CAChD,GAA6B;IAE7B,MAAM,eAAe,GAAG,GAAG,CAAC,eAAe,IAAI,wBAAwB,CAAC;IACxE,MAAM,OAAO,GAAG,GAAG,CAAC,kBAAkB,IAAI,eAAe,CAAC;IAE1D,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;IACnB,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,8DAA8D;IAC5E,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI;QAChB,WAAW,EAAE,CAAC,MAAuB,EAAsB,EAAE;YAC3D,IAAI,MAAM,CAAC,MAAM;gBAAE,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC;YACvD,sEAAsE;YACtE,mEAAmE;YACnE,wDAAwD;YACxD,IAAI,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC;YACvE,yEAAyE;YACzE,0DAA0D;YAC1D,IAAI,cAAc;gBAAE,OAAO,EAAE,CAAC;YAE9B,IAAI,MAAM,CAAC,KAAK,GAAG,SAAS,GAAG,OAAO,EAAE,CAAC;gBACvC,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;gBACzB,QAAQ,GAAG,CAAC,CAAC;gBACb,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,QAAQ,IAAI,CAAC,CAAC;YACd,IAAI,MAAM,CAAC,KAAK,GAAG,SAAS;gBAAE,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;YACvD,IAAI,QAAQ,GAAG,eAAe;gBAAE,OAAO,EAAE,CAAC;YAE1C,yEAAyE;YACzE,IAAI,IAAI,CAAC,CAAC;YACV,QAAQ,GAAG,CAAC,CAAC;YACb,MAAM,IAAI,GAAG,iBAAiB,CAAC;gBAC7B,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,UAAU,EAAE,GAAG,CAAC,UAAU;gBAC1B,KAAK,EAAE,SAAS;gBAChB,IAAI;aACL,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,SAAS;gBAAE,cAAc,GAAG,IAAI,CAAC;YAC1C,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YACnE,OAAO;gBACL,cAAc,EAAE,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC5C,IAAI,EAAE,gCAAgC,IAAI,CAAC,KAAK,UAAU,IAAI,KAAK,IAAI,CAAC,MAAM,GAAG;aAClF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/delivery/per-phase-escalation.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Per-phase escalation — hybrid policy (S5).
+ *
+ * Generalizes the single global escalate-model (repair-escalation.ts's
+ * resolveEscalateModelId) into a per-(tier, phase) escalation ladder that
+ * composes S3's per-phase model chains:
+ *   - rungs 0..n-1 walk the FIXED chain for the (tier, phase) — deterministic,
+ *     testable (e.g. execute: qwen → sonnet → opus);
+ *   - once the chain is exhausted, the FINAL rung defers to a CAPABILITY-driven
+ *     pick (the adaptive ceiling) — the "hybrid" the design selected.
+ *
+ * Pure and injectable: the capability pick is a parameter so the real
+ * unified-router selector can be wired in without changing this contract. Each
+ * phase escalates on its OWN ladder, so a stalled execute phase advances the
+ * execute chain without disturbing the review/plan phases (Generator≠Evaluator
+ * is preserved because review/execute chains are independent).
+ */
+import { type RoutingPreset, type Phase, type TaskComplexity } from '../models/types.js';
+import type { EscalationScope } from '../coordination/effort-profile.js';
+export type EscalationPolicy = 'fixed' | 'capability';
+export interface EscalationStep {
+    /** The model id to run this rung on. */
+    model: string;
+    /** Whether this rung came from the fixed chain or the capability ceiling. */
+    policy: EscalationPolicy;
+    /** The (clamped) rung index that produced this step. */
+    rung: number;
+    /** True once the fixed chain is exhausted (capability fallback engaged). */
+    exhausted: boolean;
+}
+/** Default capability ceiling: the preset's fallback role, else the last model
+ * in the preset's model list, else the executor role. */
+export declare function defaultCapabilityPick(preset: RoutingPreset): string;
+/**
+ * Resolve the model for an escalation rung of a (tier, phase). Hybrid policy:
+ * fixed chain first, capability-driven ceiling once exhausted. PURE.
+ */
+export declare function resolveEscalation(opts: {
+    preset: RoutingPreset;
+    complexity?: TaskComplexity;
+    phase: Phase;
+    /** 0-based escalation rung (0 = primary, 1 = first escalation, …). */
+    rung: number;
+    /** Injectable capability picker for the final rung; defaults to the ceiling. */
+    capabilityPick?: (preset: RoutingPreset) => string;
+}): EscalationStep;
+/**
+ * Whether a phase is allowed to escalate under an effort scope. `execute` is
+ * always allowed; `plan` only under plan+/all scopes; `review`/`reflect` only
+ * under `all`/`all+fallback`; `fallback` only under `all+fallback`.
+ */
+export declare function phaseMayEscalate(phase: Phase, scope: EscalationScope): boolean;
+//# sourceMappingURL=per-phase-escalation.d.ts.map

package/dist/delivery/per-phase-escalation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-phase-escalation.d.ts","sourceRoot":"","sources":["../../src/delivery/per-phase-escalation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAqB,KAAK,aAAa,EAAE,KAAK,KAAK,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC5G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,YAAY,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,MAAM,EAAE,gBAAgB,CAAC;IACzB,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;yDACyD;AACzD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,CAAC;CACpD,GAAG,cAAc,CAQjB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAc9E"}

package/dist/delivery/per-phase-escalation.js

@@ -0,0 +1,57 @@
+/**
+ * Per-phase escalation — hybrid policy (S5).
+ *
+ * Generalizes the single global escalate-model (repair-escalation.ts's
+ * resolveEscalateModelId) into a per-(tier, phase) escalation ladder that
+ * composes S3's per-phase model chains:
+ *   - rungs 0..n-1 walk the FIXED chain for the (tier, phase) — deterministic,
+ *     testable (e.g. execute: qwen → sonnet → opus);
+ *   - once the chain is exhausted, the FINAL rung defers to a CAPABILITY-driven
+ *     pick (the adaptive ceiling) — the "hybrid" the design selected.
+ *
+ * Pure and injectable: the capability pick is a parameter so the real
+ * unified-router selector can be wired in without changing this contract. Each
+ * phase escalates on its OWN ladder, so a stalled execute phase advances the
+ * execute chain without disturbing the review/plan phases (Generator≠Evaluator
+ * is preserved because review/execute chains are independent).
+ */
+import { resolvePhaseChain } from '../models/types.js';
+/** Default capability ceiling: the preset's fallback role, else the last model
+ * in the preset's model list, else the executor role. */
+export function defaultCapabilityPick(preset) {
+    return preset.roles.fallback ?? preset.models[preset.models.length - 1] ?? preset.roles.executor;
+}
+/**
+ * Resolve the model for an escalation rung of a (tier, phase). Hybrid policy:
+ * fixed chain first, capability-driven ceiling once exhausted. PURE.
+ */
+export function resolveEscalation(opts) {
+    const chain = resolvePhaseChain(opts.preset, { complexity: opts.complexity, phase: opts.phase });
+    const rung = Math.max(0, Math.floor(opts.rung));
+    if (chain.length > 0 && rung < chain.length) {
+        return { model: chain[rung], policy: 'fixed', rung, exhausted: false };
+    }
+    const pick = opts.capabilityPick ?? defaultCapabilityPick;
+    return { model: pick(opts.preset), policy: 'capability', rung, exhausted: true };
+}
+/**
+ * Whether a phase is allowed to escalate under an effort scope. `execute` is
+ * always allowed; `plan` only under plan+/all scopes; `review`/`reflect` only
+ * under `all`/`all+fallback`; `fallback` only under `all+fallback`.
+ */
+export function phaseMayEscalate(phase, scope) {
+    switch (phase) {
+        case 'execute':
+            return scope !== 'fallback';
+        case 'plan':
+            return scope === 'plan+execute' || scope === 'all' || scope === 'all+fallback';
+        case 'review':
+        case 'reflect':
+            return scope === 'all' || scope === 'all+fallback';
+        case 'fallback':
+            return scope === 'all+fallback' || scope === 'fallback';
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=per-phase-escalation.js.map

package/dist/delivery/per-phase-escalation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"per-phase-escalation.js","sourceRoot":"","sources":["../../src/delivery/per-phase-escalation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,iBAAiB,EAAuD,MAAM,oBAAoB,CAAC;AAgB5G;yDACyD;AACzD,MAAM,UAAU,qBAAqB,CAAC,MAAqB;IACzD,OAAO,MAAM,CAAC,KAAK,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC;AACnG,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAQjC;IACC,MAAM,KAAK,GAAG,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACjG,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAChD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAC5C,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACzE,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,IAAI,qBAAqB,CAAC;IAC1D,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AACnF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAY,EAAE,KAAsB;IACnE,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,SAAS;YACZ,OAAO,KAAK,KAAK,UAAU,CAAC;QAC9B,KAAK,MAAM;YACT,OAAO,KAAK,KAAK,cAAc,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,cAAc,CAAC;QACjF,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS;YACZ,OAAO,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,cAAc,CAAC;QACrD,KAAK,UAAU;YACb,OAAO,KAAK,KAAK,cAAc,IAAI,KAAK,KAAK,UAAU,CAAC;QAC1D;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC"}

package/dist/delivery/reflect.d.ts

@@ -0,0 +1,56 @@
+/**
+ * GEPA-style reflect phase (S6).
+ *
+ * Upgrades the loop's reflection from "fix-list for the next turn" (critic.ts)
+ * to "reflect on WHY the approach failed → rewrite the approach/instruction →
+ * retry", with a Pareto archive of the best reflected candidates so the loop
+ * reseeds from proven approaches instead of always mutating the latest one
+ * (which collapses to a local optimum — the same anti-Goodhart insight as the
+ * per-phase Generator≠Evaluator rule).
+ *
+ * This module is pure: the archive + the rewrite parser. The live wiring
+ * (a reflect turn before model escalation, feeding IterationDirective
+ * .mutateInstruction into the PromptBuilder) is the consumption step.
+ */
+export interface ApproachRewrite {
+    /** Reflection: why the prior approach/reasoning failed. */
+    why: string;
+    /** The rewritten instruction/approach to try next. */
+    newInstruction: string;
+}
+export interface ReflectCandidate {
+    /** The (possibly rewritten) approach/instruction. */
+    instruction: string;
+    /** The acceptance/quality score this approach achieved. */
+    score: number;
+    /** The turn it was produced on (tie-break: prefer earlier). */
+    turn: number;
+}
+/**
+ * A bounded best-K archive of reflected candidates by score. Deterministic:
+ * dedupes by instruction (keeping the higher score), sorts by score desc then
+ * earlier turn, and truncates to K. Pure — no I/O, no clock.
+ */
+export declare class ReflectArchive {
+    private readonly k;
+    private items;
+    constructor(k?: number);
+    add(c: ReflectCandidate): void;
+    best(): ReflectCandidate | undefined;
+    all(): ReflectCandidate[];
+    size(): number;
+    /**
+     * The best archived candidate whose instruction differs from `current` — so a
+     * reflect turn tries a proven-but-DIFFERENT approach rather than re-deriving
+     * the one that just stalled. Returns undefined when the archive holds nothing
+     * new to try.
+     */
+    reseedFrom(current: string): ReflectCandidate | undefined;
+}
+/**
+ * Parse a reflect model's output into an ApproachRewrite. Fail-soft: returns
+ * null when no usable rewrite is present, so a flaky reflect turn never wedges
+ * the loop (the caller falls back to model escalation).
+ */
+export declare function parseApproachRewrite(raw: string): ApproachRewrite | null;
+//# sourceMappingURL=reflect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reflect.d.ts","sourceRoot":"","sources":["../../src/delivery/reflect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,CAAC;IAF9B,OAAO,CAAC,KAAK,CAA0B;gBAEV,CAAC,GAAE,MAAU;IAI1C,GAAG,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAW9B,IAAI,IAAI,gBAAgB,GAAG,SAAS;IAIpC,GAAG,IAAI,gBAAgB,EAAE;IAIzB,IAAI,IAAI,MAAM;IAId;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;CAG1D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAYxE"}

package/dist/delivery/reflect.js

@@ -0,0 +1,79 @@
+/**
+ * GEPA-style reflect phase (S6).
+ *
+ * Upgrades the loop's reflection from "fix-list for the next turn" (critic.ts)
+ * to "reflect on WHY the approach failed → rewrite the approach/instruction →
+ * retry", with a Pareto archive of the best reflected candidates so the loop
+ * reseeds from proven approaches instead of always mutating the latest one
+ * (which collapses to a local optimum — the same anti-Goodhart insight as the
+ * per-phase Generator≠Evaluator rule).
+ *
+ * This module is pure: the archive + the rewrite parser. The live wiring
+ * (a reflect turn before model escalation, feeding IterationDirective
+ * .mutateInstruction into the PromptBuilder) is the consumption step.
+ */
+/**
+ * A bounded best-K archive of reflected candidates by score. Deterministic:
+ * dedupes by instruction (keeping the higher score), sorts by score desc then
+ * earlier turn, and truncates to K. Pure — no I/O, no clock.
+ */
+export class ReflectArchive {
+    k;
+    items = [];
+    constructor(k = 4) {
+        this.k = k;
+        this.k = Math.max(1, Math.floor(k));
+    }
+    add(c) {
+        const i = this.items.findIndex((x) => x.instruction === c.instruction);
+        if (i >= 0) {
+            if (c.score > this.items[i].score)
+                this.items[i] = c;
+        }
+        else {
+            this.items.push(c);
+        }
+        this.items.sort((a, b) => b.score - a.score || a.turn - b.turn);
+        if (this.items.length > this.k)
+            this.items = this.items.slice(0, this.k);
+    }
+    best() {
+        return this.items[0];
+    }
+    all() {
+        return [...this.items];
+    }
+    size() {
+        return this.items.length;
+    }
+    /**
+     * The best archived candidate whose instruction differs from `current` — so a
+     * reflect turn tries a proven-but-DIFFERENT approach rather than re-deriving
+     * the one that just stalled. Returns undefined when the archive holds nothing
+     * new to try.
+     */
+    reseedFrom(current) {
+        return this.items.find((x) => x.instruction !== current);
+    }
+}
+/**
+ * Parse a reflect model's output into an ApproachRewrite. Fail-soft: returns
+ * null when no usable rewrite is present, so a flaky reflect turn never wedges
+ * the loop (the caller falls back to model escalation).
+ */
+export function parseApproachRewrite(raw) {
+    try {
+        const m = raw.match(/\{[\s\S]*\}/);
+        if (!m)
+            return null;
+        const o = JSON.parse(m[0]);
+        if (typeof o.newInstruction === 'string' && o.newInstruction.trim() !== '') {
+            return { why: typeof o.why === 'string' ? o.why : '', newInstruction: o.newInstruction };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=reflect.js.map

package/dist/delivery/reflect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflect.js","sourceRoot":"","sources":["../../src/delivery/reflect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAkBH;;;;GAIG;AACH,MAAM,OAAO,cAAc;IAGI;IAFrB,KAAK,GAAuB,EAAE,CAAC;IAEvC,YAA6B,IAAY,CAAC;QAAb,MAAC,GAAD,CAAC,CAAY;QACxC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC;IAED,GAAG,CAAC,CAAmB;QACrB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,CAAC,CAAC,WAAW,CAAC,CAAC;QACvE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK;gBAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QAChE,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;YAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAED,GAAG;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,OAAe;QACxB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,OAAO,CAAC,CAAC;IAC3D,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QACnC,IAAI,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QACpB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAgD,CAAC;QAC1E,IAAI,OAAO,CAAC,CAAC,cAAc,KAAK,QAAQ,IAAI,CAAC,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC3E,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC,cAAc,EAAE,CAAC;QAC3F,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/delivery/verification-provenance.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Verification provenance (S1) — enforces Principle 3: "the model cannot verify
+ * itself." Deliver must never let the generator be the SOLE grader of its own
+ * output. When no evaluator is configured and the operator has not explicitly
+ * opted into self-judging, a cheap DISTINCT judge is chosen. Local/offline
+ * generators cannot reach a distinct model, so they keep self-judging but are
+ * flagged distinct=false (the honest, documented fallback).
+ *
+ * The selection logic is pure (`resolveJudgePlan`) so it is unit-testable in
+ * isolation from the model call; deliver.ts wires the executor from the plan.
+ */
+export interface JudgePlan {
+    /** Model id that will AUTHOR/JUDGE the acceptance gate. */
+    judgeModelId: string;
+    /** True when the judge differs from the generator (Generator≠Evaluator). */
+    distinct: boolean;
+    /** Why this judge was chosen — for logs/telemetry. */
+    reason: 'configured-evaluator' | 'self-judge-allowed' | 'auto-distinct-judge' | 'offline-local-no-distinct-judge';
+}
+/**
+ * Decide who judges. PURE. Precedence:
+ *  1. an explicitly-configured evaluator preset  → distinct
+ *  2. operator opted into self-judge             → generator (distinct=false)
+ *  3. cloud generator, distinct cheap judge avail → the distinct judge
+ *  4. local/offline (no distinct reachable)       → generator (distinct=false)
+ */
+export declare function resolveJudgePlan(opts: {
+    evaluatorPresetId: string | null;
+    generatorId: string;
+    generatorProvider?: string;
+    allowSelfJudge: boolean;
+    /** Cheap distinct judge preferred when the generator is cloud. */
+    distinctJudgeId?: string;
+    /** Cheap distinct judge to use when the generator itself IS distinctJudgeId. */
+    altJudgeId?: string;
+    hasPreset: (id: string) => boolean;
+}): JudgePlan;
+export interface VerificationProvenance {
+    executorModel: string;
+    judgeModel: string;
+    distinct: boolean;
+    /** Names of gates that ran fail-open this delivery (observability). */
+    failOpenGates?: string[];
+}
+/** One-line provenance banner emitted at delivery end. */
+export declare function formatVerificationProvenance(p: VerificationProvenance): string;
+//# sourceMappingURL=verification-provenance.d.ts.map

package/dist/delivery/verification-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-provenance.d.ts","sourceRoot":"","sources":["../../src/delivery/verification-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,MAAM,EACF,sBAAsB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,iCAAiC,CAAC;CACvC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,OAAO,CAAC;IACxB,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;CACpC,GAAG,SAAS,CAsBZ;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,0DAA0D;AAC1D,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAI9E"}

package/dist/delivery/verification-provenance.js

@@ -0,0 +1,48 @@
+/**
+ * Verification provenance (S1) — enforces Principle 3: "the model cannot verify
+ * itself." Deliver must never let the generator be the SOLE grader of its own
+ * output. When no evaluator is configured and the operator has not explicitly
+ * opted into self-judging, a cheap DISTINCT judge is chosen. Local/offline
+ * generators cannot reach a distinct model, so they keep self-judging but are
+ * flagged distinct=false (the honest, documented fallback).
+ *
+ * The selection logic is pure (`resolveJudgePlan`) so it is unit-testable in
+ * isolation from the model call; deliver.ts wires the executor from the plan.
+ */
+/**
+ * Decide who judges. PURE. Precedence:
+ *  1. an explicitly-configured evaluator preset  → distinct
+ *  2. operator opted into self-judge             → generator (distinct=false)
+ *  3. cloud generator, distinct cheap judge avail → the distinct judge
+ *  4. local/offline (no distinct reachable)       → generator (distinct=false)
+ */
+export function resolveJudgePlan(opts) {
+    // A configured evaluator only counts as distinct if it is actually a
+    // DIFFERENT model than the generator (CWE-345: don't assert distinctness we
+    // haven't verified). If it collides, fall through to the auto/offline logic.
+    if (opts.evaluatorPresetId && opts.evaluatorPresetId !== opts.generatorId) {
+        return { judgeModelId: opts.evaluatorPresetId, distinct: true, reason: 'configured-evaluator' };
+    }
+    if (opts.allowSelfJudge) {
+        return { judgeModelId: opts.generatorId, distinct: false, reason: 'self-judge-allowed' };
+    }
+    const cloud = opts.generatorProvider === 'anthropic' || opts.generatorProvider === 'openai';
+    const preferred = opts.distinctJudgeId ?? 'haiku-4.5';
+    const alt = opts.altJudgeId ?? 'sonnet-5';
+    const distinctId = opts.generatorId === preferred ? alt : preferred;
+    if (cloud && opts.hasPreset(distinctId)) {
+        return { judgeModelId: distinctId, distinct: true, reason: 'auto-distinct-judge' };
+    }
+    return {
+        judgeModelId: opts.generatorId,
+        distinct: false,
+        reason: 'offline-local-no-distinct-judge',
+    };
+}
+/** One-line provenance banner emitted at delivery end. */
+export function formatVerificationProvenance(p) {
+    const distinct = p.distinct ? 'yes' : 'NO(self-verify)';
+    const fo = p.failOpenGates && p.failOpenGates.length ? ` failOpen=[${p.failOpenGates.join(',')}]` : '';
+    return `verify: exec=${p.executorModel} judge=${p.judgeModel} distinct=${distinct}${fo}`;
+}
+//# sourceMappingURL=verification-provenance.js.map

package/dist/delivery/verification-provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-provenance.js","sourceRoot":"","sources":["../../src/delivery/verification-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAeH;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAUhC;IACC,qEAAqE;IACrE,4EAA4E;IAC5E,6EAA6E;IAC7E,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;QAC1E,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,iBAAiB,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC;IAClG,CAAC;IACD,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC3F,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,KAAK,WAAW,IAAI,IAAI,CAAC,iBAAiB,KAAK,QAAQ,CAAC;IAC5F,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,IAAI,WAAW,CAAC;IACtD,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC;IAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QACxC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;IACrF,CAAC;IACD,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,WAAW;QAC9B,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,iCAAiC;KAC1C,CAAC;AACJ,CAAC;AAUD,0DAA0D;AAC1D,MAAM,UAAU,4BAA4B,CAAC,CAAyB;IACpE,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB,CAAC;IACxD,MAAM,EAAE,GAAG,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IACvG,OAAO,gBAAgB,CAAC,CAAC,aAAa,UAAU,CAAC,CAAC,UAAU,aAAa,QAAQ,GAAG,EAAE,EAAE,CAAC;AAC3F,CAAC"}

package/dist/models/complexity.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Unified complexity classifier (S2).
+ *
+ * Before this module UAP had two disconnected notions of complexity:
+ *  - router.ts        → low | medium | high | critical  (keyword-driven)
+ *  - query-complexity → simple | moderate | complex      (heuristic scorer)
+ * bridged one-way by deliver.ts's COMPLEXITY_TO_TIER, which silently DROPPED
+ * `critical`. This module is the single source of truth: one 5-level `Tier`
+ * (adds `trivial` as a floor) that composes the existing scorer and preserves
+ * `critical` end-to-end. It is CHEAP-FIRST — a pure heuristic, no model call —
+ * so classifying a task adds no overhead. `source` leaves room for a future
+ * model-assisted tie-break in the ambiguous band without changing callers.
+ */
+export type Tier = 'trivial' | 'low' | 'medium' | 'high' | 'critical';
+export interface ComplexitySignal {
+    tier: Tier;
+    /** 0..1 continuous — for thresholds/telemetry. */
+    score: number;
+    /** Why this tier — keyword hits, size, file count, risk flags. */
+    reasons: string[];
+    /** How it was decided; 'model' reserved for a future ambiguous-band tie-break. */
+    source: 'heuristic' | 'model';
+}
+/**
+ * Classify task complexity into one 5-level tier. PURE, no model call.
+ * Precedence: risk/critical > trivial-floor > 3-level scorer (low/medium/high),
+ * with a file-count bump.
+ */
+export declare function classifyComplexity(input: {
+    instruction: string;
+    affectedFiles?: string[];
+    riskFlags?: string[];
+}): ComplexitySignal;
+/** Map the 5-level tier onto the 4-level routing scale (trivial folds to low). */
+export declare function tierToRouting(tier: Tier): 'low' | 'medium' | 'high' | 'critical';
+//# sourceMappingURL=complexity.d.ts.map

package/dist/models/complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/models/complexity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,MAAM,IAAI,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAEtE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,IAAI,CAAC;IACX,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kFAAkF;IAClF,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;CAC/B;AA6BD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,GAAG,gBAAgB,CAgCnB;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAEhF"}