@lensagent/core 0.1.0

package/dist/runtime/context.js

@@ -0,0 +1,169 @@
+import { digest, toolArguments } from '../core/codec.js';
+import { fail } from '../core/domain.js';
+import { estimateRequest, estimateTokens } from './tokenizer.js';
+export class ContextEngine {
+    store;
+    registry;
+    constructor(store, registry) {
+        this.store = store;
+        this.registry = registry;
+    }
+    capture(projectId, agentId) {
+        return this.store.contextSource(projectId, agentId);
+    }
+    prepare(projectId, agentId, config, contextWindowTokens, profile, requestFrame) {
+        return this.prepareSource(this.capture(projectId, agentId), config, contextWindowTokens, profile, requestFrame);
+    }
+    prepareSource(source, config, contextWindowTokens, profile, requestFrame) {
+        const agentId = string(source.agent.id, 'agent_id');
+        const sourceRevision = number(source.agent.context_revision, 'context_revision');
+        const overrides = new Map(source.overrides.map((entry) => [`${string(entry.target_kind)}:${string(entry.target_id)}`, string(entry.instructions)]));
+        const visibleItems = source.items.filter((item) => item.visible === true);
+        const latestCompaction = visibleItems.findLast((item) => item.kind === 'compaction');
+        const workItems = latestCompaction === undefined
+            ? visibleItems
+            : [latestCompaction, ...visibleItems.filter((item) => item.id !== latestCompaction.id && item.locked !== true)];
+        let messages = workItems.map((item) => {
+            const role = roleOf(item.role);
+            const content = string(item.content);
+            if (item.kind === 'tool_calls') {
+                const calls = JSON.parse(content);
+                if (!Array.isArray(calls))
+                    fail('DATABASE_CORRUPT', 503, 'A persisted Tool Call block is invalid.');
+                return {
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: calls.map((entry) => {
+                        if (typeof entry !== 'object' || entry === null || Array.isArray(entry))
+                            fail('DATABASE_CORRUPT', 503, 'A persisted Tool Call is invalid.');
+                        const value = entry;
+                        // Normalised on the way out as well as on the way in, so a Context already holding a string
+                        // from before the capture was fixed becomes replayable instead of staying permanently dead.
+                        return { id: stringValue(value.id), name: stringValue(value.name), arguments: toolArguments(value.arguments) };
+                    })
+                };
+            }
+            const override = overrides.get(`${string(item.kind)}:${string(item.source_id)}`);
+            const base = { role, content: override === undefined ? content : `${override}\n\n${content}` };
+            const toolCallId = optionalString(item.tool_call_id);
+            const toolName = optionalString(item.tool_name);
+            if (role === 'tool' && (toolCallId === undefined || toolName === undefined)) {
+                return { role: 'user', content: `Included Result:\n${base.content}` };
+            }
+            return role === 'tool'
+                ? { ...base, ...(toolCallId === undefined ? {} : { toolCallId }), ...(toolName === undefined ? {} : { toolName }) }
+                : base;
+        });
+        const agentOverride = overrides.get(`agent:${agentId}`);
+        if (agentOverride !== undefined)
+            messages = [{ role: 'system', content: agentOverride }, ...messages];
+        const skillPrompts = source.capabilities
+            .filter((entry) => entry.loaded === true)
+            .flatMap((entry) => {
+            const capabilityId = string(entry.capability_id);
+            const definition = this.registry.find(capabilityId);
+            if (definition === undefined)
+                return [];
+            return definition.kind === 'skill' && definition.promptText !== undefined ? [definition.promptText] : [];
+        });
+        if (skillPrompts.length > 0)
+            messages = [{ role: 'system', content: skillPrompts.join('\n\n') }, ...messages];
+        messages = [{ role: 'system', content: profile.value.systemPrompt.content }, ...messages];
+        const reserve = config.contextBudget?.outputReserveTokens ?? 4096;
+        const margin = config.contextBudget?.safetyMarginTokens ?? 1024;
+        const maximum = contextWindowTokens - reserve - margin;
+        if (maximum < 1)
+            fail('CONTEXT_BUDGET_INVALID', 503, 'The configured context budget leaves no model input capacity.');
+        const decisions = [];
+        let estimate = estimateMessages(messages, requestFrame);
+        const projection = config.contextProjection;
+        if (estimate.safe > maximum && projection?.toolResultMaxTokens !== undefined) {
+            const sourceTokens = estimate.safe;
+            messages = toolResultBudget(messages, projection.toolResultMaxTokens);
+            estimate = estimateMessages(messages, requestFrame);
+            decisions.push({ stage: 'tool_result_budget', sourceTokens, projectedTokens: estimate.safe });
+        }
+        if (estimate.safe > maximum && projection?.snip !== undefined && estimate.safe > projection.snip.triggerTokens && messages.length > 4) {
+            const sourceTokens = estimate.safe;
+            const retainedBytes = Math.max(1, Math.floor(projection.snip.retainedTokens * 3 / Math.max(1, messages.length - 3)));
+            messages = messages.map((entry, index) => index > 0 && index < messages.length - 2 ? { ...entry, content: snip(entry.content, retainedBytes) } : entry);
+            estimate = estimateMessages(messages, requestFrame);
+            decisions.push({ stage: 'snip', sourceTokens, projectedTokens: estimate.safe });
+        }
+        if (estimate.safe > maximum && projection?.microcompact !== undefined && estimate.safe > projection.microcompact.triggerTokens && messages.length > 6) {
+            const sourceTokens = estimate.safe;
+            const head = first(messages);
+            const tail = messages.slice(-4);
+            messages = [head, { role: 'system', content: snip(localSummary(messages.slice(1, -4)), projection.microcompact.projectedTokens * 3) }, ...tail];
+            estimate = estimateMessages(messages, requestFrame);
+            decisions.push({ stage: 'microcompact', sourceTokens, projectedTokens: estimate.safe });
+        }
+        if (estimate.safe > maximum && projection?.contextCollapse !== undefined && estimate.safe > projection.contextCollapse.triggerTokens && messages.length > 2) {
+            const sourceTokens = estimate.safe;
+            const target = Math.min(maximum, projection.contextCollapse.projectedTokens);
+            while (messages.length > 2 && estimate.safe > target) {
+                messages = [first(messages), ...messages.slice(2)];
+                estimate = estimateMessages(messages, requestFrame);
+            }
+            decisions.push({ stage: 'context_collapse', sourceTokens, projectedTokens: estimate.safe });
+        }
+        return {
+            source,
+            messages,
+            estimate,
+            sourceRevision,
+            digest: digest(messages),
+            decisions
+        };
+    }
+}
+function estimateMessages(messages, requestFrame) {
+    return requestFrame === undefined
+        ? estimateTokens(messages.map((entry) => `${entry.role}\n${entry.content}`).join('\n'))
+        : estimateRequest({ messages, ...requestFrame });
+}
+function toolResultBudget(messages, maximumTokens) {
+    const maximumBytes = maximumTokens * 3;
+    return messages.map((entry) => entry.role === 'tool' && Buffer.byteLength(entry.content) > maximumBytes
+        ? { ...entry, content: `${Buffer.from(entry.content).subarray(0, maximumBytes).toString()}\n[tool result truncated]` }
+        : entry);
+}
+function snip(value, maximumBytes) {
+    if (Buffer.byteLength(value) <= maximumBytes)
+        return value;
+    const half = Math.floor(maximumBytes / 2);
+    const bytes = Buffer.from(value);
+    return `${bytes.subarray(0, half).toString()}\n[snip]\n${bytes.subarray(bytes.length - half).toString()}`;
+}
+function localSummary(messages) {
+    return `Earlier context (${messages.length} messages):\n${messages.map((entry) => `- ${entry.role}: ${snip(entry.content.replaceAll('\n', ' '), 256)}`).join('\n')}`;
+}
+function roleOf(value) {
+    if (value === 'system' || value === 'user' || value === 'assistant' || value === 'tool')
+        return value;
+    return 'user';
+}
+function string(value, field = 'value') {
+    if (typeof value !== 'string')
+        fail('DATABASE_CORRUPT', 503, `${field} is not a string.`);
+    return value;
+}
+function number(value, field) {
+    if (typeof value !== 'number')
+        fail('DATABASE_CORRUPT', 503, `${field} is not a number.`);
+    return value;
+}
+function optionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function first(messages) {
+    const message = messages[0];
+    if (message === undefined)
+        fail('CONTEXT_EMPTY', 503, 'Prepared Context is empty.');
+    return message;
+}
+function stringValue(value) {
+    if (typeof value !== 'string')
+        fail('DATABASE_CORRUPT', 503, 'A persisted Tool Call field is invalid.');
+    return value;
+}

