infinicode 1.0.0 → 2.0.0

package/dist/kernel/mission-engine.js

@@ -0,0 +1,160 @@
+/**
+ * OpenKernel — Mission Engine
+ *
+ * Responsible for lifecycle, checkpointing, pause, resume, completion.
+ * State machine: NEW → PLANNING → READY → RUNNING → VERIFYING → WAITING → FAILED → COMPLETED
+ */
+import { nanoid } from 'nanoid';
+export class MissionEngine {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    create(input) {
+        const id = nanoid(12);
+        const policyRef = this.deps.policies.resolveRef(input.policy);
+        const workspace = input.workspace ?? { root: process.cwd() };
+        const mission = {
+            id,
+            name: input.name ?? `mission-${id.slice(0, 6)}`,
+            description: input.description,
+            goal: input.goal,
+            status: 'NEW',
+            objectives: [],
+            tasks: [],
+            policy: policyRef,
+            workspace,
+            checkpoints: [],
+            createdAt: Date.now(),
+            metadata: input.metadata,
+        };
+        this.deps.logger.info(`Mission created: ${id} — ${mission.name}`);
+        return mission;
+    }
+    plan(mission, input) {
+        this.transition(mission, 'PLANNING');
+        const { objectives, tasks } = this.deps.scheduler.planMission(mission.id, input);
+        mission.objectives = objectives;
+        mission.tasks = tasks;
+        this.transition(mission, 'READY');
+        this.deps.logger.info(`Mission planned: ${mission.id} — ${tasks.length} task(s)`);
+        return mission;
+    }
+    start(mission) {
+        if (mission.status === 'COMPLETED' || mission.status === 'FAILED' || mission.status === 'CANCELLED') {
+            throw new Error(`Mission ${mission.id} is ${mission.status}; cannot start`);
+        }
+        this.transition(mission, 'RUNNING');
+        mission.startedAt = mission.startedAt ?? Date.now();
+        this.emit(mission, 'MISSION_STARTED', { missionId: mission.id, name: mission.name });
+        return mission;
+    }
+    pause(mission) {
+        if (mission.status !== 'RUNNING')
+            return mission;
+        this.transition(mission, 'PAUSED');
+        void this.deps.checkpoints.save(mission, [], 'pause');
+        this.emit(mission, 'MISSION_PAUSED', { missionId: mission.id });
+        return mission;
+    }
+    resume(mission) {
+        if (mission.status !== 'PAUSED' && mission.status !== 'WAITING')
+            return mission;
+        const latest = this.deps.checkpoints.latest(mission.id);
+        if (latest) {
+            // restore mutable state
+            mission.objectives = latest.mission.objectives;
+            mission.tasks = latest.mission.tasks;
+        }
+        this.transition(mission, 'RUNNING');
+        this.emit(mission, 'MISSION_RESUMED', { missionId: mission.id });
+        return mission;
+    }
+    cancel(mission) {
+        this.transition(mission, 'CANCELLED');
+        this.emit(mission, 'MISSION_CANCELLED', { missionId: mission.id });
+        return mission;
+    }
+    complete(mission) {
+        this.transition(mission, 'VERIFYING');
+        this.deps.scheduler.reconcileObjectives(mission);
+        if (this.deps.scheduler.allObjectivesComplete(mission)) {
+            this.transition(mission, 'COMPLETED');
+            mission.completedAt = Date.now();
+            this.emit(mission, 'MISSION_COMPLETED', { missionId: mission.id });
+        }
+        else {
+            this.transition(mission, 'RUNNING');
+        }
+        return mission;
+    }
+    /**
+     * Mission-level verification during the VERIFYING phase.
+     * Runs the Verification Engine pipeline for every completed task that
+     * has output, then completes the mission only if all checks pass (or
+     * verification is not strict). Returns the aggregated result.
+     */
+    async verify(mission) {
+        if (!this.deps.verification) {
+            return { passed: true, summary: 'no verification engine' };
+        }
+        this.transition(mission, 'VERIFYING');
+        const policy = mission.policy.policy;
+        let allPassed = true;
+        const summaries = [];
+        for (const task of mission.tasks) {
+            if (task.status !== 'COMPLETED' || !task.output)
+                continue;
+            const result = await this.deps.verification.verify(mission, task, policy);
+            if (!result.passed) {
+                allPassed = false;
+                summaries.push(`${task.id}: ${result.summary}`);
+            }
+        }
+        if (allPassed) {
+            this.transition(mission, 'COMPLETED');
+            mission.completedAt = Date.now();
+            this.emit(mission, 'MISSION_COMPLETED', { missionId: mission.id });
+        }
+        else {
+            this.transition(mission, 'FAILED');
+            mission.error = `Verification failed: ${summaries.join('; ')}`;
+            this.emit(mission, 'MISSION_FAILED', { missionId: mission.id, error: mission.error });
+        }
+        return { passed: allPassed, summary: allPassed ? 'all verifications passed' : summaries.join('; ') };
+    }
+    fail(mission, error) {
+        mission.error = error;
+        this.transition(mission, 'FAILED');
+        this.emit(mission, 'MISSION_FAILED', { missionId: mission.id, error });
+        return mission;
+    }
+    /**
+     * Resync mission state from a checkpoint (crash recovery).
+     */
+    restoreFromCheckpoint(mission) {
+        const latest = this.deps.checkpoints.latest(mission.id);
+        if (!latest)
+            return mission;
+        mission.status = latest.mission.status === 'RUNNING' ? 'WAITING' : latest.mission.status;
+        mission.objectives = latest.mission.objectives;
+        mission.tasks = latest.mission.tasks;
+        mission.checkpoints = latest.mission.checkpoints;
+        this.deps.logger.info(`Mission ${mission.id} restored from checkpoint ${latest.id}`);
+        return mission;
+    }
+    transition(mission, next) {
+        const prev = mission.status;
+        mission.status = next;
+        this.deps.logger.info(`Mission ${mission.id}: ${prev} → ${next}`);
+    }
+    emit(mission, type, data) {
+        const event = {
+            type,
+            timestamp: Date.now(),
+            missionId: mission.id,
+            data,
+        };
+        this.deps.eventBus.emit(event);
+    }
+}

