infinicode 1.0.0 → 2.0.0

package/dist/kernel/verification-engine.js

@@ -0,0 +1,287 @@
+import { scoreFrontend } from './frontend-scoring.js';
+const PIPELINE_ORDER = [
+    'objective',
+    'compile',
+    'tests',
+    'lint',
+    'browser',
+    'expected-output',
+    'quality',
+    'llm-judge',
+];
+export class VerificationEngine {
+    deps;
+    verifiers = new Map();
+    constructor(deps) {
+        this.deps = deps;
+        this.registerBuiltins();
+    }
+    registerVerifier(verifier) {
+        const list = this.verifiers.get(verifier.stage) ?? [];
+        list.push(verifier);
+        this.verifiers.set(verifier.stage, list);
+    }
+    async verify(mission, task, policy) {
+        if (!task.output) {
+            return this.fail('No output to verify', []);
+        }
+        const ctx = {
+            mission,
+            task,
+            output: task.output,
+            strict: policy.verification?.strict ?? false,
+            workspace: mission.workspace,
+        };
+        const checks = [];
+        for (const stage of PIPELINE_ORDER) {
+            const list = this.verifiers.get(stage) ?? [];
+            for (const verifier of list) {
+                if (!verifier.enabled(ctx))
+                    continue;
+                const start = Date.now();
+                try {
+                    const check = await verifier.run(ctx);
+                    check.durationMs = Date.now() - start;
+                    checks.push(check);
+                    this.deps.logger.info(`Verify[${stage}] ${task.id}: ${check.passed ? 'PASS' : 'FAIL'} — ${check.message}`);
+                    if (!check.passed && ctx.strict && stage !== 'llm-judge') {
+                        return this.finalize(checks, task);
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    checks.push({ name: stage, passed: false, message: `verifier error: ${message}`, durationMs: Date.now() - start });
+                }
+            }
+        }
+        return this.finalize(checks, task);
+    }
+    finalize(checks, task) {
+        const passed = checks.length > 0 && checks.every(c => c.passed);
+        const score = checks.length > 0
+            ? checks.filter(c => c.passed).length / checks.length
+            : 0;
+        const summary = passed
+            ? `All ${checks.length} check(s) passed`
+            : `${checks.filter(c => !c.passed).length}/${checks.length} check(s) failed`;
+        const result = { passed, checks, score, summary };
+        this.deps.eventBus.emit({
+            type: passed ? 'VERIFY_SUCCESS' : 'VERIFY_FAILED',
+            timestamp: Date.now(),
+            missionId: task.missionId,
+            taskId: task.id,
+            data: result,
+        });
+        return result;
+    }
+    fail(message, checks) {
+        return { passed: false, checks, score: 0, summary: message };
+    }
+    registerBuiltins() {
+        this.registerVerifier(objectiveVerifier());
+        this.registerVerifier(compileVerifier());
+        this.registerVerifier(testsVerifier());
+        this.registerVerifier(lintVerifier());
+        this.registerVerifier(browserVerifier());
+        this.registerVerifier(expectedOutputVerifier());
+        this.registerVerifier(frontendQualityVerifier(this.deps.logger));
+        this.registerVerifier(this.llmJudgeVerifier());
+    }
+    llmJudgeVerifier() {
+        const self = this;
+        return {
+            stage: 'llm-judge',
+            enabled: () => true,
+            async run(ctx) {
+                const verdict = await self.runLlmJudge(ctx);
+                return verdict;
+            },
+        };
+    }
+    async runLlmJudge(ctx) {
+        const provider = await this.pickJudgeProvider();
+        if (!provider) {
+            return {
+                name: 'llm-judge',
+                passed: true,
+                message: 'no judge provider available; skipping LLM judge',
+            };
+        }
+        const caps = await provider.capabilities();
+        const model = caps.models[0];
+        if (!model) {
+            return { name: 'llm-judge', passed: true, message: 'no judge model available; skipping' };
+        }
+        const request = {
+            model: model.id,
+            systemPrompt: 'You are a verification judge. Given a task, its goal, and the produced output, decide whether the output satisfies the goal. Reply with a single line: PASS or FAIL, followed by a one-sentence reason.',
+            prompt: `Task: ${ctx.task.description}\nGoal: ${ctx.mission.goal}\nOutput:\n${ctx.output.content}\n\nVerdict:`,
+            maxTokens: 256,
+            temperature: 0,
+        };
+        try {
+            const result = await provider.complete(request);
+            const text = result.content.trim();
+            const passed = /^(pass|yes|true|✓)/i.test(text);
+            return {
+                name: 'llm-judge',
+                passed,
+                message: text.split('\n')[0].slice(0, 200),
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { name: 'llm-judge', passed: false, message: `judge error: ${message}` };
+        }
+    }
+    async pickJudgeProvider() {
+        const healthy = await this.deps.providerManager.getHealthyProviders();
+        return healthy[0];
+    }
+}
+function objectiveVerifier() {
+    return {
+        stage: 'objective',
+        enabled: ctx => ctx.mission.objectives.length > 0,
+        async run(ctx) {
+            const objective = ctx.mission.objectives.find(o => o.id === ctx.task.objectiveId);
+            if (!objective) {
+                return { name: 'objective', passed: true, message: 'no objective bound' };
+            }
+            const hasContent = ctx.output.content.trim().length > 0;
+            const criteria = objective.acceptanceCriteria;
+            if (criteria.length === 0) {
+                return {
+                    name: 'objective',
+                    passed: hasContent,
+                    message: hasContent ? 'output present' : 'empty output',
+                };
+            }
+            const passed = hasContent;
+            return {
+                name: 'objective',
+                passed,
+                message: passed
+                    ? `${criteria.length} acceptance criteria, output present`
+                    : 'empty output for objective',
+            };
+        },
+    };
+}
+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',
+            };
+        },
+    };
+}
+function testsVerifier() {
+    return {
+        stage: 'tests',
+        enabled: () => false,
+        async run() {
+            return { name: 'tests', passed: true, message: 'test runner not configured' };
+        },
+    };
+}
+function lintVerifier() {
+    return {
+        stage: 'lint',
+        enabled: () => false,
+        async run() {
+            return { name: 'lint', passed: true, message: 'linter not configured' };
+        },
+    };
+}
+function browserVerifier() {
+    return {
+        stage: 'browser',
+        enabled: () => false,
+        async run() {
+            return { name: 'browser', passed: true, message: 'browser tests not configured' };
+        },
+    };
+}
+function expectedOutputVerifier() {
+    return {
+        stage: 'expected-output',
+        enabled: ctx => {
+            const expected = ctx.task.input.context?.expectedOutput;
+            return typeof expected === 'string' && expected.length > 0;
+        },
+        async run(ctx) {
+            const expected = String(ctx.task.input.context?.expectedOutput ?? '');
+            const actual = ctx.output.content.trim();
+            const passed = actual.includes(expected.trim());
+            return {
+                name: 'expected-output',
+                passed,
+                message: passed ? 'matches expected output' : 'does not match expected output',
+            };
+        },
+    };
+}
+/**
+ * Frontend quality scorer. Enabled for frontend tasks (capability `frontend`
+ * or a `frontendAcceptance` request in context). Scores the produced code
+ * against the acceptance rubric; on a miss it writes targeted feedback back
+ * onto the task so the recovery loop's next attempt can fix the specific gaps.
+ */
+function frontendQualityVerifier(logger) {
+    return {
+        stage: 'quality',
+        enabled(ctx) {
+            return (ctx.task.capabilities.includes('frontend') ||
+                ctx.task.input.context?.frontendAcceptance !== undefined);
+        },
+        async run(ctx) {
+            const acceptance = ctx.task.input.context?.frontendAcceptance;
+            const code = collectCode(ctx.output);
+            const result = scoreFrontend(code, acceptance);
+            const failing = result.items
+                .filter(i => i.earned < i.weight)
+                .sort((a, b) => (b.weight - b.earned) - (a.weight - a.earned))
+                .slice(0, 4)
+                .map(i => `${i.name} ${i.earned}/${i.weight}`)
+                .join(', ');
+            if (!result.passed) {
+                // Feed specific fixes into the task so the next attempt improves.
+                const context = (ctx.task.input.context ?? {});
+                context.qualityFeedback =
+                    `Previous attempt scored ${result.score}/100 (need ${result.threshold}). ` +
+                        `Fix these before anything else:\n- ${result.feedback.join('\n- ')}`;
+                ctx.task.input.context = context;
+                logger.warn(`Frontend quality ${ctx.task.id}: ${result.score}/${result.threshold} — weakest: ${failing}`);
+            }
+            return {
+                name: 'frontend-quality',
+                passed: result.passed,
+                message: `score ${result.score}/100 (bar ${result.threshold})` + (failing ? ` — weakest: ${failing}` : ''),
+            };
+        },
+    };
+}
+/** Concatenate the task output text and any code/file artifacts for scoring. */
+function collectCode(output) {
+    const parts = [output.content ?? ''];
+    for (const a of output.artifacts ?? []) {
+        if ((a.type === 'code' || a.type === 'file' || a.type === 'document') && a.content) {
+            parts.push(a.content);
+        }
+    }
+    return parts.join('\n');
+}
+function hasArtifact(output, type) {
+    return output.artifacts?.some(a => a.type === type) ?? false;
+}