package/dist/runtime/diagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { Json } from '../core/domain.js';
+import type { HarnessConfig } from '../config/schema.js';
+import type { ContextSource } from './context.js';
+export interface PreparationDiagnostics {
+    readonly agentIr: Json;
+    readonly executive: Json;
+}
+export declare function derivePreparationDiagnostics(source: ContextSource, config: HarnessConfig): PreparationDiagnostics;

package/dist/runtime/diagnostics.js

@@ -0,0 +1,71 @@
+import { digest } from '../core/codec.js';
+export function derivePreparationDiagnostics(source, config) {
+    const units = source.items.map((item, index) => unit(item, index + 1));
+    const agentIrDigest = digest({ version: 'agent-ir-v1', units });
+    const intents = units.filter((entry) => entry.kind === 'UserIntent');
+    const evidence = units.filter((entry) => entry.kind === 'ToolReceipt' || entry.kind === 'Failure');
+    const checkpoint = [...units].reverse().find((entry) => entry.kind === 'Checkpoint');
+    const verification = config.executive.verification.map((entry) => ({
+        id: entry.id,
+        description: entry.description,
+        source_digest: digest({ version: 'executive-verification-v1', id: entry.id, description: entry.description })
+    }));
+    const evidenceDigest = digest({
+        version: 'executive-evidence-v1',
+        evidence: evidence.map((entry) => typeof entry.digest === 'string' ? entry.digest : '')
+    });
+    const executive = {
+        version: 'executive-snapshot-v1',
+        intent_count: intents.length,
+        verification,
+        evidence_count: evidence.length,
+        evidence_set_digest: evidenceDigest,
+        checkpoint_digest: checkpoint?.digest ?? null,
+        completion_gate_status: verification.length === 0 ? 'not_configured' : 'pending_explicit_verification'
+    };
+    return {
+        agentIr: {
+            compiler_id: 'core.agent-ir',
+            compiler_version: '1',
+            unit_count: units.length,
+            digest: agentIrDigest
+        },
+        executive: { ...executive, digest: digest(executive) }
+    };
+}
+function unit(item, ordinal) {
+    const role = string(item.role);
+    const itemKind = string(item.kind);
+    const kind = itemKind === 'compaction' ? 'Checkpoint'
+        : itemKind === 'tool_calls' ? 'ToolInvocation'
+            : itemKind === 'result' ? resultKind(item)
+                : role === 'user' ? 'UserIntent'
+                    : role === 'system' ? 'TaskConstraint'
+                        : 'Observation';
+    const source = {
+        id: string(item.source_id),
+        version: number(item.revision),
+        digest: digest({
+            source_id: string(item.source_id),
+            revision: number(item.revision),
+            content: string(item.content)
+        })
+    };
+    const base = { ordinal, kind, role, source };
+    return { ...base, digest: digest(base) };
+}
+function resultKind(item) {
+    try {
+        const value = JSON.parse(string(item.content));
+        return value.error_code === null || value.error_code === undefined ? 'ToolReceipt' : 'Failure';
+    }
+    catch {
+        return 'ToolReceipt';
+    }
+}
+function string(value) {
+    return typeof value === 'string' ? value : '';
+}
+function number(value) {
+    return typeof value === 'number' ? value : 0;
+}

