infinicode 2.3.2 → 2.3.4

package/dist/kernel/index.d.ts

@@ -32,6 +32,10 @@ export type { GeminiProviderOptions } from './providers/gemini-provider.js';
 export { ALL_BUILTIN_WORKERS, createResearchWorker, createCodingWorker, createArchitectureWorker, createReviewWorker, createDocumentationWorker, createTranslationWorker, createTerminalWorker, createVerificationWorker, createVisionWorker, createFrontendWorker, createBrowserWorker, } from './workers/builtin-workers.js';
 export { KernelCommandRegistry, DEFAULT_COMMANDS } from './command-system.js';
 export type { KernelCommand, CommandContext } from './command-system.js';
+export { MissionPlanner } from './planner.js';
+export type { MissionPlannerDeps, PlanOptions } from './planner.js';
+export { normalizeCapabilities, CANONICAL_CAPABILITIES } from './capability-map.js';
+export { phaseBenchmarkFloor, phaseLabel } from './scheduler.js';
 export * from './federation/index.js';
 export { createMcpServer, serveMcpStdio } from './mcp/index.js';
 export type { McpServerDeps } from './mcp/index.js';

package/dist/kernel/index.js

@@ -24,6 +24,9 @@ export { OpenAICompatibleProvider } from './providers/openai-compatible-provider
 export { GeminiProvider } from './providers/gemini-provider.js';
 export { ALL_BUILTIN_WORKERS, createResearchWorker, createCodingWorker, createArchitectureWorker, createReviewWorker, createDocumentationWorker, createTranslationWorker, createTerminalWorker, createVerificationWorker, createVisionWorker, createFrontendWorker, createBrowserWorker, } from './workers/builtin-workers.js';
 export { KernelCommandRegistry, DEFAULT_COMMANDS } from './command-system.js';
+export { MissionPlanner } from './planner.js';
+export { normalizeCapabilities, CANONICAL_CAPABILITIES } from './capability-map.js';
+export { phaseBenchmarkFloor, phaseLabel } from './scheduler.js';
 // Federation — neutral device mesh (peers, telemetry, config sync, MOLTFED interop)
 export * from './federation/index.js';
 // MCP — north-facing control surface (spawn/dispatch/role/voice/map over the mesh)

package/dist/kernel/kernel.d.ts

@@ -20,6 +20,8 @@ import { PolicyEngine } from './policies.js';
 import { VerificationEngine } from './verification-engine.js';
 import { RecoveryManager } from './recovery-manager.js';
 import { KernelCommandRegistry } from './command-system.js';
