infinicode 1.0.0 → 2.1.0

package/dist/kernel/router.js

@@ -0,0 +1,222 @@
+const MODE_WEIGHTS = {
+    balanced: { capability: 2, benchmark: 2.0, reliability: 1, speed: 1.0, quota: 1, context: 1.0, cost: 1.0, localBonus: 0 },
+    quality: { capability: 2, benchmark: 3.5, reliability: 1, speed: 0.5, quota: 0.5, context: 1.5, cost: 0.2, localBonus: 0 },
+    // "fastest" = most capable model with the fastest API response. Prefers
+    // fast cloud inference (Groq etc.); local is only a fallback (localBonus < 0).
+    fastest: { capability: 2, benchmark: 1.5, reliability: 1, speed: 3.0, quota: 1, context: 0.5, cost: 0.5, localBonus: -3.0 },
+    'free-first': { capability: 2, benchmark: 1.5, reliability: 1, speed: 1.0, quota: 1.5, context: 1.0, cost: 6.0, localBonus: 0.5 },
+    local: { capability: 2, benchmark: 2.0, reliability: 1, speed: 1.5, quota: 1, context: 1.0, cost: 1.5, localBonus: 2.0 },
+    privacy: { capability: 2, benchmark: 2.0, reliability: 1, speed: 1.0, quota: 1, context: 1.0, cost: 1.0, localBonus: 3.0 },
+    offline: { capability: 2, benchmark: 2.0, reliability: 1, speed: 1.5, quota: 1, context: 1.0, cost: 1.5, localBonus: 2.0 },
+};
+const DEFAULT_WEIGHTS = MODE_WEIGHTS.balanced;
+/** Providers known for ultra-low-latency inference — favored in `fastest` mode. */
+const FAST_API_PROVIDERS = new Set(['groq', 'cerebras', 'sambanova']);
+export class CapabilityRouter {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async route(request) {
+        const candidates = this.scoreCandidates(request);
+        if (candidates.length === 0) {
+            this.logger.warn('No routing candidates available');
+            return null;
+        }
+        const best = candidates[0];
+        return {
+            providerId: best.providerId,
+            modelId: best.modelId,
+            score: best.score,
+            reason: best.reason,
+        };
+    }
+    rank(request) {
+        return this.scoreCandidates(request).map(c => ({
+            providerId: c.providerId,
+            modelId: c.modelId,
+            score: c.score,
+            reason: c.reason,
+            providerInfo: c.providerInfo,
+            benchmarkScore: c.benchmarkScore,
+        }));
+    }
+    scoreCandidates(request) {
+        const { capabilities, preferences, policy, availableProviders, availableModels } = request;
+        const mode = (policy.routing?.mode ?? 'balanced');
+        const weights = MODE_WEIGHTS[mode] ?? DEFAULT_WEIGHTS;
+        const needTokens = request.estimatedRequestTokens ?? 0;
+        const providerMap = new Map(availableProviders.map(p => [p.id, p]));
+        const blocked = new Set(policy.routing?.blockedProviders ?? []);
+        const preferred = new Set(policy.routing?.preferredProviders ?? []);
+        // The one locked mode: offline never leaves the local machine.
+        const localOnly = mode === 'offline';
+        const costPref = this.costPreferenceMultiplier(preferences.cost);
+        const speedPref = 0.5 + Math.min(1, (preferences.speed ?? 60) / 100); // ~0.9–1.5
+        const scored = [];
+        for (const model of availableModels) {
+            const provider = providerMap.get(model.providerId);
+            if (!provider || !provider.healthy)
+                continue;
+            if (blocked.has(provider.id))
+                continue;
+            if (localOnly && provider.type !== 'local')
+                continue;
+            const capScore = this.capabilityScore(model.capabilities, capabilities);
+            if (capScore === 0)
+                continue;
+            const benchmark = this.estimateBenchmark(model);
+            const benchScore = this.benchmarkScore(benchmark, preferences);
+            const reliability = provider.successRate ?? 0.9;
+            const speed = 1 - Math.min(1, (provider.latencyMs ?? 1000) / 5000);
+            const quota = provider.quotaRemaining !== undefined
+                ? Math.min(1, provider.quotaRemaining / 60)
+                : 0.5;
+            // Effective per-request budget: the tier's rate limit caps this well below
+            // the context window on free tiers (e.g. Groq free ≈ 12k TPM vs 128k ctx).
+            // Model-level cap wins; else the provider-tier TPM (from headers); else ctx.
+            const effectiveLimit = model.maxRequestTokens ?? provider.maxRequestTokens ?? model.contextLength;
+            const ctxScore = this.contextScore(effectiveLimit, preferences);
+            const costPenalty = this.costScore(model) * weights.cost * costPref;
+            const localBonus = provider.type === 'local' ? weights.localBonus : 0;
+            const preferredBonus = preferred.has(provider.id) ? 1 : 0;
+            // In fastest mode, reward providers with the fastest real inference APIs
+            // so a capable fast-cloud model beats local (which stays a fallback).
+            const fastApiBonus = mode === 'fastest' && FAST_API_PROVIDERS.has(provider.id) ? 1.5 : 0;
+            // 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;
+            const score = capScore * weights.capability +
+                benchScore * weights.benchmark +
+                reliability * weights.reliability +
+                speed * weights.speed * speedPref +
+                quota * weights.quota +
+                ctxScore * weights.context +
+                localBonus +
+                preferredBonus +
+                fastApiBonus -
+                costPenalty -
+                capacityPenalty;
+            scored.push({
+                providerId: provider.id,
+                modelId: model.id,
+                score,
+                reason: this.buildReason(mode, capScore, benchmark, benchScore, speed, reliability, costPenalty, localBonus) +
+                    (capacityPenalty ? ` cap<${needTokens}` : ''),
+                providerInfo: provider,
+                benchmarkScore: benchmark,
+            });
+        }
+        return scored.sort((a, b) => b.score - a.score);
+    }
+    capabilityScore(modelCaps, requested) {
+        if (requested.length === 0)
+            return 0.5;
+        let matched = 0;
+        for (const cap of requested) {
+            if (modelCaps.includes(cap))
+                matched++;
+        }
+        return matched / requested.length;
+    }
+    /**
+     * Reasoning/quality contribution in [0,1]. Honors the worker preference
+     * "reasoning >= N": a model that clears the bar gets full credit for its
+     * benchmark; one below the bar is proportionally discounted.
+     */
+    benchmarkScore(benchmark, prefs) {
+        const normalized = Math.max(0, Math.min(1, benchmark / 100));
+        if (!prefs.reasoning)
+            return normalized;
+        if (benchmark >= prefs.reasoning)
+            return normalized;
+        return normalized * (benchmark / prefs.reasoning);
+    }
+    /**
+     * Estimate a 0–100 reasoning/quality benchmark for a model. Uses an explicit
+     * `benchmarkScore` when the provider supplies one; otherwise infers it from
+     * parameter size, model family, and context length.
+     */
+    estimateBenchmark(model) {
+        if (typeof model.benchmarkScore === 'number') {
+            return Math.max(0, Math.min(100, model.benchmarkScore));
+        }
+        const text = `${model.id} ${model.name}`.toLowerCase();
+        const paramSize = this.parseParamSize(model, text);
+        let score;
+        if (paramSize >= 70)
+            score = 86;
+        else if (paramSize >= 30)
+            score = 80;
+        else if (paramSize >= 13)
+            score = 70;
+        else if (paramSize >= 7)
+            score = 60;
+        else if (paramSize >= 3)
+            score = 50;
+        else if (paramSize > 0)
+            score = 44;
+        else
+            score = 58; // unknown-size cloud model — assume mid-tier
+        // Frontier families punch above their parameter count.
+        if (/(gpt-4o|gpt-4\.1|gpt-5|gpt-oss|o[1-9]\b|claude|deepseek-?(r1|v3|v4)|gemini-[23]|gemini-1\.5-pro|llama-3\.3|llama-4|qwen2?\.5|qwen3|qwq|glm-[45]|nemotron|mistral-large|kimi|minimax|command-r-plus|ernie)/.test(text)) {
+            score = Math.max(score, 85);
+        }
+        // Small/fast variants are capable but not top-tier (avoid demoting MoE "air"
+        // or *-nano-VL flagships by matching only clear small-size markers).
+        if (/(\bmini\b|flash|instant|1\.5b|-3b\b|-7b\b|-8b\b|e4b|tiny|\bsmall\b)/.test(text)) {
+            score = Math.min(score, 74);
+        }
+        // Coding specialists get a small bump for their domain.
+        if (/(coder|code)/.test(text))
+            score += 3;
+        // Long context correlates with newer, stronger models.
+        if (model.contextLength >= 128_000)
+            score += 3;
+        else if (model.contextLength >= 64_000)
+            score += 1;
+        return Math.max(30, Math.min(95, Math.round(score)));
+    }
+    parseParamSize(model, text) {
+        const meta = model.metadata?.parameterSize;
+        if (typeof meta === 'string') {
+            const m = meta.match(/([\d.]+)\s*b/i);
+            if (m)
+                return parseFloat(m[1]);
+        }
+        // Match "70b", "8x7b", "3.8b" but not context markers like "128k".
+        const m = text.match(/(\d+(?:\.\d+)?)\s*x?\s*(\d+(?:\.\d+)?)?\s*b\b/);
+        if (m) {
+            const a = parseFloat(m[1]);
+            const b = m[2] ? parseFloat(m[2]) : undefined;
+            return b ? a * b : a; // 8x7b ≈ 56B
+        }
+        return 0;
+    }
+    contextScore(modelCtx, prefs) {
+        if (!prefs.contextLength)
+            return 0.5;
+        if (modelCtx >= prefs.contextLength)
+            return 1;
+        return modelCtx / prefs.contextLength;
+    }
+    costScore(model) {
+        const input = model.costPer1kTokens?.input ?? 0;
+        const output = model.costPer1kTokens?.output ?? 0;
+        return input + output;
+    }
+    costPreferenceMultiplier(cost) {
+        switch (cost) {
+            case 'free': return 2.0;
+            case 'low': return 1.3;
+            case 'high': return 0.6;
+            case 'medium':
+            default: return 1.0;
+        }
+    }
+    buildReason(mode, cap, benchmark, benchScore, speed, reliability, costPenalty, localBonus) {
+        return (`mode=${mode} cap=${cap.toFixed(2)} bench=${benchmark}(${benchScore.toFixed(2)}) ` +
+            `speed=${speed.toFixed(2)} rel=${reliability.toFixed(2)} cost=-${costPenalty.toFixed(2)}` +
+            (localBonus ? ` local+${localBonus.toFixed(1)}` : ''));
+    }
+}