package/dist/runtime/events.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeSet, Json, RuntimeEvent } from '../core/domain.js';
+export interface EventLimits {
+    readonly maxBufferedEvents: number;
+    readonly maxBufferedBytes: number;
+}
+export interface Subscription {
+    readonly id: string;
+    next(signal: AbortSignal): Promise<RuntimeEvent | null>;
+    close(): void;
+}
+export declare class EventBus {
+    #private;
+    readonly instanceEpoch: string;
+    readonly metadataRevision: () => number;
+    constructor(instanceEpoch: string, limits: EventLimits, metadataRevision: () => number);
+    updateLimits(limits: EventLimits): void;
+    publish(change: ChangeSet): void;
+    emit(projectId: string, stateRevision: number, type: RuntimeEvent['type'], payload: Json): void;
+    subscribe(clientId: string, projectId: string): Subscription;
+    revoke(clientId: string): void;
+    close(): void;
+}

package/dist/runtime/events.js

@@ -0,0 +1,131 @@
+import { EventEmitter } from 'node:events';
+import { id, now } from '../core/codec.js';
+export class EventBus {
+    instanceEpoch;
+    metadataRevision;
+    #subscribers = new Map();
+    #lifecycle = new EventEmitter();
+    #limits;
+    constructor(instanceEpoch, limits, metadataRevision) {
+        this.instanceEpoch = instanceEpoch;
+        this.metadataRevision = metadataRevision;
+        this.#limits = limits;
+    }
+    updateLimits(limits) {
+        this.#limits = limits;
+    }
+    publish(change) {
+        // Drops the two internal aliases and forwards the rest of `ChangedEntityRef` whole. Listing the
+        // fields to keep is what broke this twice: first it reprojected each entry down to `{ type, id }`
+        // and discarded the `read_route` a subscriber needs, then the replacement enumerated six fields
+        // and silently dropped the 07 §4.2 invalidation scope that was added later. A subscriber cannot
+        // tell a field that was never derived from one that was derived and then omitted here, so the
+        // omission is structural: only `type` and `id` are named, and they are the only ones internal.
+        this.emit(change.projectId, change.stateRevision, 'entity.changed', {
+            changes: change.changes.map((entry) => wireChange(entry))
+        });
+    }
+    emit(projectId, stateRevision, type, payload) {
+        const event = {
+            id: id('event'),
+            projectId,
+            stateRevision,
+            metadataRevision: this.metadataRevision(),
+            type,
+            payload,
+            occurredAt: now()
+        };
+        for (const subscriber of this.#subscribers.values()) {
+            if (subscriber.projectId === projectId && !subscriber.closed)
+                this.#enqueue(subscriber, event);
+        }
+    }
+    subscribe(clientId, projectId) {
+        const subscriber = {
+            id: id('subscription'),
+            clientId,
+            projectId,
+            queue: [],
+            bytes: 0,
+            wake: undefined,
+            closeAfterDrain: false,
+            closed: false
+        };
+        this.#subscribers.set(subscriber.id, subscriber);
+        this.#lifecycle.emit('subscribed', subscriber.id);
+        return {
+            id: subscriber.id,
+            next: (signal) => this.#next(subscriber, signal),
+            close: () => this.#close(subscriber)
+        };
+    }
+    revoke(clientId) {
+        for (const subscriber of this.#subscribers.values()) {
+            if (subscriber.clientId === clientId)
+                this.#close(subscriber);
+        }
+    }
+    close() {
+        for (const subscriber of this.#subscribers.values())
+            this.#close(subscriber);
+        this.#lifecycle.removeAllListeners();
+    }
+    async #next(subscriber, signal) {
+        while (!subscriber.closed) {
+            const event = subscriber.queue.shift();
+            if (event !== undefined) {
+                subscriber.bytes -= bytes(event);
+                if (subscriber.closeAfterDrain && subscriber.queue.length === 0)
+                    this.#close(subscriber);
+                return event;
+            }
+            if (signal.aborted)
+                return null;
+            await new Promise((resolve) => {
+                const done = () => {
+                    signal.removeEventListener('abort', done);
+                    subscriber.wake = undefined;
+                    resolve();
+                };
+                subscriber.wake = done;
+                signal.addEventListener('abort', done, { once: true });
+            });
+        }
+        return null;
+    }
+    #enqueue(subscriber, event) {
+        const eventBytes = bytes(event);
+        if (subscriber.queue.length >= this.#limits.maxBufferedEvents || subscriber.bytes + eventBytes > this.#limits.maxBufferedBytes) {
+            const overflow = {
+                ...event,
+                id: id('event'),
+                type: 'snapshot.required',
+                payload: { reason: 'buffer_overflow' }
+            };
+            subscriber.queue.splice(0, subscriber.queue.length, overflow);
+            subscriber.bytes = bytes(overflow);
+            subscriber.closeAfterDrain = true;
+        }
+        else {
+            subscriber.queue.push(event);
+            subscriber.bytes += eventBytes;
+        }
+        subscriber.wake?.();
+    }
+    #close(subscriber) {
+        if (subscriber.closed)
+            return;
+        subscriber.closed = true;
+        this.#subscribers.delete(subscriber.id);
+        subscriber.wake?.();
+        this.#lifecycle.emit('closed', subscriber.id);
+    }
+}
+/** The internal aliases `ChangedEntity` carries for the publisher's own use; 07 does not define them. */
+const INTERNAL_CHANGE_KEYS = new Set(['type', 'id']);
+function wireChange(entry) {
+    return Object.fromEntries(Object.entries(entry).filter(([key]) => !INTERNAL_CHANGE_KEYS.has(key)));
+}
+function bytes(event) {
+    return Buffer.byteLength(JSON.stringify(event));
+}

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