package/dist/kernel/orchestrator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * OpenKernel — Native Orchestrator
+ *
+ * Always running. Coordinates Mission Engine, Scheduler, Worker Runtime,
+ * Provider Manager, Router, Verification Engine, Recovery Manager,
+ * Checkpoints. Never executes tasks directly.
+ */
+import type { Logger, Mission, MissionInput } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { MissionEngine } from './mission-engine.js';
+import type { Scheduler } from './scheduler.js';
+import type { WorkerRuntime } from './worker-runtime.js';
+import type { CheckpointEngine } from './checkpoint-engine.js';
+import type { ProviderManager } from './provider-manager.js';
+import type { CapabilityRouter } from './router.js';
+import type { VerificationEngine } from './verification-engine.js';
+import type { RecoveryManager } from './recovery-manager.js';
+export interface OrchestratorDeps {
+    eventBus: EventBus;
+    missionEngine: MissionEngine;
+    scheduler: Scheduler;
+    workerRuntime: WorkerRuntime;
+    checkpoints: CheckpointEngine;
+    providerManager: ProviderManager;
+    router: CapabilityRouter;
+    verification: VerificationEngine;
+    recovery: RecoveryManager;
+    logger: Logger;
+}
+export declare class Orchestrator {
+    private deps;
+    private pausedMissions;
+    private cancelledMissions;
+    private workersByMission;
+    /** Per-task forced provider/model overrides set by the recovery manager. */
+    private taskOverrides;
+    /** Per-task forced worker type override set by the recovery manager. */
+    private taskWorkerOverrides;
+    constructor(deps: OrchestratorDeps);
+    run(mission: Mission, input: MissionInput): Promise<Mission>;
+    private runTasks;
+    private executeTask;
+    private handleRecovery;
+    private skipBlockedTasks;
+    private trackWorker;
+    private collectWorkerStates;
+    pauseMission(missionId: string): void;
+    resumeMission(missionId: string): void;
+    cancelMission(missionId: string): void;
+    private sleep;
+}

package/dist/kernel/orchestrator.js

