@myagentroam/node 0.1.3 → 0.1.6

package/dist/runner/abstract-runner.js

@@ -0,0 +1,154 @@
+/**
+ * Stable lifecycle boundary for every Node Runner implementation.
+ *
+ * Vendor clients and payload decoders stay behind subclasses. Domain services
+ * depend on this boundary (or a capability interface implemented by it), never
+ * on an SDK/App Server client directly.
+ */
+export class AbstractRunner {
+    control;
+    commandControl;
+    /** Test-only runners are registered explicitly but never advertised. */
+    advertised = true;
+    interceptsRuns = false;
+    async refreshProfile(capabilities, workspace, environment = {}) {
+        void [workspace, environment];
+        return this.profile(capabilities);
+    }
+    supportsConfiguration(configuration, workspace) {
+        void workspace;
+        const profile = this.profileForValidation();
+        const model = profile.models.find((candidate) => candidate.id === configuration.model);
+        return (configuration.runner === this.name &&
+            model !== undefined &&
+            model.supportedEfforts.includes(configuration.effort) &&
+            profile.accessOptions.some((candidate) => candidate.id === configuration.access));
+    }
+    presentSession(session, capabilities, context) {
+        void [session, capabilities, context];
+        throw new RunnerCapabilityError(this.name, 'session.presentation');
+    }
+    prepareMessageInput(input, collaborationMode) {
+        void collaborationMode;
+        return input;
+    }
+    channelToken(sessionId) {
+        void sessionId;
+        return undefined;
+    }
+    deliverChannel(sessionId, messageId, senderId, token, content, notify) {
+        void [sessionId, messageId, senderId, token, content, notify];
+        return 'REJECTED';
+    }
+    executeGlobalCommand(commandId, input) {
+        void [commandId, input];
+        throw new RunnerCapabilityError(this.name, 'global-command');
+    }
+    serviceTier() {
+        return undefined;
+    }
+    usesRunnerTitleForRename() {
+        return false;
+    }
+    async renameNative(session, input, database) {
+        if (session.externalSessionId === null)
+            return;
+        database.saveNativeSessionMetadata({
+            runner: session.runner,
+            externalSessionId: session.externalSessionId,
+            workspaceId: session.workspaceId,
+            ...(input.title === undefined ? {} : { customTitle: input.title }),
+            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
+        });
+    }
+    async removeNative(session, nativeSessionId) {
+        void [session, nativeSessionId];
+        return false;
+    }
+    async forkNative(session, boundary, title) {
+        void [session, boundary, title];
+        throw new RunnerCapabilityError(this.name, 'session.rewind');
+    }
+    projectedRunnerTitle(metadata, input, database) {
+        void database;
+        return input.title ?? metadata?.runnerTitle ?? null;
+    }
+    managedAliasId(nativeSessionId) {
+        void nativeSessionId;
+        return undefined;
+    }
+    nativeAliasesFor(managedSessionId) {
+        void managedSessionId;
+        return [];
+    }
+    forgetNativeAlias(nativeSessionId) {
+        void nativeSessionId;
+    }
+    rememberManagedNative(session, nativeSessionId) {
+        void [session, nativeSessionId];
+    }
+    async readManagedRunnerTitle(session, nativeSessionId) {
+        void [session, nativeSessionId];
+        return undefined;
+    }
+    async readOfficialConversation(session, input, managedTurn) {
+        void [session, input, managedTurn];
+        return undefined;
+    }
+    async readExternalActivity(session) {
+        void session;
+        return undefined;
+    }
+    acceptsTruncatedNativeHistory() {
+        return true;
+    }
+    nativeImageRoot(session) {
+        void session;
+        return undefined;
+    }
+    managedRunForNativeTurn(nativeTurnId) {
+        void nativeTurnId;
+        return undefined;
+    }
+    bindControl(control) {
+        if (this.control !== undefined)
+            throw new Error(`RUNNER_CONTROL_ALREADY_BOUND:${this.name}`);
+        this.control = control;
+    }
+    acceptsRun(runner) {
+        return this.interceptsRuns || runner === this.name;
+    }
+    startManagedRun(envelope) {
+        if (this.control === undefined)
+            throw new Error(`RUNNER_CONTROL_NOT_BOUND:${this.name}`);
+        this.control.start(envelope);
+    }
+    cancelManagedRun(runId, intent) {
+        return this.control?.cancel(runId, intent) === true;
+    }
+    decideApproval(input) {
+        return this.control?.decideApproval?.(input) === true;
+    }
+    respondUserInput(runId, requestId, answers) {
+        return this.control?.respondUserInput?.(runId, requestId, answers) === true;
+    }
+    bindCommandControl(control) {
+        if (this.commandControl !== undefined)
+            throw new Error(`RUNNER_COMMAND_CONTROL_ALREADY_BOUND:${this.name}`);
+        this.commandControl = control;
+    }
+    executeCommand(session, command, input, context) {
+        if (this.commandControl === undefined)
+            return Promise.reject(new Error('RUNNER_COMMAND_UNAVAILABLE'));
+        return this.commandControl.execute(session, command, input, context);
+    }
+}
+export class RunnerCapabilityError extends Error {
+    runner;
+    capability;
+    constructor(runner, capability) {
+        super('RUNNER_CAPABILITY_UNSUPPORTED');
+        this.runner = runner;
+        this.capability = capability;
+    }
+}