@@ -0,0 +1,32 @@
+import { type CapabilityAdapter, type CapabilityInvocation, type CapabilityOutput } from '../core/domain.js';
+import type { ConfigRuntime } from '../config/runtime.js';
+import type { Document, Store } from '../store/store.js';
+import type { RegisteredCapability, CapabilityRegistry } from './capabilities.js';
+export declare class KernelAdapter implements CapabilityAdapter {
+    #private;
+    readonly store: Store;
+    readonly registry: CapabilityRegistry;
+    readonly config: ConfigRuntime;
+    readonly wakeAgent: (projectId: string, agentId: string) => void;
+    readonly createSubagent: (projectId: string, input: {
+        readonly parentAgentId: string;
+        readonly name: string;
+        readonly forkContext: 'full' | 'compact' | 'none';
+        readonly model?: string;
+        readonly modelReasoningEffort?: string;
+        readonly initialPrompt?: string;
+        readonly initialMessage?: string;
+    }, signal: AbortSignal) => Promise<Document>;
+    readonly id = "kernel";
+    constructor(store: Store, registry: CapabilityRegistry, config: ConfigRuntime, wakeAgent: (projectId: string, agentId: string) => void, createSubagent: (projectId: string, input: {
+        readonly parentAgentId: string;
+        readonly name: string;
+        readonly forkContext: 'full' | 'compact' | 'none';
+        readonly model?: string;
+        readonly modelReasoningEffort?: string;
+        readonly initialPrompt?: string;
+        readonly initialMessage?: string;
+    }, signal: AbortSignal) => Promise<Document>);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityOutput>;
+}
+export declare function kernelCapabilities(adapter: KernelAdapter): readonly RegisteredCapability[];

