@richhardry/codor 0.10.0

package/node_modules/@codor/adapter-claude-code/dist/adapter.js

@@ -0,0 +1,785 @@
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { PolicySchema, ThinkingLevelSchema } from '@codor/protocol';
+import { probeClaudeLimits } from './limits-probe.js';
+import { peekClaudeContextUsage } from './peek.js';
+import { claudeQuery, } from './query.js';
+import { claudeContextWindow, createTurnTranslator, wireEventFromHook, } from './translate.js';
+const SESSION_FILE_RE = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+const CLAUDE_SETTING_SOURCES = [
+    'user',
+    'project',
+    'local',
+];
+// harn:assume harness-declares-supported-thinking-levels ref=claude-thinking-level-declaration
+export const CLAUDE_THINKING_LEVELS = [
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+    'ultracode',
+];
+function invalidPolicy(policy) {
+    return new Error(`unknown policy '${policy}'; valid policies: ${PolicySchema.options.join(', ')}`);
+}
+function assertThinkingLevel(thinking) {
+    if (thinking === undefined)
+        return;
+    if (!CLAUDE_THINKING_LEVELS.includes(thinking)) {
+        throw new Error(`adapter 'claude-code' does not support thinking level '${thinking}'; ` +
+            `valid levels: ${CLAUDE_THINKING_LEVELS.join(', ')}`);
+    }
+}
+// harn:end harness-declares-supported-thinking-levels
+// harn:assume canonical-spawn-controls-enforced ref=claude-spawn-control-mapping
+export function claudePermissionMode(policy) {
+    if (policy === undefined)
+        return undefined;
+    if (!PolicySchema.safeParse(policy).success)
+        throw invalidPolicy(policy);
+    return {
+        'read-only': 'plan',
+        'workspace-write': 'acceptEdits',
+        'full-access': 'bypassPermissions',
+    }[policy];
+}
+function claudeThinkingOptions(thinking) {
+    if (thinking === undefined)
+        return {};
+    ThinkingLevelSchema.parse(thinking);
+    assertThinkingLevel(thinking);
+    if (thinking === 'ultracode') {
+        return {
+            thinking: { type: 'adaptive' },
+            effort: 'xhigh',
+            settings: { ultracode: true },
+        };
+    }
+    return {
+        thinking: { type: 'adaptive' },
+        effort: thinking,
+    };
+}
+function createAsyncMessageInput() {
+    const queue = [];
+    const resolvers = [];
+    let closed = false;
+    return {
+        push(item) {
+            if (closed)
+                throw new Error('Claude SDK input is closed');
+            const resolve = resolvers.shift();
+            if (resolve)
+                resolve({ value: item, done: false });
+            else
+                queue.push(item);
+        },
+        end() {
+            closed = true;
+            while (resolvers.length > 0) {
+                resolvers.shift()?.({ value: undefined, done: true });
+            }
+        },
+        iterable: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => {
+                        const value = queue.shift();
+                        if (value !== undefined)
+                            return Promise.resolve({ value, done: false });
+                        if (closed)
+                            return Promise.resolve({ value: undefined, done: true });
+                        return new Promise((resolve) => resolvers.push(resolve));
+                    },
+                };
+            },
+        },
+    };
+}
+/**
+ * Compaction runs as its own engine turn and can legitimately take minutes on a
+ * long session; bound it so an engine that accepts `/compact` and then goes
+ * quiet surfaces as an error instead of a spinner that never resolves.
+ */
+const COMPACTION_TIMEOUT_MS = 180_000;
+function sortedEnvironment(env) {
+    return JSON.stringify(Object.entries(env)
+        .filter((entry) => entry[1] !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right)));
+}
+function queryIdentity(session) {
+    return {
+        cwd: session.cwd,
+        model: session.model,
+        policy: session.policy,
+        thinking: session.thinking,
+        env: sortedEnvironment({ ...process.env, ...session.env }),
+    };
+}
+function sameIdentity(left, right) {
+    return left !== undefined &&
+        left.cwd === right.cwd &&
+        left.model === right.model &&
+        left.policy === right.policy &&
+        left.thinking === right.thinking &&
+        left.env === right.env;
+}
+function asQuestion(input) {
+    if (!Array.isArray(input.questions))
+        return undefined;
+    const first = input.questions[0];
+    if (typeof first !== 'object' || first === null)
+        return undefined;
+    const source = first;
+    const options = Array.isArray(source.options)
+        ? source.options.flatMap((value) => {
+            if (typeof value !== 'object' || value === null)
+                return [];
+            const option = value;
+            return typeof option.label === 'string'
+                ? [{
+                        label: option.label,
+                        ...(typeof option.description === 'string' && { description: option.description }),
+                    }]
+                : [];
+        })
+        : undefined;
+    return {
+        ...(typeof source.question === 'string' && { question: source.question }),
+        ...(options !== undefined && { options }),
+        ...(typeof source.multiSelect === 'boolean' && { multiSelect: source.multiSelect }),
+    };
+}
+export function cardFromSdkPermission(interactionId, toolName, input, options = {}) {
+    if (toolName === 'AskUserQuestion') {
+        const question = asQuestion(input);
+        return {
+            interaction_id: interactionId,
+            kind: 'ask',
+            prompt: question?.question ?? options.title ?? '',
+            options: question?.options,
+            multi: question?.multiSelect ?? false,
+        };
+    }
+    const command = typeof input.command === 'string' ? input.command : undefined;
+    return {
+        interaction_id: interactionId,
+        kind: 'approval',
+        prompt: options.title ?? `Allow ${toolName}?`,
+        options: [
+            { label: 'allow once' },
+            { label: 'allow always' },
+            { label: 'deny' },
+        ],
+        tool: toolName,
+        detail: command ?? options.description ?? JSON.stringify(input),
+    };
+}
+function questionAnswers(input, answer) {
+    if (typeof answer === 'object' && answer !== null && !Array.isArray(answer)) {
+        return answer;
+    }
+    const question = asQuestion(input)?.question ?? '';
+    return {
+        [question]: Array.isArray(answer) ? answer.join(', ') : String(answer ?? ''),
+    };
+}
+function defaultInboxHookRunner(context) {
+    return new Promise((resolve, reject) => {
+        // harn:assume codor-runtime-identity-is-a-clean-break ref=adapter-runtime-identity
+        execFile('codor', ['inbox', '--new', '--consume', '--format', 'hook'], { cwd: context.cwd, env: context.env, maxBuffer: 256 * 1024 }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            const output = stdout.trim();
+            if (output === '') {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(output));
+            }
+            catch (parseError) {
+                reject(parseError);
+            }
+        });
+        // harn:end codor-runtime-identity-is-a-clean-break
+    });
+}
+/**
+ * Claude Code adapter backed by one long-lived Agent SDK query per member.
+ * query() owns the Claude runtime/control transport; Codor owns turn
+ * normalization, durable interaction cards, and session recovery.
+ */
+export class ClaudeCodeAdapter {
+    id = 'claude-code';
+    capabilities = {
+        resume: true,
+        discover: true,
+        interactiveAttach: true,
+        ask: true,
+        approvals: 'runtime',
+        extensions: true,
+        thinking: true,
+        thinking_levels: CLAUDE_THINKING_LEVELS,
+        // harn:assume live-inbox-capability-is-evidence-backed ref=claude-live-inbox-capability
+        live_inbox: true,
+        // harn:end live-inbox-capability-is-evidence-backed
+        // harn:assume harness-declares-what-a-policy-becomes ref=adapter-policy-declarations
+        policies: {
+            'read-only': 'plan',
+            'workspace-write': 'acceptEdits',
+            'full-access': 'bypassPermissions',
+        },
+        // harn:end harness-declares-what-a-policy-becomes
+    };
+    runtimes = new WeakMap();
+    memberRuntimes = new Map();
+    queryFactory;
+    inboxHookRunner;
+    constructor(options = {}) {
+        this.queryFactory = options.queryFactory ?? ((input) => claudeQuery(input));
+        this.inboxHookRunner = options.inboxHookRunner ?? defaultInboxHookRunner;
+    }
+    spawn(opts) {
+        claudePermissionMode(opts.policy);
+        if (opts.thinking !== undefined) {
+            ThinkingLevelSchema.parse(opts.thinking);
+            assertThinkingLevel(opts.thinking);
+        }
+        return {
+            harness: this.id,
+            cwd: opts.cwd,
+            model: opts.model,
+            policy: opts.policy,
+            thinking: opts.thinking,
+        };
+    }
+    // harn:assume adapters-own-their-model-catalog ref=claude-code-model-catalog
+    listModels() {
+        return Promise.resolve({
+            models: ['haiku', 'sonnet', 'opus', 'fable'],
+            source: 'curated',
+        });
+    }
+    // harn:end adapters-own-their-model-catalog
+    // harn:assume context-peek-reads-session-artifacts ref=claude-context-peek
+    peekContextUsage(session_ref) {
+        return Promise.resolve(peekClaudeContextUsage(session_ref, claudeContextWindow));
+    }
+    // harn:end context-peek-reads-session-artifacts
+    attach(session_ref) {
+        return { harness: this.id, session_ref, cwd: process.cwd() };
+    }
+    // harn:assume claude-agent-sdk-query-is-the-session-runtime ref=claude-sdk-session-lifecycle
+    async *deliver(session, payload, hooks = {}) {
+        const runtime = this.runtimeFor(session);
+        await this.prepareRuntime(runtime, session);
+        if (runtime.active !== null) {
+            throw new Error('a Claude turn is already in flight for this member');
+        }
+        const turn = {
+            translator: createTurnTranslator(runtime.context),
+            hooks,
+            queue: [],
+            wake: null,
+            terminal: false,
+            done: false,
+            interrupted: false,
+            reportedSessionRef: session.session_ref,
+        };
+        runtime.active = turn;
+        try {
+            try {
+                await this.ensureQuery(runtime);
+                hooks.onStarted?.({});
+                this.startQueryPump(runtime);
+                runtime.input.push({
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: [{ type: 'text', text: payload }],
+                    },
+                    parent_tool_use_id: null,
+                    uuid: randomUUID(),
+                    session_id: session.session_ref ?? '',
+                });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                this.push(turn, [{ type: 'run.completed', status: 'failed', error: detail }]);
+                turn.terminal = true;
+                turn.done = true;
+                await this.retireQuery(runtime);
+            }
+            while (true) {
+                if (turn.queue.length > 0) {
+                    yield turn.queue.shift();
+                    continue;
+                }
+                if (turn.done)
+                    break;
+                await new Promise((resolve) => {
+                    turn.wake = resolve;
+                });
+                turn.wake = null;
+            }
+        }
+        finally {
+            if (runtime.active === turn)
+                runtime.active = null;
+            if (!turn.terminal) {
+                this.completeTurn(runtime, turn, {
+                    type: 'run.completed',
+                    status: 'interrupted',
+                });
+                void this.retireQuery(runtime);
+            }
+        }
+    }
+    runtimeFor(session) {
+        const existing = this.runtimes.get(session);
+        if (existing !== undefined) {
+            existing.session = session;
+            return existing;
+        }
+        const memberKey = session.env?.CODOR_MEMBER_ID;
+        const memberRuntime = memberKey === undefined
+            ? undefined
+            : this.memberRuntimes.get(memberKey);
+        const runtime = memberRuntime ?? {
+            session,
+            ...(memberKey !== undefined && { memberKey }),
+            query: null,
+            input: null,
+            pump: null,
+            retiring: null,
+            active: null,
+            context: {
+                ...(session.session_ref !== undefined && { sessionId: session.session_ref }),
+            },
+            pendingPermissions: new Map(),
+            pendingCompaction: null,
+        };
+        runtime.session = session;
+        this.runtimes.set(session, runtime);
+        if (memberKey !== undefined)
+            this.memberRuntimes.set(memberKey, runtime);
+        return runtime;
+    }
+    async prepareRuntime(runtime, session) {
+        if (runtime.retiring !== null)
+            await runtime.retiring;
+        const nextIdentity = queryIdentity(session);
+        if (runtime.query !== null && !sameIdentity(runtime.identity, nextIdentity)) {
+            await this.retireQuery(runtime);
+        }
+        runtime.session = session;
+        runtime.context.sessionId = session.session_ref ?? runtime.context.sessionId;
+        if (runtime.query === null)
+            runtime.identity = nextIdentity;
+    }
+    async ensureQuery(runtime) {
+        if (runtime.retiring !== null)
+            await runtime.retiring;
+        if (runtime.query !== null)
+            return;
+        // A query that just exited clears runtime.query from inside its pump before
+        // the pump's completion callback clears runtime.pump. Do not install the
+        // replacement in that narrow window or startQueryPump would mistake the
+        // settled, previous pump for the replacement's pump.
+        if (runtime.pump !== null)
+            await runtime.pump;
+        if (runtime.query !== null)
+            return;
+        const input = createAsyncMessageInput();
+        const query = claudeQuery({ prompt: input.iterable, options: this.queryOptions(runtime) }, this.queryFactory);
+        runtime.input = input;
+        runtime.query = query;
+        runtime.identity = queryIdentity(runtime.session);
+    }
+    startQueryPump(runtime) {
+        if (runtime.query === null || runtime.pump !== null)
+            return;
+        const pump = this.runQueryPump(runtime, runtime.query);
+        runtime.pump = pump;
+        void pump.finally(() => {
+            if (runtime.pump === pump)
+                runtime.pump = null;
+        });
+    }
+    queryOptions(runtime) {
+        const session = runtime.session;
+        const permissionMode = claudePermissionMode(session.policy);
+        const extensionHook = async (input) => {
+            const event = wireEventFromHook(input);
+            if (event !== undefined && runtime.active !== null)
+                this.push(runtime.active, [event]);
+            return {};
+        };
+        // harn:assume claude-sdk-hooks-are-authoritative ref=claude-sdk-hook-callbacks
+        const postToolUseHook = async () => {
+            const current = runtime.session;
+            // harn:assume live-inbox-capability-is-evidence-backed ref=claude-post-tool-use-hook
+            return await this.inboxHookRunner({
+                cwd: current.cwd,
+                env: { ...process.env, ...current.env },
+            }) ?? {};
+            // harn:end live-inbox-capability-is-evidence-backed
+        };
+        // harn:end claude-sdk-hooks-are-authoritative
+        return {
+            cwd: session.cwd,
+            includePartialMessages: true,
+            systemPrompt: { type: 'preset', preset: 'claude_code' },
+            settingSources: CLAUDE_SETTING_SOURCES,
+            canUseTool: this.permissionCallback(runtime),
+            hooks: {
+                SubagentStart: [{ hooks: [extensionHook] }],
+                SubagentStop: [{ hooks: [extensionHook] }],
+                PostToolUse: [{ hooks: [postToolUseHook] }],
+            },
+            allowDangerouslySkipPermissions: true,
+            ...(permissionMode !== undefined && { permissionMode }),
+            ...(session.model !== undefined && { model: session.model }),
+            ...(session.session_ref !== undefined && { resume: session.session_ref }),
+            ...claudeThinkingOptions(session.thinking),
+            // harn:assume adapter-children-inherit-session-env ref=claude-child-environment
+            env: { ...process.env, ...session.env },
+            // harn:end adapter-children-inherit-session-env
+        };
+    }
+    permissionCallback(runtime) {
+        // harn:assume claude-sdk-permissions-back-codor-interactions ref=claude-sdk-permission-callback
+        return async (toolName, input, options) => {
+            const turn = runtime.active;
+            if (turn === null || turn.done) {
+                throw new Error('Claude requested permission without an active turn');
+            }
+            const interactionId = `permission-${randomUUID()}`;
+            const card = cardFromSdkPermission(interactionId, toolName, input, options);
+            this.push(turn, [
+                card.kind === 'ask'
+                    ? { type: 'ask.raised', card }
+                    : { type: 'approval.raised', card },
+            ]);
+            return await new Promise((resolve, reject) => {
+                const abort = () => {
+                    runtime.pendingPermissions.delete(interactionId);
+                    reject(new Error('Claude permission request aborted'));
+                };
+                if (options.signal.aborted) {
+                    abort();
+                    return;
+                }
+                options.signal.addEventListener('abort', abort, { once: true });
+                runtime.pendingPermissions.set(interactionId, {
+                    toolName,
+                    input,
+                    suggestions: options.suggestions,
+                    resolve,
+                    reject,
+                    cleanup: () => options.signal.removeEventListener('abort', abort),
+                });
+            });
+        };
+        // harn:end claude-sdk-permissions-back-codor-interactions
+    }
+    async runQueryPump(runtime, query) {
+        let failure;
+        try {
+            for await (const message of query) {
+                if (runtime.query !== query)
+                    return;
+                this.routeMessage(runtime, message);
+            }
+        }
+        catch (error) {
+            failure = error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            if (runtime.query === query) {
+                runtime.query = null;
+                runtime.input?.end();
+                runtime.input = null;
+                // A query that ended can never deliver the boundary: fail now with the
+                // real reason instead of leaving the operator on a 180s timeout.
+                this.failCompaction(runtime, failure ?? new Error('Claude query closed before compaction completed'));
+                this.rejectPendingPermissions(runtime, failure ?? new Error('Claude SDK query ended before permission resolution'));
+                const turn = runtime.active;
+                if (turn !== null && !turn.terminal) {
+                    this.completeTurn(runtime, turn, turn.interrupted
+                        ? { type: 'run.completed', status: 'interrupted' }
+                        : {
+                            type: 'run.completed',
+                            status: 'failed',
+                            error: failure?.message ?? 'Claude SDK query ended before terminal result',
+                        });
+                }
+            }
+        }
+    }
+    routeMessage(runtime, message) {
+        const turn = runtime.active;
+        if (turn === null || turn.done) {
+            this.observeCompaction(runtime, message);
+            return;
+        }
+        const events = turn.translator.push(message);
+        this.push(turn, events);
+        const discovered = turn.translator.sessionId();
+        if (discovered !== undefined && discovered !== turn.reportedSessionRef) {
+            runtime.context.sessionId = discovered;
+            runtime.session.session_ref = discovered;
+            turn.reportedSessionRef = discovered;
+            turn.hooks.onSessionRef?.(discovered);
+        }
+        if (events.some((event) => event.type === 'run.completed')) {
+            turn.terminal = true;
+            turn.done = true;
+            turn.wake?.();
+        }
+    }
+    push(turn, events) {
+        if (events.length === 0)
+            return;
+        turn.queue.push(...events);
+        turn.wake?.();
+    }
+    completeTurn(runtime, turn, event) {
+        if (turn.terminal)
+            return;
+        this.rejectPendingPermissions(runtime, new Error('Claude turn ended before permission resolution'));
+        this.push(turn, [event]);
+        turn.terminal = true;
+        turn.done = true;
+        turn.wake?.();
+    }
+    rejectPendingPermissions(runtime, error) {
+        for (const [id, pending] of runtime.pendingPermissions) {
+            pending.cleanup();
+            pending.reject(error);
+            runtime.pendingPermissions.delete(id);
+        }
+    }
+    async retireQuery(runtime, removeRuntime = false) {
+        if (runtime.retiring !== null)
+            return await runtime.retiring;
+        this.failCompaction(runtime, new Error('Claude query retired before compaction completed'));
+        const query = runtime.query;
+        const input = runtime.input;
+        const pump = runtime.pump;
+        runtime.query = null;
+        runtime.input = null;
+        this.rejectPendingPermissions(runtime, new Error('Claude SDK query retired'));
+        const retiring = (async () => {
+            if (query !== null) {
+                try {
+                    await query.interrupt();
+                }
+                catch {
+                    // A crashed query is already unavailable; close/return still release it.
+                }
+                input?.end();
+                query.close();
+                try {
+                    await query.return?.();
+                }
+                catch {
+                    // The iterator may already have failed.
+                }
+            }
+            await pump?.catch(() => undefined);
+            if (removeRuntime && runtime.memberKey !== undefined) {
+                this.memberRuntimes.delete(runtime.memberKey);
+            }
+        })();
+        runtime.retiring = retiring;
+        try {
+            await retiring;
+        }
+        finally {
+            if (runtime.retiring === retiring)
+                runtime.retiring = null;
+        }
+    }
+    // harn:end claude-agent-sdk-query-is-the-session-runtime
+    probeLimits() {
+        return probeClaudeLimits();
+    }
+    // harn:assume claude-sdk-permissions-back-codor-interactions ref=claude-sdk-permission-callback
+    async respondInteraction(session, interaction_id, answer) {
+        const runtime = this.runtimes.get(session)
+            ?? (session.env?.CODOR_MEMBER_ID === undefined
+                ? undefined
+                : this.memberRuntimes.get(session.env.CODOR_MEMBER_ID));
+        const pending = runtime?.pendingPermissions.get(interaction_id);
+        if (runtime === undefined || pending === undefined) {
+            throw new Error(`no pending interaction ${interaction_id}`);
+        }
+        runtime.pendingPermissions.delete(interaction_id);
+        pending.cleanup();
+        if (pending.toolName === 'AskUserQuestion') {
+            pending.resolve({
+                behavior: 'allow',
+                updatedInput: {
+                    ...pending.input,
+                    answers: questionAnswers(pending.input, answer),
+                },
+            });
+            return;
+        }
+        const choice = typeof answer === 'string' ? answer : 'deny';
+        if (choice === 'deny') {
+            pending.resolve({ behavior: 'deny', message: 'denied by codor operator' });
+            return;
+        }
+        pending.resolve({
+            behavior: 'allow',
+            updatedInput: pending.input,
+            ...(choice === 'allow always' &&
+                pending.suggestions !== undefined &&
+                pending.suggestions.length > 0 && {
+                updatedPermissions: pending.suggestions,
+            }),
+        });
+    }
+    // harn:end claude-sdk-permissions-back-codor-interactions
+    /**
+     * Compact this session using Claude's OWN compaction: an unwrapped `/compact`
+     * pushed into the persistent SDK query, exactly as a human typing it would.
+     * Only ever called for an idle session — a turn in flight is refused rather
+     * than raced, because compaction rewrites the very history the turn is using.
+     * Resolves with the re-baselined context the compact_boundary reports, so the
+     * ring updates without waiting for a next turn; the boundary's timeline items
+     * are NOT journaled — compaction outside a run is member state, not evidence.
+     */
+    async compactSession(session) {
+        const runtime = this.liveRuntime(session);
+        if (runtime === undefined)
+            throw new Error('no live Claude session to compact');
+        if (runtime.active !== null && !runtime.active.terminal) {
+            throw new Error('cannot compact while a turn is in flight');
+        }
+        if (runtime.pendingCompaction !== null)
+            throw new Error('a compaction is already in flight');
+        await this.ensureQuery(runtime);
+        this.startQueryPump(runtime);
+        const settled = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => this.failCompaction(runtime, new Error('Claude compaction timed out')), COMPACTION_TIMEOUT_MS);
+            timer.unref?.();
+            runtime.pendingCompaction = {
+                translator: createTurnTranslator(runtime.context),
+                settle: resolve,
+                fail: reject,
+                timer,
+            };
+        });
+        try {
+            runtime.input.push({
+                type: 'user',
+                message: { role: 'user', content: [{ type: 'text', text: '/compact' }] },
+                parent_tool_use_id: null,
+                uuid: randomUUID(),
+                session_id: session.session_ref ?? '',
+            });
+        }
+        catch (error) {
+            this.clearCompaction(runtime);
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+        return await settled;
+    }
+    /**
+     * The pump drops every message while no turn is active — which is precisely
+     * when a manual compaction runs — so the boundary is observed here instead.
+     * Only the engine's own re-baseline settles it: a boundary that reports no
+     * post-token count resolves undefined rather than clobbering a good gauge.
+     */
+    observeCompaction(runtime, message) {
+        const pending = runtime.pendingCompaction;
+        if (pending === null)
+            return;
+        let events;
+        try {
+            events = pending.translator.push(message);
+        }
+        catch (error) {
+            this.failCompaction(runtime, error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const usage = events.find((event) => event.type === 'usage_updated');
+        const completed = events.some((event) => event.type === 'timeline' &&
+            event.item.type === 'compaction' &&
+            event.item.status === 'completed');
+        if (!completed)
+            return;
+        this.clearCompaction(runtime);
+        pending.settle(usage?.type === 'usage_updated' ? usage.usage : undefined);
+    }
+    /** Every terminal path clears the pending state; none may leak a promise. */
+    clearCompaction(runtime) {
+        const pending = runtime.pendingCompaction;
+        if (pending === null)
+            return null;
+        clearTimeout(pending.timer);
+        runtime.pendingCompaction = null;
+        return pending;
+    }
+    failCompaction(runtime, error) {
+        this.clearCompaction(runtime)?.fail(error);
+    }
+    /** Find-only: the runtime this session already has, never creating one. */
+    liveRuntime(session) {
+        return this.runtimes.get(session)
+            ?? (session.env?.CODOR_MEMBER_ID === undefined
+                ? undefined
+                : this.memberRuntimes.get(session.env.CODOR_MEMBER_ID));
+    }
+    interrupt(session) {
+        const runtime = this.liveRuntime(session);
+        if (runtime === undefined)
+            return;
+        const turn = runtime.active;
+        if (turn !== null && !turn.terminal) {
+            turn.interrupted = true;
+            this.completeTurn(runtime, turn, { type: 'run.completed', status: 'interrupted' });
+        }
+        void this.retireQuery(runtime, true);
+    }
+    /** Session ids from the transcript store (~/.claude/projects/<cwd-slug>/). */
+    discoverSessions() {
+        const refs = [];
+        const root = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'projects');
+        let projects;
+        try {
+            projects = readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            return refs;
+        }
+        for (const project of projects) {
+            if (!project.isDirectory())
+                continue;
+            let files;
+            try {
+                files = readdirSync(join(root, project.name));
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                const match = SESSION_FILE_RE.exec(file);
+                if (match)
+                    refs.push(match[1]);
+            }
+        }
+        return refs;
+    }
+}
+//# sourceMappingURL=adapter.js.map