handmux 0.23.0 → 0.25.0

package/dist/src/agents/codexConversationActivation.js

@@ -0,0 +1,121 @@
+import { serializePaneInput } from '../paneInput.js';
+import { codex, codexExitSessionId } from './codex.js';
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const SHELLS = new Set(['sh', 'bash', 'zsh', 'fish', 'dash', 'ksh', 'tcsh']);
+function throwIfAborted(signal) {
+    if (signal.aborted)
+        throw signal.reason instanceof Error ? signal.reason : new Error('Activation cancelled');
+}
+export function createCodexConversationActivationController({ panes, process, commands, wait = pause, }) {
+    if (!panes || !process || !commands || typeof commands.sendKey !== 'function'
+        || typeof commands.capturePlain !== 'function' || typeof commands.runPaneCommand !== 'function') {
+        throw new TypeError('Codex Conversation activation requires pane control');
+    }
+    const pane = async (paneId) => (await panes.list()).find((item) => item.paneId === paneId) ?? null;
+    const codexIdentity = async (paneId) => {
+        const current = await pane(paneId);
+        if (!current)
+            return null;
+        const identity = await process.inspectForeground(current);
+        if (!identity)
+            return null;
+        return await codex.process.verify(current, { inspectForeground: async () => identity })
+            ? identity : null;
+    };
+    const shellIdentity = async (paneId) => {
+        const current = await pane(paneId);
+        if (!current)
+            return null;
+        const identity = await process.inspectForeground(current);
+        if (!identity)
+            return null;
+        const executable = identity.executable?.split('/').pop()?.toLowerCase();
+        return SHELLS.has(current.currentCommand.toLowerCase()) || (executable && SHELLS.has(executable))
+            ? identity : null;
+    };
+    const sameProcess = (first, second) => (first.pid === second.pid
+        && (first.startedAt === undefined || second.startedAt === first.startedAt)
+        && (first.tty === undefined || second.tty === first.tty));
+    return {
+        apiVersion: 1,
+        async describe(run) {
+            if (run.ref.sessionId || run.signal.aborted || !await codexIdentity(run.ref.paneId))
+                return null;
+            return { effect: 'replace-process-preserve-session' };
+        },
+        async activate(run, signal) {
+            await serializePaneInput(run.ref.paneId, async () => {
+                const paneId = run.ref.paneId;
+                throwIfAborted(signal);
+                const original = !run.ref.sessionId && !run.signal.aborted
+                    ? await codexIdentity(paneId) : null;
+                throwIfAborted(signal);
+                if (!original)
+                    throw new Error('The Agent run changed before Conversation activation');
+                // Authorization is bound to the verified run above. Exiting that exact process intentionally revokes
+                // its lease, so subsequent checks bind recovery to the shell that replaced it.
+                let exited = false;
+                let shell = null;
+                for (let press = 0; press < 2 && !exited; press += 1) {
+                    throwIfAborted(signal);
+                    const beforePress = await codexIdentity(paneId);
+                    if (!beforePress || !sameProcess(original, beforePress)) {
+                        throw new Error('The Agent process changed before Conversation activation');
+                    }
+                    throwIfAborted(signal);
+                    await commands.sendKey(paneId, 'C-c');
+                    for (let attempt = 0; attempt < 10; attempt += 1) {
+                        await wait(500);
+                        throwIfAborted(signal);
+                        if (!await pane(paneId))
+                            throw new Error('The pane closed during Conversation activation');
+                        const currentIdentity = await codexIdentity(paneId);
+                        if (!currentIdentity) {
+                            shell = await shellIdentity(paneId);
+                            if (!shell)
+                                throw new Error('The pane did not return to the expected shell');
+                            exited = true;
+                            break;
+                        }
+                        if (!sameProcess(original, currentIdentity)) {
+                            throw new Error('The Agent process changed during Conversation activation');
+                        }
+                    }
+                }
+                if (!exited || !shell)
+                    throw new Error('Codex did not exit; close any open panel in the terminal and try again');
+                let sessionId = null;
+                for (let attempt = 0; attempt < 20; attempt += 1) {
+                    throwIfAborted(signal);
+                    const beforeCapture = await shellIdentity(paneId);
+                    if (!beforeCapture || !sameProcess(shell, beforeCapture)) {
+                        throw new Error('The pane shell changed during Conversation activation');
+                    }
+                    try {
+                        const candidate = codexExitSessionId(await commands.capturePlain(paneId));
+                        if (codex.sessions.isId(candidate)) {
+                            sessionId = candidate;
+                            break;
+                        }
+                    }
+                    catch {
+                        throw new Error('The pane closed during Conversation activation');
+                    }
+                    await wait(100);
+                }
+                if (!sessionId)
+                    throw new Error('Codex did not expose a resumable session; continue in the terminal');
+                const resume = codex.sessions.managedResumeCmd?.(sessionId);
+                if (!resume)
+                    throw new Error('Managed Conversation activation is unavailable');
+                throwIfAborted(signal);
+                const beforeResume = await shellIdentity(paneId);
+                if (!beforeResume || !sameProcess(shell, beforeResume)) {
+                    throw new Error('The pane shell changed before Conversation activation');
+                }
+                throwIfAborted(signal);
+                await commands.runPaneCommand(paneId, resume);
+            });
+        },
+    };
+}