package/dist/kernel/sample-missions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sample missions for the OpenKernel runtime.
+ *
+ * These illustrate the mission → objective → task → worker → provider flow.
+ * They can be executed via the `infinicode mission run` command or
+ * programmatically through the Kernel API.
+ */
+import type { MissionInput } from '../kernel/index.js';
+export declare const SAMPLE_MISSIONS: Record<string, MissionInput>;
+export declare function getSampleMission(name: string): MissionInput | undefined;
+export declare function listSampleMissions(): string[];

package/dist/kernel/sample-missions.js

@@ -0,0 +1,132 @@
+export const SAMPLE_MISSIONS = {
+    'hello-code': {
+        name: 'hello-code',
+        description: 'Verify the kernel can route a coding task to a provider.',
+        goal: 'Generate a TypeScript function that reverses a string.',
+        policy: 'local-first',
+        tasks: [
+            {
+                description: 'Write a TypeScript function that reverses a string.',
+                capabilities: ['coding', 'reasoning'],
+                input: {
+                    prompt: 'Write a TypeScript function `reverseString(s: string): string` that reverses its input. Include only the function and a one-line comment. No imports.',
+                },
+            },
+        ],
+    },
+    'research-summary': {
+        name: 'research-summary',
+        description: 'Multi-task research mission with a dependency.',
+        goal: 'Produce a short research brief on local LLM inference.',
+        policy: 'balanced',
+        tasks: [
+            {
+                description: 'Summarize the benefits of local LLM inference.',
+                capabilities: ['summarize', 'reasoning'],
+                input: {
+                    prompt: 'List the top 3 benefits of running LLMs locally versus using cloud APIs. Be concise.',
+                },
+            },
+            {
+                description: 'Draft a one-paragraph brief combining the benefits with a recommendation.',
+                capabilities: ['summarize', 'citations'],
+                dependencies: [],
+                input: {
+                    prompt: 'Using the prior summary, write a single paragraph recommending local inference for a small team. Keep under 120 words.',
+                },
+            },
+        ],
+    },
+    'review-code': {
+        name: 'review-code',
+        description: 'Run a review worker over a snippet.',
+        goal: 'Review a code snippet for bugs and style.',
+        policy: 'highest-quality',
+        tasks: [
+            {
+                description: 'Review this TypeScript snippet for bugs and style.',
+                capabilities: ['review', 'coding', 'reasoning'],
+                input: {
+                    prompt: 'Review this code:\n\n```ts\nfunction add(a, b) { return a + b }\n```\n\nList concrete issues (bugs, types, naming) and suggested fixes. Be brief.',
+                },
+            },
+        ],
+    },
+};
+const FRONTEND_ARCHITECT_BRIEF = 'You are an elite frontend architect, design-systems engineer, motion designer, ' +
+    'accessibility expert, and data-visualization engineer. Build production-grade, ' +
+    'framework-independent UI using only HTML5, CSS3, and vanilla ES6+ JavaScript. ' +
+    'Do NOT use React, Vue, Angular, Tailwind, Bootstrap, or jQuery. Use CSS custom ' +
+    'properties for all design tokens, support runtime theme switching via ' +
+    '[data-theme], make every component reusable, responsive, animated (60fps), and ' +
+    'accessible (semantic HTML, ARIA, :focus-visible, prefers-reduced-motion). ' +
+    'No placeholders, no TODOs, no lorem ipsum — finish every section with real content. ' +
+    'The aesthetic target is Apple × Linear × Stripe × Vercel with glassmorphism and a ' +
+    'futuristic HUD feel. Output complete, self-contained code.';
+// Acceptance criteria travel with each task as a "worker request"; the
+// frontend-quality verifier scores against them and feeds fixes back on a miss.
+SAMPLE_MISSIONS['frontend-platform'] = {
+    name: 'frontend-platform',
+    description: 'Build a production-grade, framework-independent frontend design system + component library.',
+    goal: 'Produce a reusable frontend platform (design tokens, themes, components, animation) at senior quality.',
+    policy: 'quality',
+    tasks: [
+        {
+            description: 'Design system foundation: tokens, themes, typography, spacing, elevation, glass, motion.',
+            capabilities: ['frontend', 'design', 'coding', 'reasoning'],
+            input: {
+                prompt: 'Build the foundation of the design system: a complete set of CSS custom-property design tokens ' +
+                    '(colors, semantic colors, typography scale, spacing, radius, shadow/elevation, blur/glass, glow, ' +
+                    'motion timings, breakpoints) and at least 10 runtime themes via [data-theme] (Dark, Light, ' +
+                    'Cyberpunk, OLED, Glass, Purple Neon, Blue Neon, Green Matrix, Amber Terminal, High Contrast). ' +
+                    'Every value must be a token consumed with var(--…).',
+                context: {
+                    systemPrompt: FRONTEND_ARCHITECT_BRIEF,
+                    frontendAcceptance: {
+                        threshold: 88, minThemes: 10, minTokens: 80,
+                        requireDesignTokens: true, requireResponsive: true, noPlaceholders: true,
+                    },
+                },
+            },
+        },
+        {
+            description: 'Component library: 120+ reusable, accessible, animated components with full states.',
+            capabilities: ['frontend', 'coding', 'accessibility', 'animation', 'reasoning'],
+            input: {
+                prompt: 'Build a reusable component library of at least 120 production-ready components (buttons, inputs, ' +
+                    'cards, navigation, command palette, modals, drawers, tabs, tables, data grid, charts host, toasts, ' +
+                    'tooltips, etc.). Each component: reusable class-based CSS, all states (hover/focus/active/disabled/' +
+                    'loading/error), keyboard navigation, ARIA, :focus-visible, and smooth animation. Vanilla JS only.',
+                context: {
+                    systemPrompt: FRONTEND_ARCHITECT_BRIEF,
+                    frontendAcceptance: {
+                        threshold: 88, minComponents: 120, requireAccessibility: true,
+                        requireAnimation: true, noPlaceholders: true,
+                    },
+                },
+            },
+        },
+        {
+            description: 'Demo application built exclusively from the component library (AI OS / analytics dashboard).',
+            capabilities: ['frontend', 'coding', 'dataviz', 'animation', 'reasoning'],
+            input: {
+                prompt: 'Build a polished demo application (an AI Operating System dashboard) using ONLY reusable components ' +
+                    'and tokens from the library. Include a responsive dashboard layout, data visualizations, a command ' +
+                    'palette, a dock, and live-feeling microinteractions. Framework-independent, accessible, 60fps.',
+                context: {
+                    systemPrompt: FRONTEND_ARCHITECT_BRIEF,
+                    frontendAcceptance: {
+                        threshold: 85, requireResponsive: true, requireAnimation: true,
+                        requireAccessibility: true, noPlaceholders: true,
+                    },
+                },
+            },
+        },
+    ],
+};
+export function getSampleMission(name) {
+    return SAMPLE_MISSIONS[name];
+}
+export function listSampleMissions() {
+    return Object.keys(SAMPLE_MISSIONS);
+}