package/dist/runner/claude/managed-run-controller.d.ts

@@ -0,0 +1,52 @@
+import type { NodeEnvelope, RunnerCommandDescriptor, RunnerCommandState } from '@myagentroam/protocol';
+import { denyPermission } from '../../claude-agent-sdk.js';
+import type { NodeAgentSession } from '../../database.js';
+import type { FakeRunnerStatus } from '../../fake-runner.js';
+import { type PublicConversationItem } from '../codex/conversation-parser.js';
+import { ClaudeCodeRunner } from '../claude-code-runner.js';
+export interface ClaudeRunnerImageAttachment {
+    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+    readonly dataBase64: string;
+}
+export interface ClaudeManagedRunHost<TAttachment extends ClaudeRunnerImageAttachment> {
+    intercepted(): boolean;
+    readonly active: Set<string>;
+    parseAttachments(value: unknown): readonly TAttachment[];
+    emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
+    adopt(input: {
+        runId: string;
+        sessionId: string;
+        runner: 'claude-code';
+        cwd: string;
+        externalSessionId?: string;
+    }): void;
+    run(runId: string): {
+        readonly status: string;
+    } | undefined;
+    hasActiveSessionLease(sessionId: string): boolean;
+    session(sessionId: string): NodeAgentSession | undefined;
+    completeCancelled(runId: string, cwd: string): boolean;
+    captureSnapshot(runId: string, cwd: string): Promise<void>;
+    requestUserInput(runId: string, input: Record<string, unknown>, toolUseId: string): Promise<ReturnType<typeof denyPermission>>;
+    requestApproval(runId: string, toolName: string, input: Record<string, unknown>): Promise<ReturnType<typeof denyPermission>>;
+    rememberNative(nativeSessionId: string, sessionId: string): void;
+    promote(sessionId: string, nativeSessionId: string): void;
+    send(type: string, payload: unknown): void;
+    emitItem(runId: string, item: PublicConversationItem): void;
+    syncTitle(sessionId: string, nativeSessionId: string, cwd: string): Promise<void>;
+    setChannelToken(sessionId: string, token: string): void;
+    commandState(sessionId: string, commandId: string): RunnerCommandState | undefined;
+    setCommandState(sessionId: string, state: RunnerCommandState): void;
+    clearCommandState(sessionId: string, commandId: string): void;
+    commandStates(sessionId: string): readonly RunnerCommandState[];
+}
+export declare class ClaudeManagedRunController<TAttachment extends ClaudeRunnerImageAttachment> {
+    private readonly runner;
+    private readonly host;
+    constructor(runner: ClaudeCodeRunner, host: ClaudeManagedRunHost<TAttachment>);
+    executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
+        readonly secretEnvironment: Readonly<Record<string, string>>;
+    }): Promise<unknown>;
+    private compact;
+    start(envelope: NodeEnvelope): void;
+}

package/dist/runner/claude/managed-run-controller.js

