infinicode 2.3.2 → 2.3.3

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.3",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",