@@ -0,0 +1,226 @@
+export class Orchestrator {
+    deps;
+    pausedMissions = new Set();
+    cancelledMissions = new Set();
+    workersByMission = new Map();
+    /** Per-task forced provider/model overrides set by the recovery manager. */
+    taskOverrides = new Map();
+    /** Per-task forced worker type override set by the recovery manager. */
+    taskWorkerOverrides = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async run(mission, input) {
+        // 1. Plan if not yet planned
+        if (mission.tasks.length === 0) {
+            this.deps.missionEngine.plan(mission, input);
+        }
+        // 2. Start
+        this.deps.missionEngine.start(mission);
+        // 3. Execute tasks
+        const parallelism = mission.policy.policy.execution?.parallelism ?? 4;
+        await this.runTasks(mission, parallelism);
+        // 4. Verify the mission as a whole (objective-level + LLM judge)
+        if (this.deps.scheduler.isMissionComplete(mission)) {
+            const vresult = await this.deps.missionEngine.verify(mission);
+            if (!vresult.passed && !mission.policy.policy.verification?.strict) {
+                // non-strict: fall back to simple completion if verification engine returned failure
+                this.deps.missionEngine.complete(mission);
+            }
+        }
+        else if (this.deps.scheduler.hasFailed(mission)) {
+            this.deps.missionEngine.fail(mission, 'One or more tasks failed beyond retry limit');
+        }
+        // 5. Final checkpoint
+        await this.deps.checkpoints.save(mission, this.collectWorkerStates(mission.id), 'task');
+        return mission;
+    }
+    async runTasks(mission, parallelism) {
+        while (mission.status === 'RUNNING') {
+            if (this.cancelledMissions.has(mission.id))
+                return;
+            // handle pause
+            while (this.pausedMissions.has(mission.id) && mission.status === 'RUNNING') {
+                await this.sleep(200);
+                if (this.cancelledMissions.has(mission.id))
+                    return;
+            }
+            const ready = this.deps.scheduler.nextReadyTasks(mission, parallelism);
+            if (ready.length === 0) {
+                // nothing ready — check if done
+                if (this.deps.scheduler.isMissionComplete(mission))
+                    return;
+                if (this.deps.scheduler.hasFailed(mission))
+                    return;
+                // stuck waiting on dependencies that failed → mark blocked tasks skipped
+                this.skipBlockedTasks(mission);
+                if (this.deps.scheduler.isMissionComplete(mission))
+                    return;
+                // truly nothing more to do
+                return;
+            }
+            // execute ready tasks in parallel
+            await Promise.all(ready.map(task => this.executeTask(mission, task)));
+            // checkpoint after each wave if policy says so
+            if (mission.policy.policy.checkpoint?.everyTask) {
+                await this.deps.checkpoints.save(mission, this.collectWorkerStates(mission.id), 'task');
+            }
+        }
+    }
+    async executeTask(mission, task) {
+        const overrideType = this.taskWorkerOverrides.get(task.id);
+        let workerType = overrideType ?? this.deps.workerRuntime.matchWorkerType(task.capabilities);
+        if (!workerType) {
+            task.status = 'FAILED';
+            task.error = `No worker registered for capabilities: ${task.capabilities.join(', ')}`;
+            this.deps.logger.error(`Task ${task.id}: ${task.error}`);
+            return;
+        }
+        // Apply recovery-mandated provider/model override if any.
+        const providerOverride = this.taskOverrides.get(task.id);
+        const instance = await this.deps.workerRuntime.spawn(workerType, mission.id, task.id, task.capabilities);
+        this.trackWorker(mission.id, instance);
+        try {
+            task.attempts += 1;
+            if (providerOverride) {
+                instance.providerId = providerOverride.providerId;
+                instance.modelId = providerOverride.modelId;
+            }
+            await this.deps.workerRuntime.execute(instance, task, providerOverride ?? undefined);
+            // 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.
+                await this.handleRecovery(mission, task, `verification failed: ${vresult.summary}`, instance);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await this.handleRecovery(mission, task, message, instance);
+        }
+        finally {
+            await this.deps.workerRuntime.destroy(instance);
+        }
+    }
+    async handleRecovery(mission, task, message, instance) {
+        this.deps.logger.warn(`Task ${task.id} attempt ${task.attempts} failed: ${message}`);
+        const decision = await this.deps.recovery.decide({
+            mission,
+            task,
+            error: message,
+            attempts: task.attempts,
+            policy: mission.policy.policy,
+            currentProviderId: instance.providerId,
+            currentModelId: instance.modelId,
+        });
+        const maxAttempts = mission.policy.policy.retry?.maxAttempts ?? 3;
+        switch (decision.action) {
+            case 'retry': {
+                task.status = 'PENDING';
+                task.error = message;
+                const backoff = mission.policy.policy.retry?.backoffMs ?? 1000;
+                await this.sleep(backoff);
+                break;
+            }
+            case 'rotate-provider': {
+                if (decision.rotateToProviderId && decision.rotateToModelId) {
+                    this.taskOverrides.set(task.id, {
+                        providerId: decision.rotateToProviderId,
+                        modelId: decision.rotateToModelId,
+                    });
+                    this.deps.eventBus.emit({
+                        type: 'PROVIDER_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,
+                        },
+                    });
+                }
+                task.status = 'PENDING';
+                task.error = message;
+                break;
+            }
+            case 'spawn-different-worker': {
+                if (decision.newWorkerType) {
+                    this.taskWorkerOverrides.set(task.id, decision.newWorkerType);
+                    this.deps.logger.info(`Task ${task.id}: switching worker to ${decision.newWorkerType}`);
+                }
+                task.status = 'PENDING';
+                task.error = message;
+                break;
+            }
+            case 'replan':
+            case 'checkpoint': {
+                await this.deps.checkpoints.save(mission, this.collectWorkerStates(mission.id), 'crash');
+                task.status = 'PENDING';
+                task.error = message;
+                break;
+            }
+            case 'continue': {
+                task.status = 'PENDING';
+                task.error = message;
+                break;
+            }
+            case 'abort':
+            default: {
+                task.status = 'FAILED';
+                task.error = message;
+                this.deps.eventBus.emit({
+                    type: 'TASK_FAILED',
+                    timestamp: Date.now(),
+                    missionId: mission.id,
+                    taskId: task.id,
+                    workerId: instance.id,
+                    data: { error: message, attempts: task.attempts, maxAttempts },
+                });
+                break;
+            }
+        }
+    }
+    skipBlockedTasks(mission) {
+        const failed = new Set(mission.tasks.filter(t => t.status === 'FAILED' && t.attempts >= t.maxAttempts).map(t => t.id));
+        for (const task of mission.tasks) {
+            if (task.status !== 'PENDING' && task.status !== 'QUEUED')
+                continue;
+            if (task.dependencies.some(d => failed.has(d))) {
+                task.status = 'SKIPPED';
+                task.error = 'Skipped: dependency failed';
+            }
+        }
+    }
+    trackWorker(missionId, instance) {
+        let arr = this.workersByMission.get(missionId);
+        if (!arr) {
+            arr = [];
+            this.workersByMission.set(missionId, arr);
+        }
+        arr.push(instance);
+    }
+    collectWorkerStates(missionId) {
+        return (this.workersByMission.get(missionId) ?? []).map(w => ({
+            workerId: w.id,
+            status: w.status,
+            taskId: w.taskId,
+            providerId: w.providerId,
+            modelId: w.modelId,
+            partialOutput: w.result?.content,
+        }));
+    }
+    pauseMission(missionId) {
+        this.pausedMissions.add(missionId);
+    }
+    resumeMission(missionId) {
+        this.pausedMissions.delete(missionId);
+    }
+    cancelMission(missionId) {
+        this.cancelledMissions.add(missionId);
+        this.pausedMissions.delete(missionId);
+    }
+    sleep(ms) {
+        return new Promise(r => setTimeout(r, ms));
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * OpenKernel — Plugin Manager
+ *
+ * Core stays tiny. Everything else is a plugin: Telegram, Discord, Slack,
+ * GitHub, Browser, Search, Vision, Email, Database, Storage, Monitoring.
+ */
+import type { EventBus } from './event-bus.js';
+import type { Logger, Plugin, PluginCommand } from './types.js';
+export interface PluginContext {
+    eventBus: EventBus;
+    logger: Logger;
+    commands: PluginManager;
+}
+export declare class PluginManager {
+    private eventBus;
+    private logger;
+    private plugins;
+    private commands;
+    private unsubscribers;
+    constructor(eventBus: EventBus, logger: Logger);
+    register(plugin: Plugin): void;
+    registerWithContext(plugin: Plugin, kernel: unknown): Promise<void>;
+    unregister(name: string): void;
+    listPlugins(): Plugin[];
+    registerCommand(cmd: PluginCommand): void;
+    listCommands(): PluginCommand[];
+    destroy(): void;
+}

package/dist/kernel/plugin-manager.js

@@ -0,0 +1,76 @@
+export class PluginManager {
+    eventBus;
+    logger;
+    plugins = new Map();
+    commands = [];
+    unsubscribers = [];
+    constructor(eventBus, logger) {
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    register(plugin) {
+        if (this.plugins.has(plugin.manifest.name)) {
+            this.logger.warn(`Plugin already registered: ${plugin.manifest.name}`);
+            return;
+        }
+        this.plugins.set(plugin.manifest.name, plugin);
+        if (plugin.manifest.commands) {
+            for (const cmd of plugin.manifest.commands) {
+                this.registerCommand(cmd);
+            }
+        }
+        if (plugin.manifest.subscriptions && plugin.onEvent) {
+            const unsub = this.eventBus.on(plugin.manifest.subscriptions, plugin.onEvent.bind(plugin));
+            this.unsubscribers.push(unsub);
+        }
+        this.logger.info(`Plugin registered: ${plugin.manifest.name} v${plugin.manifest.version}`);
+    }
+    async registerWithContext(plugin, kernel) {
+        this.register(plugin);
+        if (plugin.onRegister) {
+            await plugin.onRegister(kernel);
+        }
+    }
+    unregister(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin)
+            return;
+        if (plugin.onDestroy) {
+            try {
+                plugin.onDestroy();
+            }
+            catch (err) {
+                this.logger.warn(`Plugin ${name} destroy error: ${err}`);
+            }
+        }
+        this.plugins.delete(name);
+        this.commands = this.commands.filter(c => c.name !== `${name}.${c.name}`);
+        this.logger.info(`Plugin unregistered: ${name}`);
+    }
+    listPlugins() {
+        return [...this.plugins.values()];
+    }
+    registerCommand(cmd) {
+        this.commands.push(cmd);
+    }
+    listCommands() {
+        return [...this.commands];
+    }
+    destroy() {
+        for (const unsub of this.unsubscribers)
+            unsub();
+        this.unsubscribers = [];
+        for (const plugin of this.plugins.values()) {
+            if (plugin.onDestroy) {
+                try {
+                    plugin.onDestroy();
+                }
+                catch (err) {
+                    this.logger.warn(`Plugin destroy error: ${err}`);
+                }
+            }
+        }
+        this.plugins.clear();
+        this.commands = [];
+    }
+}

package/dist/kernel/plugins/browser-plugin.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OpenKernel — Browser Plugin
+ *
+ * Playwright-backed browser automation. Provides a shared BrowserController
+ * that the browser worker handler uses. Emits NOTIFICATION events on
+ * significant browser actions (configurable).
+ *
+ * If Playwright is not installed, the controller degrades to fetch-based
+ * read-only mode automatically.
+ */
+import type { Plugin } from '../types.js';
+import { BrowserController } from '../browser/browser-controller.js';
+import type { BrowserControllerOptions } from '../browser/browser-controller.js';
+export interface BrowserPluginOptions extends BrowserControllerOptions {
+    /** Emit a NOTIFICATION event on these action types. */
+    notifyOn?: string[];
+    /** Keep the browser open between actions (default: true). */
+    persistent?: boolean;
+}
+export declare function createBrowserPlugin(options?: BrowserPluginOptions): Plugin;
+export { BrowserController };
+export type { BrowserControllerOptions, BrowserAction, BrowserActionResult } from '../browser/browser-controller.js';

package/dist/kernel/plugins/browser-plugin.js

@@ -0,0 +1,34 @@
+import { BrowserController } from '../browser/browser-controller.js';
+import { setBrowserController } from '../workers/browser-worker.js';
+export function createBrowserPlugin(options = {}) {
+    const controller = new BrowserController(options);
+    let initialized = false;
+    const notifyOn = new Set(options.notifyOn ?? ['navigate', 'screenshot']);
+    const persistent = options.persistent ?? true;
+    async function ensureInit() {
+        if (!initialized) {
+            await controller.init();
+            initialized = true;
+        }
+        return controller;
+    }
+    return {
+        manifest: {
+            name: 'browser',
+            version: '0.2.0',
+            description: 'Playwright browser automation (Phase 4)',
+            subscriptions: [],
+        },
+        onRegister() {
+            void ensureInit().then(c => setBrowserController(c));
+        },
+        onEvent() {
+            // stateless; the worker handler drives the controller directly
+        },
+        async onDestroy() {
+            if (initialized && !persistent)
+                await controller.close();
+        },
+    };
+}
+export { BrowserController };

package/dist/kernel/plugins/dashboard-plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OpenKernel — Dashboard Plugin
+ *
+ * Serves an HTTP endpoint with live mission/provider/worker status.
+ *   GET /          → HTML dashboard
+ *   GET /status     → JSON status snapshot
+ *   GET /missions   → JSON mission list
+ *   GET /events     → JSON recent event history
+ *
+ * Read-only. No auth. Intended for local dev / ops visibility.
+ */
+import type { Plugin } from '../types.js';
+export interface DashboardPluginOptions {
+    port?: number;
+    host?: string;
+}
+export declare function createDashboardPlugin(options?: DashboardPluginOptions): Plugin;