@@ -0,0 +1,326 @@
+import { createEnvelope } from '@myagentroam/protocol';
+import { ClaudeChannelGate } from '../../claude-channel.js';
+import { boundedConversationItemId, claudePlanText, compactRunnerText, compactRunnerValue, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolResults, extractClaudeToolUses, isClaudeCommandTool } from '../codex/conversation-parser.js';
+import { isTerminalRunStatus } from '../../util/node-operation-parsers.js';
+import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
+import { parseSecretEnvironment } from '../../util/secret-environment.js';
+export class ClaudeManagedRunController {
+    runner;
+    host;
+    constructor(runner, host) {
+        this.runner = runner;
+        this.host = host;
+    }
+    async executeCommand(session, command, input, context) {
+        if (command.id === 'compact')
+            return this.compact(session, input, context.secretEnvironment);
+        if (command.id !== 'plan' || session.access === 'plan')
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const current = this.host.commandState(session.id, 'plan');
+        if (current?.active)
+            this.host.clearCommandState(session.id, 'plan');
+        else
+            this.host.setCommandState(session.id, {
+                commandId: 'plan',
+                active: true,
+                label: 'Plan Mode',
+                detail: '后续消息将以标签式规划模式运行，只读规划并输出计划卡。',
+                closable: true,
+                closeInput: '/plan',
+                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+            });
+        return { command: command.id, states: this.host.commandStates(session.id) };
+    }
+    compact(session, input, secretEnvironment) {
+        if (session.externalSessionId === null ||
+            session.nativeControl !== 'MAR_MANAGED' ||
+            this.host.hasActiveSessionLease(session.id))
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const runId = crypto.randomUUID();
+        this.host.adopt({
+            runId,
+            sessionId: session.id,
+            runner: 'claude-code',
+            cwd: session.cwd,
+            externalSessionId: session.externalSessionId
+        });
+        this.host.rememberNative(session.externalSessionId, session.id);
+        this.start(createEnvelope('run.start', {
+            runId,
+            sessionId: session.id,
+            runner: 'claude-code',
+            input,
+            cwd: session.cwd,
+            externalSessionId: session.externalSessionId,
+            model: session.model,
+            effort: session.effort,
+            access: session.access,
+            secretEnvironment
+        }));
+        return {
+            command: 'compact',
+            run: this.host.run(runId),
+            states: this.host.commandStates(session.id)
+        };
+    }
+    start(envelope) {
+        const payload = envelope.payload;
+        if (payload.runner !== 'claude-code' ||
+            typeof payload.runId !== 'string' ||
+            typeof payload.sessionId !== 'string' ||
+            typeof payload.input !== 'string' ||
+            typeof payload.cwd !== 'string' ||
+            this.host.intercepted() ||
+            this.host.active.has(payload.runId))
+            return;
+        const runId = payload.runId;
+        const sessionId = payload.sessionId;
+        const cwd = payload.cwd;
+        let attachments;
+        let secretEnvironment;
+        try {
+            attachments = this.host.parseAttachments(payload.attachments);
+            secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
+        }
+        catch (error) {
+            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'MESSAGE_ATTACHMENTS_INVALID' }, 'FAILED');
+            return;
+        }
+        this.host.adopt({
+            runId,
+            sessionId,
+            runner: 'claude-code',
+            cwd,
+            ...(typeof payload.externalSessionId === 'string'
+                ? { externalSessionId: payload.externalSessionId }
+                : {})
+        });
+        // An insert request may interrupt a Claude Run while its SDK Channel is
+        // still starting. Do not start that stale Channel after the replacement
+        // message has been accepted; emit its terminal projection to release the
+        // replacement queued behind it.
+        if (this.host.run(runId)?.status === 'INTERRUPTED') {
+            this.host.emit(runId, 'run.completed', { status: 'INTERRUPTED' }, 'INTERRUPTED');
+            return;
+        }
+        if (this.host.completeCancelled(runId, cwd))
+            return;
+        if (typeof payload.externalSessionId === 'string' &&
+            !this.runner.execution.managedNativeIds.has(payload.externalSessionId)) {
+            this.host.emit(runId, 'run.rejected', { code: 'EXTERNAL_SESSION_OBSERVE_ONLY' }, 'FAILED');
+            return;
+        }
+        this.host.active.add(runId);
+        this.host.emit(runId, 'run.started', {}, 'STARTING');
+        let terminal = false;
+        let handle;
+        const toolKinds = new Map();
+        const finish = (status, eventType, eventPayload) => {
+            if (terminal)
+                return;
+            terminal = true;
+            this.host.emit(runId, eventType, eventPayload, status);
+            this.runner.execution.runs.delete(runId);
+            handle?.cancel();
+            this.host.active.delete(runId);
+            if (isTerminalRunStatus(status))
+                void this.host.captureSnapshot(runId, cwd);
+        };
+        try {
+            const gate = new ClaudeChannelGate(sessionId);
+            handle = this.runner.startChannel({
+                prompt: payload.input,
+                cwd,
+                ...(typeof payload.externalSessionId === 'string'
+                    ? { resumeSessionId: payload.externalSessionId }
+                    : {}),
+                ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
+                ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
+                ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
+                environment: secretEnvironment,
+                ...(attachments.length === 0
+                    ? {}
+                    : {
+                        attachments: attachments.map((attachment) => ({
+                            mime: attachment.mime,
+                            dataBase64: attachment.dataBase64
+                        }))
+                    }),
+                onPermission: (toolName, toolInput, options) => toolName === 'AskUserQuestion'
+                    ? (toolKinds.set(options.toolUseID, 'user_input_request'),
+                        this.host.requestUserInput(runId, toolInput, options.toolUseID))
+                    : this.host.requestApproval(runId, toolName, toolInput),
+                onChannelReply: (content) => this.host.emit(runId, 'channel.reply', { content }),
+                onMessage: (message) => {
+                    const record = message;
+                    const nativeSessionId = typeof record.session_id === 'string' ? record.session_id : undefined;
+                    const current = this.runner.execution.runs.get(runId);
+                    if (nativeSessionId !== undefined && current !== undefined) {
+                        const firstNativeSessionId = current.nativeSessionId === undefined;
+                        if (firstNativeSessionId)
+                            this.runner.execution.runs.set(runId, { ...current, nativeSessionId });
+                        const managed = this.host.session(sessionId);
+                        if (managed?.nativeControl === 'MAR_MANAGED')
+                            this.host.rememberNative(nativeSessionId, managed.id);
+                        if (firstNativeSessionId && typeof payload.externalSessionId !== 'string') {
+                            this.host.promote(sessionId, nativeSessionId);
+                            this.host.send('session.external-id', {
+                                sessionId,
+                                externalSessionId: nativeSessionId
+                            });
+                            const managed = this.runner.execution.runs.get(runId);
+                            if (managed !== undefined)
+                                this.runner.execution.runs.set(runId, {
+                                    ...managed,
+                                    marSessionId: nativeSessionId
+                                });
+                        }
+                    }
+                    if (record.type === 'assistant') {
+                        const text = extractClaudeText(record);
+                        const planText = claudePlanText(text);
+                        if (planText !== undefined)
+                            this.host.emitItem(runId, {
+                                itemId: boundedConversationItemId('claude-plan', typeof record.uuid === 'string' ? record.uuid : `${runId}:plan`),
+                                kind: 'plan',
+                                status: 'COMPLETED',
+                                payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
+                            });
+                        else if (text.length > 0)
+                            this.host.emit(runId, 'text.delta', { text });
+                        for (const [index, text] of extractClaudeThinkingSummaries(record).entries()) {
+                            this.host.emitItem(runId, {
+                                itemId: boundedConversationItemId('claude-reasoning', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
+                                kind: 'reasoning_summary',
+                                status: 'COMPLETED',
+                                payload: { sections: [{ index, text }] }
+                            });
+                        }
+                        for (const tool of extractClaudeToolUses(record)) {
+                            if (tool.name === 'AskUserQuestion') {
+                                toolKinds.set(tool.id, 'user_input_request');
+                                continue;
+                            }
+                            const itemId = boundedConversationItemId('claude-tool', tool.id);
+                            const kind = isClaudeCommandTool(tool.name) ? 'command_execution' : 'tool_call';
+                            toolKinds.set(tool.id, kind);
+                            this.host.emitItem(runId, {
+                                itemId,
+                                kind,
+                                status: 'IN_PROGRESS',
+                                payload: kind === 'command_execution'
+                                    ? {
+                                        command: compactRunnerText(tool.command ?? tool.name, 10_000),
+                                        cwd: null,
+                                        outputPreview: '',
+                                        outputRef: null,
+                                        exitCode: null,
+                                        durationMs: null,
+                                        truncated: false
+                                    }
+                                    : {
+                                        namespace: 'claude-code',
+                                        toolName: compactRunnerText(tool.name, 128),
+                                        title: compactRunnerText(tool.name, 500),
+                                        inputSummary: compactRunnerValue(tool.input, 10_000).text || null,
+                                        outputSummary: null,
+                                        progressLabel: null,
+                                        errorCode: null,
+                                        truncated: tool.inputTruncated
+                                    }
+                            });
+                        }
+                        for (const [index, block] of claudeContentBlocks(record).entries()) {
+                            const type = typeof block.type === 'string' ? block.type : 'unknown';
+                            if (type === 'text' ||
+                                type === 'thinking' ||
+                                type === 'redacted_thinking' ||
+                                type === 'encrypted_thinking' ||
+                                type === 'tool_use' ||
+                                type === 'tool_result')
+                                continue;
+                            this.host.emitItem(runId, {
+                                itemId: boundedConversationItemId('claude-item', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
+                                kind: 'unknown',
+                                status: 'COMPLETED',
+                                payload: {
+                                    sourceEventType: `claude-code:${type}`,
+                                    label: `Claude Code ${compactRunnerText(type, 128)}`
+                                }
+                            });
+                        }
+                    }
+                    if (record.type === 'tool_progress' && typeof record.tool_use_id === 'string') {
+                        const kind = toolKinds.get(record.tool_use_id);
+                        if (kind === 'tool_call') {
+                            const elapsed = typeof record.elapsed_time_seconds === 'number'
+                                ? `（${Math.max(0, Math.round(record.elapsed_time_seconds))} 秒）`
+                                : '';
+                            this.host.emitItem(runId, {
+                                itemId: boundedConversationItemId('claude-tool', record.tool_use_id),
+                                kind,
+                                status: 'IN_PROGRESS',
+                                payload: {
+                                    progressLabel: compactRunnerText(`${typeof record.tool_name === 'string' ? record.tool_name : '工具'}正在执行${elapsed}`, 500)
+                                },
+                                merge: true
+                            });
+                        }
+                    }
+                    if (record.type === 'user') {
+                        for (const result of extractClaudeToolResults(record)) {
+                            const kind = toolKinds.get(result.toolUseId) ?? 'tool_call';
+                            if (kind === 'user_input_request')
+                                continue;
+                            this.host.emitItem(runId, {
+                                itemId: boundedConversationItemId('claude-tool', result.toolUseId),
+                                kind,
+                                status: result.failed ? 'FAILED' : 'COMPLETED',
+                                payload: kind === 'command_execution'
+                                    ? {
+                                        outputPreview: result.output,
+                                        exitCode: null,
+                                        durationMs: null,
+                                        truncated: result.truncated
+                                    }
+                                    : {
+                                        outputSummary: result.output,
+                                        progressLabel: null,
+                                        errorCode: result.failed ? 'TOOL_EXECUTION_FAILED' : null,
+                                        truncated: result.truncated
+                                    },
+                                merge: true
+                            });
+                        }
+                    }
+                    if (record.type === 'result') {
+                        const subtype = typeof record.subtype === 'string' ? record.subtype : 'unknown';
+                        const completedNativeSessionId = this.runner.execution.runs.get(runId)?.nativeSessionId ?? nativeSessionId;
+                        this.host.emit(runId, 'turn.completed', {
+                            subtype
+                        });
+                        // A Channel uses a long-lived input iterable. Receiving an SDK
+                        // result completes this AgentRun even though that iterable can
+                        // remain open waiting for another user turn; waiting only for
+                        // stream closure would leave the WorkspaceLease permanently held.
+                        finish(subtype === 'success' && record.is_error !== true ? 'SUCCEEDED' : 'FAILED', subtype === 'success' && record.is_error !== true ? 'run.completed' : 'run.failed', { subtype });
+                        if (completedNativeSessionId !== undefined)
+                            void this.host.syncTitle(sessionId, completedNativeSessionId, cwd);
+                    }
+                }
+            });
+            this.runner.execution.runs.set(runId, { marSessionId: sessionId, cwd, handle, gate });
+            this.host.setChannelToken(sessionId, gate.token);
+            this.host.send('session.channel.ready', { sessionId, token: gate.token });
+            this.host.emit(runId, 'run.running', {}, 'RUNNING');
+            void handle.completed.then(() => finish('SUCCEEDED', 'run.completed', { subtype: 'stream_closed' }), (error) => finish('FAILED', 'run.failed', {
+                code: error instanceof Error ? error.message : 'CLAUDE_RUN_FAILED'
+            }));
+        }
+        catch (error) {
+            finish('FAILED', 'run.failed', {
+                code: error instanceof Error ? error.message : 'CLAUDE_RUN_START_FAILED'
+            });
+        }
+    }
+}