+import { MissionPlanner } from './planner.js';
+import type { Federation } from './federation/federation.js';
 import type { CommandResult, EventHandler, KernelEvent, KernelEventType, KernelLike, Logger, Mission, MissionInput, Plugin, Policy, ProviderInterface, WorkerDefinition, MissionStatus } from './types.js';
 export interface KernelOptions {
     logger?: Logger;
@@ -42,8 +44,18 @@ export declare class Kernel implements KernelLike {
     readonly logger: Logger;
     /** Canonical OpenKernel slash-command surface (/status, /workers, /goal …). */
     readonly commands: KernelCommandRegistry;
+    /** Decomposes a goal into phases when a mission is run with `autoPlan`. */
+    readonly planner: MissionPlanner;
+    /**
+     * The mesh node this kernel is part of, once `infinicode serve`/`mcp` wires it
+     * in via {@link attachFederation}. Undefined when running stand-alone. Node
+     * commands (/nodes, /node, /activity …) read it off the command context.
+     */
+    federation?: Federation;
     private missions;
     constructor(options?: KernelOptions);
+    /** Attach the federation mesh node so node/mesh slash-commands can reach it. */
+    attachFederation(federation: Federation): void;
     execute(input: MissionInput): Promise<Mission>;
     pause(missionId: string): Promise<void>;
     resume(missionId: string): Promise<Mission>;

package/dist/kernel/kernel.js

@@ -22,6 +22,7 @@ import { RecoveryManager } from './recovery-manager.js';
 import { ConsoleLogger } from './logger.js';
 import { ALL_BUILTIN_WORKERS } from './workers/builtin-workers.js';
 import { KernelCommandRegistry } from './command-system.js';
+import { MissionPlanner } from './planner.js';
 export class Kernel {
     eventBus;
     providerManager;
@@ -38,6 +39,14 @@ export class Kernel {
     logger;
     /** Canonical OpenKernel slash-command surface (/status, /workers, /goal …). */
     commands;
+    /** Decomposes a goal into phases when a mission is run with `autoPlan`. */
+    planner;
+    /**
+     * The mesh node this kernel is part of, once `infinicode serve`/`mcp` wires it
+     * in via {@link attachFederation}. Undefined when running stand-alone. Node
+     * commands (/nodes, /node, /activity …) read it off the command context.
+     */
+    federation;
     missions = new Map();
     constructor(options = {}) {
         this.logger = options.logger ?? new ConsoleLogger();
@@ -89,17 +98,35 @@ export class Kernel {
         });
         this.plugins = new PluginManager(this.eventBus, this.logger);
         this.commands = new KernelCommandRegistry(this);
+        this.planner = new MissionPlanner({
+            providerManager: this.providerManager,
+            router: this.router,
+            logger: this.logger,
+        });
         if (options.loadBuiltinWorkers ?? true) {
             for (const handler of ALL_BUILTIN_WORKERS) {
                 this.workerRuntime.registerHandler(handler);
             }
         }
     }
+    /** Attach the federation mesh node so node/mesh slash-commands can reach it. */
+    attachFederation(federation) {
+        this.federation = federation;
+    }
     async execute(input) {
-        const mission = this.missionEngine.create(input);
+        // Auto-planning: decompose a bare goal into phases before execution when
+        // asked and no tasks/phases were supplied. Each phase → its own objective +
+        // model tier (see MissionPlanner + scheduler.planPhases).
+        let effective = input;
+        if (input.autoPlan && !input.tasks?.length && !input.phases?.length) {
+            const policy = this.policies.resolveRef(input.policy).policy;
+            const phases = await this.planner.plan(input.goal, { description: input.description, policy });
+            effective = { ...input, phases };
+        }
+        const mission = this.missionEngine.create(effective);
         this.missions.set(mission.id, mission);
         try {
-            await this.orchestrator.run(mission, input);
+            await this.orchestrator.run(mission, effective);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

package/dist/kernel/mission-engine.js

@@ -38,6 +38,20 @@ export class MissionEngine {
         mission.tasks = tasks;
         this.transition(mission, 'READY');
         this.deps.logger.info(`Mission planned: ${mission.id} — ${tasks.length} task(s)`);
+        // Broadcast the phase breakdown so harnesses (InfiniBot mesh map) can render
+        // the plan + each phase's capabilities and model tier.
+        this.emit(mission, 'PLAN_CREATED', {
+            missionId: mission.id,
+            goal: mission.goal,
+            phases: objectives.map(o => ({
+                id: o.id,
+                phase: o.phase,
+                description: o.description,
+                capabilities: o.capabilities,
+                minBenchmark: o.minBenchmark,
+                taskCount: o.taskIds.length,
+            })),
+        });
         return mission;
     }
     start(mission) {

package/dist/kernel/orchestrator.d.ts

@@ -36,6 +36,9 @@ export declare class Orchestrator {
     private taskOverrides;
     /** Per-task forced worker type override set by the recovery manager. */
     private taskWorkerOverrides;
+    /** How many times each task has been replanned (bounds the replan loop). */
+    private taskReplans;
+    private maxReplans;
     constructor(deps: OrchestratorDeps);
     run(mission: Mission, input: MissionInput): Promise<Mission>;
     private runTasks;

package/dist/kernel/orchestrator.js

@@ -7,6 +7,9 @@ export class Orchestrator {
     taskOverrides = new Map();
     /** Per-task forced worker type override set by the recovery manager. */
     taskWorkerOverrides = new Map();
+    /** How many times each task has been replanned (bounds the replan loop). */
+    taskReplans = new Map();
+    maxReplans = 2;
     constructor(deps) {
         this.deps = deps;
     }
@@ -68,6 +71,15 @@ export class Orchestrator {
         }
     }
     async executeTask(mission, task) {
+        // Per-phase model assignment: inherit this task's objective (phase) benchmark
+        // floor so demanding phases (architecture, verification) route to a more
+        // capable model tier than light phases — instead of one model for the whole
+        // mission. Escalation may later raise this floor further.
+        if (task.minBenchmark === undefined) {
+            const objective = mission.objectives.find(o => o.id === task.objectiveId);
+            if (objective?.minBenchmark)
+                task.minBenchmark = objective.minBenchmark;
+        }
         const overrideType = this.taskWorkerOverrides.get(task.id);
         let workerType = overrideType ?? this.deps.workerRuntime.matchWorkerType(task.capabilities);
         if (!workerType) {
@@ -90,7 +102,8 @@ export class Orchestrator {
             // Per-task verification via the Verification Engine pipeline.
             const vresult = await this.deps.verification.verify(mission, task, mission.policy.policy);
             if (!vresult.passed) {
-                // Treat as a verification-failure recovery case.
+                // Count verification misses — repeated misses escalate the model tier.
+                task.verificationFailures = (task.verificationFailures ?? 0) + 1;
                 await this.handleRecovery(mission, task, `verification failed: ${vresult.summary}`, instance);
             }
         }
@@ -112,6 +125,7 @@ export class Orchestrator {
             policy: mission.policy.policy,
             currentProviderId: instance.providerId,
             currentModelId: instance.modelId,
+            verificationFailures: task.verificationFailures,
         });
         const maxAttempts = mission.policy.policy.retry?.maxAttempts ?? 3;
         switch (decision.action) {
@@ -144,6 +158,35 @@ export class Orchestrator {
                 task.error = message;
                 break;
             }
+            case 'escalate-model': {
+                // Climb the benchmark ladder to a more capable model and raise this
+                // task's routing floor so it keeps escalating on further failures.
+                if (decision.rotateToProviderId && decision.rotateToModelId) {
+                    this.taskOverrides.set(task.id, {
+                        providerId: decision.rotateToProviderId,
+                        modelId: decision.rotateToModelId,
+                    });
+                    if (decision.escalateToBenchmark) {
+                        task.minBenchmark = Math.max(task.minBenchmark ?? 0, decision.escalateToBenchmark);
+                    }
+                    this.deps.eventBus.emit({
+                        type: 'MODEL_CHANGED',
+                        timestamp: Date.now(),
+                        missionId: mission.id,
+                        taskId: task.id,
+                        data: {
+                            from: { providerId: instance.providerId, modelId: instance.modelId },
+                            to: { providerId: decision.rotateToProviderId, modelId: decision.rotateToModelId },
+                            reason: decision.reason,
+                            escalated: true,
+                            minBenchmark: task.minBenchmark,
+                        },
+                    });
+                }
+                task.status = 'PENDING';
+                task.error = message;
+                break;
+            }
             case 'spawn-different-worker': {
                 if (decision.newWorkerType) {
                     this.taskWorkerOverrides.set(task.id, decision.newWorkerType);
@@ -153,7 +196,36 @@ export class Orchestrator {
                 task.error = message;
                 break;
             }
-            case 'replan':
+            case 'replan': {
+                // Real replan: checkpoint, then restart the task with a CLEAN slate —
+                // drop the provider/model + worker overrides so it re-routes from
+                // scratch, and reset the attempt/verification counters. Bounded by
+                // maxReplans so an unsatisfiable task can't loop forever.
+                const replans = (this.taskReplans.get(task.id) ?? 0) + 1;
+                this.taskReplans.set(task.id, replans);
+                await this.deps.checkpoints.save(mission, this.collectWorkerStates(mission.id), 'crash');
+                if (replans > this.maxReplans) {
+                    task.status = 'FAILED';
+                    task.error = `${message} (replan limit reached)`;
+                    this.deps.eventBus.emit({
+                        type: 'TASK_FAILED',
+                        timestamp: Date.now(),
+                        missionId: mission.id,
+                        taskId: task.id,
+                        workerId: instance.id,
+                        data: { error: task.error, attempts: task.attempts, replans },
+                    });
+                    break;
+                }
+                this.taskOverrides.delete(task.id);
+                this.taskWorkerOverrides.delete(task.id);
+                task.verificationFailures = 0;
+                task.attempts = 0;
+                task.status = 'PENDING';
+                task.error = message;
+                this.deps.logger.info(`Task ${task.id}: replan #${replans} — fresh routing + counters`);
+                break;
+            }
             case 'checkpoint': {
                 await this.deps.checkpoints.save(mission, this.collectWorkerStates(mission.id), 'crash');
                 task.status = 'PENDING';

package/dist/kernel/planner.d.ts

@@ -0,0 +1,42 @@
+/**
+ * OpenKernel — Mission Planner
+ *
+ * Decomposes a one-line goal into a sequence of PHASES (each becomes an
+ * objective), so a large build spreads across the right models by aspect
+ * (architecture → implementation → verification) instead of one model
+ * one-shotting the whole thing. Each phase carries the capabilities it needs;
+ * the scheduler turns those into a per-phase model benchmark floor.
+ *
+ * LLM-driven when a capable provider is available, with a deterministic
+ * heuristic fallback so planning never blocks on model availability.
+ */
+import type { Logger, MissionPhaseInput, Policy } from './types.js';
+import type { ProviderManager } from './provider-manager.js';
+import type { CapabilityRouter } from './router.js';
+import { normalizeCapabilities } from './capability-map.js';
+export interface MissionPlannerDeps {
+    providerManager: ProviderManager;
+    router: CapabilityRouter;
+    logger: Logger;
+}
+export interface PlanOptions {
+    description?: string;
+    policy?: Policy;
+    /** Max phases to request (default 6). */
+    maxPhases?: number;
+}
+export declare class MissionPlanner {
+    private deps;
+    constructor(deps: MissionPlannerDeps);
+    plan(goal: string, opts?: PlanOptions): Promise<MissionPhaseInput[]>;
+    private planWithLlm;
+    /** Extract + validate a phase array from a model's (possibly noisy) response. */
+    private parsePhases;
+    /**
+     * Deterministic fallback plan. Always yields buildable phases; adds a frontend
+     * phase for UI-shaped goals. Capabilities are natural — the scheduler
+     * normalizes them and derives each phase's model tier.
+     */
+    private heuristicPhases;
+}
+export { normalizeCapabilities };

package/dist/kernel/planner.js

@@ -0,0 +1,174 @@
+import { CANONICAL_CAPABILITIES, normalizeCapabilities } from './capability-map.js';
+export class MissionPlanner {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async plan(goal, opts = {}) {
+        const llm = await this.planWithLlm(goal, opts).catch(err => {
+            this.deps.logger.warn(`[planner] LLM planning failed: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        });
+        if (llm && llm.length) {
+            this.deps.logger.info(`[planner] LLM decomposed goal into ${llm.length} phase(s): ${llm.map(p => p.name).join(' → ')}`);
+            return llm;
+        }
+        const heuristic = this.heuristicPhases(goal);
+        this.deps.logger.info(`[planner] heuristic plan: ${heuristic.map(p => p.name).join(' → ')}`);
+        return heuristic;
+    }
+    async planWithLlm(goal, opts) {
+        const providers = (await this.deps.providerManager.getHealthyProviders()).map(p => p.info);
+        const models = await this.deps.providerManager.getAvailableModels();
+        if (providers.length === 0 || models.length === 0)
+            return null;
+        // Route the planning call to a capable reasoning model.
+        const decision = await this.deps.router.route({
+            capabilities: ['planning', 'reasoning'],
+            preferences: { reasoning: 85 },
+            policy: opts.policy ?? { name: 'balanced', routing: { mode: 'balanced' } },
+            availableProviders: providers,
+            availableModels: models,
+            minBenchmark: 82,
+        });
+        if (!decision)
+            return null;
+        const provider = this.deps.providerManager.get(decision.providerId);
+        if (!provider)
+            return null;
+        const maxPhases = opts.maxPhases ?? 6;
+        const request = {
+            model: decision.modelId,
+            systemPrompt: 'You are a senior software project planner for an execution kernel. Break the goal into 2–' +
+                `${maxPhases} sequential PHASES. Reply with ONLY minified JSON, no prose, of the form: ` +
+                '{"phases":[{"name":"...","description":"...","capabilities":["..."],"dependsOn":["<earlier phase name>"],"acceptanceCriteria":["..."]}]}. ' +
+                'Order phases so later ones dependsOn earlier ones. Prefer capability names from this list where they fit: ' +
+                CANONICAL_CAPABILITIES.join(', ') +
+                '. You may also use natural terms like backend, ui, tests, devops. Keep it concise and buildable.',
+            prompt: `Goal: ${goal}${opts.description ? `\nContext: ${opts.description}` : ''}\n\nPhased plan (JSON):`,
+            maxTokens: 1200,
+            temperature: 0.2,
+        };
+        const result = await provider.complete(request);
+        const parsed = this.parsePhases(result.content);
+        if (!parsed || parsed.length === 0)
+            return null;
+        return parsed.slice(0, maxPhases);
+    }
+    /** Extract + validate a phase array from a model's (possibly noisy) response. */
+    parsePhases(text) {
+        const json = extractJson(text);
+        if (!json)
+            return null;
+        let raw;
+        try {
+            raw = JSON.parse(json);
+        }
+        catch {
+            return null;
+        }
+        const list = Array.isArray(raw)
+            ? raw
+            : Array.isArray(raw?.phases)
+                ? raw.phases
+                : null;
+        if (!list)
+            return null;
+        const phases = [];
+        const seen = new Set();
+        for (const item of list) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const p = item;
+            const name = String(p.name ?? p.phase ?? `phase-${phases.length + 1}`).trim().slice(0, 40);
+            if (!name || seen.has(name.toLowerCase()))
+                continue;
+            seen.add(name.toLowerCase());
+            const description = String(p.description ?? name).trim();
+            const capabilities = Array.isArray(p.capabilities) ? p.capabilities.map(String) : undefined;
+            const dependsOn = Array.isArray(p.dependsOn) ? p.dependsOn.map(String) : undefined;
+            const acceptanceCriteria = Array.isArray(p.acceptanceCriteria)
+                ? p.acceptanceCriteria.map(String)
+                : undefined;
+            phases.push({ name, description, capabilities, dependsOn, acceptanceCriteria });
+        }
+        return phases.length ? phases : null;
+    }
+    /**
+     * Deterministic fallback plan. Always yields buildable phases; adds a frontend
+     * phase for UI-shaped goals. Capabilities are natural — the scheduler
+     * normalizes them and derives each phase's model tier.
+     */
+    heuristicPhases(goal) {
+        const g = goal.toLowerCase();
+        const isUi = /\b(ui|ux|frontend|front-end|web|website|page|css|react|vue|svelte|design|dashboard|landing)\b/.test(g);
+        const phases = [
+            {
+                name: 'architecture',
+                description: `Plan the architecture, approach, and file/component breakdown for: ${goal}`,
+                capabilities: ['architecture', 'planning', 'reasoning'],
+                acceptanceCriteria: ['A concrete plan / component breakdown exists'],
+            },
+            {
+                name: 'implementation',
+                description: `Implement the core of: ${goal}`,
+                capabilities: ['coding', 'filesystem', 'terminal', 'reasoning'],
+                dependsOn: ['architecture'],
+                acceptanceCriteria: ['Core functionality is implemented'],
+            },
+        ];
+        if (isUi) {
+            phases.push({
+                name: 'frontend',
+                description: `Build the user interface for: ${goal}`,
+                capabilities: ['frontend', 'design', 'accessibility'],
+                dependsOn: ['architecture'],
+                acceptanceCriteria: ['A polished, responsive, accessible UI'],
+            });
+        }
+        phases.push({
+            name: 'verification',
+            description: `Test, review, and verify the implementation of: ${goal}`,
+            capabilities: ['verification', 'review', 'reasoning'],
+            dependsOn: isUi ? ['implementation', 'frontend'] : ['implementation'],
+            acceptanceCriteria: ['Builds, tests pass, and the goal is met'],
+        });
+        return phases;
+    }
+}
+/** Pull the first balanced JSON object/array out of a text blob. */
+function extractJson(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?/i, '').replace(/```$/, '').trim();
+    const start = trimmed.search(/[[{]/);
+    if (start === -1)
+        return null;
+    const open = trimmed[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === open)
+            depth++;
+        else if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return trimmed.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+// Re-export so harnesses can normalize capabilities the same way.
+export { normalizeCapabilities };

package/dist/kernel/recovery-manager.d.ts

@@ -27,6 +27,8 @@ export interface RecoveryContext {
     policy: Policy;
     currentProviderId?: string;
     currentModelId?: string;
+    /** How many times this task has failed verification — drives model escalation. */
+    verificationFailures?: number;
 }
 export declare class RecoveryManager {
     private deps;
@@ -34,5 +36,12 @@ export declare class RecoveryManager {
     classify(error: string): FailureType;
     decide(ctx: RecoveryContext): Promise<RecoveryDecision>;
     private findAlternateProvider;
+    /**
+     * Find a strictly MORE capable model than the one that just failed
+     * verification — the escalation ladder. Ranks across all healthy providers by
+     * benchmark and returns the best above the current model's tier, or null at
+     * the ceiling.
+     */
+    private findMoreCapableModel;
     private findAlternateWorker;
 }

package/dist/kernel/recovery-manager.js

@@ -33,6 +33,7 @@ export class RecoveryManager {
         let rotateToProviderId;
         let rotateToModelId;
         let newWorkerType;
+        let escalateToBenchmark;
         switch (failureType) {
             case '429':
             case 'provider-down': {
@@ -61,9 +62,22 @@ export class RecoveryManager {
                 break;
             }
             case 'hallucination':
-            case 'tool-failure':
             case 'verification-failure': {
-                if (belowLimit) {
+                // Quality failures usually mean the model isn't strong enough. After the
+                // first verification miss, climb the benchmark ladder to a MORE capable
+                // model before anything else; only swap worker type if we're at the top.
+                const vFails = ctx.verificationFailures ?? 0;
+                // Escalate after MULTIPLE verification misses — the first miss retries or
+                // swaps worker; the second climbs to a more capable model.
+                const better = vFails >= 2 ? await this.findMoreCapableModel(ctx) : null;
+                if (better) {
+                    action = 'escalate-model';
+                    reason = `${failureType}: escalate → ${better.providerId}/${better.modelId} (bench ${better.benchmarkScore})`;
+                    rotateToProviderId = better.providerId;
+                    rotateToModelId = better.modelId;
+                    escalateToBenchmark = better.benchmarkScore;
+                }
+                else if (belowLimit) {
                     const altType = this.findAlternateWorker(ctx);
                     if (altType) {
                         action = 'spawn-different-worker';
@@ -77,7 +91,26 @@ export class RecoveryManager {
                 }
                 else {
                     action = 'replan';
-                    reason = `${failureType}: attempts exhausted → replan`;
+                    reason = `${failureType}: attempts exhausted, at model ceiling → replan`;
+                }
+                break;
+            }
+            case 'tool-failure': {
+                if (belowLimit) {
+                    const altType = this.findAlternateWorker(ctx);
+                    if (altType) {
+                        action = 'spawn-different-worker';
+                        reason = `tool-failure: spawn ${altType} worker`;
+                        newWorkerType = altType;
+                    }
+                    else {
+                        action = 'retry';
+                        reason = `tool-failure: retry (attempt ${ctx.attempts}/${maxAttempts})`;
+                    }
+                }
+                else {
+                    action = 'replan';
+                    reason = 'tool-failure: attempts exhausted → replan';
                 }
                 break;
             }
@@ -102,6 +135,7 @@ export class RecoveryManager {
             rotateToProviderId,
             rotateToModelId,
             newWorkerType,
+            escalateToBenchmark,
         };
         this.deps.eventBus.emit({
             type: 'RECOVERY',
@@ -135,6 +169,33 @@ export class RecoveryManager {
             return null;
         return { providerId: ranked[0].providerId, modelId: ranked[0].modelId };
     }
+    /**
+     * Find a strictly MORE capable model than the one that just failed
+     * verification — the escalation ladder. Ranks across all healthy providers by
+     * benchmark and returns the best above the current model's tier, or null at
+     * the ceiling.
+     */
+    async findMoreCapableModel(ctx) {
+        const providers = (await this.deps.providerManager.getHealthyProviders()).map(p => p.info);
+        const models = await this.deps.providerManager.getAvailableModels();
+        if (providers.length === 0 || models.length === 0)
+            return null;
+        const escalated = this.deps.router.escalate({
+            capabilities: ctx.task.capabilities,
+            preferences: { reasoning: 85 },
+            policy: ctx.policy,
+            availableProviders: providers,
+            availableModels: models,
+            minBenchmark: ctx.task.minBenchmark,
+        }, ctx.currentProviderId, ctx.currentModelId);
+        if (!escalated)
+            return null;
+        return {
+            providerId: escalated.providerId,
+            modelId: escalated.modelId,
+            benchmarkScore: escalated.benchmarkScore,
+        };
+    }
     findAlternateWorker(ctx) {
         const current = this.deps.workerRuntime.getHandler(this.deps.workerRuntime.matchWorkerType(ctx.task.capabilities) ?? 'coding');
         if (!current)

package/dist/kernel/router.d.ts

@@ -12,7 +12,7 @@
  * Every policy auto-routes across all healthy providers. The single exception
  * is the `offline` mode, which is LOCKED to local providers.
  */
-import type { ProviderInfo, RoutingDecision, RoutingRequest } from './types.js';
+import type { ProviderInfo, ProviderModel, RoutingDecision, RoutingRequest } from './types.js';
 import type { Logger } from './types.js';
 export declare class CapabilityRouter {
     private logger;
@@ -22,6 +22,17 @@ export declare class CapabilityRouter {
         providerInfo: ProviderInfo;
         benchmarkScore: number;
     }>;
+    /** Public benchmark estimate for a model (0–100) — used by recovery/escalation. */
+    benchmarkFor(model: ProviderModel): number;
+    /**
+     * Pick a strictly MORE capable model than the current one for the same
+     * capabilities — the verification-failure escalation ladder. Ranks candidates
+     * whose benchmark exceeds the current model's, preferring the highest
+     * benchmark (tie-broken by overall score). Returns null at the ceiling.
+     */
+    escalate(request: RoutingRequest, currentProviderId?: string, currentModelId?: string): (RoutingDecision & {
+        benchmarkScore: number;
+    }) | null;
     private scoreCandidates;
     private capabilityScore;
     /**