package/dist/kernel/scheduler.d.ts

@@ -0,0 +1,30 @@
+import type { Capability, Logger, Mission, MissionInput, Objective, Task, TaskInput } from './types.js';
+import type { EventBus } from './event-bus.js';
+export declare class Scheduler {
+    private eventBus;
+    private logger;
+    constructor(eventBus: EventBus, logger: Logger);
+    planMission(missionId: string, input: MissionInput): {
+        objectives: Objective[];
+        tasks: Task[];
+    };
+    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:
+     * dependencies satisfied, not yet completed/failed/skipped.
+     */
+    nextReadyTasks(mission: Mission, maxBatch: number): Task[];
+    /**
+     * Topologically sorts tasks honoring dependency edges.
+     * Used for sequential mode.
+     */
+    topoSort(tasks: Task[]): Task[];
+    isMissionComplete(mission: Mission): boolean;
+    hasFailed(mission: Mission): boolean;
+    allObjectivesComplete(mission: Mission): boolean;
+    /**
+     * Marks an objective complete when all its tasks complete.
+     */
+    reconcileObjectives(mission: Mission): void;
+    private aggregateCapabilities;
+}

package/dist/kernel/scheduler.js

@@ -0,0 +1,147 @@
+/**
+ * OpenKernel — Scheduler
+ *
+ * Mission → Objectives → Tasks → Execution Queue → Workers
+ * Supports: sequential, parallel, dependency graphs
+ */
+import { nanoid } from 'nanoid';
+export class Scheduler {
+    eventBus;
+    logger;
+    constructor(eventBus, logger) {
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    planMission(missionId, input) {
+        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 objective = {
+            id: objectiveId,
+            missionId,
+            description: input.goal,
+            capabilities: this.aggregateCapabilities(tasks),
+            acceptanceCriteria: [],
+            taskIds: tasks.map(t => t.id),
+            status: tasks.length > 0 ? 'PENDING' : 'COMPLETED',
+            createdAt: Date.now(),
+        };
+        this.logger.info(`Mission planned: ${missionId} with ${tasks.length} task(s) across 1 objective`);
+        return { objectives: [objective], tasks };
+    }
+    createTask(missionId, objectiveId, description, capabilities, dependencies, input) {
+        const id = nanoid(10);
+        const task = {
+            id,
+            objectiveId,
+            missionId,
+            description,
+            capabilities,
+            dependencies,
+            status: 'PENDING',
+            input,
+            attempts: 0,
+            maxAttempts: 3,
+            createdAt: Date.now(),
+        };
+        this.eventBus.emit({ type: 'TASK_QUEUED', timestamp: Date.now(), missionId, objectiveId, taskId: id, data: { description } });
+        return task;
+    }
+    /**
+     * Returns the next batch of tasks that are ready to execute:
+     * dependencies satisfied, not yet completed/failed/skipped.
+     */
+    nextReadyTasks(mission, maxBatch) {
+        const completed = new Set(mission.tasks.filter(t => t.status === 'COMPLETED').map(t => t.id));
+        const inFlight = new Set(mission.tasks.filter(t => t.status === 'RUNNING' || t.status === 'VERIFYING').map(t => t.id));
+        const ready = [];
+        const startedObjectives = new Set();
+        for (const task of mission.tasks) {
+            if (task.status !== 'PENDING' && task.status !== 'QUEUED')
+                continue;
+            if (inFlight.size >= maxBatch)
+                break;
+            const depsOk = task.dependencies.every(d => completed.has(d));
+            if (!depsOk)
+                continue;
+            ready.push(task);
+            inFlight.add(task.id);
+            if (!startedObjectives.has(task.objectiveId)) {
+                startedObjectives.add(task.objectiveId);
+                const objective = mission.objectives.find(o => o.id === task.objectiveId);
+                if (objective && objective.status === 'PENDING') {
+                    objective.status = 'RUNNING';
+                    this.eventBus.emit({
+                        type: 'OBJECTIVE_STARTED',
+                        timestamp: Date.now(),
+                        missionId: mission.id,
+                        objectiveId: objective.id,
+                        data: { description: objective.description },
+                    });
+                }
+            }
+        }
+        return ready;
+    }
+    /**
+     * Topologically sorts tasks honoring dependency edges.
+     * Used for sequential mode.
+     */
+    topoSort(tasks) {
+        const map = new Map(tasks.map(t => [t.id, t]));
+        const visited = new Set();
+        const result = [];
+        const visit = (task) => {
+            if (visited.has(task.id))
+                return;
+            visited.add(task.id);
+            for (const dep of task.dependencies) {
+                const depTask = map.get(dep);
+                if (depTask)
+                    visit(depTask);
+            }
+            result.push(task);
+        };
+        for (const t of tasks)
+            visit(t);
+        return result;
+    }
+    isMissionComplete(mission) {
+        return mission.tasks.length > 0 && mission.tasks.every(t => t.status === 'COMPLETED' || t.status === 'SKIPPED');
+    }
+    hasFailed(mission) {
+        return mission.tasks.some(t => t.status === 'FAILED' && t.attempts >= t.maxAttempts);
+    }
+    allObjectivesComplete(mission) {
+        return mission.objectives.length > 0 && mission.objectives.every(o => o.status === 'COMPLETED');
+    }
+    /**
+     * Marks an objective complete when all its tasks complete.
+     */
+    reconcileObjectives(mission) {
+        for (const objective of mission.objectives) {
+            const objTasks = mission.tasks.filter(t => t.objectiveId === objective.id);
+            const allDone = objTasks.length > 0 && objTasks.every(t => t.status === 'COMPLETED' || t.status === 'SKIPPED');
+            if (allDone && objective.status !== 'COMPLETED') {
+                objective.status = 'COMPLETED';
+                objective.completedAt = Date.now();
+                this.eventBus.emit({
+                    type: 'OBJECTIVE_COMPLETED',
+                    timestamp: Date.now(),
+                    missionId: mission.id,
+                    objectiveId: objective.id,
+                });
+            }
+        }
+    }
+    aggregateCapabilities(tasks) {
+        const set = new Set();
+        for (const t of tasks)
+            for (const c of t.capabilities)
+                set.add(c);
+        return [...set];
+    }
+}

package/dist/kernel/sdk/harness-sdk.d.ts

@@ -0,0 +1,37 @@
+/**
+ * OpenKernel — Harness SDK
+ *
+ * Helpers for harnesses to build MissionInput / MissionTaskInput without
+ * touching the kernel internals. A harness owns prompts, workflows,
+ * templates, agent design, memory strategy — it produces mission inputs;
+ * the kernel executes them.
+ *
+ *   const input = mission('reverse-string', 'Produce a reverseString function')
+ *     .description('Write a TypeScript string reverser')
+ *     .policy('local-first')
+ *     .task('Write the function', ['coding', 'reasoning'], { prompt: '...' })
+ *     .task('Write tests', ['coding'], { prompt: '...' }, ['t1'])
+ *     .build();
+ *
+ *   const result = await kernel.execute(input);
+ */
+import type { Capability, FrontendAcceptance, MissionInput, PolicyName, TaskInput, WorkspaceRef } from '../types.js';
+export interface MissionBuilder {
+    description(d: string): this;
+    goal(g: string): this;
+    policy(p: PolicyName): this;
+    workspace(root: string, git?: WorkspaceRef['git']): this;
+    metadata(meta: Record<string, unknown>): this;
+    task(description: string, capabilities: Capability[], input: TaskInput, dependencies?: string[]): this;
+    build(): MissionInput;
+}
+export declare function mission(name: string, goal: string): MissionBuilder;
+export declare function taskInput(prompt: string, context?: Record<string, unknown>): TaskInput;
+export declare function browserTaskInput(prompt: string, actions: Array<Record<string, unknown>>, context?: Record<string, unknown>): TaskInput;
+export declare function researchTaskInput(query: string, context?: Record<string, unknown>): TaskInput;
+/**
+ * Build a frontend "worker request": the brief plus the acceptance criteria
+ * (quality bar + constraints) that the frontend-quality verifier enforces and
+ * feeds back on. Pair with capabilities `['frontend', 'coding', 'reasoning']`.
+ */
+export declare function frontendTaskInput(prompt: string, acceptance?: FrontendAcceptance, context?: Record<string, unknown>): TaskInput;

package/dist/kernel/sdk/harness-sdk.js

@@ -0,0 +1,48 @@
+export function mission(name, goal) {
+    let desc = '';
+    let goalStr = goal;
+    let policy;
+    let workspace;
+    let metadata;
+    const tasks = [];
+    const builder = {
+        description(d) { desc = d; return this; },
+        goal(g) { goalStr = g; return this; },
+        policy(p) { policy = p; return this; },
+        workspace(root, git) { workspace = { root, git }; return this; },
+        metadata(m) { metadata = m; return this; },
+        task(description, capabilities, input, dependencies) {
+            tasks.push({ description, capabilities, input, dependencies });
+            return this;
+        },
+        build() {
+            return {
+                name,
+                description: desc,
+                goal: goalStr,
+                policy,
+                workspace,
+                metadata,
+                tasks,
+            };
+        },
+    };
+    return builder;
+}
+export function taskInput(prompt, context) {
+    return { prompt, context };
+}
+export function browserTaskInput(prompt, actions, context) {
+    return { prompt, context: { ...context, actions } };
+}
+export function researchTaskInput(query, context) {
+    return { prompt: query, context: { ...context, query } };
+}
+/**
+ * Build a frontend "worker request": the brief plus the acceptance criteria
+ * (quality bar + constraints) that the frontend-quality verifier enforces and
+ * feeds back on. Pair with capabilities `['frontend', 'coding', 'reasoning']`.
+ */
+export function frontendTaskInput(prompt, acceptance, context) {
+    return { prompt, context: { ...context, frontendAcceptance: acceptance ?? {} } };
+}

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

@@ -0,0 +1,27 @@
+/**
+ * OpenKernel — Plugin SDK
+ *
+ * Typed helpers for authoring plugins concisely. Provides a fluent
+ * PluginBuilder and a definePlugin() shortcut.
+ *
+ *   const myPlugin = definePlugin('my-plugin')
+ *     .version('1.0.0')
+ *     .description('Does things')
+ *     .subscribe(['MISSION_STARTED'], (e) => console.log(e))
+ *     .command('greet', 'Greet someone', async (args) => console.log(args))
+ *     .onRegister((kernel) => { ... })
+ *     .onDestroy(() => { ... })
+ *     .build();
+ */
+import type { KernelEvent, KernelEventType, KernelLike, Plugin, PluginCommand, EventHandler } from '../types.js';
+export interface PluginBuilder {
+    version(v: string): this;
+    description(d: string): this;
+    subscribe(types: KernelEventType[], handler: EventHandler): this;
+    command(name: string, description: string, handler: PluginCommand['handler']): this;
+    onRegister(fn: (kernel: KernelLike) => void | Promise<void>): this;
+    onDestroy(fn: () => void | Promise<void>): this;
+    onEvent(handler: (event: KernelEvent) => void | Promise<void>): this;
+    build(): Plugin;
+}
+export declare function definePlugin(name: string): PluginBuilder;