package/dist/kernel/worker-runtime.d.ts

@@ -0,0 +1,66 @@
+import type { Capability, Logger, Policy, ProviderInterface, ProviderModel, Task, TaskOutput, WorkerDefinition, WorkerInstance, WorkerPreferences, WorkerType } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { CapabilityRouter } from './router.js';
+import type { ProviderManager } from './provider-manager.js';
+import type { PolicyEngine } from './policies.js';
+export interface WorkerContext {
+    eventBus: EventBus;
+    router: CapabilityRouter;
+    providerManager: ProviderManager;
+    policies: PolicyEngine;
+    logger: Logger;
+}
+export type WorkerExecuteFn = (task: Task, provider: ProviderInterface, model: ProviderModel, ctx: WorkerContext) => Promise<TaskOutput>;
+export interface WorkerHandler {
+    type: WorkerType;
+    capabilities: Capability[];
+    preferences: WorkerPreferences;
+    execute: WorkerExecuteFn;
+    verify?: (task: Task, output: TaskOutput) => Promise<boolean>;
+}
+export declare class WorkerRuntime {
+    private ctx;
+    private handlers;
+    private active;
+    private registered;
+    /** Default policy used when a mission doesn't specify one. */
+    private defaultPolicyName;
+    /** Per-worker-type model pins set by the host application. */
+    private workerPins;
+    constructor(ctx: WorkerContext);
+    /** Override the default policy used for routing. */
+    setDefaultPolicy(name: Policy['name']): void;
+    /** Set a model pin for a worker type — overrides the router when healthy. */
+    setWorkerPin(type: WorkerType, providerId: string, modelId: string): void;
+    /** Bulk-set worker pins. */
+    setWorkerPins(pins: Map<WorkerType, {
+        providerId: string;
+        modelId: string;
+    }>): void;
+    /** Clear all pins. */
+    clearWorkerPins(): void;
+    registerWorker(definition: WorkerDefinition): void;
+    registerHandler(handler: WorkerHandler): void;
+    getHandler(type: WorkerType): WorkerHandler | undefined;
+    listWorkerTypes(): WorkerType[];
+    listRegisteredDefinitions(): WorkerDefinition[];
+    matchWorkerType(capabilities: Capability[]): WorkerType | undefined;
+    private capabilityOverlap;
+    spawn(type: WorkerType, missionId: string, taskId: string, capabilities: Capability[]): Promise<WorkerInstance>;
+    execute(instance: WorkerInstance, task: Task, override?: {
+        providerId: string;
+        modelId: string;
+    }): Promise<TaskOutput>;
+    destroy(instance: WorkerInstance): Promise<void>;
+    getActive(): WorkerInstance[];
+    getInstance(id: string): WorkerInstance | undefined;
+    /**
+     * Build a routing plan: the chosen model plus the ranked alternatives the
+     * router considered. Honors worker pins (a hard lock), otherwise defers to
+     * the policy-driven capability router.
+     */
+    private planRoute;
+    private lockedPlan;
+    private emitRouting;
+    private emit;
+}

