@lensagent/core 0.1.0 → 0.1.2

package/dist/runtime/calls.js

@@ -1,6 +1,7 @@
 import { LensError, UserInputRequiredError, fail } from '../core/domain.js';
 import { McpElicitationError } from '../adapters/mcp.js';
-import { normalizeOutput } from './results.js';
+import { storeOutput } from './results.js';
+import { digest } from '../core/codec.js';
 export class CallRuntime {
     store;
     registry;
@@ -9,6 +10,8 @@ export class CallRuntime {
     events;
     #running = new Map();
     #controllers = new Map();
+    #closed = false;
+    #failure;
     constructor(store, registry, scheduler, artifacts, events) {
         this.store = store;
         this.registry = registry;
@@ -17,13 +20,27 @@ export class CallRuntime {
         this.events = events;
     }
     dispatch(projectId, callId, parentSignal) {
+        if (this.#closed)
+            fail('CALL_RUNTIME_CLOSED', 503, 'The Call runtime is closed.');
         if (this.#running.has(callId))
             return;
         const controller = new AbortController();
-        parentSignal?.addEventListener('abort', () => controller.abort(parentSignal.reason), { once: true });
+        const abort = () => controller.abort(parentSignal?.reason);
+        if (parentSignal?.aborted === true)
+            abort();
+        else
+            parentSignal?.addEventListener('abort', abort, { once: true });
         this.#controllers.set(callId, controller);
         const running = this.#execute(projectId, callId, controller.signal)
+            .catch((error) => {
+            this.#failure ??= error;
+            this.#closed = true;
+            for (const active of this.#controllers.values())
+                active.abort(error);
+            this.store.observability?.record('runtime', 'call_dispatch', 'failed', 0, { error_code: errorCode(error) });
+        })
             .finally(() => {
+            parentSignal?.removeEventListener('abort', abort);
             this.#running.delete(callId);
             this.#controllers.delete(callId);
         });
@@ -36,72 +53,173 @@ export class CallRuntime {
         return decision;
     }
     async waitAll(projectId, callIds, signal) {
-        while (!signal.aborted) {
+        return this.events.waitFor(projectId, () => {
             const calls = callIds.map((callId) => this.store.getCall(projectId, callId));
-            if (calls.every((call) => call.state === 'TERMINAL'))
-                return calls;
-            await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-        throw signal.reason;
+            return calls.every((call) => call.state === 'TERMINAL') ? calls : undefined;
+        }, signal);
     }
-    async close() {
+    async close(projectId) {
+        this.#closed = true;
+        if (projectId !== undefined) {
+            try {
+                this.store.interruptProjectCalls(projectId);
+            }
+            catch (error) {
+                this.#failure ??= error;
+            }
+        }
         for (const controller of this.#controllers.values())
             controller.abort(new Error('Call runtime closed.'));
         await Promise.allSettled(this.#running.values());
+        if (this.#failure !== undefined) {
+            throw this.#failure instanceof Error ? this.#failure : new Error('The Call runtime failed.', { cause: this.#failure });
+        }
     }
     async #execute(projectId, callId, signal) {
-        let call = this.store.getCall(projectId, callId);
-        if (call.state !== 'QUEUED')
-            return;
         let acquired = false;
+        let unsubscribeParent;
         try {
-            const capabilityId = string(call.capability_id);
-            const definition = this.registry.get(capabilityId);
-            // Every Workspace in the Project, the Call's own first. A Project is one working set: an
-            // Agent bound to one folder can still read and search the others, which is what makes a Skill
-            // in one Workspace able to act on data in another.
-            const workspacePaths = this.store.projectWorkspacePaths(projectId, string(call.workspace_id));
-            const argumentsValue = jsonValue(call.input);
-            const validationArguments = originalArguments(argumentsValue);
-            const claims = this.registry.claims(capabilityId, { projectId, workspaceId: string(call.workspace_id), workspacePaths, arguments: validationArguments });
-            const executionSignal = await this.scheduler.acquire(callId, definition.adapterId, optionalString(call.step_id) ?? null, claims, () => { call = this.store.startCall(projectId, callId); }, signal);
-            acquired = true;
-            const output = await this.registry.execute({
-                callId,
-                projectId,
-                agentId: optionalString(call.agent_id) ?? null,
-                capabilityId,
-                arguments: capabilityId === 'ask_user' || capabilityId.startsWith('mcp:') ? argumentsValue : validationArguments,
-                workspacePaths,
-                workspaceId: string(call.workspace_id),
-                ...(call.policy === 'full_access' ? { fullAccess: true } : {}),
-                signal: executionSignal
-            }, validationArguments);
-            const normalized = normalizeOutput(output, definition.outputLimitBytes);
-            const artifactIds = await this.artifacts.save(projectId, normalized.artifacts);
-            if (this.store.getCall(projectId, callId).state === 'RUNNING') {
-                const outcome = output.outcome ?? 'success';
-                this.store.completeCall(projectId, callId, outcome, normalized.content, outcome === 'failed' ? output.errorCode ?? 'CAPABILITY_FAILED' : null, null, artifactIds, normalized.truncated);
+            let call = this.store.getCall(projectId, callId);
+            if (call.state !== 'QUEUED')
+                return;
+            if (typeof call.parent_call_id === 'string') {
+                const parentId = call.parent_call_id;
+                unsubscribeParent = this.events.onProjectChange(projectId, () => {
+                    try {
+                        if (this.store.getCall(projectId, parentId).state !== 'RUNNING') {
+                            this.#controllers.get(callId)?.abort(new Error('The parent Call stopped.'));
+                        }
+                    }
+                    catch (error) {
+                        this.#controllers.get(callId)?.abort(error);
+                    }
+                });
+            }
+            for (;;) {
+                call = await this.events.waitFor(projectId, () => {
+                    const current = this.store.getCall(projectId, callId);
+                    if (current.state !== 'QUEUED')
+                        return current;
+                    const admission = this.store.callAdmission(projectId, callId);
+                    this.#validateCall(projectId, current);
+                    return admission === 'blocked' ? undefined : current;
+                }, signal);
+                if (call.state !== 'QUEUED')
+                    return;
+                const capabilityId = string(call.capability_id);
+                const definition = this.registry.get(capabilityId);
+                // Every Workspace in the Project, the Call's own first. A Project is one working set: an
+                // Agent bound to one folder can still read and search the others, which is what makes a Skill
+                // in one Workspace able to act on data in another.
+                const workspacePaths = this.store.projectWorkspacePaths(projectId, string(call.workspace_id));
+                const argumentsValue = jsonValue(call.input);
+                const validationArguments = argumentsValue;
+                const continuation = call.continuation;
+                const claims = this.registry.claims(capabilityId, { projectId, workspaceId: string(call.workspace_id), workspacePaths, arguments: validationArguments });
+                let executionSignal = signal;
+                signal.throwIfAborted();
+                const start = () => {
+                    call = this.store.startCall(projectId, callId, (current) => {
+                        signal.throwIfAborted();
+                        this.#validateCall(projectId, current);
+                    });
+                };
+                try {
+                    if (capabilityId === 'programmatic_tool_run' || capabilityId === 'subagent_wait') {
+                        // Coordinators must not occupy a tool lease while waiting for other work.
+                        start();
+                    }
+                    else {
+                        executionSignal = await this.scheduler.acquire(callId, definition.adapterId, optionalString(call.step_id) ?? null, claims, start, signal);
+                        acquired = true;
+                    }
+                }
+                catch (error) {
+                    if (!signal.aborted && error instanceof LensError && error.code === 'CALL_BLOCKED')
+                        continue;
+                    throw error;
+                }
+                const output = await this.registry.execute({
+                    callId,
+                    ...(typeof call.agent_id === 'string' ? { taskId: string(this.store.getAgent(projectId, call.agent_id).task_id) } : {}),
+                    projectId,
+                    agentId: optionalString(call.agent_id) ?? null,
+                    capabilityId,
+                    arguments: argumentsValue,
+                    ...(continuation == null ? {} : { continuation }),
+                    workspacePaths,
+                    workspaceId: string(call.workspace_id),
+                    ...(call.policy === 'full_access' ? { fullAccess: true } : {}),
+                    signal: executionSignal
+                }, validationArguments);
+                if (signal.aborted) {
+                    this.store.interruptCall(projectId, callId, 'CALL_CANCELLED', 'The Call was stopped and will not be resumed.');
+                    return;
+                }
+                if (this.store.getCall(projectId, callId).state !== 'RUNNING')
+                    return;
+                // Local program calls return their raw content to the program, not a Context preview.
+                const normalized = call.source === 'program' || capabilityId === 'programmatic_tool_run'
+                    ? (output.artifacts?.length ?? 0) + (output.artifactReferences?.length ?? 0) > 0
+                        ? await storeOutput(projectId, output, this.artifacts, false)
+                        : { content: output.content, artifacts: [], truncated: false }
+                    : await storeOutput(projectId, output, this.artifacts);
+                if (this.store.getCall(projectId, callId).state === 'RUNNING') {
+                    const outcome = output.outcome ?? 'success';
+                    this.store.completeCall(projectId, callId, outcome, normalized.content, outcome === 'failed' ? output.errorCode ?? 'CAPABILITY_FAILED' : null, null, normalized.artifacts, normalized.truncated, output.capture ?? 'unknown', 'full');
+                }
+                return;
             }
         }
         catch (error) {
             let current = this.store.getCall(projectId, callId);
-            if (current.state === 'QUEUED')
-                current = this.store.startCall(projectId, callId);
-            if (current.state === 'RUNNING' && (error instanceof McpElicitationError || error instanceof UserInputRequiredError)) {
+            if (signal.aborted) {
+                this.store.interruptCall(projectId, callId, 'CALL_CANCELLED', 'The Call was stopped and will not be resumed.');
+            }
+            else if (current.state === 'QUEUED') {
+                this.store.failQueuedCall(projectId, callId, errorCode(error), error instanceof Error ? error.message : String(error), current.capability_id === 'programmatic_tool_run' || current.source === 'program'
+                    ? { error_code: errorCode(error), error_message: error instanceof Error ? error.message : String(error) } : {});
+            }
+            else if (current.state === 'RUNNING' && (error instanceof McpElicitationError || error instanceof UserInputRequiredError)) {
                 current = this.store.waitCall(projectId, callId, error.prompt);
                 this.events.emit(projectId, this.store.stateRevision(), 'attention.required', { code: 'CALL_WAITING_USER', entity_type: 'call', entity_id: callId, agent_id: current.agent_id ?? null });
             }
             else if (current.state === 'RUNNING') {
-                const cancelled = signal.aborted;
-                this.store.completeCall(projectId, callId, cancelled ? 'cancelled' : 'failed', {}, cancelled ? 'CALL_CANCELLED' : errorCode(error), error instanceof Error ? error.message : String(error));
+                this.store.completeCall(projectId, callId, 'failed', current.capability_id === 'programmatic_tool_run' ? { error_code: errorCode(error), error_message: error instanceof Error ? error.message : String(error) } : {}, errorCode(error), error instanceof Error ? error.message : String(error));
             }
         }
         finally {
+            unsubscribeParent?.();
             if (acquired)
                 this.scheduler.release(callId);
         }
     }
+    #validateCall(projectId, call) {
+        if (typeof call.attempt_id !== 'string' || typeof call.agent_id !== 'string')
+            return;
+        const capabilityId = string(call.capability_id);
+        const attempt = this.store.getAttempt(projectId, call.attempt_id);
+        if (attempt.agent_id !== call.agent_id || attempt.step_id !== call.step_id) {
+            fail('CALL_ATTEMPT_INVALID', 409, 'The Call does not belong to its model attempt.');
+        }
+        const capabilities = Array.isArray(attempt.capabilities) ? attempt.capabilities : [];
+        const frozen = capabilities.find(entry => jsonObject(entry) && entry.capability_id === capabilityId);
+        if (frozen === undefined || !jsonObject(frozen)) {
+            fail('CAPABILITY_NOT_LOADED', 403, 'The Capability is outside the frozen model attempt.');
+        }
+        const definition = this.registry.get(capabilityId);
+        if (digest(frozen.schema ?? null) !== digest(definition.inputSchema)) {
+            fail('CAPABILITY_MANIFEST_CHANGED', 409, 'The Capability input Schema changed after the model attempt.');
+        }
+        const assignment = this.store.getCapabilityAssignment(projectId, call.agent_id, capabilityId);
+        if (assignment.loaded !== true)
+            fail('CAPABILITY_NOT_LOADED', 403, 'The Capability is no longer loaded.');
+        if (assignment.policy !== call.policy)
+            fail('CALL_POLICY_CHANGED', 403, 'The Capability policy changed after the Call was authorized.');
+        if (this.registry.effect(capabilityId, jsonValue(call.input)) !== call.effect) {
+            fail('CAPABILITY_MANIFEST_CHANGED', 409, 'The Capability effect changed after the Call was authorized.');
+        }
+    }
 }
 function errorCode(error) {
     if (error instanceof LensError)
@@ -123,8 +241,6 @@ function jsonValue(value) {
         fail('DATABASE_CORRUPT', 503, 'Call input is missing.');
     return value;
 }
-function originalArguments(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return value;
-    return 'arguments' in value && ('answer' in value || 'prompt' in value) ? value.arguments : value;
+function jsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/runtime/capabilities.d.ts

@@ -45,12 +45,12 @@ export declare class CapabilityRegistry {
      * values for the same global field, and the handshake check comparing readiness against
      * `subscription.ready` could never pass for a Project whose Skills differed from the default
      * one's: a permanent resync loop rather than a transient mismatch. A changed Skill is still
-     * visible through `metadata_revision` and the Agent's Assignment digest.
+     * visible through `project_capabilities_digest` and Project-scoped Snapshot invalidation.
      */
     contractManifests(): readonly AdapterManifest[];
     get(capabilityId: string): CapabilityDefinition;
     find(capabilityId: string): CapabilityDefinition | undefined;
-    search(query: string, limit: number): readonly CapabilityDefinition[];
+    search(query: string): readonly CapabilityDefinition[];
     claims(capabilityId: string, context: ClaimContext): readonly ResourceClaim[];
     effect(capabilityId: string, argumentsValue: Json): EffectScope;
     execute(invocation: CapabilityInvocation, validationArguments?: Json): Promise<CapabilityOutput>;

package/dist/runtime/capabilities.js

@@ -76,7 +76,7 @@ export class CapabilityRegistry {
      * values for the same global field, and the handshake check comparing readiness against
      * `subscription.ready` could never pass for a Project whose Skills differed from the default
      * one's: a permanent resync loop rather than a transient mismatch. A changed Skill is still
-     * visible through `metadata_revision` and the Agent's Assignment digest.
+     * visible through `project_capabilities_digest` and Project-scoped Snapshot invalidation.
      */
     contractManifests() {
         const contract = new Set(this.list().filter((definition) => definition.kind !== 'skill').map((definition) => definition.id));
@@ -88,13 +88,12 @@ export class CapabilityRegistry {
     find(capabilityId) {
         return this.#entries.get(capabilityId)?.definition;
     }
-    search(query, limit) {
+    search(query) {
         const words = query.toLowerCase().split(/\s+/).filter(Boolean);
         return this.list()
             .map((entry) => ({ entry, score: words.reduce((score, word) => score + `${entry.id} ${entry.title} ${entry.description}`.toLowerCase().split(word).length - 1, 0) }))
             .filter(({ score }) => score > 0)
             .sort((left, right) => right.score - left.score || left.entry.id.localeCompare(right.entry.id))
-            .slice(0, limit)
             .map(({ entry }) => entry);
     }
     // Any failure to work out the resources falls back to a global write claim: AGENTS.md requires the
@@ -118,10 +117,10 @@ export class CapabilityRegistry {
     async execute(invocation, validationArguments = invocation.arguments) {
         const entry = this.#validated(invocation.capabilityId, validationArguments);
         const output = await entry.adapter.execute(invocation);
-        if (entry.validateOutput !== undefined) {
+        if (entry.validateOutput !== undefined && output.outcome !== 'failed') {
             const content = jsonObject(output.content);
             const structured = content?.structured_content;
-            if (structured !== undefined && !entry.validateOutput(structured)) {
+            if (structured === undefined || !entry.validateOutput(structured)) {
                 fail('RESULT_NORMALIZATION_FAILED', 422, 'Capability output does not match the declared Schema.');
             }
         }

package/dist/runtime/cleanup.d.ts

@@ -1,7 +1,10 @@
 import type { ExecutorClient } from '../adapters/executor.js';
-import type { Document } from '../store/store.js';
+type CleanupExecutor = Pick<ExecutorClient, 'health' | 'deleteCallHistory'>;
+import type { Document, Store } from '../store/store.js';
 import type { ArtifactStore } from './artifacts.js';
-export declare function applyPurge(purged: Document, artifacts: ArtifactStore, executor: ExecutorClient): Promise<{
+export declare function commitPurge(executor: CleanupExecutor, purge: (stateId: string) => Document): Promise<Document>;
+export declare function applyPurge(projectId: string, store: Store, artifacts: ArtifactStore, executor: CleanupExecutor): Promise<{
     readonly deleted: number;
     readonly failed: number;
 }>;
+export {};

package/dist/runtime/cleanup.js

@@ -1,21 +1,52 @@
-import { fail } from '../core/domain.js';
-// The out-of-transaction half of a Task purge. Store#purgeTaskRows deletes the rows and reports what
-// is left over: Artifact files on disk, and the Calls whose file history the Executor still holds
-// (see docs/architecture/harness-level3/09-file-snapshot-storage-decision.md). Neither can happen
-// inside the transaction, which does no file or network I/O.
-//
-// Errors propagate. The purge has already committed and those Call ids no longer exist in SQLite, so
-// a failure here leaks Executor-side history permanently -- the Executor never expires history on
-// its own. Surfacing that once is better than hiding it.
-export async function applyPurge(purged, artifacts, executor) {
-    const paths = purged.orphaned_artifact_paths;
-    if (!Array.isArray(paths) || paths.some((entry) => typeof entry !== 'string'))
-        fail('DATABASE_CORRUPT', 503, 'Task purge returned invalid Artifact paths.');
-    const files = await artifacts.remove(paths);
-    for (const [workspaceId, callIds] of byWorkspace(purged.purged_calls)) {
-        await executor.deleteCallHistory(workspaceId, callIds);
+import { fail, LensError } from '../core/domain.js';
+// Store rejects a purge needing identity inside its transaction, so nothing is committed or
+// published before this fallback. Running it again also rechecks ownership and revisions.
+export async function commitPurge(executor, purge) {
+    try {
+        return purge('');
     }
-    return files;
+    catch (error) {
+        if (!(error instanceof LensError) || error.code !== 'EXECUTOR_IDENTITY_REQUIRED')
+            throw error;
+    }
+    return purge(await executorStateId(executor));
+}
+async function executorStateId(executor) {
+    const health = await executor.health();
+    if (typeof health !== 'object' || health === null || !('state_id' in health) || typeof health.state_id !== 'string' || health.state_id.length === 0) {
+        fail('EXECUTOR_IDENTITY_REQUIRED', 503, 'Executor state identity is unavailable; no Task was purged.');
+    }
+    return health.state_id;
+}
+export async function applyPurge(projectId, store, artifacts, executor) {
+    let deleted = 0;
+    for (const entry of store.pendingPurges(projectId)) {
+        try {
+            if (typeof entry.id !== 'string')
+                fail('DATABASE_CORRUPT', 503, 'Cleanup identity is invalid.');
+            const payload = entry.payload;
+            const calls = byWorkspace(payload.purged_calls);
+            if (calls.size > 0 && await executorStateId(executor) !== entry.executor_state_id)
+                fail('EXECUTOR_STATE_CHANGED', 409, 'The original Executor history store is not connected.');
+            const paths = payload.orphaned_artifact_paths;
+            if (!Array.isArray(paths) || paths.some((path) => typeof path !== 'string'))
+                fail('DATABASE_CORRUPT', 503, 'Task purge returned invalid Artifact paths.');
+            const files = await artifacts.remove(paths);
+            deleted += files.deleted;
+            if (files.failed > 0)
+                fail('ARTIFACT_DELETE_FAILED', 503, 'Some Artifact files could not be removed.');
+            for (const [workspaceId, callIds] of calls)
+                await executor.deleteCallHistory(workspaceId, callIds);
+            store.completePurge(projectId, entry.id);
+        }
+        catch (error) {
+            fail('PURGE_INCOMPLETE', 503, 'Logical deletion is committed; cleanup remains pending. Retry the maintenance command.', {
+                cleanup_id: entry.id ?? null,
+                cause: typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : 'CLEANUP_FAILED'
+            });
+        }
+    }
+    return { deleted, failed: 0 };
 }
 function byWorkspace(value) {
     const grouped = new Map();

package/dist/runtime/compaction.d.ts

@@ -0,0 +1,9 @@
+import { type ModelMessage } from '../core/domain.js';
+import type { HarnessConfig } from '../config/schema.js';
+import type { PreparedContext } from './context.js';
+export declare function compactionThreshold(config: HarnessConfig, reference: string, window: number): number;
+/** Keep at least 5000 estimated tokens, rounded outward to whole messages/tool exchanges. */
+export declare function compactionRange(prepared: PreparedContext): {
+    readonly ids: readonly string[];
+    readonly messages: readonly ModelMessage[];
+};

package/dist/runtime/compaction.js

@@ -0,0 +1,52 @@
+import { assertContextBoundaries } from '../core/context-boundaries.js';
+import { fail } from '../core/domain.js';
+import { estimateRequest } from './tokenizer.js';
+export function compactionThreshold(config, reference, window) {
+    const slash = reference.indexOf('/');
+    const provider = config.providers[reference.slice(0, slash)];
+    const model = provider?.models[reference.slice(slash + 1)];
+    return model?.compactionThresholdTokens ?? provider?.compactionThresholdTokens ?? Math.max(window - 25000, Math.ceil(window * 0.95));
+}
+/** Keep at least 5000 estimated tokens, rounded outward to whole messages/tool exchanges. */
+export function compactionRange(prepared) {
+    const source = new Map(prepared.source.items.map((item) => [item.id, item]));
+    const history = prepared.messages.filter((message) => {
+        const item = source.get(message.contextItemId ?? '');
+        return item !== undefined && !(item.kind === 'message' && item.role === 'system');
+    });
+    const boundaries = assertContextBoundaries(history, { allowOpenTail: true, unsettledItemIds: prepared.source.unsettledItemIds ?? [] });
+    let retained = 0;
+    let naiveCut = history.length;
+    while (naiveCut > 0 && retained < 5000) {
+        naiveCut -= 1;
+        retained += estimateRequest([history[naiveCut]]).expected;
+    }
+    let cut = boundaries.legalCuts.findLast((position) => position <= naiveCut) ?? 0;
+    const legal = new Set(boundaries.legalCuts);
+    // Prefer a nearby real turn boundary. Spend at most one additional tail budget;
+    // an arbitrarily long business turn must never become a hard atomic group.
+    let extraTokens = 0;
+    for (let candidate = cut; candidate > 0; candidate -= 1) {
+        const next = history[candidate];
+        const previous = history[candidate - 1];
+        if (next === undefined || previous === undefined)
+            break;
+        const nextItem = source.get(next.contextItemId ?? '');
+        const previousItem = source.get(previous.contextItemId ?? '');
+        if (legal.has(candidate) && nextItem?.kind === 'message' && next.role === 'user' &&
+            (nextItem.turn_group_id === undefined || nextItem.turn_group_id !== previousItem?.turn_group_id)) {
+            cut = candidate;
+            break;
+        }
+        extraTokens += estimateRequest([previous]).expected;
+        if (extraTokens > 5000)
+            break;
+    }
+    const covered = history.slice(0, cut);
+    if (covered.length === 0)
+        fail('COMPACTION_NOT_NEEDED', 409, 'No complete history block remains before the retained 5000-token tail.');
+    return {
+        ids: covered.map((message) => message.contextItemId),
+        messages: [...prepared.messages.filter((message) => message.contextItemId === undefined || (source.get(message.contextItemId)?.kind === 'message' && message.role === 'system')), ...covered]
+    };
+}

package/dist/runtime/context.d.ts

@@ -1,17 +1,17 @@
 import { type Json, type ModelMessage } from '../core/domain.js';
-import type { Store } from '../store/store.js';
+import type { Store, Document } from '../store/store.js';
 import type { HarnessConfig } from '../config/schema.js';
-import type { Document } from '../store/store.js';
 import type { ResolvedProfile } from './profile.js';
 import type { CapabilityRegistry } from './capabilities.js';
 import { type TokenEstimate } from './tokenizer.js';
 export interface ContextDecision {
-    readonly stage: 'tool_result_budget' | 'snip' | 'microcompact' | 'context_collapse';
+    readonly stage: 'snip';
     readonly sourceTokens: number;
     readonly projectedTokens: number;
 }
 export interface PreparedContext {
     readonly source: ContextSource;
+    readonly fullMessages: readonly ModelMessage[];
     readonly messages: readonly ModelMessage[];
     readonly estimate: TokenEstimate;
     readonly sourceRevision: number;
@@ -21,14 +21,18 @@ export interface PreparedContext {
 export interface ContextSource {
     readonly agent: Document;
     readonly items: readonly Document[];
+    readonly todo?: Document | null;
+    readonly unsettledItemIds?: readonly string[];
+    readonly workingItems?: readonly Document[];
     readonly overrides: readonly Document[];
     readonly capabilities: readonly Document[];
 }
 export declare class ContextEngine {
+    #private;
     readonly store: Store;
     readonly registry: CapabilityRegistry;
     constructor(store: Store, registry: CapabilityRegistry);
     capture(projectId: string, agentId: string): ContextSource;
     prepare(projectId: string, agentId: string, config: HarnessConfig, contextWindowTokens: number, profile: ResolvedProfile, requestFrame?: Json): PreparedContext;
-    prepareSource(source: ContextSource, config: HarnessConfig, contextWindowTokens: number, profile: ResolvedProfile, requestFrame?: Json): PreparedContext;
+    prepareSource(source: ContextSource, config: HarnessConfig, contextWindowTokens: number, profile: ResolvedProfile, requestFrame?: Json, projectId?: string): PreparedContext;
 }