package/dist/runner/claude-code-runner.d.ts

@@ -0,0 +1,70 @@
+import { ClaudeAgentSdkAdapter, type ClaudeChannelRunHandle, type ClaudeQueryInput, type ClaudeRunHandle } from '../claude-agent-sdk.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerSessionPresentationContext, type RunnerSessionPresentation } from './abstract-runner.js';
+import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
+import { ClaudeChannelGate } from '../claude-channel.js';
+import type { ChannelDelivery } from '../claude-channel.js';
+import { claudeUserInputQuestions } from '../util/runner-native-session-parsers.js';
+import type { NodeAgentSession, NodeWorkspace } from '../database.js';
+import { type NativeSessionHistory } from '../native-session-history.js';
+export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
+    private readonly client;
+    private readonly environment;
+    readonly name: "claude-code";
+    readonly discoveryScope: "WORKSPACE_REQUIRED";
+    readonly execution: ClaudeExecutionState;
+    constructor(client?: ClaudeAgentSdkAdapter, environment?: NodeJS.ProcessEnv);
+    profile(capabilities: NodeCapabilities): RunnerProfile;
+    available(capabilities: NodeCapabilities): boolean;
+    protected profileForValidation(): RunnerProfile;
+    defaultConfiguration(): RunnerDefaultConfiguration;
+    resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
+    discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
+    readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;
+    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
+    presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
+    prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
+    channelToken(sessionId: string): string | undefined;
+    deliverChannel(sessionId: string, messageId: string, senderId: string, token: string, content: string, notify: (runId: string, messageId: string, delivery: ChannelDelivery) => void): ChannelDelivery;
+    managedAliasId(nativeSessionId: string): string | undefined;
+    nativeAliasesFor(managedSessionId: string): readonly string[];
+    forgetNativeAlias(nativeSessionId: string): void;
+    rememberManagedNative(session: NodeAgentSession, nativeSessionId: string): void;
+    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
+    projectDiscoveredSessions(context: RunnerDiscoveryContext, workspace: NodeWorkspace, discovered: readonly ClaudeDiscoveredSession[]): readonly NodeAgentSession[];
+    stop(): void;
+    start(input: ClaudeQueryInput): ClaudeRunHandle;
+    startChannel(input: ClaudeQueryInput): ClaudeChannelRunHandle;
+    listSessions(cwd: string): ReturnType<ClaudeAgentSdkAdapter['listSessions']>;
+    sessionInfo(sessionId: string, cwd: string): ReturnType<ClaudeAgentSdkAdapter['sessionInfo']>;
+}
+export declare class ClaudeExecutionState {
+    readonly runs: Map<string, {
+        marSessionId: string;
+        nativeSessionId?: string;
+        cwd: string;
+        handle: ClaudeChannelRunHandle;
+        gate: ClaudeChannelGate;
+    }>;
+    readonly managedNativeIds: Set<string>;
+    readonly managedSessionByNativeId: Map<string, string>;
+    readonly approvals: Map<string, {
+        readonly runId: string;
+        readonly resolve: (decision: "APPROVED" | "REJECTED") => void;
+        readonly timer: NodeJS.Timeout;
+    }>;
+    readonly userInputs: Map<string, {
+        readonly runId: string;
+        readonly requestId: string;
+        readonly questions: ReturnType<typeof claudeUserInputQuestions>;
+        readonly input: Record<string, unknown>;
+        readonly resolve: (answers: Record<string, string>) => void;
+        readonly reject: (message?: string) => void;
+        readonly timer: NodeJS.Timeout;
+    }>;
+}
+type ClaudeDiscoveredSession = NativeSessionHistory | {
+    readonly externalSessionId: string;
+    readonly cwd: string;
+    readonly title?: string;
+};
+export {};