infinicode 2.3.2 → 2.3.4

package/dist/kernel/router.js

@@ -41,6 +41,34 @@ export class CapabilityRouter {
             benchmarkScore: c.benchmarkScore,
         }));
     }
+    /** Public benchmark estimate for a model (0–100) — used by recovery/escalation. */
+    benchmarkFor(model) {
+        return this.estimateBenchmark(model);
+    }
+    /**
+     * 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, currentProviderId, currentModelId) {
+        const current = request.availableModels.find(m => m.providerId === currentProviderId && m.id === currentModelId);
+        const currentBench = current ? this.estimateBenchmark(current) : (request.minBenchmark ?? 0);
+        const candidates = this.scoreCandidates(request)
+            .filter(c => !(c.providerId === currentProviderId && c.modelId === currentModelId))
+            .filter(c => c.benchmarkScore > currentBench + 1)
+            .sort((a, b) => b.benchmarkScore - a.benchmarkScore || b.score - a.score);
+        const top = candidates[0];
+        if (!top)
+            return null;
+        return {
+            providerId: top.providerId,
+            modelId: top.modelId,
+            score: top.score,
+            benchmarkScore: top.benchmarkScore,
+            reason: `escalate ↑bench ${currentBench}→${top.benchmarkScore}: ${top.reason}`,
+        };
+    }
     scoreCandidates(request) {
         const { capabilities, preferences, policy, availableProviders, availableModels } = request;
         const mode = (policy.routing?.mode ?? 'balanced');
@@ -86,6 +114,12 @@ export class CapabilityRouter {
             // Heavy penalty when the model can't fit the estimated request — keeps it
             // as a last resort but routes to a capable model when one exists.
             const capacityPenalty = needTokens > 0 && effectiveLimit < needTokens ? 6 : 0;
+            // Phase/escalation floor: models below the requested benchmark are pushed
+            // down (proportional, not hard-excluded) so demanding phases climb to a
+            // capable model and the escalation ladder can keep ascending.
+            const floorPenalty = request.minBenchmark && benchmark < request.minBenchmark
+                ? (request.minBenchmark - benchmark) / 5
+                : 0;
             const score = capScore * weights.capability +
                 benchScore * weights.benchmark +
                 reliability * weights.reliability +
@@ -96,7 +130,8 @@ export class CapabilityRouter {
                 preferredBonus +
                 fastApiBonus -
                 costPenalty -
-                capacityPenalty;
+                capacityPenalty -
+                floorPenalty;
             scored.push({
                 providerId: provider.id,
                 modelId: model.id,

package/dist/kernel/scheduler.d.ts

@@ -8,6 +8,13 @@ export declare class Scheduler {
         objectives: Objective[];
         tasks: Task[];
     };
+    /**
+     * Build one objective per phase. Capabilities are normalized (natural names
+     * allowed), each phase's tasks depend on ALL tasks of the phases it dependsOn
+     * (so phases run in order but tasks within a phase can parallelize), and each
+     * phase gets its own model benchmark floor → different models per phase.
+     */
+    private planPhases;
     createTask(missionId: string, objectiveId: string, description: string, capabilities: Capability[], dependencies: string[], input: TaskInput): Task;
     /**
      * Returns the next batch of tasks that are ready to execute:
@@ -28,3 +35,13 @@ export declare class Scheduler {
     reconcileObjectives(mission: Mission): void;
     private aggregateCapabilities;
 }
+/**
+ * Per-phase model benchmark floor (0–100). Demanding phases (architecture,
+ * verification, review, reasoning-heavy) demand a more capable model; lighter
+ * phases (docs, translation, plain search) leave the floor open so the router
+ * can pick a cheaper/faster model. This is what lets one large mission spread
+ * across models by aspect instead of one-shotting with a single model.
+ */
+export declare function phaseBenchmarkFloor(caps: Capability[]): number;
+/** Human-readable phase label from an objective's dominant capability. */
+export declare function phaseLabel(caps: Capability[]): string;

package/dist/kernel/scheduler.js

@@ -5,6 +5,7 @@
  * Supports: sequential, parallel, dependency graphs
  */
 import { nanoid } from 'nanoid';