package/dist/runtime/kernel-capabilities.js

@@ -0,0 +1,200 @@
+import { jsonValue } from '../core/codec.js';
+import { UserInputRequiredError, fail } from '../core/domain.js';
+import { capabilityManifest } from './manifests.js';
+export class KernelAdapter {
+    store;
+    registry;
+    config;
+    wakeAgent;
+    createSubagent;
+    id = 'kernel';
+    constructor(store, registry, config, wakeAgent, createSubagent) {
+        this.store = store;
+        this.registry = registry;
+        this.config = config;
+        this.wakeAgent = wakeAgent;
+        this.createSubagent = createSubagent;
+    }
+    execute(invocation) {
+        const envelope = object(invocation.arguments);
+        const input = envelope.arguments === undefined
+            ? envelope
+            : { ...object(jsonValue(envelope.arguments)), ...(envelope.answer === undefined ? {} : { answer: envelope.answer }) };
+        if (invocation.capabilityId === 'system_echo')
+            return output(jsonValue(input));
+        if (invocation.capabilityId === 'programmatic_tool_run')
+            fail('ADAPTER_INCOMPATIBLE', 503, 'Programmatic Tool Calling must be executed by a supported Provider.');
+        if (invocation.capabilityId === 'capability_search') {
+            const assigned = invocation.agentId === null
+                ? null
+                : new Set(this.store.listCapabilities(invocation.projectId, invocation.agentId).map((entry) => string(entry.capability_id)));
+            const matches = this.registry.search(text(input.query, 'query'), optionalInteger(input.limit) ?? 20)
+                .filter((entry) => assigned === null || assigned.has(entry.id));
+            const requested = optionalStrings(input.load);
+            if (requested.some((capabilityId) => !matches.some((entry) => entry.id === capabilityId))) {
+                fail('CAPABILITY_ARGUMENT_INVALID', 400, 'A requested Capability was not returned by this search.');
+            }
+            if (requested.length > 0) {
+                const agentId = invocation.agentId;
+                if (agentId === null)
+                    fail('AGENT_REQUIRED', 409, 'Loading a Capability requires an Agent.');
+                this.store.loadCapabilities(invocation.projectId, agentId, Object.fromEntries(requested.map((capabilityId) => {
+                    const definition = this.registry.get(capabilityId);
+                    return [capabilityId, definition.effect === 'read_only' ? 'read_only' : 'ask'];
+                })));
+            }
+            return output({ matches: matches, loaded: requested, effective_from: 'next_eligible_model_attempt' });
+        }
+        const agentId = invocation.agentId;
+        if (agentId === null)
+            fail('AGENT_REQUIRED', 409, 'This Capability requires an Agent.');
+        if (invocation.capabilityId === 'update_plan' || invocation.capabilityId === 'update_todo') {
+            return output(this.store.updatePlan(invocation.projectId, agentId, jsonValue(input.items ?? [])));
+        }
+        if (invocation.capabilityId === 'ask_user') {
+            if (input.answer === undefined)
+                throw new UserInputRequiredError({
+                    kind: 'question',
+                    question: text(input.question, 'question'),
+                    options: jsonValue(input.options ?? []),
+                    allow_freeform: input.allow_freeform !== false,
+                    multi_select: input.multi_select === true
+                });
+            return output({ answer: jsonValue(input.answer) });
+        }
+        if (invocation.capabilityId === 'compact') {
+            const document = this.store.compactContext(invocation.projectId, agentId, text(input.summary, 'summary'), integer(input.preserve_from_ordinal, 'preserve_from_ordinal'));
+            return output(document);
+        }
+        if (invocation.capabilityId === 'subagent_create')
+            return this.#createSubagent(invocation.projectId, agentId, input, invocation.signal);
+        if (invocation.capabilityId === 'subagent_message')
+            return this.#messageSubagent(invocation.projectId, agentId, input);
+        if (invocation.capabilityId === 'subagent_broadcast')
+            return this.#broadcast(invocation.projectId, agentId, input);
+        if (invocation.capabilityId === 'subagent_wait') {
+            return this.store.waitForSubagent(invocation.projectId, agentId, text(input.target_agent_id, 'target_agent_id'), optionalInteger(input.timeout_ms) ?? 30000, invocation.signal).then(output);
+        }
+        if (invocation.capabilityId === 'slash_command_list') {
+            return output({ commands: this.registry.list().filter((entry) => entry.kind === 'command').map((entry) => ({ name: `/${entry.id}`, capability_id: entry.id, description: entry.description })) });
+        }
+        if (invocation.capabilityId === 'slash_command_run') {
+            const commandId = text(input.command, 'command').replace(/^\/+/, '');
+            const definition = this.registry.find(commandId);
+            if (definition?.kind !== 'command')
+                fail('SLASH_COMMAND_NOT_FOUND', 404, 'The requested slash command is not registered.');
+            return this.registry.execute({ ...invocation, capabilityId: commandId, arguments: jsonValue(input.arguments ?? {}) });
+        }
+        fail('CAPABILITY_NOT_FOUND', 404, 'The Kernel Capability does not exist.');
+    }
+    #createSubagent(projectId, parentAgentId, input, signal) {
+        const forkContext = input.forkContext;
+        if (forkContext !== 'full' && forkContext !== 'compact' && forkContext !== 'none')
+            fail('INVALID_INPUT', 400, 'forkContext is required.');
+        return this.createSubagent(projectId, {
+            parentAgentId,
+            name: text(input.name, 'name'),
+            forkContext,
+            ...(typeof input.model === 'string' ? { model: input.model } : {}),
+            ...(typeof input.modelReasoningEffort === 'string' ? { modelReasoningEffort: input.modelReasoningEffort } : {}),
+            ...(typeof input.initialPrompt === 'string' ? { initialPrompt: input.initialPrompt } : {}),
+            ...(typeof input.message === 'string' ? { initialMessage: input.message } : {})
+        }, signal).then(output);
+    }
+    #messageSubagent(projectId, sourceAgentId, input) {
+        const targetId = text(input.agent_id, 'agent_id');
+        if (this.store.getAgent(projectId, targetId).parent_agent_id !== sourceAgentId)
+            fail('SUBAGENT_TARGET_INVALID', 422, 'The target is not a direct child Agent.');
+        const message = this.store.enqueueMessage(projectId, targetId, text(input.content, 'content'), sourceAgentId);
+        this.wakeAgent(projectId, targetId);
+        return output(message);
+    }
+    #broadcast(projectId, sourceAgentId, input) {
+        const source = this.store.getAgent(projectId, sourceAgentId);
+        const content = text(input.content, 'content');
+        const targets = this.store.listAgents(projectId, 'task_id', string(source.task_id)).filter((entry) => entry.parent_agent_id === sourceAgentId);
+        const messages = targets.map((target) => {
+            const targetId = string(target.id);
+            const message = this.store.enqueueMessage(projectId, targetId, content, sourceAgentId);
+            this.wakeAgent(projectId, targetId);
+            return message.message;
+        });
+        return output({ messages });
+    }
+}
+export function kernelCapabilities(adapter) {
+    return definitions.map((definition) => ({
+        definition,
+        adapter,
+        manifest: capabilityManifest(definition),
+        claims: () => definition.effect === 'read_only' ? [] : [{ resource: `agent:${definition.id}`, mode: 'write' }]
+    }));
+}
+const stringSchema = { type: 'string', minLength: 1 };
+const integerSchema = { type: 'integer', minimum: 0 };
+const kernelOutputLimits = {
+    programmatic_tool_run: 1048576, system_echo: 1048576, compact: 1048576, slash_command_list: 524288, slash_command_run: 1048576
+};
+const definitions = [
+    definition('capability_search', 'Search capabilities', 'Find and load capabilities available to the Agent.', 'read_only', { query: stringSchema, limit: integerSchema, load: { type: 'array', items: stringSchema } }, ['query']),
+    definition('programmatic_tool_run', 'Run hosted tool program', 'Coordinate frozen capabilities in the Provider hosted program runtime.', 'full', { program: stringSchema, capabilityIds: { type: 'array', items: stringSchema } }, ['program', 'capabilityIds']),
+    definition('system_echo', 'Echo', 'Return the supplied JSON input.', 'read_only', {}, []),
+    definition('update_plan', 'Update plan', 'Replace the Agent plan items.', 'workspace_write', { items: { type: 'array' } }, ['items']),
+    definition('update_todo', 'Update todo', 'Replace the Agent todo items.', 'workspace_write', { items: { type: 'array' } }, ['items']),
+    definition('ask_user', 'Ask user', 'Pause until the user supplies an answer.', 'read_only', {
+        question: stringSchema,
+        options: { type: 'array', maxItems: 100, items: { type: 'object', additionalProperties: false, properties: { label: stringSchema, value: stringSchema, description: { type: 'string' } }, required: ['label', 'value'] } },
+        allow_freeform: { type: 'boolean' },
+        multi_select: { type: 'boolean' }
+    }, ['question']),
+    definition('compact', 'Compact context', 'Append a Context compaction summary.', 'workspace_write', { summary: stringSchema, preserve_from_ordinal: integerSchema }, ['summary', 'preserve_from_ordinal'], 'command'),
+    definition('subagent_create', 'Create subagent', 'Create a child Agent in the same Task.', 'workspace_write', {
+        name: stringSchema,
+        forkContext: { type: 'string', enum: ['full', 'compact', 'none'] },
+        model: stringSchema,
+        modelReasoningEffort: stringSchema,
+        initialPrompt: stringSchema,
+        message: stringSchema
+    }, ['name', 'forkContext']),
+    definition('subagent_message', 'Message subagent', 'Send a copied Message to one child Agent.', 'workspace_write', { agent_id: stringSchema, content: stringSchema }, ['agent_id', 'content']),
+    definition('subagent_broadcast', 'Broadcast to subagents', 'Send a copied Message to every direct child Agent.', 'workspace_write', { content: stringSchema }, ['content']),
+    definition('subagent_wait', 'Wait for subagent', 'Wait for a Subagent message or terminal state.', 'read_only', { target_agent_id: stringSchema, timeout_ms: { type: 'integer', minimum: 1, maximum: 120000 } }, ['target_agent_id']),
+    definition('slash_command_list', 'List slash commands', 'List available control commands.', 'read_only', {}, []),
+    definition('slash_command_run', 'Run slash command', 'Run a control command.', 'workspace_write', { command: stringSchema }, ['command'])
+];
+function definition(id, title, description, effect, properties, required, kind = 'tool') {
+    return { id, title, description, effect, adapterId: 'kernel', loadMode: 'eager', outputLimitBytes: kernelOutputLimits[id] ?? 262144, defaultAssignment: 'all_new_agents', kind, inputSchema: { type: 'object', additionalProperties: true, properties, required } };
+}
+function output(content) {
+    return Promise.resolve({ content: content });
+}
+function object(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        fail('INVALID_INPUT', 400, 'Capability input must be an object.');
+    return value;
+}
+function text(value, field) {
+    if (typeof value !== 'string' || value.length === 0)
+        fail('INVALID_INPUT', 400, `${field} must be a non-empty string.`);
+    return value;
+}
+function integer(value, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        fail('INVALID_INPUT', 400, `${field} must be a non-negative integer.`);
+    return value;
+}
+function optionalInteger(value) {
+    return value === undefined ? undefined : integer(value, 'limit');
+}
+function optionalStrings(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+        fail('INVALID_INPUT', 400, 'load must be a string array.');
+    return value;
+}
+function string(value) {
+    if (typeof value !== 'string')
+        fail('DATABASE_CORRUPT', 503, 'Agent data is invalid.');
+    return value;
+}

package/dist/runtime/manifests.d.ts

@@ -0,0 +1,14 @@
+import { type AdapterManifest, type AdapterPlatform, type AdapterRuntime, type CapabilityDefinition, type EffectScope } from '../core/domain.js';
+import { type HarnessConfig } from '../config/schema.js';
+export interface AdapterTarget {
+    readonly platform: AdapterPlatform;
+    readonly runtime: AdapterRuntime;
+}
+export declare function adapterTarget(runtime: AdapterRuntime): AdapterTarget;
+export declare function capabilityManifest(definition: CapabilityDefinition, effectScopes?: readonly EffectScope[]): AdapterManifest;
+export declare function providerManifest(config: HarnessConfig, providerId: string): AdapterManifest;
+export declare function coreManifests(config: HarnessConfig): readonly AdapterManifest[];
+export declare function assertCapabilityManifest(manifest: AdapterManifest, definition: CapabilityDefinition, target: AdapterTarget): void;
+export declare function assertProviderManifest(manifest: AdapterManifest, reference: string, target: AdapterTarget): void;
+export declare function assertManifestSet(manifests: readonly AdapterManifest[], target: AdapterTarget): void;
+export declare function manifestSetDigest(manifests: readonly AdapterManifest[], target: AdapterTarget): string;