package/dist/src/agents/codexConversationControls.js

@@ -0,0 +1,256 @@
+import { stat as statFile } from 'node:fs/promises';
+import { parseCodexGoal } from '../codexStreamProtocol.js';
+import { readLatestContextUsage } from '../codexUsageSnapshot.js';
+import { resolveCodexRollout, sessionsDir } from './codex.js';
+const CONTEXT_RECOVERY_TTL_MS = 2_000;
+const CONTEXT_RECOVERY_CACHE_LIMIT = 64;
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null);
+const string = (value) => (typeof value === 'string' && value.trim() ? value.trim() : undefined);
+function target(run) {
+    const threadId = run.ref.sessionId;
+    if (!threadId)
+        throw new Error('Codex conversation control requires a managed thread');
+    return { pane: run.ref.paneId, threadId };
+}
+const PERMISSION_SETTINGS = {
+    default: {
+        approvalPolicy: 'on-request', approvalsReviewer: 'user',
+        sandboxPolicy: { type: 'workspaceWrite' },
+    },
+    'auto-review': {
+        approvalPolicy: 'on-request', approvalsReviewer: 'auto_review',
+        sandboxPolicy: { type: 'workspaceWrite' },
+    },
+    'full-access': {
+        approvalPolicy: 'never', approvalsReviewer: 'user',
+        sandboxPolicy: { type: 'dangerFullAccess' },
+    },
+};
+function permissionMode(settings) {
+    const sandbox = string(record(settings.sandboxPolicy)?.type);
+    const approval = string(settings.approvalPolicy);
+    const reviewer = string(settings.approvalsReviewer);
+    if ((sandbox === 'dangerFullAccess' || sandbox === 'danger-full-access') && approval === 'never') {
+        return 'full-access';
+    }
+    if ((sandbox === 'workspaceWrite' || sandbox === 'workspace-write') && approval === 'on-request') {
+        return reviewer === 'auto_review' || reviewer === 'guardian_subagent' ? 'auto-review' : 'default';
+    }
+    return 'custom';
+}
+function contextSnapshot(value) {
+    const status = record(value) ?? {};
+    const settings = record(status.settings) ?? {};
+    const usage = record(status.contextUsage);
+    const nativeStatus = record(status.status);
+    const flags = Array.isArray(nativeStatus?.activeFlags) ? nativeStatus.activeFlags : [];
+    const activity = status.activityKind === 'compacting' ? 'compacting'
+        : flags.includes('waitingOnApproval') || flags.includes('waitingOnUserInput')
+            || (Array.isArray(status.approvals) && status.approvals.length > 0)
+            || (Array.isArray(status.userInputs) && status.userInputs.length > 0) ? 'waiting'
+            : nativeStatus?.type === 'active' ? 'working' : 'idle';
+    const sandbox = string(record(settings.sandboxPolicy)?.type);
+    const access = sandbox === 'readOnly' || sandbox === 'read-only' ? 'read-only'
+        : sandbox === 'workspaceWrite' || sandbox === 'workspace-write' ? 'workspace-write'
+            : sandbox === 'dangerFullAccess' || sandbox === 'danger-full-access' ? 'full-access' : undefined;
+    const usedTokens = typeof usage?.usedTokens === 'number' ? usage.usedTokens : undefined;
+    const totalTokens = typeof usage?.totalTokens === 'number' ? usage.totalTokens : undefined;
+    const cwd = string(settings.cwd);
+    const branch = string(status.gitBranch);
+    return {
+        activity,
+        ...(usedTokens === undefined ? {} : { usedTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(branch === undefined ? {} : { branch }),
+        ...(access === undefined ? {} : { access }),
+    };
+}
+function permissionSnapshot(value) {
+    const status = record(value) ?? {};
+    const settings = record(status.settings) ?? {};
+    return {
+        mode: permissionMode(settings),
+        options: ['default', 'auto-review', 'full-access'],
+    };
+}
+function planSnapshot(value) {
+    const status = record(value) ?? {};
+    const plan = record(status.plan);
+    const stepsValue = Array.isArray(plan?.steps) ? plan.steps : Array.isArray(plan?.plan) ? plan.plan : [];
+    const steps = stepsValue.flatMap((candidate) => {
+        const step = record(candidate);
+        const label = string(step?.step);
+        const state = ['pending', 'inProgress', 'completed'].find((item) => item === step?.status);
+        return label && state ? [{ step: label, status: state }] : [];
+    });
+    if (!steps.length)
+        return null;
+    const explanation = string(plan?.explanation);
+    const turnId = string(plan?.turnId) ?? string(status.activeTurnId);
+    const waiting = contextSnapshot(status).activity === 'waiting';
+    return {
+        steps,
+        ...(explanation === undefined ? {} : { explanation }),
+        ...(turnId === undefined ? {} : { turnId }),
+        ...(waiting ? { waiting: true } : {}),
+    };
+}
+export function createCodexConversationControls(app, clear, { sessionsRoot = sessionsDir(), findRollout = resolveCodexRollout, reader = readLatestContextUsage, stat = statFile, now = Date.now, } = {}) {
+    let cached;
+    const recoveredContexts = new Map();
+    const storeRecovered = (threadId, entry) => {
+        if (recoveredContexts.has(threadId))
+            recoveredContexts.delete(threadId);
+        if (recoveredContexts.size >= CONTEXT_RECOVERY_CACHE_LIMIT) {
+            const oldest = recoveredContexts.keys().next().value;
+            if (oldest !== undefined)
+                recoveredContexts.delete(oldest);
+        }
+        recoveredContexts.set(threadId, entry);
+    };
+    const recoverContext = (threadId) => {
+        const checkedAt = now();
+        const previous = recoveredContexts.get(threadId);
+        if (previous?.inFlight)
+            return previous.inFlight;
+        if (previous && previous.checkedAt + CONTEXT_RECOVERY_TTL_MS > checkedAt) {
+            return Promise.resolve(previous.value);
+        }
+        let pending;
+        pending = (async () => {
+            try {
+                const file = await findRollout(sessionsRoot, threadId);
+                if (!file) {
+                    storeRecovered(threadId, { checkedAt, file: null, value: null });
+                    return null;
+                }
+                const metadata = await stat(file);
+                if (previous?.file === file && previous.size === metadata.size
+                    && previous.mtimeMs === metadata.mtimeMs) {
+                    storeRecovered(threadId, {
+                        checkedAt,
+                        file,
+                        size: metadata.size,
+                        mtimeMs: metadata.mtimeMs,
+                        value: previous.value,
+                    });
+                    return previous.value;
+                }
+                const value = await reader(file);
+                storeRecovered(threadId, {
+                    checkedAt, file, size: metadata.size, mtimeMs: metadata.mtimeMs, value,
+                });
+                return value;
+            }
+            catch {
+                const fallback = previous ?? { checkedAt, file: null, value: null };
+                storeRecovered(threadId, {
+                    checkedAt,
+                    file: fallback.file,
+                    ...(fallback.size === undefined ? {} : { size: fallback.size }),
+                    ...(fallback.mtimeMs === undefined ? {} : { mtimeMs: fallback.mtimeMs }),
+                    value: fallback.value,
+                });
+                return fallback.value;
+            }
+        })();
+        storeRecovered(threadId, {
+            checkedAt,
+            file: previous?.file ?? null,
+            ...(previous?.size === undefined ? {} : { size: previous.size }),
+            ...(previous?.mtimeMs === undefined ? {} : { mtimeMs: previous.mtimeMs }),
+            value: previous?.value ?? null,
+            inFlight: pending,
+        });
+        return pending;
+    };
+    const status = (pane, threadId) => {
+        const key = `${pane}\0${threadId}`;
+        if (cached?.key === key && cached.expiresAt >= now())
+            return cached.value;
+        const value = app.status(pane, threadId);
+        cached = { key, expiresAt: now() + 100, value };
+        void value.catch(() => { if (cached?.value === value)
+            cached = undefined; });
+        return value;
+    };
+    const invalidate = () => { cached = undefined; };
+    return {
+        goal: {
+            apiVersion: 1,
+            async read(run) {
+                const { pane, threadId } = target(run);
+                return parseCodexGoal(await app.getGoal(pane, threadId));
+            },
+            async start(run, objective) {
+                const { pane, threadId } = target(run);
+                const goal = parseCodexGoal(await app.startGoal(pane, threadId, objective));
+                if (!goal)
+                    throw new Error('Codex returned an invalid Goal');
+                invalidate();
+                return goal;
+            },
+            async update(run, patch) {
+                const { pane, threadId } = target(run);
+                const goal = parseCodexGoal(await app.updateGoal(pane, threadId, patch));
+                if (!goal)
+                    throw new Error('Codex returned an invalid Goal');
+                invalidate();
+                return goal;
+            },
+            async clear(run) {
+                const { pane, threadId } = target(run);
+                await app.clearGoal(pane, threadId);
+                invalidate();
+            },
+        },
+        plan: {
+            apiVersion: 1,
+            async read(run) {
+                const { pane, threadId } = target(run);
+                return planSnapshot(await status(pane, threadId));
+            },
+        },
+        context: {
+            apiVersion: 1,
+            async read(run) {
+                const { pane, threadId } = target(run);
+                const snapshot = contextSnapshot(await status(pane, threadId));
+                if (snapshot.usedTokens !== undefined && snapshot.totalTokens !== undefined)
+                    return snapshot;
+                const recovered = await recoverContext(threadId);
+                return recovered ? {
+                    ...snapshot,
+                    usedTokens: recovered.usedTokens,
+                    totalTokens: recovered.totalTokens,
+                } : snapshot;
+            },
+        },
+        permission: {
+            apiVersion: 1,
+            async read(run) {
+                const { pane, threadId } = target(run);
+                return permissionSnapshot(await status(pane, threadId));
+            },
+            async update(run, mode) {
+                const { pane, threadId } = target(run);
+                await app.updateSettings(pane, threadId, PERMISSION_SETTINGS[mode]);
+                invalidate();
+                return permissionSnapshot(await status(pane, threadId));
+            },
+        },
+        commands: {
+            apiVersion: 1,
+            commands: ['compact', 'clear'],
+            async execute(run, command) {
+                const { pane, threadId } = target(run);
+                if (command === 'compact')
+                    await app.compact(pane, threadId);
+                else
+                    await clear(pane, threadId);
+                invalidate();
+            },
+        },
+    };
+}

package/dist/src/agents/codexInteraction.js

@@ -0,0 +1,306 @@
+function decisionId(value) {
+    return typeof value === 'string' ? value : value.id;
+}
+function decisionLabel(value) {
+    if (typeof value === 'string') {
+        return {
+            accept: 'Allow once', acceptForSession: 'Allow for session', decline: 'Deny', cancel: 'Cancel',
+        }[value] ?? value;
+    }
+    if (value.type === 'networkPolicy') {
+        return `${value.action === 'deny' ? 'Deny' : 'Allow'} network${value.host ? `: ${value.host}` : ''}`;
+    }
+    return `${value.action === 'deny' ? 'Deny' : 'Allow'} command policy`;
+}
+function approval(value) {
+    const sourceId = `approval:${value.id}`;
+    const intent = value.type === 'command' ? 'command_approval'
+        : value.type === 'file' ? 'file_approval' : 'permission_approval';
+    const prompt = value.reason || value.command || value.type;
+    const details = [
+        ...(value.reason ? [{ kind: 'reason', type: 'text', text: value.reason }] : []),
+        ...(value.command ? [{ kind: 'command', type: 'code', text: value.command }] : []),
+        ...(value.cwd ? [{
+                kind: 'working_directory', type: 'path', text: value.cwd,
+            }] : []),
+    ];
+    const options = [...new Map(value.decisions.map((decision) => [
+            decisionId(decision), { id: decisionId(decision), label: decisionLabel(decision) },
+        ])).values()];
+    if (!options.length) {
+        return {
+            sourceId,
+            requestId: value.id,
+            kind: 'local_only',
+            pending: {
+                id: sourceId, type: 'local_only', intent, prompt,
+                ...(details.length ? { details } : {}),
+                ...(value.correlationId || value.itemId || value.turnId
+                    ? { correlationId: value.correlationId || value.itemId || value.turnId } : {}),
+            },
+        };
+    }
+    return {
+        sourceId,
+        requestId: value.id,
+        kind: 'approval',
+        decisionIds: new Set(options.map((option) => option.id)),
+        pending: {
+            id: sourceId, type: 'approval', intent, prompt, options,
+            ...(details.length ? { details } : {}),
+            ...(value.correlationId || value.itemId || value.turnId
+                ? { correlationId: value.correlationId || value.itemId || value.turnId } : {}),
+        },
+    };
+}
+function userInput(value) {
+    const sourceId = `input:${value.id}`;
+    const correlationId = value.correlationId || value.itemId || value.turnId;
+    if (!value.questions.length) {
+        return {
+            sourceId, requestId: value.id, kind: 'local_only',
+            pending: {
+                id: sourceId, type: 'local_only', intent: 'input_request', prompt: value.id,
+                ...(correlationId ? { correlationId } : {}),
+            },
+        };
+    }
+    const inputFields = new Map();
+    const fields = [];
+    for (const [questionIndex, question] of value.questions.entries()) {
+        const fieldId = `field:${questionIndex}`;
+        if (question.options) {
+            const usableOptions = question.options.filter((option) => option.label.length > 0);
+            if (usableOptions.length !== question.options.length || !usableOptions.length)
+                continue;
+            const optionValues = new Map();
+            const options = usableOptions.map((option, optionIndex) => {
+                const id = `option:${questionIndex}:${optionIndex}`;
+                optionValues.set(id, option.label);
+                return {
+                    id, label: option.label,
+                    ...(option.description ? { description: option.description } : {}),
+                };
+            });
+            inputFields.set(fieldId, {
+                questionId: question.id, optionValues,
+                ...(question.isOther ? { allowOther: true } : {}),
+            });
+            fields.push({
+                id: fieldId, type: 'select', prompt: question.question, options,
+                ...(question.header ? { label: question.header } : {}),
+                ...(question.isOther ? { allowOther: true } : {}),
+            });
+            continue;
+        }
+        inputFields.set(fieldId, { questionId: question.id });
+        fields.push({
+            id: fieldId, type: question.isSecret ? 'secret' : 'text',
+            prompt: question.question,
+            ...(question.header ? { label: question.header } : {}),
+        });
+    }
+    if (fields.length !== value.questions.length) {
+        return {
+            sourceId, requestId: value.id, kind: 'local_only',
+            pending: {
+                id: sourceId, type: 'local_only', intent: 'input_request',
+                prompt: value.questions.map((question) => question.question).join('\n'),
+                ...(correlationId ? { correlationId } : {}),
+            },
+        };
+    }
+    return {
+        sourceId, requestId: value.id, kind: 'input', inputFields,
+        pending: {
+            id: sourceId, type: 'form', intent: 'input_request',
+            prompt: value.questions[0].question, fields,
+            ...(correlationId ? { correlationId } : {}),
+        },
+    };
+}
+function normalizeSnapshot(snapshot) {
+    const values = [
+        ...snapshot.approvals.map(approval),
+        ...snapshot.userInputs.map(userInput),
+    ];
+    return new Map(values.map((value) => [value.sourceId, value]));
+}
+function sourceCursor(cursor, ordinal) {
+    return `codex-interactions:${cursor}:${ordinal}`;
+}
+function errorReceipt(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/no longer pending/i.test(message))
+        return { status: 'already_resolved' };
+    if (/session changed|not managed|stale/i.test(message))
+        return { status: 'stale_run' };
+    if (/unavailable|bad user input|unsupported|decision/i.test(message)) {
+        return { status: 'rejected', reason: 'provider_rejected' };
+    }
+    return { status: 'unknown', reason: 'temporarily_unavailable' };
+}
+export function createCodexInteractionAdapter(app) {
+    if (!app || typeof app.discover !== 'function' || typeof app.observeInteractions !== 'function'
+        || typeof app.decide !== 'function' || typeof app.answerInput !== 'function') {
+        throw new TypeError('Codex Interaction adapter requires App Server interaction APIs');
+    }
+    const bindings = new Map();
+    return {
+        apiVersion: 1,
+        async observeNative(run, sink) {
+            const threadId = run.ref.sessionId;
+            if (!threadId)
+                throw new Error('Codex Interaction run has no thread');
+            const discovered = await app.discover(run.ref.paneId);
+            if (!discovered?.managed || discovered.threadId !== threadId) {
+                throw new Error('Codex Interaction run is not the pane-owned thread');
+            }
+            let phase = 'opening';
+            let current = new Map();
+            const buffered = [];
+            let tail = Promise.resolve();
+            let reset = 0;
+            const emitSnapshot = async (snapshot) => {
+                if (phase === 'closed' || !Number.isSafeInteger(snapshot.cursor) || snapshot.cursor < 0) {
+                    throw new Error('Invalid Codex Interaction snapshot');
+                }
+                const next = normalizeSnapshot(snapshot);
+                const events = [];
+                for (const [id] of current) {
+                    if (!next.has(id))
+                        events.push(snapshot.disconnected
+                            ? { type: 'cancelled', interactionId: id, reason: 'stream_reset' }
+                            : { type: 'resolved', interactionId: id });
+                }
+                for (const [id, item] of next) {
+                    const previous = current.get(id);
+                    if (!previous || JSON.stringify(previous.pending) !== JSON.stringify(item.pending)) {
+                        events.push({ type: 'opened', interaction: item.pending });
+                    }
+                }
+                current = next;
+                binding.interactions = next;
+                for (const [index, event] of events.entries()) {
+                    const cursor = snapshot.disconnected
+                        ? `codex-interactions:reset:${++reset}:${index}`
+                        : sourceCursor(snapshot.cursor, index + 1);
+                    await sink({ ...event, sourceCursor: cursor });
+                }
+            };
+            const failClosed = async () => {
+                if (phase === 'closed')
+                    return;
+                const pending = [...current.keys()];
+                current.clear();
+                binding.interactions.clear();
+                for (const [index, interactionId] of pending.entries()) {
+                    try {
+                        await sink({
+                            type: 'cancelled', interactionId, reason: 'stream_reset',
+                            sourceCursor: `codex-interactions:reset:${++reset}:${index}`,
+                        });
+                    }
+                    catch {
+                        break;
+                    }
+                }
+                phase = 'closed';
+                observed.close();
+            };
+            const observed = await app.observeInteractions(run.ref.paneId, threadId, (snapshot) => {
+                if (phase === 'opening') {
+                    buffered.push(structuredClone(snapshot));
+                    return;
+                }
+                tail = tail.then(async () => {
+                    await emitSnapshot(snapshot);
+                    if (snapshot.disconnected) {
+                        phase = 'closed';
+                        observed.close();
+                    }
+                }).catch(failClosed);
+            });
+            current = normalizeSnapshot(observed);
+            const previous = bindings.get(run.ref.runId);
+            previous?.detachAbort();
+            const binding = { run, interactions: current, detachAbort: () => { } };
+            const onAbort = () => {
+                phase = 'closed';
+                observed.close();
+                if (bindings.get(run.ref.runId) === binding)
+                    bindings.delete(run.ref.runId);
+            };
+            run.signal.addEventListener('abort', onAbort, { once: true });
+            binding.detachAbort = () => run.signal.removeEventListener('abort', onAbort);
+            bindings.set(run.ref.runId, binding);
+            phase = 'live';
+            for (const snapshot of buffered.splice(0)) {
+                if (snapshot.cursor <= observed.cursor)
+                    continue;
+                tail = tail.then(() => emitSnapshot(snapshot));
+            }
+            tail = tail.catch(failClosed);
+            return {
+                checkpoint: {
+                    sourceCursor: sourceCursor(observed.cursor, 0),
+                    pending: [...current.values()].map((item) => structuredClone(item.pending)),
+                },
+                close() {
+                    if (phase === 'closed')
+                        return;
+                    phase = 'closed';
+                    observed.close();
+                },
+            };
+        },
+        async dispatchResponse(run, request) {
+            const threadId = run.ref.sessionId;
+            const binding = bindings.get(run.ref.runId);
+            if (!threadId || !binding || binding.run !== run || run.signal.aborted) {
+                return { status: 'stale_run' };
+            }
+            const native = binding.interactions.get(request.interactionId);
+            if (!native)
+                return { status: 'already_resolved' };
+            if (native.kind === 'local_only')
+                return { status: 'rejected', reason: 'local_only' };
+            try {
+                if (native.kind === 'approval') {
+                    if (request.value.type !== 'approval' || !native.decisionIds?.has(request.value.optionId)) {
+                        return { status: 'rejected', reason: 'invalid_value' };
+                    }
+                    await app.decide(run.ref.paneId, threadId, native.requestId, request.value.optionId);
+                }
+                else {
+                    const answers = inputAnswers(native, request.value);
+                    if (answers === null)
+                        return { status: 'rejected', reason: 'invalid_value' };
+                    await app.answerInput(run.ref.paneId, threadId, native.requestId, answers);
+                }
+                binding.interactions.delete(request.interactionId);
+                return { status: 'accepted' };
+            }
+            catch (error) {
+                return errorReceipt(error);
+            }
+        },
+    };
+}
+function inputAnswers(native, value) {
+    if (value.type !== 'form' || native.pending.type !== 'form' || !native.inputFields)
+        return null;
+    if (Object.keys(value.answers).length !== native.inputFields.size)
+        return null;
+    const answers = {};
+    for (const [fieldId, field] of native.inputFields) {
+        const raw = value.answers[fieldId];
+        if (typeof raw !== 'string' || !raw.length)
+            return null;
+        const answer = field.optionValues?.get(raw) ?? (field.allowOther ? raw : field.optionValues ? null : raw);
+        if (answer === null)
+            return null;
+        answers[field.questionId] = [answer];
+    }
+    return answers;
+}