+import { normalizeCapabilities } from './capability-map.js';
 export class Scheduler {
     eventBus;
     logger;
@@ -13,27 +14,81 @@ export class Scheduler {
         this.logger = logger;
     }
     planMission(missionId, input) {
+        // Phase-based plan (each phase → one objective, with cross-phase deps).
+        if (input.phases && input.phases.length > 0) {
+            return this.planPhases(missionId, input.phases);
+        }
         const taskInputs = input.tasks ?? [];
         const objectiveId = nanoid(10);
         const tasks = [];
         for (const ti of taskInputs) {
             tasks.push(this.createTask(missionId, objectiveId, ti.description, ti.capabilities, ti.dependencies ?? [], ti.input));
         }
+        const objCaps = this.aggregateCapabilities(tasks);
         const objective = {
             id: objectiveId,
             missionId,
             description: input.goal,
-            capabilities: this.aggregateCapabilities(tasks),
+            capabilities: objCaps,
             acceptanceCriteria: [],
             taskIds: tasks.map(t => t.id),
             status: tasks.length > 0 ? 'PENDING' : 'COMPLETED',
             createdAt: Date.now(),
+            phase: phaseLabel(objCaps),
+            minBenchmark: tasks.reduce((max, t) => Math.max(max, t.minBenchmark ?? 0), 0) || undefined,
         };
         this.logger.info(`Mission planned: ${missionId} with ${tasks.length} task(s) across 1 objective`);
         return { objectives: [objective], tasks };
     }
+    /**
+     * Build one objective per phase. Capabilities are normalized (natural names
+     * allowed), each phase's tasks depend on ALL tasks of the phases it dependsOn
+     * (so phases run in order but tasks within a phase can parallelize), and each
+     * phase gets its own model benchmark floor → different models per phase.
+     */
+    planPhases(missionId, phases) {
+        const objectives = [];
+        const tasks = [];
+        const phaseTaskIds = new Map(); // phase name (lower) → task ids
+        for (const phase of phases) {
+            const objectiveId = nanoid(10);
+            const phaseCaps = normalizeCapabilities(phase.capabilities);
+            const deps = (phase.dependsOn ?? []).flatMap(n => phaseTaskIds.get(n.trim().toLowerCase()) ?? []);
+            const taskInputs = phase.tasks && phase.tasks.length > 0
+                ? phase.tasks
+                : [{ description: phase.description, capabilities: phaseCaps, input: { prompt: phase.description } }];
+            const phaseTasks = taskInputs.map(ti => {
+                const tCaps = ti.capabilities && ti.capabilities.length > 0
+                    ? normalizeCapabilities(ti.capabilities)
+                    : phaseCaps;
+                const task = this.createTask(missionId, objectiveId, ti.description, tCaps, [...deps, ...(ti.dependencies ?? [])], ti.input ?? { prompt: ti.description });
+                // Explicit phase floor overrides the capability-derived one.
+                if (phase.minBenchmark)
+                    task.minBenchmark = phase.minBenchmark;
+                return task;
+            });
+            tasks.push(...phaseTasks);
+            phaseTaskIds.set(phase.name.trim().toLowerCase(), phaseTasks.map(t => t.id));
+            const derivedFloor = phaseTasks.reduce((max, t) => Math.max(max, t.minBenchmark ?? 0), 0);
+            objectives.push({
+                id: objectiveId,
+                missionId,
+                description: phase.description,
+                capabilities: phaseCaps,
+                acceptanceCriteria: phase.acceptanceCriteria ?? [],
+                taskIds: phaseTasks.map(t => t.id),
+                status: phaseTasks.length > 0 ? 'PENDING' : 'COMPLETED',
+                createdAt: Date.now(),
+                phase: phase.name,
+                minBenchmark: (phase.minBenchmark ?? derivedFloor) || undefined,
+            });
+        }
+        this.logger.info(`Mission planned: ${missionId} with ${tasks.length} task(s) across ${objectives.length} phase(s): ${phases.map(p => p.name).join(' → ')}`);
+        return { objectives, tasks };
+    }
     createTask(missionId, objectiveId, description, capabilities, dependencies, input) {
         const id = nanoid(10);
+        const floor = phaseBenchmarkFloor(capabilities);
         const task = {
             id,
             objectiveId,
@@ -46,6 +101,7 @@ export class Scheduler {
             attempts: 0,
             maxAttempts: 3,
             createdAt: Date.now(),
+            minBenchmark: floor > 0 ? floor : undefined,
         };
         this.eventBus.emit({ type: 'TASK_QUEUED', timestamp: Date.now(), missionId, objectiveId, taskId: id, data: { description } });
         return task;
@@ -145,3 +201,43 @@ export class Scheduler {
         return [...set];
     }
 }
+/**
+ * Per-phase model benchmark floor (0–100). Demanding phases (architecture,
+ * verification, review, reasoning-heavy) demand a more capable model; lighter
+ * phases (docs, translation, plain search) leave the floor open so the router
+ * can pick a cheaper/faster model. This is what lets one large mission spread
+ * across models by aspect instead of one-shotting with a single model.
+ */
+export function phaseBenchmarkFloor(caps) {
+    const has = (c) => caps.includes(c);
+    if (has('architecture') || has('planning'))
+        return 85;
+    if (has('verification') || has('review'))
+        return 84;
+    if (has('coding') || has('frontend'))
+        return 78;
+    if (has('vision') || has('ocr'))
+        return 74;
+    if (has('reasoning'))
+        return 80;
+    return 0; // search / crawl / summarize / documentation / translation → open
+}
+/** Human-readable phase label from an objective's dominant capability. */
+export function phaseLabel(caps) {
+    const has = (c) => caps.includes(c);
+    if (has('architecture') || has('planning'))
+        return 'architecture';
+    if (has('frontend'))
+        return 'frontend';
+    if (has('coding'))
+        return 'implementation';
+    if (has('verification') || has('review'))
+        return 'verification';
+    if (has('vision') || has('ocr'))
+        return 'vision';
+    if (has('search') || has('crawl'))
+        return 'research';
+    if (has('documentation') || has('translation'))
+        return 'documentation';
+    return 'general';
+}

package/dist/kernel/setup.d.ts

@@ -15,6 +15,15 @@ export type { InfinicodeConfig, CloudProviderConfig, WorkerModelPref } from './c
  * count of enabled providers registered.
  */
 export declare function registerCloudProviders(kernel: Kernel, cloudProviders: CloudProviderConfig[]): number;
+/**
+ * Register (or re-register) local OpenAI-compatible providers (LM Studio, vLLM,
+ * SGLang, llama.cpp) on a live kernel from config. Providers register with
+ * type 'local' and require NO API key — they are never skipped for a missing
+ * key the way cloud providers can be, and the local server does not need to be
+ * running (unreachable ones are marked unhealthy by the health check). Returns
+ * the count of enabled providers registered.
+ */
+export declare function registerLocalProviders(kernel: Kernel, localProviders: CloudProviderConfig[]): number;
 export declare function buildKernelFromConfig(config: Conf<InfinicodeConfig>, options?: {
     logger?: Logger;
 }): Kernel;

package/dist/kernel/setup.js

@@ -27,6 +27,35 @@ export function registerCloudProviders(kernel, cloudProviders) {
         const options = {
             id: cfg.id,
             name: cfg.name,
+            type: cfg.type,
+            baseURL: cfg.baseURL,
+            apiKey: cfg.apiKey,
+            headerName: cfg.headerName,
+            knownModels: preset?.knownModels ?? [],
+        };
+        kernel.registerProvider(cfg.id, new OpenAICompatibleProvider(options));
+        n++;
+    }
+    return n;
+}
+/**
+ * Register (or re-register) local OpenAI-compatible providers (LM Studio, vLLM,
+ * SGLang, llama.cpp) on a live kernel from config. Providers register with
+ * type 'local' and require NO API key — they are never skipped for a missing
+ * key the way cloud providers can be, and the local server does not need to be
+ * running (unreachable ones are marked unhealthy by the health check). Returns
+ * the count of enabled providers registered.
+ */
+export function registerLocalProviders(kernel, localProviders) {
+    let n = 0;
+    for (const cfg of localProviders) {
+        if (!cfg.enabled)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        const options = {
+            id: cfg.id,
+            name: cfg.name,
+            type: 'local',
             baseURL: cfg.baseURL,
             apiKey: cfg.apiKey,
             headerName: cfg.headerName,
@@ -52,6 +81,15 @@ export function buildKernelFromConfig(config, options) {
     kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
     // Register cloud providers
     registerCloudProviders(kernel, config.get('cloudProviders') ?? []);
+    // Register local OpenAI-compatible providers (LM Studio, vLLM, SGLang,
+    // llama.cpp) the user has configured in `localProviders`. No API key is
+    // required; an unreachable server is marked unhealthy by the health check.
+    // Only configured ones are registered — this avoids probing dead localhost
+    // ports on every machine. The presets (`localProviderConfigs()` in
+    // free-providers.ts / the setup wizard) make enabling one a one-liner.
+    const localProviders = config.get('localProviders') ?? [];
+    if (localProviders.length > 0)
+        registerLocalProviders(kernel, localProviders);
     // Apply per-worker model pins — the worker runtime honors them when routing.
     const workerModels = config.get('workerModels') ?? {};
     if (workerModels && Object.keys(workerModels).length > 0) {

package/dist/kernel/types.d.ts

@@ -19,6 +19,15 @@ export interface Objective {
     status: TaskStatus;
     createdAt: number;
     completedAt?: number;
+    /** Human phase label for large projects (e.g. "architecture", "frontend"). */
+    phase?: string;
+    /**
+     * Minimum model benchmark (0–100) this phase should route to. Lets the
+     * orchestrator assign a more capable model to demanding phases (architecture,
+     * verification) and a cheaper one to light phases (docs) — instead of one
+     * model for the whole mission. Flows into each task's routing floor.
+     */
+    minBenchmark?: number;
 }
 export interface Task {
     id: string;
@@ -39,6 +48,11 @@ export interface Task {
     startedAt?: number;
     completedAt?: number;
     error?: string;
+    /** Routing floor for this task/phase (0–100). Escalates upward on repeated
+     *  verification failure so the task climbs to a more capable model. */
+    minBenchmark?: number;
+    /** How many times this task's output failed verification — drives model escalation. */
+    verificationFailures?: number;
 }
 export interface TaskInput {
     prompt: string;
@@ -258,6 +272,12 @@ export interface Checkpoint {
     workerStates: WorkerInstanceState[];
     timestamp: number;
     reason: 'task' | 'interval' | 'pause' | 'crash' | 'manual';
+    /** Recent event log for this mission — restored so long-running/crash recovery
+     *  keeps its activity trail. */
+    logs?: KernelEvent[];
+    /** Free-form memory bag persisted with the checkpoint (mission.metadata plus
+     *  any harness-supplied working memory). */
+    memory?: Record<string, unknown>;
 }
 export interface WorkerInstanceState {
     workerId: string;
@@ -267,7 +287,7 @@ export interface WorkerInstanceState {
     modelId?: string;
     partialOutput?: string;
 }
-export type KernelEventType = 'MISSION_STARTED' | 'MISSION_COMPLETED' | 'MISSION_FAILED' | 'MISSION_PAUSED' | 'MISSION_RESUMED' | 'MISSION_CANCELLED' | 'OBJECTIVE_STARTED' | 'OBJECTIVE_COMPLETED' | 'TASK_QUEUED' | 'TASK_STARTED' | 'TASK_COMPLETED' | 'TASK_FAILED' | 'WORKER_SPAWNED' | 'WORKER_EXITED' | 'ROUTING_DECISION' | 'MODEL_CHANGED' | 'PROVIDER_CHANGED' | 'CHECKPOINT' | 'VERIFY_SUCCESS' | 'VERIFY_FAILED' | 'RECOVERY' | 'PROVIDER_HEALTH' | 'NOTIFICATION' | 'LOG';
+export type KernelEventType = 'MISSION_STARTED' | 'MISSION_COMPLETED' | 'MISSION_FAILED' | 'MISSION_PAUSED' | 'MISSION_RESUMED' | 'MISSION_CANCELLED' | 'PLAN_CREATED' | 'OBJECTIVE_STARTED' | 'OBJECTIVE_COMPLETED' | 'TASK_QUEUED' | 'TASK_STARTED' | 'TASK_COMPLETED' | 'TASK_FAILED' | 'WORKER_SPAWNED' | 'WORKER_EXITED' | 'ROUTING_DECISION' | 'MODEL_CHANGED' | 'PROVIDER_CHANGED' | 'CHECKPOINT' | 'VERIFY_SUCCESS' | 'VERIFY_FAILED' | 'RECOVERY' | 'PROVIDER_HEALTH' | 'NOTIFICATION' | 'LOG';
 export interface KernelEvent<T = unknown> {
     type: KernelEventType;
     timestamp: number;
@@ -290,6 +310,12 @@ export interface RoutingRequest {
      * preventing "request too large" failures on rate-limited tiers.
      */
     estimatedRequestTokens?: number;
+    /**
+     * Minimum acceptable model benchmark (0–100). Models below the floor are
+     * heavily penalized (not hard-excluded), so demanding phases route to capable
+     * models and escalation can climb the tier ladder.
+     */
+    minBenchmark?: number;
 }
 export interface RoutingDecision {
     providerId: string;
@@ -382,13 +408,16 @@ export interface LlmJudgeOptions {
     modelId?: string;
 }
 export type FailureType = '429' | 'timeout' | 'provider-down' | 'hallucination' | 'tool-failure' | 'verification-failure' | 'planning-failure' | 'browser-failure' | 'unknown';
-export type RecoveryAction = 'retry' | 'rotate-provider' | 'spawn-different-worker' | 'replan' | 'checkpoint' | 'continue' | 'abort';
+export type RecoveryAction = 'retry' | 'rotate-provider' | 'escalate-model' | 'spawn-different-worker' | 'replan' | 'checkpoint' | 'continue' | 'abort';
 export interface RecoveryDecision {
     action: RecoveryAction;
     reason: string;
     rotateToProviderId?: string;
     rotateToModelId?: string;
     newWorkerType?: WorkerType;
+    /** For 'escalate-model': the benchmark of the more-capable target, so the
+     *  orchestrator can raise the task's routing floor and keep climbing. */
+    escalateToBenchmark?: number;
 }
 export interface PluginManifest {
     name: string;
@@ -442,6 +471,21 @@ export interface MissionInput {
     policy?: PolicyName;
     workspace?: WorkspaceRef;
     tasks?: MissionTaskInput[];
+    /**
+     * Explicit phase breakdown (each phase → one objective). When present it wins
+     * over `tasks`. Harnesses (e.g. InfiniBot) can pass phases directly with
+     * capabilities written naturally ("backend", "ui", "tests") — they're
+     * normalized to canonical capabilities and each phase routes to its own model
+     * tier via its benchmark floor.
+     */
+    phases?: MissionPhaseInput[];
+    /**
+     * When true and neither `tasks` nor `phases` is given, the MissionPlanner
+     * decomposes `goal` into phases (LLM-driven, heuristic fallback) before
+     * execution — turning a one-line goal into architecture → implementation →
+     * verification phases, each with an appropriate model.
+     */
+    autoPlan?: boolean;
     metadata?: Record<string, unknown>;
 }
 export interface MissionTaskInput {
@@ -450,6 +494,25 @@ export interface MissionTaskInput {
     dependencies?: string[];
     input: TaskInput;
 }
+/**
+ * A phase of a mission — becomes one Objective plus its tasks. Capabilities may
+ * be written naturally (natural language / synonyms) and are normalized; the
+ * phase's model tier is derived from them unless `minBenchmark` is set.
+ */
+export interface MissionPhaseInput {
+    /** Short phase label, e.g. "architecture", "backend", "frontend", "tests". */
+    name: string;
+    description: string;
+    /** Needed capabilities — natural names allowed ("backend", "ui", "testing"). */
+    capabilities?: string[];
+    acceptanceCriteria?: string[];
+    /** Names of phases that must finish before this one starts. */
+    dependsOn?: string[];
+    /** Explicit tasks; if omitted the phase runs as a single task from its description. */
+    tasks?: MissionTaskInput[];
+    /** Explicit model benchmark floor (0–100); else derived from capabilities. */
+    minBenchmark?: number;
+}
 export interface ProviderVerifyResult {
     ok: boolean;
     latencyMs: number;

package/dist/kernel/verification-engine.js

@@ -1,4 +1,7 @@
 import { scoreFrontend } from './frontend-scoring.js';
+import { runCommand, tail } from './verification-exec.js';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 const PIPELINE_ORDER = [
     'objective',
     'compile',
@@ -169,38 +172,91 @@ function objectiveVerifier() {
     };
 }
 function compileVerifier() {
-    return {
-        stage: 'compile',
-        enabled: ctx => hasArtifact(ctx.output, 'code') || hasArtifact(ctx.output, 'file'),
-        async run(ctx) {
-            const codeArtifacts = ctx.output.artifacts?.filter(a => a.type === 'code' || a.type === 'file') ?? [];
-            if (codeArtifacts.length === 0) {
-                return { name: 'compile', passed: true, message: 'no code artifacts' };
-            }
-            const hasSyntax = codeArtifacts.every(a => (a.content ?? '').trim().length > 0);
-            return {
-                name: 'compile',
-                passed: hasSyntax,
-                message: hasSyntax ? `${codeArtifacts.length} artifact(s) non-empty` : 'empty code artifact',
-            };
-        },
-    };
+    return commandVerifier('compile', 'compile');
 }
 function testsVerifier() {
-    return {
-        stage: 'tests',
-        enabled: () => false,
-        async run() {
-            return { name: 'tests', passed: true, message: 'test runner not configured' };
-        },
-    };
+    return commandVerifier('tests', 'test');
 }
 function lintVerifier() {
+    return commandVerifier('lint', 'lint');
+}
+/** package.json script names to auto-detect per stage, in priority order. */
+const SCRIPT_CANDIDATES = {
+    compile: ['build', 'compile', 'typecheck'],
+    test: ['test'],
+    lint: ['lint'],
+};
+/** True when the task actually produced code/file artifacts to verify. */
+function producedCode(output) {
+    return hasArtifact(output, 'code') || hasArtifact(output, 'file');
+}
+/** Read `<root>/package.json` scripts, or undefined if missing/invalid. */
+function readScripts(root) {
+    try {
+        const raw = readFileSync(join(root, 'package.json'), 'utf8');
+        const pkg = JSON.parse(raw);
+        return pkg.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Pull an explicit command for `kind` from task context, then mission metadata. */
+function explicitCommand(ctx, kind) {
+    const sources = [ctx.task.input.context?.verify, ctx.mission.metadata?.verify];
+    for (const src of sources) {
+        if (src && typeof src === 'object') {
+            const cmd = src[kind];
+            if (typeof cmd === 'string' && cmd.trim().length > 0)
+                return cmd.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the command for a stage: explicit context/metadata command first,
+ * else an auto-detected `npm run <script>` from the workspace package.json.
+ * Returns undefined when nothing can be resolved (stage stays disabled).
+ */
+function resolveCommand(ctx, kind) {
+    const explicit = explicitCommand(ctx, kind);
+    if (explicit)
+        return explicit;
+    const scripts = readScripts(ctx.workspace.root);
+    if (!scripts)
+        return undefined;
+    for (const name of SCRIPT_CANDIDATES[kind]) {
+        if (typeof scripts[name] === 'string' && scripts[name].trim().length > 0) {
+            return `npm run ${name}`;
+        }
+    }
+    return undefined;
+}
+/**
+ * A verifier that runs a real project command (compile/tests/lint) in the
+ * mission workspace root and passes/fails on the process exit code. Enabled
+ * only when a command resolves AND the task produced code/file artifacts.
+ */
+function commandVerifier(stage, kind) {
     return {
-        stage: 'lint',
-        enabled: () => false,
-        async run() {
-            return { name: 'lint', passed: true, message: 'linter not configured' };
+        stage,
+        enabled(ctx) {
+            return producedCode(ctx.output) && resolveCommand(ctx, kind) !== undefined;
+        },
+        async run(ctx) {
+            const command = resolveCommand(ctx, kind);
+            if (!command) {
+                // Should not happen (gated by enabled), but stay safe & non-blocking.
+                return { name: stage, passed: true, message: `no ${kind} command resolved` };
+            }
+            const result = await runCommand(command, ctx.workspace.root);
+            const passed = result.code === 0 && !result.timedOut;
+            const combined = tail(`${result.stdout}\n${result.stderr}`.trim());
+            const status = result.timedOut ? 'timed out' : `exit ${result.code}`;
+            const message = passed
+                ? `\`${command}\` passed (${status})`
+                : `\`${command}\` failed (${status})${combined ? `\n${combined}` : ''}`;
+            return { name: stage, passed, message };
         },
     };
 }

package/dist/kernel/verification-exec.d.ts

@@ -0,0 +1,14 @@
+export interface ExecResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+/** Keep only the last `max` characters of a string. */
+export declare function tail(text: string, max?: number): string;
+/**
+ * Run `command` in `cwd` via a shell, capturing stdout/stderr. On Windows we
+ * use `shell: true` so npm scripts / .cmd shims resolve. Resolves (never
+ * rejects) with the exit code and captured output; kills the process on timeout.
+ */
+export declare function runCommand(command: string, cwd: string, timeoutMs?: number): Promise<ExecResult>;

package/dist/kernel/verification-exec.js

@@ -0,0 +1,65 @@
+/**
+ * OpenKernel — Verification Exec Helper
+ *
+ * Runs a real project command (compile/tests/lint) in a workspace directory
+ * and reports pass/fail on the process exit code. Effect-free, no new deps —
+ * just node:child_process.
+ */
+import { spawn } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 180_000;
+const MAX_TAIL_CHARS = 4000;
+/** Keep only the last `max` characters of a string. */
+export function tail(text, max = MAX_TAIL_CHARS) {
+    if (text.length <= max)
+        return text;
+    return `…${text.slice(text.length - max)}`;
+}
+/**
+ * Run `command` in `cwd` via a shell, capturing stdout/stderr. On Windows we
+ * use `shell: true` so npm scripts / .cmd shims resolve. Resolves (never
+ * rejects) with the exit code and captured output; kills the process on timeout.
+ */
+export function runCommand(command, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return new Promise(resolve => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            windowsHide: true,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* already gone */
+            }
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.length > MAX_TAIL_CHARS * 2)
+                stdout = tail(stdout, MAX_TAIL_CHARS * 2);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+            if (stderr.length > MAX_TAIL_CHARS * 2)
+                stderr = tail(stderr, MAX_TAIL_CHARS * 2);
+        });
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut });
+        };
+        child.on('error', err => {
+            stderr += `\n${err instanceof Error ? err.message : String(err)}`;
+            finish(1);
+        });
+        child.on('close', code => finish(code));
+    });
+}

package/dist/kernel/worker-runtime.js

@@ -109,7 +109,7 @@ export class WorkerRuntime {
         instance.status = 'INITIALIZED';
         const plan = override
             ? this.lockedPlan(override, 'recovery override')
-            : await this.planRoute(task.capabilities, handler.preferences, instance.type, estimateRequestTokens(task));
+            : await this.planRoute(task.capabilities, handler.preferences, instance.type, estimateRequestTokens(task), task.minBenchmark);
         // Surface the orchestrator's choice (ranked candidates + winner) so the
         // CLI / TUI can animate and highlight it.
         this.emitRouting(instance, task, plan);
@@ -189,7 +189,7 @@ export class WorkerRuntime {
      * router considered. Honors worker pins (a hard lock), otherwise defers to
      * the policy-driven capability router.
      */
-    async planRoute(capabilities, preferences, workerType, estimatedRequestTokens) {
+    async planRoute(capabilities, preferences, workerType, estimatedRequestTokens, minBenchmark) {
         const providers = (await this.ctx.providerManager.getHealthyProviders()).map(p => p.info);
         const models = await this.ctx.providerManager.getAvailableModels();
         const policy = this.ctx.policies.get(this.defaultPolicyName);
@@ -214,6 +214,7 @@ export class WorkerRuntime {
             availableProviders: providers,
             availableModels: models,
             estimatedRequestTokens,
+            minBenchmark,
         });
         if (ranked.length === 0) {
             return { chosen: null, candidates: [], locked: false, mode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",