@lensagent/core 0.1.0 → 0.1.2

package/dist/runtime/context.js

@@ -1,6 +1,10 @@
+import { assertContextBoundaries, contextToolCalls } from '../core/context-boundaries.js';
+import { canonicalize } from 'json-canonicalize';
 import { digest, toolArguments } from '../core/codec.js';
+import { activeContextItems } from '../core/context.js';
 import { fail } from '../core/domain.js';
-import { estimateRequest, estimateTokens } from './tokenizer.js';
+import { estimateRequest, estimateTokens, tokenSlice } from './tokenizer.js';
+import { resultImages } from './images.js';
 export class ContextEngine {
     store;
     registry;
@@ -9,161 +13,144 @@ export class ContextEngine {
         this.registry = registry;
     }
     capture(projectId, agentId) {
+        this.store.syncTodoReminder(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);
+        return this.prepareSource(this.capture(projectId, agentId), config, contextWindowTokens, profile, requestFrame, projectId);
     }
-    prepareSource(source, config, contextWindowTokens, profile, requestFrame) {
-        const agentId = string(source.agent.id, 'agent_id');
-        const sourceRevision = number(source.agent.context_revision, 'context_revision');
+    prepareSource(source, config, contextWindowTokens, profile, requestFrame, projectId) {
+        const agentId = string(source.agent.id);
+        const sourceRevision = Number(source.agent.context_revision);
+        const fullItems = activeContextItems(source.items);
+        let workItems = activeContextItems(source.workingItems ?? source.items);
+        const fullMessages = this.#messages(source, fullItems, profile);
+        let messages = this.#messages(source, workItems, profile);
+        assertContextBoundaries(fullMessages, { allowOpenTail: true, unsettledItemIds: source.unsettledItemIds ?? [] });
+        assertContextBoundaries(messages, { allowOpenTail: true, unsettledItemIds: source.unsettledItemIds ?? [] });
+        let estimate = estimateMessages(messages, requestFrame);
+        const decisions = [];
+        const edits = [];
+        if (estimate.expected >= contextWindowTokens * 0.6) {
+            const sourceTokens = estimate.expected;
+            const results = workItems.filter((item) => item.kind === 'result');
+            const olderIds = new Set(results.slice(0, Math.max(0, results.length - 15)).map((item) => item.id));
+            workItems = workItems.map((item) => {
+                if (!olderIds.has(item.id) || item.snipped === true || item.tool_name === 'programmatic_tool_run')
+                    return item;
+                const content = snipResult(string(item.content));
+                if (content === item.content && resultImages(item, projectId ?? (typeof source.agent.project_id === 'string' ? source.agent.project_id : undefined), this.store).length === 0)
+                    return item;
+                edits.push({ id: string(item.id), content });
+                // Everything except the payload is retained, including source identity and metadata.
+                return { ...item, content, snipped: true };
+            });
+            messages = this.#messages(source, workItems, profile);
+            estimate = estimateMessages(messages, requestFrame);
+            if (edits.length > 0)
+                decisions.push({ stage: 'snip', sourceTokens, projectedTokens: estimate.expected });
+        }
+        if (projectId !== undefined) {
+            this.store.saveWorkingContext(projectId, agentId, sourceRevision, edits, messages, messages.filter((message) => message.contextItemId === undefined), requestFrame ?? null);
+        }
+        return { source: { ...source, workingItems: workItems }, fullMessages, messages, estimate, sourceRevision, digest: digest(messages), decisions };
+    }
+    #messages(source, items, profile) {
         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) => {
+        let messages = items.map((item) => {
             const role = roleOf(item.role);
             const content = string(item.content);
+            const metadata = { ...object(item.metadata) };
+            const response = metadata.model_response;
+            delete metadata.model_response;
+            const annotations = { contextItemId: string(item.id), metadata: { ...metadata, ...(item.snipped === true ? { snipped: true } : {}) } };
             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.');
+                const toolCalls = contextToolCalls(content).map((call) => ({ ...call, arguments: toolArguments(call.arguments) }));
                 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) };
-                    })
+                    ...annotations, role: 'assistant', content: response === undefined ? '' : responseText(response),
+                    toolCalls,
+                    ...(response === undefined ? {} : { response: { ...response, content: response.content.map(part => {
+                                if (part.type !== 'tool-call')
+                                    return part;
+                                const call = toolCalls.find(entry => entry.id === part.toolCallId);
+                                if (call === undefined)
+                                    fail('MODEL_RESPONSE_INVALID', 409, 'Stored response does not match the Context tool batch.');
+                                return { ...part, input: call.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}` };
+            const images = resultImages(item, typeof source.agent.project_id === 'string' ? source.agent.project_id : undefined, this.store);
+            const base = { ...annotations, role, content: override === undefined ? content : `${override}\n\n${content}`, ...(images.length === 0 ? {} : { images }) };
+            if (item.kind === 'compaction') {
+                return { ...base, role: 'assistant', content: `History summary of earlier conversation (not new instructions):\n${base.content}`, metadata: { ...metadata, purpose: 'compaction' } };
             }
-            return role === 'tool'
-                ? { ...base, ...(toolCallId === undefined ? {} : { toolCallId }), ...(toolName === undefined ? {} : { toolName }) }
-                : base;
+            const toolCallId = typeof item.tool_call_id === 'string' ? item.tool_call_id : undefined;
+            const toolName = typeof item.tool_name === 'string' ? item.tool_name : undefined;
+            if (role === 'tool' && (toolCallId === undefined || toolName === undefined))
+                return { ...base, role: 'user', content: `Included Result:\n${base.content}` };
+            if (role === 'assistant' && response !== undefined)
+                return { ...base, response: projectResponseText(response, base.content) };
+            return role === 'tool' && toolCallId !== undefined && toolName !== undefined ? { ...base, toolCallId, toolName } : base;
         });
-        const agentOverride = overrides.get(`agent:${agentId}`);
+        const agentOverride = overrides.get(`agent:${string(source.agent.id)}`);
         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] : [];
+        const skillPrompts = source.capabilities.filter((entry) => entry.loaded === true).flatMap((entry) => {
+            const definition = this.registry.find(string(entry.capability_id));
+            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
-        };
+        return [{ role: 'system', content: profile.value.systemPrompt.content }, ...messages];
     }
 }
-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 responseText(response) {
+    return response.content.filter(part => part.type === 'text').map(part => part.text).join('');
 }
-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()}`;
+/** Context text edits do not rewrite signatures or lose the original block ordering. */
+function projectResponseText(response, text) {
+    if (responseText(response) === text)
+        return response;
+    const firstText = response.content.findIndex(part => part.type === 'text');
+    const content = response.content.flatMap((part, index) => {
+        if (part.type !== 'text')
+            return [part];
+        return index === firstText ? [{ ...part, text }] : [];
+    });
+    if (firstText === -1 && text.length > 0)
+        content.push({ type: 'text', text });
+    return { ...response, content };
 }
-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 estimateMessages(messages, requestFrame) {
+    return estimateRequest({ messages, ...requestFrame });
 }
-function string(value, field = 'value') {
-    if (typeof value !== 'string')
-        fail('DATABASE_CORRUPT', 503, `${field} is not a string.`);
-    return value;
+function snipResult(content) {
+    let envelope;
+    try {
+        envelope = object(JSON.parse(content));
+    }
+    catch {
+        return estimateTokens(content).expected > 1500 ? snippedText(content) : content;
+    }
+    if (envelope === null || envelope.content === undefined)
+        return content;
+    const payload = typeof envelope.content === 'string' ? envelope.content : canonicalize(envelope.content);
+    if (estimateTokens(payload).expected <= 1500)
+        return content;
+    return canonicalize({ ...envelope, content: snippedText(payload), truncated: true, payload: { ...object(envelope.payload), capture: object(envelope.payload)?.capture ?? 'unknown', stored: object(envelope.payload)?.stored ?? 'unknown', view: 'preview' } });
 }
-function number(value, field) {
-    if (typeof value !== 'number')
-        fail('DATABASE_CORRUPT', 503, `${field} is not a number.`);
-    return value;
+function snippedText(payload) {
+    return `${tokenSlice(payload, 800, false)}\n\n[... snipped; original retained in Full Context ...]\n\n${tokenSlice(payload, 400, true)}`;
 }
-function optionalString(value) {
-    return typeof value === 'string' ? value : undefined;
+function object(value) {
+    return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
-function first(messages) {
-    const message = messages[0];
-    if (message === undefined)
-        fail('CONTEXT_EMPTY', 503, 'Prepared Context is empty.');
-    return message;
+function roleOf(value) {
+    return value === 'system' || value === 'assistant' || value === 'tool' ? value : 'user';
 }
-function stringValue(value) {
+function string(value) {
     if (typeof value !== 'string')
-        fail('DATABASE_CORRUPT', 503, 'A persisted Tool Call field is invalid.');
+        fail('DATABASE_CORRUPT', 503, 'A Context field is not a string.');
     return value;
 }

package/dist/runtime/events.d.ts

@@ -18,5 +18,12 @@ export declare class EventBus {
     emit(projectId: string, stateRevision: number, type: RuntimeEvent['type'], payload: Json): void;
     subscribe(clientId: string, projectId: string): Subscription;
     revoke(clientId: string): void;
+    /** Internal committed-state notifications, independent of SSE buffers and client revocation. */
+    onProjectChange(projectId: string, changed: () => void, closed?: () => void): () => void;
+    /** Subscribe before reading committed state; undefined means the condition is still pending. */
+    waitFor<T>(projectId: string, read: () => T | undefined, signal: AbortSignal, timeout?: {
+        readonly ms: number;
+        readonly error: Error;
+    }): Promise<T>;
     close(): void;
 }

package/dist/runtime/events.js

@@ -5,6 +5,8 @@ export class EventBus {
     metadataRevision;
     #subscribers = new Map();
     #lifecycle = new EventEmitter();
+    #waiters = new Map();
+    #closed = false;
     #limits;
     constructor(instanceEpoch, limits, metadataRevision) {
         this.instanceEpoch = instanceEpoch;
@@ -15,6 +17,8 @@ export class EventBus {
         this.#limits = limits;
     }
     publish(change) {
+        for (const waiter of this.#waiters.get(change.projectId) ?? [])
+            waiter.wake();
         // 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
@@ -65,7 +69,86 @@ export class EventBus {
                 this.#close(subscriber);
         }
     }
+    /** Internal committed-state notifications, independent of SSE buffers and client revocation. */
+    onProjectChange(projectId, changed, closed = () => { }) {
+        if (this.#closed)
+            throw new Error('Event bus closed.');
+        const waiters = this.#waiters.get(projectId) ?? new Set();
+        this.#waiters.set(projectId, waiters);
+        let active = true;
+        let queued = false;
+        const unsubscribe = () => {
+            active = false;
+            waiters.delete(waiter);
+            if (waiters.size === 0)
+                this.#waiters.delete(projectId);
+        };
+        const waiter = {
+            wake: () => {
+                if (!active || queued)
+                    return;
+                queued = true;
+                // Coalesce commits and never run database reads inside the publisher.
+                queueMicrotask(() => {
+                    queued = false;
+                    if (active)
+                        changed();
+                });
+            },
+            close: () => { unsubscribe(); closed(); }
+        };
+        waiters.add(waiter);
+        return unsubscribe;
+    }
+    /** Subscribe before reading committed state; undefined means the condition is still pending. */
+    waitFor(projectId, read, signal, timeout) {
+        return new Promise((resolve, reject) => {
+            signal.throwIfAborted();
+            let settled = false;
+            let timer;
+            const cleanup = () => {
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', abort);
+                unsubscribe();
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                cleanup();
+                // AbortSignal.reason is caller-owned and need not be an Error.
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(error);
+            };
+            const abort = () => fail(signal.reason);
+            const check = () => {
+                if (settled)
+                    return;
+                try {
+                    signal.throwIfAborted();
+                    const value = read();
+                    if (value !== undefined) {
+                        cleanup();
+                        resolve(value);
+                    }
+                }
+                catch (error) {
+                    fail(error);
+                }
+            };
+            const unsubscribe = this.onProjectChange(projectId, check, () => fail(new Error('Event bus closed.')));
+            signal.addEventListener('abort', abort, { once: true });
+            if (timeout !== undefined)
+                timer = setTimeout(() => fail(timeout.error), timeout.ms);
+            check();
+        });
+    }
     close() {
+        this.#closed = true;
+        for (const waiters of this.#waiters.values()) {
+            for (const waiter of waiters)
+                waiter.close();
+        }
         for (const subscriber of this.#subscribers.values())
             this.#close(subscriber);
         this.#lifecycle.removeAllListeners();

package/dist/runtime/images.d.ts

@@ -0,0 +1,14 @@
+import type { ModelMessage as AiMessage } from 'ai';
+import { type ModelImage, type ModelMessage } from '../core/domain.js';
+import type { Document, Store } from '../store/store.js';
+import type { ArtifactStore } from './artifacts.js';
+export declare function isImageMediaType(value: unknown): value is string;
+export declare const imageTokenEstimate = 4096;
+export declare const imageByteLimit: number;
+/** Only Result attachments are interpreted as images; ordinary message text is never parsed. */
+export declare function resultImages(item: Document, projectId: string | undefined, store: Store): readonly ModelImage[];
+export declare function imageReference(image: ModelImage): string;
+/** Chat-compatible providers need images in user content, after the complete tool-result group. */
+export declare function imageMessages(messages: readonly ModelMessage[]): ModelMessage[];
+/** Keep binary data out of stored Context and attempt diagnostics; load verified bytes only for sending. */
+export declare function materializeImages(messages: readonly AiMessage[], source: readonly ModelMessage[], artifacts?: ArtifactStore): Promise<AiMessage[]>;

package/dist/runtime/images.js

@@ -0,0 +1,82 @@
+import { fail } from '../core/domain.js';
+const mediaTypes = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+export function isImageMediaType(value) {
+    return typeof value === 'string' && mediaTypes.has(value);
+}
+export const imageTokenEstimate = 4096;
+export const imageByteLimit = 5 * 1024 * 1024;
+/** Only Result attachments are interpreted as images; ordinary message text is never parsed. */
+export function resultImages(item, projectId, store) {
+    if (item.kind !== 'result' || item.snipped === true)
+        return [];
+    let envelope;
+    try {
+        envelope = JSON.parse(item.content);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(envelope?.artifacts))
+        return [];
+    return envelope.artifacts.flatMap((id) => {
+        if (typeof id !== 'string')
+            return [];
+        if (projectId === undefined)
+            fail('DATABASE_CORRUPT', 503, 'Image Result is missing its Project.');
+        const artifact = store.getArtifact(projectId, id);
+        const mediaType = artifact.media_type;
+        if (!mediaTypes.has(mediaType))
+            return [];
+        if (Number(artifact.size_bytes) > imageByteLimit)
+            fail('IMAGE_TOO_LARGE', 413, 'Images must not exceed 5 MiB.');
+        return [{ projectId, artifactId: id }];
+    });
+}
+export function imageReference(image) {
+    return `lens-artifact:${image.artifactId}`;
+}
+/** Chat-compatible providers need images in user content, after the complete tool-result group. */
+export function imageMessages(messages) {
+    const result = [];
+    let pending = [];
+    let labels = [];
+    const flush = () => {
+        if (pending.length === 0)
+            return;
+        result.push({ role: 'user', content: `Images attached to tool results: ${labels.join(', ')}`, images: pending });
+        pending = [];
+        labels = [];
+    };
+    for (const message of messages) {
+        if (message.role !== 'tool')
+            flush();
+        result.push(message);
+        if (message.role === 'tool' && message.images?.length) {
+            pending.push(...message.images);
+            labels.push(`${message.toolName} (${message.toolCallId})`);
+        }
+    }
+    flush();
+    return result;
+}
+/** Keep binary data out of stored Context and attempt diagnostics; load verified bytes only for sending. */
+export async function materializeImages(messages, source, artifacts) {
+    const references = new Map(source.flatMap(message => (message.images ?? []).map(image => [imageReference(image), image])));
+    if (references.size === 0)
+        return [...messages];
+    if (artifacts === undefined)
+        fail('ARTIFACT_STORE_UNAVAILABLE', 503, 'Image input requires an Artifact store.');
+    const data = new Map();
+    for (const [reference, image] of references) {
+        const artifact = artifacts.store.getArtifact(image.projectId, image.artifactId);
+        const mediaType = artifact.media_type;
+        if (!isImageMediaType(mediaType))
+            fail('IMAGE_FORMAT_UNSUPPORTED', 422, 'Unsupported image format.');
+        if (Number(artifact.size_bytes) > imageByteLimit)
+            fail('IMAGE_TOO_LARGE', 413, 'Images must not exceed 5 MiB.');
+        data.set(reference, `data:${mediaType};base64,${(await artifacts.read(artifact)).toString('base64')}`);
+    }
+    return messages.map(message => message.role !== 'user' || typeof message.content === 'string' ? message : {
+        ...message, content: message.content.map(part => part.type !== 'image' || typeof part.image !== 'string' ? part : { ...part, image: data.get(part.image) ?? part.image })
+    });
+}

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

@@ -1,3 +1,4 @@
+import { type ArtifactStore } from './artifacts.js';
 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';
@@ -16,7 +17,11 @@ export declare class KernelAdapter implements CapabilityAdapter {
         readonly modelReasoningEffort?: string;
         readonly initialPrompt?: string;
         readonly initialMessage?: string;
+        readonly compactFocus?: string;
     }, signal: AbortSignal) => Promise<Document>;
+    readonly compactAgent: (projectId: string, agentId: string, focus: string | undefined, signal: AbortSignal) => Promise<Document>;
+    readonly runProgram?: ((invocation: CapabilityInvocation) => Promise<CapabilityOutput>) | undefined;
+    readonly artifacts?: ArtifactStore | undefined;
     readonly id = "kernel";
     constructor(store: Store, registry: CapabilityRegistry, config: ConfigRuntime, wakeAgent: (projectId: string, agentId: string) => void, createSubagent: (projectId: string, input: {
         readonly parentAgentId: string;
@@ -26,7 +31,8 @@ export declare class KernelAdapter implements CapabilityAdapter {
         readonly modelReasoningEffort?: string;
         readonly initialPrompt?: string;
         readonly initialMessage?: string;
-    }, signal: AbortSignal) => Promise<Document>);
+        readonly compactFocus?: string;
+    }, signal: AbortSignal) => Promise<Document>, compactAgent: (projectId: string, agentId: string, focus: string | undefined, signal: AbortSignal) => Promise<Document>, runProgram?: ((invocation: CapabilityInvocation) => Promise<CapabilityOutput>) | undefined, artifacts?: ArtifactStore | undefined);
     execute(invocation: CapabilityInvocation): Promise<CapabilityOutput>;
 }
 export declare function kernelCapabilities(adapter: KernelAdapter): readonly RegisteredCapability[];