package/dist/kernel/worker-runtime.js

@@ -0,0 +1,261 @@
+/**
+ * OpenKernel — Worker Runtime
+ *
+ * Workers are disposable capability containers. Not personalities.
+ * Lifecycle: Spawn → Initialize → Execute → Verify → Publish → Destroy
+ */
+import { nanoid } from 'nanoid';
+/** Rough token estimate of a task's request (prompt + context), ~4 chars/token. */
+function estimateRequestTokens(task) {
+    const ctx = task.input.context ? JSON.stringify(task.input.context) : '';
+    const chars = (task.input.prompt?.length ?? 0) + ctx.length;
+    return Math.ceil(chars / 4) + 500; // headroom for worker/system framing
+}
+export class WorkerRuntime {
+    ctx;
+    handlers = new Map();
+    active = new Map();
+    registered = new Map();
+    /** Default policy used when a mission doesn't specify one. */
+    defaultPolicyName = 'balanced';
+    /** Per-worker-type model pins set by the host application. */
+    workerPins = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** Override the default policy used for routing. */
+    setDefaultPolicy(name) {
+        this.defaultPolicyName = name;
+    }
+    /** Set a model pin for a worker type — overrides the router when healthy. */
+    setWorkerPin(type, providerId, modelId) {
+        this.workerPins.set(type, { providerId, modelId });
+    }
+    /** Bulk-set worker pins. */
+    setWorkerPins(pins) {
+        this.workerPins = new Map(pins);
+    }
+    /** Clear all pins. */
+    clearWorkerPins() {
+        this.workerPins.clear();
+    }
+    registerWorker(definition) {
+        this.registered.set(definition.type, definition);
+        this.ctx.logger.info(`Worker type registered: ${definition.type}`);
+    }
+    registerHandler(handler) {
+        this.handlers.set(handler.type, handler);
+        const def = {
+            type: handler.type,
+            capabilities: handler.capabilities,
+            preferences: handler.preferences,
+        };
+        this.registered.set(handler.type, def);
+    }
+    getHandler(type) {
+        return this.handlers.get(type);
+    }
+    listWorkerTypes() {
+        return [...this.handlers.keys()];
+    }
+    listRegisteredDefinitions() {
+        return [...this.registered.values()];
+    }
+    matchWorkerType(capabilities) {
+        let best;
+        let bestScore = 0;
+        for (const [type, def] of this.registered) {
+            const score = this.capabilityOverlap(def.capabilities, capabilities);
+            if (score > bestScore) {
+                bestScore = score;
+                best = type;
+            }
+        }
+        return best;
+    }
+    capabilityOverlap(workerCaps, taskCaps) {
+        if (taskCaps.length === 0)
+            return 0;
+        let matched = 0;
+        for (const cap of taskCaps) {
+            if (workerCaps.includes(cap))
+                matched++;
+        }
+        return matched / taskCaps.length;
+    }
+    async spawn(type, missionId, taskId, capabilities) {
+        const id = nanoid(10);
+        const def = this.registered.get(type);
+        const instance = {
+            id,
+            type,
+            capabilities: def?.capabilities ?? capabilities,
+            preferences: def?.preferences ?? {},
+            status: 'SPAWNED',
+            missionId,
+            taskId,
+            createdAt: Date.now(),
+        };
+        this.active.set(id, instance);
+        this.emit('WORKER_SPAWNED', missionId, { workerId: id, type }, taskId);
+        this.ctx.logger.info(`Worker spawned: ${id} (${type}) for mission ${missionId}`);
+        return instance;
+    }
+    async execute(instance, task, override) {
+        const handler = this.handlers.get(instance.type);
+        if (!handler) {
+            throw new Error(`No handler registered for worker type: ${instance.type}`);
+        }
+        instance.status = 'INITIALIZED';
+        const plan = override
+            ? this.lockedPlan(override, 'recovery override')
+            : await this.planRoute(task.capabilities, handler.preferences, instance.type, estimateRequestTokens(task));
+        // Surface the orchestrator's choice (ranked candidates + winner) so the
+        // CLI / TUI can animate and highlight it.
+        this.emitRouting(instance, task, plan);
+        const routing = plan.chosen;
+        if (!routing) {
+            throw new Error(`No provider available for capabilities: ${task.capabilities.join(', ')}`);
+        }
+        const provider = this.ctx.providerManager.get(routing.providerId);
+        if (!provider)
+            throw new Error(`Provider not found: ${routing.providerId}`);
+        const caps = await provider.capabilities();
+        const model = caps.models.find(m => m.id === routing.modelId);
+        if (!model)
+            throw new Error(`Model not found: ${routing.modelId}`);
+        instance.providerId = provider.info.id;
+        instance.modelId = model.id;
+        instance.status = 'EXECUTING';
+        instance.startedAt = Date.now();
+        task.assignedWorkerId = instance.id;
+        task.providerId = provider.info.id;
+        task.modelId = model.id;
+        task.status = 'RUNNING';
+        task.startedAt = Date.now();
+        this.emit('TASK_STARTED', instance.missionId, { taskId: task.id, workerId: instance.id, providerId: provider.info.id, modelId: model.id }, task.id, instance.id);
+        this.emit('MODEL_CHANGED', instance.missionId, { taskId: task.id, providerId: provider.info.id, modelId: model.id, previousModelId: undefined }, task.id, instance.id);
+        try {
+            const output = await handler.execute(task, provider, model, this.ctx);
+            this.ctx.providerManager.recordSuccess(provider.info.id);
+            instance.result = output;
+            instance.status = 'COMPLETED';
+            instance.completedAt = Date.now();
+            task.output = output;
+            task.status = 'COMPLETED';
+            task.completedAt = Date.now();
+            this.emit('TASK_COMPLETED', instance.missionId, { taskId: task.id, workerId: instance.id, output }, task.id, instance.id);
+            if (handler.verify) {
+                const verified = await handler.verify(task, output);
+                if (!verified) {
+                    this.ctx.logger.warn(`Worker verification failed for task ${task.id}`);
+                    this.emit('VERIFY_FAILED', instance.missionId, { taskId: task.id }, task.id, instance.id);
+                }
+                else {
+                    this.emit('VERIFY_SUCCESS', instance.missionId, { taskId: task.id }, task.id, instance.id);
+                }
+            }
+            return output;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (/429|rate.?limit|too many requests/i.test(message)) {
+                this.ctx.providerManager.record429(provider.info.id);
+            }
+            else {
+                this.ctx.providerManager.recordFailure(provider.info.id);
+            }
+            instance.error = message;
+            instance.status = 'FAILED';
+            task.status = 'FAILED';
+            task.error = message;
+            this.emit('TASK_FAILED', instance.missionId, { taskId: task.id, workerId: instance.id, error: message }, task.id, instance.id);
+            throw err;
+        }
+    }
+    async destroy(instance) {
+        instance.status = 'DESTROYED';
+        this.active.delete(instance.id);
+        this.emit('WORKER_EXITED', instance.missionId, { workerId: instance.id, type: instance.type }, instance.taskId, instance.id);
+    }
+    getActive() {
+        return [...this.active.values()];
+    }
+    getInstance(id) {
+        return this.active.get(id);
+    }
+    /**
+     * Build a routing plan: the chosen model plus the ranked alternatives the
+     * router considered. Honors worker pins (a hard lock), otherwise defers to
+     * the policy-driven capability router.
+     */
+    async planRoute(capabilities, preferences, workerType, estimatedRequestTokens) {
+        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);
+        const mode = policy.routing?.mode ?? 'balanced';
+        // 1. Honor a pinned model for this worker type if it's healthy → locked.
+        if (workerType) {
+            const pin = this.workerPins.get(workerType);
+            if (pin) {
+                const provider = providers.find(p => p.id === pin.providerId);
+                const model = models.find(m => m.id === pin.modelId && m.providerId === pin.providerId);
+                if (provider && model) {
+                    return this.lockedPlan(pin, `pinned for ${workerType}`, provider.name, provider.type, mode);
+                }
+                this.ctx.logger.warn(`Worker pin for ${workerType} (${pin.providerId}/${pin.modelId}) not available; routing normally`);
+            }
+        }
+        // 2. Policy-driven router — rank all candidates, keep the top slice for display.
+        const ranked = this.ctx.router.rank({
+            capabilities,
+            preferences,
+            policy,
+            availableProviders: providers,
+            availableModels: models,
+            estimatedRequestTokens,
+        });
+        if (ranked.length === 0) {
+            return { chosen: null, candidates: [], locked: false, mode };
+        }
+        const candidates = ranked.slice(0, 6).map(r => ({
+            providerId: r.providerId,
+            modelId: r.modelId,
+            score: r.score,
+            reason: r.reason,
+            providerName: r.providerInfo.name,
+            providerType: r.providerInfo.type,
+            benchmarkScore: r.benchmarkScore,
+        }));
+        return { chosen: candidates[0], candidates, locked: false, mode };
+    }
+    lockedPlan(target, reason, providerName, providerType, mode = 'locked') {
+        const info = this.ctx.providerManager.get(target.providerId)?.info;
+        const candidate = {
+            providerId: target.providerId,
+            modelId: target.modelId,
+            score: 1000,
+            reason,
+            providerName: providerName ?? info?.name ?? target.providerId,
+            providerType: providerType ?? info?.type ?? 'cloud',
+            benchmarkScore: 0,
+        };
+        return { chosen: candidate, candidates: [candidate], locked: true, mode };
+    }
+    emitRouting(instance, task, plan) {
+        if (!plan.chosen)
+            return;
+        const data = {
+            taskId: task.id,
+            workerType: instance.type,
+            mode: plan.mode,
+            locked: plan.locked,
+            chosen: plan.chosen,
+            candidates: plan.candidates,
+        };
+        this.emit('ROUTING_DECISION', instance.missionId, data, task.id, instance.id);
+    }
+    emit(type, missionId, data, taskId, workerId) {
+        this.ctx.eventBus.emit({ type, timestamp: Date.now(), missionId, taskId, workerId, data });
+    }
+}

package/dist/kernel/workers/browser-worker.d.ts

@@ -0,0 +1,6 @@
+import type { WorkerHandler } from '../worker-runtime.js';
+import { BrowserController, htmlToMarkdown } from '../browser/browser-controller.js';
+export declare function setBrowserController(controller: BrowserController): void;
+export declare function setBrowserControllerOptions(options: Record<string, unknown>): void;
+export declare function createBrowserWorker(): WorkerHandler;
+export { htmlToMarkdown };