infinicode 2.3.2 → 2.3.3

package/dist/kernel/federation/federation.d.ts

@@ -23,6 +23,9 @@ export interface DispatchTask {
     prompt: string;
     role?: string;
     context?: Record<string, unknown>;
+    /** When true, the receiving node auto-plans the goal into phases (a phased
+     *  build) instead of running it as one atomic task. */
+    autoPlan?: boolean;
 }
 export interface FederationOptions {
     version: string;
@@ -100,6 +103,13 @@ export declare class Federation {
         runId: string;
         record: RunRecord;
     } | null>;
+    /** Runs received + executing on THIS node (async handoff), newest last. */
+    localRuns(): RunRecord[];
+    /** Runs WE dispatched to peers → { runId, peerId } for monitoring. */
+    outboundRuns(): Array<{
+        runId: string;
+        peerId: string;
+    }>;
     /** Query a dispatched run's current record (from whichever peer holds it). */
     followRun(runId: string): Promise<{
         record: RunRecord;

package/dist/kernel/federation/federation.js

@@ -174,15 +174,26 @@ export class Federation {
         const localRole = loadRole();
         const preamble = rolePreamble(localRole);
         const prompt = preamble ? `${preamble}\n\n${task.prompt}` : task.prompt;
-        const mission = await this.deps.kernel.execute({
-            description: task.description,
-            goal: task.description,
-            tasks: [{
-                    description: task.description,
-                    capabilities: task.capabilities.length ? task.capabilities : ['reasoning'],
-                    input: { prompt, context: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context } },
-                }],
-        });
+        // Auto-planned dispatch → the remote kernel decomposes the goal into phases
+        // (architecture → implementation → verification …), each routed to its own
+        // model tier. The phase/task events stream back to the dispatcher for
+        // monitoring. Otherwise run it as a single atomic task.
+        const mission = task.autoPlan
+            ? await this.deps.kernel.execute({
+                description: task.description,
+                goal: task.prompt || task.description,
+                autoPlan: true,
+                metadata: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context },
+            })
+            : await this.deps.kernel.execute({
+                description: task.description,
+                goal: task.description,
+                tasks: [{
+                        description: task.description,
+                        capabilities: task.capabilities.length ? task.capabilities : ['reasoning'],
+                        input: { prompt, context: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context } },
+                    }],
+            });
         return {
             missionId: mission.id,
             status: mission.status,
@@ -238,6 +249,14 @@ export class Federation {
         }
         return { peerId: target.nodeId, runId, record };
     }
+    /** Runs received + executing on THIS node (async handoff), newest last. */
+    localRuns() {
+        return [...this.runs.values()];
+    }
+    /** Runs WE dispatched to peers → { runId, peerId } for monitoring. */
+    outboundRuns() {
+        return [...this.dispatchedRuns.entries()].map(([runId, peerId]) => ({ runId, peerId }));
+    }
     /** Query a dispatched run's current record (from whichever peer holds it). */
     async followRun(runId) {
         const local = this.runs.get(runId);

package/dist/kernel/free-providers.d.ts

@@ -9,6 +9,11 @@ import type { ProviderModel, WorkerType } from './types.js';
 export interface FreeProviderPreset {
     id: string;
     name: string;
+    /**
+     * Provider kind. 'local' presets register as local (offline-eligible)
+     * providers and require no API key. Defaults to 'cloud' when omitted.
+     */
+    type?: 'local' | 'cloud';
     baseURL: string;
     headerName?: string;
     /** Where to get the API key. */
@@ -24,5 +29,23 @@ export interface FreeProviderPreset {
     notes?: string;
 }
 export declare const FREE_PROVIDERS: FreeProviderPreset[];
+/**
+ * Local OpenAI-compatible servers the wizard can register. These speak the same
+ * /v1/chat/completions + /v1/models API as the cloud providers but run on the
+ * user's machine, so they need NO API key and register with type 'local' (which
+ * makes the router apply its localBonus and include them in 'offline' mode).
+ *
+ * knownModels are intentionally empty: every one of these servers exposes the
+ * currently loaded model(s) dynamically via /v1/models, so there is no fixed
+ * catalog to hard-code. Unreachable servers are marked unhealthy by the health
+ * check and simply skipped by the router.
+ */
+export declare const LOCAL_PROVIDERS: FreeProviderPreset[];
 export declare function getProviderPreset(id: string): FreeProviderPreset | undefined;
+/**
+ * Build ready-to-register config entries for every built-in local provider.
+ * Used to register LM Studio / vLLM / SGLang / llama.cpp out of the box when the
+ * user has not customized `config.localProviders`.
+ */
+export declare function localProviderConfigs(): CloudProviderConfig[];
 export declare function toCloudProviderConfig(preset: FreeProviderPreset, apiKey: string): CloudProviderConfig;

package/dist/kernel/free-providers.js

@@ -147,8 +147,80 @@ export const FREE_PROVIDERS = [
         notes: 'Google Generative Language API. Free tier (15 RPM / 1500 RPD on Flash). Long context.',
     },
 ];
+/**
+ * Local OpenAI-compatible servers the wizard can register. These speak the same
+ * /v1/chat/completions + /v1/models API as the cloud providers but run on the
+ * user's machine, so they need NO API key and register with type 'local' (which
+ * makes the router apply its localBonus and include them in 'offline' mode).
+ *
+ * knownModels are intentionally empty: every one of these servers exposes the
+ * currently loaded model(s) dynamically via /v1/models, so there is no fixed
+ * catalog to hard-code. Unreachable servers are marked unhealthy by the health
+ * check and simply skipped by the router.
+ */
+export const LOCAL_PROVIDERS = [
+    {
+        id: 'lmstudio',
+        name: 'LM Studio',
+        type: 'local',
+        baseURL: 'http://localhost:1234/v1',
+        keyUrl: 'https://lmstudio.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'LM Studio local server. Start it from the "Developer" tab. No API key required.',
+    },
+    {
+        id: 'vllm',
+        name: 'vLLM',
+        type: 'local',
+        baseURL: 'http://localhost:8000/v1',
+        keyUrl: 'https://docs.vllm.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'vLLM OpenAI-compatible server (`vllm serve <model>`). No API key required.',
+    },
+    {
+        id: 'sglang',
+        name: 'SGLang',
+        type: 'local',
+        baseURL: 'http://localhost:30000/v1',
+        keyUrl: 'https://docs.sglang.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'SGLang OpenAI-compatible server (`python -m sglang.launch_server`). No API key required.',
+    },
+    {
+        id: 'llamacpp',
+        name: 'llama.cpp',
+        type: 'local',
+        baseURL: 'http://localhost:8080/v1',
+        keyUrl: 'https://github.com/ggml-org/llama.cpp',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'llama.cpp server (`llama-server`). No API key required.',
+    },
+];
 export function getProviderPreset(id) {
-    return FREE_PROVIDERS.find(p => p.id === id);
+    return FREE_PROVIDERS.find(p => p.id === id) ?? LOCAL_PROVIDERS.find(p => p.id === id);
+}
+/**
+ * Build ready-to-register config entries for every built-in local provider.
+ * Used to register LM Studio / vLLM / SGLang / llama.cpp out of the box when the
+ * user has not customized `config.localProviders`.
+ */
+export function localProviderConfigs() {
+    return LOCAL_PROVIDERS.map((preset) => ({
+        id: preset.id,
+        name: preset.name,
+        type: 'local',
+        baseURL: preset.baseURL,
+        headerName: preset.headerName,
+        enabled: true,
+    }));
 }
 export function toCloudProviderConfig(preset, apiKey) {
     return {

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 };