@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/src/claude-provider.js

@@ -0,0 +1,391 @@
+import { execFile, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isDeepStrictEqual, promisify } from 'node:util';
+import { resolveClaudeExecutable } from './claude-executable.js';
+import { resolveTrustedTaskkill } from './shell.js';
+const executeFile = promisify(execFile);
+const OUTPUT_LIMIT = 8 * 1024 * 1024;
+// Stop after the first paid response, including the CLI's otherwise automatic length recovery.
+const AUXILIARY_BUDGET_USD = '0.000000001';
+const signInMessage = 'Sign in with the Claude CLI (claude auth login), then retry the Claude subscription provider.';
+const systemPrompt = 'You are the model component of Andorra Code. The supplied conversation is the complete context. Return one structured response with text and toolCalls. To request an Andorra tool, return its name and JSON-encoded arguments in toolCalls. Andorra authorizes and executes tools and supplies observations in the next conversation. Do not use built-in tools. Otherwise return text and an empty toolCalls array.';
+const auxiliarySystemPrompt = 'You are the text-only model component of Andorra Code. The supplied conversation is the complete context. Follow its instructions and return only the requested text. Do not call tools.';
+const outputSchema = {
+    type: 'object', additionalProperties: false, required: ['text', 'toolCalls'],
+    properties: {
+        text: { type: 'string' },
+        toolCalls: { type: 'array', items: {
+                type: 'object', additionalProperties: false, required: ['name', 'arguments'],
+                properties: { name: { type: 'string' }, arguments: { type: 'string' } },
+            } },
+    },
+};
+/** Keep managed authentication at its existing home, excluding credential/provider overrides. */
+export function claudeEnvironment(source = process.env) {
+    return Object.fromEntries(Object.entries(source).filter(([key]) => key.toUpperCase() === 'CLAUDE_CONFIG_DIR' || !/^(?:ANTHROPIC_|CLAUDE_|NODE_OPTIONS$|NODE_PATH$)/i.test(key)));
+}
+// Safe mode retains managed policy and authentication while disabling customizations, including
+// hooks, CLAUDE.md, plugins, skills and agents. Empty setting sources prevent apiKeyHelper execution.
+export const claudeIsolationArgs = [
+    '--safe-mode', '--setting-sources', '', '--settings', '{}', '--tools', '',
+    '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}',
+    '--disable-slash-commands', '--no-chrome', '--no-session-persistence',
+];
+/** Bounded subprocess transport. Prompts and images travel only on stdin, never through a shell. */
+export const runClaudeProcess = async (args, input, signal, options = {}) => {
+    signal.throwIfAborted();
+    if (options.maxTokens !== undefined && (!Number.isSafeInteger(options.maxTokens) || options.maxTokens < 1))
+        throw new Error('Invalid auxiliary output allowance.');
+    if (Buffer.byteLength(input) > 32 * 1024 * 1024)
+        throw new Error('Claude CLI input exceeded the safety limit');
+    const executable = options.executable ?? await resolveClaudeExecutable();
+    const cwd = await mkdtemp(join(tmpdir(), 'andorra-claude-'));
+    try {
+        const env = claudeEnvironment(options.env);
+        if (options.maxTokens !== undefined) {
+            // Apply only after sanitization, to this child. Managed auth and parent environment survive.
+            env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = String(options.maxTokens);
+            env.MAX_THINKING_TOKENS = '0';
+        }
+        const taskkill = process.platform === 'win32' ? await resolveTrustedTaskkill(cwd, env) : undefined;
+        signal.throwIfAborted();
+        const child = spawn(executable, args, { cwd, env, windowsHide: true, shell: false,
+            detached: process.platform !== 'win32', stdio: 'pipe' });
+        let output = '';
+        let bufferedLine = '';
+        let bytes = 0;
+        let failure;
+        let stopping;
+        const stop = () => stopping ??= (async () => {
+            if (!child.pid || child.exitCode !== null || child.signalCode !== null)
+                return;
+            if (taskkill) {
+                try {
+                    await executeFile(taskkill, ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, timeout: 20_000 });
+                }
+                catch {
+                    child.kill('SIGKILL');
+                }
+            }
+            else {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
+                }
+                catch {
+                    child.kill('SIGKILL');
+                }
+            }
+        })();
+        const abort = () => { failure ??= new Error(signal.reason?.name === 'TimeoutError' ? 'Claude CLI timed out' : 'Claude CLI request cancelled'); void stop(); };
+        await new Promise((resolve, reject) => {
+            child.once('error', () => { failure ??= new Error('Could not start the native Claude CLI'); });
+            child.once('close', code => {
+                signal.removeEventListener('abort', abort);
+                if (failure)
+                    reject(failure);
+                else if (!(options.acceptedExitCodes ?? [0]).includes(code ?? -1))
+                    reject(new Error('Claude CLI failed. Check its managed sign-in and selected model.'));
+                else
+                    resolve();
+            });
+            const count = (chunk) => {
+                bytes += Buffer.byteLength(chunk);
+                if (bytes <= (options.outputLimit ?? OUTPUT_LIMIT))
+                    return true;
+                failure ??= new Error('Claude CLI output exceeded the safety limit');
+                void stop();
+                return false;
+            };
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (text) => {
+                if (!count(text))
+                    return;
+                output += text;
+                if (!options.catalogRequestId)
+                    return;
+                bufferedLine += text;
+                let newline;
+                while ((newline = bufferedLine.indexOf('\n')) >= 0) {
+                    const line = bufferedLine.slice(0, newline);
+                    bufferedLine = bufferedLine.slice(newline + 1);
+                    try {
+                        const value = JSON.parse(line);
+                        if (value.type === 'control_response' && value.response?.request_id === options.catalogRequestId)
+                            child.stdin.end();
+                    }
+                    catch { /* Parse the complete transport response after the child has exited. */ }
+                }
+            });
+            // Never include stderr in diagnostics: it can contain account details or credential values.
+            child.stderr.on('data', (chunk) => { count(chunk); });
+            child.stdin.on('error', () => { failure ??= new Error('Claude CLI closed its input unexpectedly'); void stop(); });
+            signal.addEventListener('abort', abort, { once: true });
+            if (signal.aborted)
+                abort();
+            else if (options.catalogRequestId)
+                child.stdin.write(input);
+            else
+                child.stdin.end(input);
+        }).finally(async () => { signal.removeEventListener('abort', abort); await stopping; });
+        return output;
+    }
+    finally {
+        await rm(cwd, { recursive: true, force: true });
+    }
+};
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error('Claude CLI returned malformed JSON');
+    }
+}
+function frames(text) { return text.split(/\r?\n/).filter(line => line.trim()).map(parseJson); }
+async function signedIn(run, signal) {
+    const status = parseJson(await run(['--safe-mode', '--setting-sources', '', '--settings', '{}', 'auth', 'status', '--json'], '', signal, { acceptedExitCodes: [0, 1] }));
+    return status?.loggedIn === true && status.authMethod === 'claude.ai' && status.apiProvider === 'firstParty';
+}
+/** Read the CLI's managed login status and its current supported model catalog without inference. */
+export async function readClaudeCatalog(signal, dependencies = {}) {
+    const run = dependencies.run ?? runClaudeProcess;
+    const bounded = AbortSignal.any([signal, AbortSignal.timeout(30_000)]);
+    if (!await signedIn(run, bounded))
+        return { signedIn: false, models: [] };
+    const id = randomUUID();
+    const output = await run([...claudeIsolationArgs, '--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose'], `${JSON.stringify({ type: 'control_request', request_id: id, request: { subtype: 'initialize' } })}\n`, bounded, { catalogRequestId: id });
+    const response = frames(output).find(frame => frame.type === 'control_response' && frame.response?.request_id === id)?.response;
+    if (response?.subtype !== 'success' || !Array.isArray(response.response?.models))
+        throw new Error('Claude CLI did not return a supported model catalog');
+    const models = response.response.models.map((model) => {
+        if (!model || typeof model !== 'object' || Array.isArray(model))
+            throw new Error('Claude CLI returned an invalid model catalog');
+        // Context selectors can resolve to the same base model while changing effective context.
+        const suffix = typeof model.value === 'string' ? model.value.match(/\[[^\]]+\]$/)?.[0] : undefined;
+        const resolved = model.resolvedModel ?? model.value;
+        return suffix && typeof resolved === 'string' && !resolved.endsWith(suffix) ? `${resolved}${suffix}` : resolved;
+    });
+    if (models.length > 1000 || models.some((model) => typeof model !== 'string' || !model.trim()))
+        throw new Error('Claude CLI returned an invalid model catalog');
+    return { signedIn: true, models: [...new Set(models)] };
+}
+function argumentObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Claude returned invalid Andorra tool arguments');
+    return value;
+}
+function structuredResponse(value, names) {
+    if (!value || typeof value.text !== 'string' || !Array.isArray(value.toolCalls) || value.toolCalls.length > 100
+        || Object.keys(value).some(key => key !== 'text' && key !== 'toolCalls'))
+        throw new Error('Claude returned an invalid Andorra response');
+    const calls = value.toolCalls.map((call) => {
+        if (!call || typeof call.name !== 'string' || !call.name.trim() || typeof call.arguments !== 'string')
+            throw new Error('Claude returned a malformed Andorra tool call');
+        if (!names.has(call.name))
+            throw new Error('Claude requested a tool outside the Andorra manifest');
+        try {
+            argumentObject(JSON.parse(call.arguments));
+        }
+        catch {
+            throw new Error('Claude returned invalid Andorra tool arguments');
+        }
+        return { id: randomUUID(), name: call.name, arguments: call.arguments };
+    });
+    if (calls.some((call, index) => calls.slice(0, index).some((previous) => sameCalls([previous], [call])))) {
+        throw new Error('Claude returned duplicate Andorra tool calls');
+    }
+    return { text: value.text, toolCalls: calls };
+}
+function sameCalls(first, second) {
+    return isDeepStrictEqual(first.map(call => ({ name: call.name, arguments: JSON.parse(call.arguments) })), second.map(call => ({ name: call.name, arguments: JSON.parse(call.arguments) })));
+}
+/** Accept one model step only. Native-shaped Andorra calls never gain native tool access. */
+export function parseClaudeResponse(output, tools = []) {
+    const events = frames(output);
+    const results = events.filter(frame => frame?.type === 'result');
+    if (results.length !== 1)
+        throw new Error('Claude did not return exactly one model result');
+    const result = results[0];
+    const success = result.is_error === false && result.subtype === 'success';
+    const turnLimit = result.is_error === true && result.subtype === 'error_max_turns';
+    if (!success && !turnLimit)
+        throw new Error('Claude inference failed. Check its managed sign-in, model access, and subscription limits.');
+    for (const event of events.filter(frame => frame?.type === 'system' && frame.subtype === 'init')) {
+        if (event.tools !== undefined && (!Array.isArray(event.tools) || event.tools.some((name) => name !== 'StructuredOutput'))) {
+            throw new Error('Claude exposed unexpected native tools');
+        }
+        if (event.mcp_servers !== undefined && (!Array.isArray(event.mcp_servers) || event.mcp_servers.length))
+            throw new Error('Claude exposed unexpected native MCP servers');
+    }
+    const names = new Set(tools.map(tool => tool.name));
+    if (names.size !== tools.length || names.has('StructuredOutput'))
+        throw new Error('Claude received an ambiguous Andorra tool manifest');
+    const direct = [];
+    const ids = new Set();
+    const messageIds = new Set();
+    const texts = [];
+    let schemaResponse;
+    for (const event of events.filter(frame => frame?.type === 'assistant')) {
+        if (event.parent_tool_use_id || typeof event.message?.id !== 'string' || !event.message.id || !Array.isArray(event.message.content))
+            throw new Error('Claude returned an invalid assistant step');
+        messageIds.add(event.message.id);
+        if (messageIds.size > 1)
+            throw new Error('Claude returned multiple assistant steps');
+        // Claude emits separate complete blocks bearing one message ID, including thinking blocks.
+        for (const block of event.message.content) {
+            if (block?.type === 'text' && typeof block.text === 'string')
+                texts.push(block.text);
+            if (block?.type !== 'tool_use')
+                continue;
+            if (typeof block.id !== 'string' || !block.id || ids.has(block.id))
+                throw new Error('Claude returned duplicate or invalid tool call IDs');
+            ids.add(block.id);
+            if (block.name === 'StructuredOutput') {
+                if (schemaResponse)
+                    throw new Error('Claude returned multiple structured responses');
+                schemaResponse = structuredResponse(block.input, names);
+            }
+            else {
+                if (!names.has(block.name))
+                    throw new Error('Claude requested a tool outside the Andorra manifest');
+                const call = { id: randomUUID(), name: block.name, arguments: JSON.stringify(argumentObject(block.input)) };
+                if (direct.length >= 100 || direct.some(previous => sameCalls([previous], [call])))
+                    throw new Error('Claude returned duplicate or excessive Andorra tool calls');
+                direct.push(call);
+                const observations = events.filter(frame => frame?.type === 'user').flatMap(frame => Array.isArray(frame.message?.content) ? frame.message.content : [])
+                    .filter((item) => item?.type === 'tool_result' && item.tool_use_id === block.id);
+                const unavailable = [
+                    `<tool_use_error>Error: No such tool available: ${block.name}</tool_use_error>`,
+                    `<tool_use_error>Error: No such tool available: ${block.name}.</tool_use_error>`,
+                    `<tool_use_error>Error: No such tool available: ${block.name}. ${block.name} is disabled for this session, in subagents as well as here.</tool_use_error>`,
+                ];
+                if (observations.length !== 1 || observations[0].is_error !== true || typeof observations[0].content !== 'string'
+                    || !unavailable.includes(observations[0].content)) {
+                    throw new Error('Claude did not confirm that the native-shaped Andorra tool was disabled');
+                }
+            }
+        }
+    }
+    const structured = result.structured_output === undefined ? schemaResponse : structuredResponse(result.structured_output, names);
+    if (schemaResponse && structured && (!sameCalls(schemaResponse.toolCalls, structured.toolCalls) || schemaResponse.text !== structured.text))
+        throw new Error('Claude returned conflicting structured responses');
+    if (direct.length && structured && !sameCalls(direct, structured.toolCalls))
+        throw new Error('Claude returned conflicting Andorra tool requests');
+    let response;
+    if (success && structured)
+        response = structured;
+    else if (turnLimit && direct.length && !structured)
+        response = { text: texts.join('\n'), toolCalls: direct };
+    else
+        throw new Error('Claude did not return a complete Andorra model step');
+    if (result.usage)
+        response.usage = claudeUsage(result.usage);
+    return response;
+}
+function claudeUsage(usage) {
+    const token = (name) => typeof usage[name] === 'number' && Number.isSafeInteger(usage[name]) && usage[name] >= 0 ? usage[name] : undefined;
+    const input = token('input_tokens');
+    const output = token('output_tokens');
+    const read = token('cache_read_input_tokens');
+    const created = token('cache_creation_input_tokens');
+    return { requests: 1,
+        ...(input === undefined ? {} : { inputTokens: input + (read ?? 0) + (created ?? 0) }),
+        ...(output === undefined ? {} : { outputTokens: output }),
+        ...(read === undefined ? {} : { cacheRead: read }), ...(created === undefined ? {} : { cacheWrite: created }) };
+}
+/**
+ * Bounded auxiliaries require CLI support for the documented child output/budget controls and
+ * partial-message metadata. The output cap alone permits automatic continuations. The positive
+ * budget stops after one paid response; verify that single response and its real stream usage.
+ */
+export function parseClaudeAuxiliaryResponse(output, maxTokens) {
+    if (!Number.isSafeInteger(maxTokens) || maxTokens < 1)
+        throw new Error('Invalid auxiliary output allowance.');
+    const events = frames(output);
+    const inits = events.filter(frame => frame?.type === 'system' && frame.subtype === 'init');
+    if (inits.length !== 1 || !Array.isArray(inits[0].tools) || inits[0].tools.length
+        || !Array.isArray(inits[0].mcp_servers) || inits[0].mcp_servers.length)
+        throw new Error('Claude exposed tools during bounded auxiliary generation');
+    const starts = events.filter(frame => frame?.type === 'stream_event' && frame.event?.type === 'message_start');
+    const deltas = events.filter(frame => frame?.type === 'stream_event' && frame.event?.type === 'message_delta');
+    const results = events.filter(frame => frame?.type === 'result');
+    if (starts.length !== 1 || deltas.length !== 1 || results.length !== 1)
+        throw new Error('Claude did not return exactly one bounded auxiliary response');
+    if (events.indexOf(starts[0]) >= events.indexOf(deltas[0]) || events.indexOf(deltas[0]) >= events.indexOf(results[0])
+        || events.some(frame => ['tool_use', 'server_tool_use'].includes(frame?.event?.content_block?.type)))
+        throw new Error('Claude returned conflicting auxiliary events');
+    const id = starts[0].event.message?.id;
+    if (typeof id !== 'string' || !id)
+        throw new Error('Claude returned an invalid auxiliary message ID');
+    const result = results[0];
+    const delta = deltas[0].event;
+    const stopReason = delta.delta?.stop_reason;
+    const budgetStop = result.subtype === 'error_max_budget_usd' && result.is_error === true;
+    if (!['end_turn', 'max_tokens', 'stop_sequence'].includes(stopReason) || result.stop_reason !== stopReason
+        || !((result.subtype === 'success' && result.is_error === false) || budgetStop)
+        || result.structured_output !== undefined || typeof result.total_cost_usd !== 'number' || !Number.isFinite(result.total_cost_usd) || result.total_cost_usd <= 0
+        || (budgetStop && result.total_cost_usd < Number(AUXILIARY_BUDGET_USD))) {
+        throw new Error('Claude returned an invalid bounded auxiliary completion');
+    }
+    const usage = delta.usage;
+    const count = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+    if (!usage || !count(usage.input_tokens) || !count(usage.output_tokens) || usage.output_tokens > maxTokens
+        || !Array.isArray(usage.iterations) || usage.iterations.length !== 1
+        || usage.iterations[0]?.input_tokens !== usage.input_tokens || usage.iterations[0]?.output_tokens !== usage.output_tokens) {
+        throw new Error('Claude did not confirm the auxiliary output allowance');
+    }
+    const assistants = events.filter(frame => frame?.type === 'assistant');
+    if (!assistants.length)
+        throw new Error('Claude returned no bounded auxiliary message');
+    const texts = [];
+    for (const assistant of assistants) {
+        if (events.indexOf(assistant) <= events.indexOf(starts[0]) || events.indexOf(assistant) >= events.indexOf(deltas[0])
+            || assistant.error || assistant.parent_tool_use_id || assistant.message?.id !== id || !Array.isArray(assistant.message.content))
+            throw new Error('Claude returned conflicting auxiliary messages');
+        for (const block of assistant.message.content) {
+            if (block?.type === 'text' && typeof block.text === 'string')
+                texts.push(block.text);
+            else if (block?.type !== 'thinking' && block?.type !== 'redacted_thinking')
+                throw new Error('Claude attempted a tool during bounded auxiliary generation');
+        }
+    }
+    if (texts.length > 1)
+        throw new Error('Claude returned conflicting auxiliary text blocks');
+    return { text: texts.join(''), toolCalls: [], usage: claudeUsage(usage), stopReason };
+}
+/** Claude produces one model response; Andorra owns tool execution, graph state, and permissions. */
+export function createClaudeAdapter(_config, dependencies = {}) {
+    const run = dependencies.run ?? runClaudeProcess;
+    return {
+        async listModels(signal) { return (await readClaudeCatalog(signal, dependencies)).models; },
+        async generate(request) {
+            request.signal.throwIfAborted();
+            const auxiliary = request.maxTokens !== undefined;
+            if (auxiliary && (!Number.isSafeInteger(request.maxTokens) || request.maxTokens < 1))
+                throw new Error('Invalid auxiliary output allowance.');
+            if (auxiliary && request.tools.length)
+                throw new Error('Claude cannot apply an auxiliary output allowance to tool-bearing requests.');
+            const signal = AbortSignal.any([request.signal, AbortSignal.timeout(10 * 60_000)]);
+            if (!await signedIn(run, signal))
+                throw new Error(signInMessage);
+            const content = [{ type: 'text', text: JSON.stringify({
+                        conversation: request.messages.map(({ images, providerContinuation, reasoningContent, ...message }) => ({ ...message, ...(images?.length ? { imageCount: images.length } : {}) })),
+                        availableTools: request.tools,
+                    }) }];
+            request.messages.forEach((message, index) => message.images?.forEach((image, imageIndex) => {
+                content.push({ type: 'text', text: `Image ${imageIndex + 1} from conversation message ${index + 1}:` }, { type: 'image', source: { type: 'base64', media_type: image.mimeType, data: image.data } });
+            }));
+            request.onRequest?.();
+            const output = await run([...claudeIsolationArgs, '--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+                '--max-turns', '1',
+                '--model', request.model, ...(auxiliary
+                    ? ['--include-partial-messages', '--max-budget-usd', AUXILIARY_BUDGET_USD, '--system-prompt', auxiliarySystemPrompt]
+                    : ['--json-schema', JSON.stringify(outputSchema), '--system-prompt', systemPrompt])], `${JSON.stringify({ type: 'user', client_composed: true, message: { role: 'user', content } })}\n`, signal, { acceptedExitCodes: [0, 1], ...(auxiliary ? { maxTokens: request.maxTokens } : {}) });
+            signal.throwIfAborted();
+            return auxiliary ? parseClaudeAuxiliaryResponse(output, request.maxTokens) : parseClaudeResponse(output, request.tools);
+        },
+    };
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { saveConfig } from './config.js';
+import { providerSecrets } from './providers.js';
+import { type RunResult } from './runtime.js';
+import { checkGraphModelHealth } from './graph-health.js';
+import { loadAccessibleGraph } from './membership.js';
+import type { RuntimeEvent } from './types.js';
+/**
+ * The version this build reports, read from the package manifest rather than hard-coded.
+ *
+ * The release workflow rewrites `package.json` and then publishes; a literal here would keep
+ * reporting the old version forever, so `andorra --version` would disagree with the package that
+ * was actually installed. `dist/src/cli.js` sits two directories below the manifest
+ * (`dist/src/cli.js` -> `dist` -> repository root), both in a checkout and in an installed
+ * package. A manifest that cannot be read leaves the version unknown rather than wrong.
+ */
+export declare function cliVersion(): Promise<string>;
+/** Display-only Git metadata must never run workspace-controlled PATH helpers. */
+export declare function gitBranch(workspace: string): Promise<string>;
+export declare function safeTerminal(text: string): string;
+/** Short follow-up directions that mean "continue the unfinished work" rather than start a new task. */
+export declare function isContinuationPrompt(text: string): boolean;
+/** Retain an unfinished run's plan only when the next prompt explicitly continues that work. */
+export declare function continuedTodos(task: string, lastRun?: RunResult): import('./todos.js').TodoItem[];
+export { providerSecrets };
+/**
+ * Append one runtime event to the record of the run it belongs to.
+ *
+ * Not every event belongs to a run. The memory health check emitted while the memory manager is
+ * constructed, and code-intelligence state before the first run starts, carry no run identity at
+ * all: they describe the session. They are skipped, because a per-run file cannot name them --
+ * writing one anyway is what used to leave a `runs/undefined.jsonl` behind in the installation.
+ * An identity that is present but not well formed is a bug in whatever produced it rather than an
+ * absent one, so `runRecordPath` still throws for it.
+ * @param directory - the installation directory holding `runs/`.
+ * @param event - the runtime event to persist.
+ */
+export declare function appendRunEvent(directory: string, event: RuntimeEvent): Promise<void>;
+/**
+ * A node's resolved model plus the reasoning effort that came with it.
+ *
+ * `ResolvedGraphModel` carries the model, its adapter and its context window; the effort is the
+ * one that adapter was built with, so it is kept beside them for the footer instead of being
+ * re-derived from the graph configuration the node was declared in.
+ */
+export type ResolvedNodeModel = import('./runtime.js').ResolvedGraphModel & {
+    reasoningEffort?: string;
+};
+/**
+ * Add the reasoning effort and context window of a root node's own resolution to its
+ * `agent.session.started` data, so the footer can describe the model that is answering.
+ *
+ * The executor reports the provider and model a node resolved but not the effort or window that
+ * came with them, and those differ per node: a node that overrides the model loses the provider's
+ * saved effort and window (`resolveModelContext`), so reusing the session's numbers would put
+ * values on the footer that belong to a model that is not running. Only a root node session is
+ * decorated -- a delegated child repeats its parent's node id, and a plain prompt run has no
+ * graph node at all -- and the caller's event object is never mutated, so the events the run
+ * record holds stay exactly as the runtime emitted them. Both keys are always written together,
+ * even when unknown: the terminal reads their presence as proof that this node's resolution is
+ * authoritative, so an unknown window cannot silently inherit the session's.
+ * @param event - the runtime event on its way to the terminal.
+ * @param lookup - the memoized resolution of a provider/model pair, as the node's executor asked for it.
+ * @returns the event to hand to the terminal; the original event when there is nothing to add.
+ */
+export declare function withNodeModelResolution(event: RuntimeEvent, lookup: (provider: string, model: string) => Promise<ResolvedNodeModel | undefined> | undefined): Promise<RuntimeEvent>;
+export declare function main(argv?: string[], dependencies?: {
+    loadGraph?: typeof loadAccessibleGraph;
+    checkGraphHealth?: typeof checkGraphModelHealth;
+    trajectoryDirectory?: string;
+    saveConfig?: typeof saveConfig;
+}): Promise<number>;
+/**
+ * The exit code a finished subagent command reports.
+ *
+ * A signal that arrived while the records were still being written is still a signal: the
+ * supervisor that sent it is told the run was interrupted, not that it succeeded. The run's own
+ * cancellation is refused that late, and the refusal must not turn into a success.
+ */
+export declare function subagentExitCode(outcome: {
+    status: string;
+}, signals: {
+    interrupted: boolean;
+    terminated: boolean;
+}): number;