@ai-workbench/remote-agent 0.8.21 → 0.8.23

package/dist/agents.d.ts

@@ -7,7 +7,6 @@ export interface AgentDefinition {
     }>;
     readonly command: string;
     readonly loginProvider: 'claude' | 'codex';
-    readonly oneShot: boolean;
 }
 export declare const CODEX_AGENT: AgentDefinition;
 export declare const CLAUDE_AGENT: AgentDefinition;

package/dist/agents.js

@@ -1,4 +1,4 @@
-export const CODEX_AGENT = Object.freeze({ id: 'codex-remote', name: Object.freeze({ zh: 'Codex（远程主机）', en: 'Codex (Remote Host)' }), command: '/usr/local/aw-host/bin/codex-acp', loginProvider: 'codex', oneShot: true });
-export const CLAUDE_AGENT = Object.freeze({ id: 'claude-code-workbench', name: Object.freeze({ zh: 'Claude（远程主机）', en: 'Claude (Remote Host)' }), command: '/usr/local/aw-host/bin/claude-agent-acp', loginProvider: 'claude', oneShot: false });
+export const CODEX_AGENT = Object.freeze({ id: 'codex-remote', name: Object.freeze({ zh: 'Codex（远程主机）', en: 'Codex (Remote Host)' }), command: '/usr/local/aw-host/bin/codex-acp', loginProvider: 'codex' });
+export const CLAUDE_AGENT = Object.freeze({ id: 'claude-code-workbench', name: Object.freeze({ zh: 'Claude（远程主机）', en: 'Claude (Remote Host)' }), command: '/usr/local/aw-host/bin/claude-agent-acp', loginProvider: 'claude' });
 export const AGENTS = Object.freeze([CODEX_AGENT, CLAUDE_AGENT]);
 export function agentForProvider(id) { return AGENTS.find(agent => agent.id === id); }

package/dist/broker-runtime.d.ts

@@ -1,10 +1,8 @@
 import { type SshArgv, type BrokerIo, type BrokerSettings } from './broker.ts';
 import { type ConnectApi, type ConnectTarget, type Project, type Runtime, type RuntimeRequest } from './provider.ts';
 import type { Interaction } from './interaction.ts';
-import { type RecoveryJournal } from './recovery.ts';
-/** Test ports are explicit; deployed code always supplies the official-profile journal. */
-export declare function brokerFactory(get: () => ConnectApi | undefined, _ask: Interaction | undefined, configuration: BrokerSettings | (() => BrokerSettings), provided?: {
+/** Each invocation owns a new agent. Context resumes by native session ID, never by reattaching a broker. */
+export declare function brokerFactory(_get: () => ConnectApi | undefined, _ask: Interaction | undefined, configuration: BrokerSettings | (() => BrokerSettings), provided?: {
     argv?: SshArgv;
     io?: (target: ConnectTarget) => BrokerIo;
-    journal?: (key: string) => RecoveryJournal;
-}): (target: ConnectTarget, project: Project, initialRequest: RuntimeRequest) => Promise<Runtime>;
+}): (target: ConnectTarget, project: Project, request: RuntimeRequest) => Promise<Runtime>;

package/dist/broker-runtime.js

@@ -6,355 +6,58 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { CloseDiagnostics, closeCode, flushCloseDiagnostics } from "./close-diagnostics.js";
-import { BrokerTransport, brokerCommand, brokerId, legacyBrokerId, sshIo, controlJson } from "./broker.js";
+import { randomUUID } from 'node:crypto';
+import { CloseDiagnostics } from "./close-diagnostics.js";
+import { BrokerTransport, brokerCommand, brokerId, sshIo, controlJson } from "./broker.js";
 import { CODEX_AGENT } from "./agents.js";
-import { protectedOneShotLayout } from "./host-layout.js";
 import { NeedError } from "./remote.js";
-import { identity, unwrap, validateTarget, sameTarget } from "./provider.js";
-import { StageTiming } from "./stage-timing.js";
-import { recoveryKey } from "./recovery.js";
-const need = (code) => new NeedError(code, '原主机会话暂时无法安全接续，本轮尚未发送', '技术详情中的原会话状态');
-const modern = (entry) => Object.hasOwn(entry, 'instanceId');
-function validEntry(entry) {
-    if (!entry || typeof entry.id !== 'string' || !Number.isSafeInteger(entry.pid) || entry.pid < 1 || !['running', 'exited'].includes(entry.state) || ![entry.firstSequence, entry.lastSequence].every(Number.isSafeInteger) || entry.lastSequence < 0 || entry.firstSequence < 1 || entry.firstSequence > entry.lastSequence + 1)
-        throw need('BROKER_PROTOCOL_INVALID');
-    if (modern(entry) && (typeof entry.instanceId !== 'string' || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(entry.instanceId) || !Number.isSafeInteger(entry.controlMaxBytes) || entry.controlMaxBytes < 1))
-        throw need('BROKER_PROTOCOL_INVALID');
-}
-async function leaseWait(ms, signal) {
-    if (!Number.isSafeInteger(ms) || ms < 0 || ms > 2147483647)
-        throw need('LEASE_POLICY_INVALID');
-    signal?.throwIfAborted();
-    await new Promise((resolve, reject) => { const clear = () => signal?.removeEventListener('abort', abort); const timer = setTimeout(() => { clear(); resolve(); }, ms); const abort = () => { clearTimeout(timer); clear(); reject(need('ABORTED')); }; signal?.addEventListener('abort', abort, { once: true }); if (signal?.aborted)
-        abort(); });
-}
-/** Test ports are explicit; deployed code always supplies the official-profile journal. */
-export function brokerFactory(get, _ask, configuration, provided) {
-    const active = new Set();
-    const retained = new Map();
-    const testJournals = new Map();
-    const open = async (target, project, initialRequest) => {
-        let request = initialRequest;
-        const settings = request.brokerSettings ?? (typeof configuration === 'function' ? configuration() : configuration);
-        const agent = request.agent ?? CODEX_AGENT;
-        if (!request.sessionId)
-            throw need('SESSION_REQUIRED');
-        const employeeScope = request.employeeScope;
-        if (employeeScope && (request.mode !== 'session' || request.resumeSessionId || request.recoveryCheckpointId))
-            throw need('EMPLOYEE_OPERATION_UNSUPPORTED');
-        if (request.mode === 'one-shot') {
-            const key = 'one-shot/' + identity(target) + '/' + agent.id + '/' + request.sessionId;
-            if (active.has(key))
-                throw need('TURN_BUSY');
-            const layout = protectedOneShotLayout(target);
-            active.add(key);
-            return { identity: identity(target), cwd: project.path, oneShot: { target, cwd: project.path, ...layout }, dispose: async () => { active.delete(key); } };
+import { identity } from "./provider.js";
+/** Each invocation owns a new agent. Context resumes by native session ID, never by reattaching a broker. */
+export function brokerFactory(_get, _ask, configuration, provided) {
+    return async (target, project, request) => {
+        const agent = request.agent ?? CODEX_AGENT, settings = request.brokerSettings ?? (typeof configuration === 'function' ? configuration() : configuration);
+        let argv = provided?.argv;
+        if (!provided?.io && !argv) {
+            const module = '@ai-workbench/connect';
+            argv = (await import(__rewriteRelativeImportExtension(module))).sshArgs;
         }
-        if (![settings.brokerMaxFrameBytes, settings.brokerControlMaxBytes].every(n => Number.isSafeInteger(n) && n > 0))
-            throw need('SETTINGS_REQUIRED');
-        const key = recoveryKey([identity(target), agent.id, request.sessionId, ...(employeeScope ? [employeeScope] : [])]);
-        // New employee scopes compare execution values, independent of JSON key insertion order.
-        // Legacy journals retain their historical serialization bytes.
-        const scopedSession = employeeScope ? { command: target.session.command, root: target.session.root, settingsPath: target.session.settingsPath, protocolVersion: target.session.protocolVersion } : target.session;
-        const scopedSettings = employeeScope ? { brokerMaxFrameBytes: settings.brokerMaxFrameBytes, brokerControlMaxBytes: settings.brokerControlMaxBytes } : settings;
-        const scopeParts = [target.host, target.username, target.port, target.proxyCommand, target.knownHostsFile, target.projectRoot, scopedSession, project.path, agent.id, scopedSettings, request.bindingId, request.workspaceId];
-        if (employeeScope)
-            scopeParts.push(employeeScope);
-        const contextBoundScope = recoveryKey([...scopeParts, request.contextSha256]);
-        // A Codex ACP process can own several immutable native sessions. D18's durable
-        // pointer controls their context; the broker still binds every transport identity.
-        const scope = recoveryKey([...scopeParts, undefined]);
-        const previousContextScope = agent.loginProvider === 'claude' && request.previousContextSha256 ? recoveryKey([...scopeParts, request.previousContextSha256]) : contextBoundScope;
-        const existing = request.retainProcess ? retained.get(key) : undefined;
-        if (existing) {
-            if (existing.scope !== scope)
-                throw need('SESSION_CONTEXT_MISMATCH');
-            if (existing.runtime.broker?.error)
-                throw existing.runtime.broker.error;
-            if (request.requireFreshSession) {
-                if (existing.runtime.broker?.promptInFlight)
-                    throw need('INPUT_DELIVERY_UNCONFIRMED');
-                await existing.runtime.dispose?.({ layer: 'broker', initiator: 'broker.fresh-session-required', reason: 'PRIVATE_RECOVERY_POINTER_ABSENT', action: 'dispose' });
-                return open(target, project, request);
-            }
-            existing.update(request);
-            existing.runtime.restartNotice = undefined;
-            existing.runtime.restartInputIds = undefined;
-            existing.runtime.freshSessionConfirmed = undefined;
-            existing.runtime.recoveredSession = undefined;
-            return existing.runtime;
-        }
-        if (active.has(key))
-            throw need('TURN_BUSY');
-        active.add(key);
+        const io = provided?.io?.(target) ?? sshIo(target, argv, settings.brokerControlMaxBytes);
+        const command = (args) => brokerCommand(target, args);
+        const diagnostics = request.closeDiagnostics ?? new CloseDiagnostics(detail => request.detailChannel?.record(detail));
+        const id = brokerId(request.sessionId + '/' + randomUUID(), agent.id);
+        const startCommand = command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--', agent.command]);
+        // environments.toml overrides CODEX_EXEC_SERVER_URL. Refuse that host default rather
+        // than allowing a local-workspace resume to select a host executor.
+        const employeeStart = request.employeeScope && agent.loginProvider === 'codex';
+        const guardedStart = employeeStart ? `if [ -e "\${CODEX_HOME:-$HOME/.codex}/environments.toml" ] || [ -L "\${CODEX_HOME:-$HOME/.codex}/environments.toml" ]; then printf '%s\\n' '{"code":"AW_EMPLOYEE_ENVIRONMENTS_CONFIG_UNSUPPORTED"}'; else CODEX_EXEC_SERVER_URL=none ${startCommand}; fi` : startCommand;
+        const started = controlJson(await io.run(guardedStart, request.signal));
+        if (started.code === 'AW_EMPLOYEE_ENVIRONMENTS_CONFIG_UNSUPPORTED')
+            throw new NeedError(started.code, '主机的环境配置会覆盖本机执行位置，本轮已停止；请由管理员移开该配置后在原会话重试。', '主机 CODEX_HOME/environments.toml 不存在');
+        if (started.protocolVersion !== 1 || started.id !== id || !started.instanceId)
+            throw new NeedError('BROKER_PROTOCOL_INVALID', '主机会话未能启动，请恢复连接后再试。', '有效的主机会话启动回应');
+        const channel = new BrokerTransport({ observeClose: diagnostics.capture(), maxFrameBytes: settings.brokerMaxFrameBytes, instanceId: started.instanceId, leased: true, controlMaxBytes: started.controlMaxBytes, attach: () => io.attach(command(['attach', id, '--after', '0', '--framed', '--leased', '--if-instance', started.instanceId])) });
+        let ended = false;
+        const dispose = async (cause = { layer: 'broker', initiator: 'broker.dispose', reason: 'BROKER_DISPOSE', action: 'dispose' }) => {
+            if (ended)
+                return;
+            ended = true;
+            diagnostics.record(cause);
+            channel.close(cause);
+            void io.run(command(['kill', id, '--if-instance', started.instanceId])).catch(() => console.warn('[remote-agent] 旧主机会话暂未清理，将由主机自动回收'));
+        };
+        const aborted = () => channel.fail(new NeedError('ABORTED', '本轮已取消。', '确认主机状态'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
+        request.signal?.addEventListener('abort', aborted, { once: true });
         try {
-            const journal = request.recoveryJournal ?? provided?.journal?.(key) ?? (provided?.io ? { read: async () => structuredClone(testJournals.get(key)), write: async (value) => { testJournals.set(key, structuredClone(value)); } } : undefined);
-            if (!journal)
-                throw need('RECOVERY_STORAGE_REQUIRED');
-            let state = await journal.read();
-            const legacyContextScope = !!state && state.scope !== scope && state.scope === previousContextScope;
-            if (state && state.scope !== scope && !legacyContextScope)
-                throw need(agent.loginProvider === 'codex' ? 'RECOVERY_CONTEXT_POLICY_UNSUPPORTED' : 'SESSION_CONTEXT_MISMATCH');
-            if (legacyContextScope && state?.phase !== 'clean')
-                throw need('RECOVERY_CONTEXT_POLICY_UNSUPPORTED');
-            let argv = provided?.argv;
-            if (!provided?.io && !argv) {
-                const name = '@ai-workbench/connect';
-                const supplied = await import(__rewriteRelativeImportExtension(name));
-                if (typeof supplied.sshArgs !== 'function')
-                    throw need('DEPENDENCY_REQUIRED');
-                argv = supplied.sshArgs;
-            }
-            const ioFor = (t) => provided?.io?.(t) ?? sshIo(t, argv, settings.brokerControlMaxBytes);
-            let io = ioFor(target);
-            const command = (args) => brokerCommand(target, args);
-            let timing = request.timing ?? new StageTiming();
-            const validate = async (cleanup = false) => { if (!cleanup)
-                request.signal?.throwIfAborted(); await request.validateContext?.(cleanup); if (!cleanup)
-                request.signal?.throwIfAborted(); };
-            const report = async (code, extra = {}, cleanup = false) => { request.detailChannel?.record({ kind: 'need', severity: 'warning', code, summary: '远端会话恢复状态：' + code, payload: extra }); await request.detailChannel?.flush(); await validate(cleanup); };
-            const list = async (cleanup = false) => timing.run('broker-list', async () => { const rows = controlJson(await io.run(command(['list']), cleanup ? undefined : request.signal)); if (!Array.isArray(rows) || rows.some(row => typeof row?.id !== 'string'))
-                throw need('BROKER_PROTOCOL_INVALID'); return rows; });
-            const detailSink = request.detailChannel;
-            const closeDiagnostics = request.closeDiagnostics ?? new CloseDiagnostics(event => detailSink?.record(event));
-            let rows = await list();
-            const id = brokerId(request.sessionId, employeeScope ? agent.id + '/employee/' + employeeScope : agent.id), oldId = legacyBrokerId(request.sessionId, agent.id);
-            let restarted = !!request.requireFreshSession;
-            const attachArgs = (entry, after) => ['attach', entry.id, '--after', String(after), '--framed', ...(modern(entry) ? ['--leased', '--if-instance', entry.instanceId] : [])];
-            const connectWithLease = async (transport, entry, cleanup = false) => {
-                try {
-                    await transport.connect();
-                }
-                catch (error) {
-                    if (!(error instanceof NeedError) || error.code !== 'ATTACH_BUSY' || !modern(entry))
-                        throw error;
-                    const current = (await list(cleanup)).find(row => row.id === entry.id);
-                    if (!current || current.instanceId !== entry.instanceId)
-                        throw need('SESSION_INSTANCE_MISMATCH');
-                    validEntry(current);
-                    const policy = current.lifecycle;
-                    if (!policy || typeof policy.enabled !== 'boolean' || typeof policy.attached !== 'boolean')
-                        throw need('LEASE_POLICY_INVALID');
-                    if (policy.attached && !policy.enabled)
-                        throw need('SESSION_IN_USE');
-                    const remaining = policy.attached ? policy.remainingLeaseMs : 0;
-                    if (remaining === undefined || remaining === null || !Number.isSafeInteger(remaining) || remaining < 0)
-                        throw need('LEASE_POLICY_INVALID');
-                    await report('WAITING_PRIOR_CLIENT_LEASE', { brokerId: entry.id, instanceId: entry.instanceId, remainingLeaseMs: remaining }, cleanup);
-                    await leaseWait(remaining, cleanup ? undefined : request.signal);
-                    await validate(cleanup);
-                    try {
-                        await transport.connect();
-                    }
-                    catch (next) {
-                        if (next instanceof NeedError && next.code === 'ATTACH_BUSY')
-                            throw need('SESSION_IN_USE');
-                        throw next;
-                    }
-                }
-            };
-            const claim = async (entry, cleanup = false) => {
-                const probe = new BrokerTransport({ observeClose: closeDiagnostics.child().capture(), discardOutput: true, onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId ?? null } }), maxFrameBytes: settings.brokerMaxFrameBytes, initialSequence: entry.lastSequence, instanceId: entry.instanceId, leased: modern(entry), controlMaxBytes: entry.controlMaxBytes, attach: after => io.attach(command(attachArgs(entry, after))) });
-                try {
-                    await connectWithLease(probe, entry, cleanup);
-                }
-                catch (error) {
-                    if (!(entry.state === 'exited' && error instanceof NeedError && error.code === 'AGENT_EXITED')) {
-                        probe.close({ layer: 'broker', initiator: 'broker.probe-close', reason: 'BROKER_PROBE_FINISHED', action: 'close' });
-                        throw error;
-                    }
-                }
-                return probe;
-            };
-            const stop = async (entry, code, owned, cleanup = false, freshOwned = false) => {
-                validEntry(entry);
-                if (!modern(entry))
-                    throw need('BROKER_CAPABILITY_REQUIRED');
-                if (!owned?.online && !freshOwned) {
-                    const current = (await list(cleanup)).find(row => row.id === entry.id);
-                    if (!current) {
-                        await report('SESSION_ALREADY_ABSENT', { brokerId: entry.id, instanceId: entry.instanceId ?? null }, cleanup);
-                        return;
-                    }
-                    validEntry(current);
-                    if (modern(current) !== modern(entry) || current.instanceId !== entry.instanceId)
-                        throw need('SESSION_INSTANCE_MISMATCH');
-                    entry = current;
-                }
-                const probe = owned?.online || freshOwned ? owned : await claim(entry, cleanup);
-                try {
-                    await report(code, { brokerId: entry.id, ...(entry.instanceId ? { instanceId: entry.instanceId } : {}), observedPid: entry.pid, legacySessionSlot: !modern(entry) }, cleanup);
-                    if (entry.state === 'running' && !probe.online && !freshOwned)
-                        throw need('MIGRATION_CLAIM_LOST');
-                    await validate(cleanup);
-                    const ack = controlJson(await io.run(command(['kill', entry.id, ...(entry.instanceId ? ['--if-instance', entry.instanceId] : [])]), cleanup ? undefined : request.signal));
-                    if (ack?.type !== 'killed' || ack.id !== entry.id || modern(entry) && ack.instanceId !== entry.instanceId)
-                        throw need('REMOTE_CLEANUP_UNCONFIRMED');
-                    if ((await list(cleanup)).some(row => row.id === entry.id))
-                        throw need('REMOTE_CLEANUP_UNCONFIRMED');
-                }
-                finally {
-                    probe.close({ layer: 'broker', initiator: 'broker.probe-close', reason: 'BROKER_PROBE_FINISHED', action: 'close' });
-                }
-            };
-            const legacy = employeeScope ? undefined : rows.find(row => row.id === oldId);
-            if (legacy)
-                await report('PRE_0410_TEST_SESSION_NOT_RESUMED', { brokerId: legacy.id, observedPid: legacy.pid, state: legacy.state, instanceId: legacy.instanceId ?? null, reason: 'OLD_TEST_SESSION_COORDINATOR_CLEANUP', decision: '2026-10-22-00:05', approvalReplies: 0 });
-            let entry = rows.find(row => row.id === id);
-            if (entry)
-                validEntry(entry);
-            if (legacyContextScope && !entry && !request.requireFreshSession)
-                throw need('RECOVERY_CONTEXT_POLICY_UNSUPPORTED');
-            if (legacy && !entry)
-                restarted = true;
-            let transport;
-            let resume;
-            const build = (entry, after, recovery) => new BrokerTransport({ observeClose: closeDiagnostics.capture(), onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId } }), maxFrameBytes: settings.brokerMaxFrameBytes, maxMessageBytes: request.acpMaxMessageBytes ?? settings.brokerMaxFrameBytes, initialSequence: after, instanceId: entry.instanceId, leased: true, controlMaxBytes: entry.controlMaxBytes, beforeInput: async () => { await validate(); if (state?.phase !== 'dirty' || state.instanceId !== entry.instanceId) {
-                    const dirty = { version: 1, scope, brokerId: id, instanceId: entry.instanceId, pid: entry.pid, phase: 'dirty' };
-                    await journal.write(dirty);
-                    state = dirty;
-                } await validate(); }, ...(recovery ? { recoverySessionId: recovery.sessionId, onRecoveryUpdate: (message) => { const params = message.params; if (params.update?.sessionUpdate === 'config_option_update' && recovery.modelConfiguration) {
-                        if (!Array.isArray(params.update.configOptions))
-                            throw need('RECOVERY_MODEL_CONFIGURATION_INVALID');
-                        (recovery.configUpdates ??= []).push(structuredClone(params.update.configOptions));
-                    } request.detailChannel?.record({ kind: 'session', severity: 'info', code: 'ACP_IDLE_UPDATE', summary: '恢复期间的远端状态轨迹', method: 'session/update', payload: message.params }); } } : {}), attach: after => io.attach(command(attachArgs(entry, after))), onDisconnect: async () => {
-                    if (employeeScope)
-                        throw need('EMPLOYEE_EXEC_UNKNOWN');
-                    const api = get();
-                    if (!provided?.io) {
-                        if (!api)
-                            throw need('DEPENDENCY_REQUIRED');
-                        const next = unwrap(await api.getSshTarget());
-                        validateTarget(next);
-                        if (!sameTarget(next, target))
-                            throw need('SESSION_CONTEXT_MISMATCH');
-                        io = ioFor(next);
-                    }
-                    await validate();
-                    await connectWithLease(transport, entry);
-                } });
-            if (entry) {
-                if (!modern(entry))
-                    throw need('BROKER_CAPABILITY_REQUIRED');
-                if (request.requireFreshSession) {
-                    if (!state || !['clean', 'ended'].includes(state.phase) || state.instanceId !== entry.instanceId)
-                        throw need('INPUT_DELIVERY_UNCONFIRMED');
-                    await stop(entry, 'PRIVATE_RECOVERY_POINTER_ABSENT');
-                    restarted = true;
-                    entry = undefined;
-                }
-            }
-            if (entry) {
-                const clean = !employeeScope && state?.phase === 'clean' && state.instanceId === entry.instanceId && state.acp?.sessionId === request.resumeSessionId && state.checkpointId === request.recoveryCheckpointId && state.cursor >= entry.firstSequence - 1 && state.cursor <= entry.lastSequence && entry.state === 'running' && (legacyContextScope ? await request.verifyRecovery?.() === true : await request.verifyRecovery?.() !== false);
-                if (legacyContextScope && !clean)
-                    throw need('RECOVERY_CONTEXT_POLICY_UNSUPPORTED');
-                if (clean) {
-                    transport = build(entry, state.cursor, state.acp);
-                    try {
-                        await timing.run('broker-attach', () => connectWithLease(transport, entry));
-                        await transport.replayThrough(entry.lastSequence, request.signal);
-                        await request.detailChannel?.flush();
-                        await validate();
-                        if (legacyContextScope) {
-                            const migrated = { ...state, scope };
-                            await report(agent.loginProvider === 'codex' ? 'CODEX_RECOVERY_SCOPE_MIGRATED' : 'CLAUDE_RECOVERY_SCOPE_MIGRATED', { oldScope: state.scope, newScope: scope, sessionId: state.acp.sessionId, checkpointId: state.checkpointId, instanceId: entry.instanceId, cursor: state.cursor });
-                            await journal.write(migrated);
-                            state = migrated;
-                        }
-                        resume = state.acp;
-                    }
-                    catch (error) {
-                        transport.close({ layer: 'broker', initiator: 'broker.replay-failure', reason: closeCode(error, 'RECOVERY_UNCONFIRMED'), action: 'close' });
-                        if (legacyContextScope || error instanceof NeedError && ['ATTACH_BUSY', 'SESSION_IN_USE', 'SESSION_INSTANCE_MISMATCH', 'ABORTED'].includes(error.code))
-                            throw error;
-                        await report('SESSION_REPLAY_UNRECOVERABLE', { brokerId: id, instanceId: entry.instanceId, reason: error instanceof NeedError ? error.code : 'UNKNOWN_FAILURE', recordedCursor: state?.cursor ?? null, firstSequence: entry.firstSequence, lastSequence: entry.lastSequence });
-                    }
-                }
-                if (!resume) {
-                    await stop(entry, 'SESSION_CHECKPOINT_UNRECOVERABLE', transport);
-                    restarted = true;
-                    entry = undefined;
-                    transport = undefined;
-                }
-            }
-            if (!entry) {
-                if (request.resumeSessionId) {
-                    restarted = true;
-                    await report('SESSION_BROKER_ABSENT', { brokerId: id });
-                }
-                await validate();
-                state = { version: 1, scope, brokerId: id, phase: 'dirty' };
-                await journal.write(state);
-                const started = await timing.run('broker-start', async () => controlJson(await io.run(command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--', agent.command]), request.signal)));
-                if (started?.protocolVersion !== 1 || started.id !== id || typeof started.socket !== 'string' || !started.instanceId || !Number.isSafeInteger(started.controlMaxBytes) || !Number.isSafeInteger(started.pid) || started.pid < 1)
-                    throw need('BROKER_START_UNCONFIRMED');
-                entry = { ...started, state: 'running', firstSequence: 1, lastSequence: 0 };
-                state = { ...state, instanceId: entry.instanceId, pid: entry.pid };
-                await journal.write(state);
-                validEntry(entry);
-                transport = build(entry, 0);
-                const opening = transport;
-                const aborted = () => opening.fail(need('ABORTED'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
-                request.signal?.addEventListener('abort', aborted, { once: true });
-                try {
-                    request.signal?.throwIfAborted();
-                    await timing.run('broker-attach', () => connectWithLease(opening, entry));
-                    await validate();
-                }
-                catch (error) {
-                    if (!(error instanceof NeedError && ['ATTACH_BUSY', 'SESSION_IN_USE', 'SESSION_INSTANCE_MISMATCH'].includes(error.code)))
-                        await stop(entry, 'SESSION_OPEN_FAILED', opening, true, true);
-                    opening.close({ layer: 'broker', initiator: 'broker.open-failure', reason: closeCode(error), action: 'close' });
-                    throw error;
-                }
-                finally {
-                    request.signal?.removeEventListener('abort', aborted);
-                }
-            }
-            const ownedEntry = entry, ownedTransport = transport;
-            let disposed = false;
-            let disposal;
-            const runtime = { closeDiagnostics, identity: identity(target), cwd: project.path, broker: ownedTransport, acpTransport: ownedTransport,
-                ...(resume ? { recoveredSession: resume } : {}), ...(restarted ? { restartNotice: '上次会话无法接回，已新建会话；本次从你的这条请求继续。', restartInputIds: request.currentInputIds } : {}), ...(request.requireFreshSession ? { freshSessionConfirmed: true } : {}),
-                saveCheckpoint: async (checkpointId, acp) => { await validate(); const saved = await ownedTransport.commitCheckpoint(async (cursor) => { await validate(); const clean = { version: 1, phase: 'clean', scope, brokerId: id, instanceId: ownedEntry.instanceId, pid: ownedEntry.pid, cursor, checkpointId, acp }; try {
-                    await journal.write(clean);
-                    state = clean;
-                }
-                catch (error) {
-                    state = undefined;
-                    throw error;
-                } }); if (!saved)
-                    await report('SESSION_CHECKPOINT_NOT_CLEAN', { brokerId: id, instanceId: ownedEntry.instanceId }); return saved; },
-                detach: async (cause = { layer: 'broker', initiator: 'broker.runtime-detach', reason: 'BROKER_DETACH', action: 'detach' }) => { const sink = request.detailChannel; closeDiagnostics.record(cause); ownedTransport.close(cause); active.delete(key); retained.delete(key); await flushCloseDiagnostics(closeDiagnostics, sink ? () => sink.flush() : undefined); },
-                dispose: (cause = { layer: 'broker', initiator: 'broker.runtime-dispose', reason: 'BROKER_DISPOSE', action: 'dispose' }) => { const sink = request.detailChannel; closeDiagnostics.record(cause); return disposal ??= (async () => { if (disposed)
-                    return; let primary; try {
-                    await stop(ownedEntry, 'SESSION_ENDED', ownedTransport, true);
-                    await journal.write({ version: 1, phase: 'ended', scope, brokerId: id, instanceId: ownedEntry.instanceId, pid: ownedEntry.pid });
-                    disposed = true;
-                }
-                catch (error) {
-                    primary = { error };
-                }
-                finally {
-                    ownedTransport.close({ layer: 'broker', initiator: 'broker.dispose-finally', reason: 'BROKER_DISPOSE_CLEANUP', action: 'close' });
-                    active.delete(key);
-                    retained.delete(key);
-                } await flushCloseDiagnostics(closeDiagnostics, sink ? () => sink.flush() : undefined, primary); })(); },
-            };
-            if (employeeScope) {
-                runtime.saveCheckpoint = undefined;
-                runtime.detach = runtime.dispose;
-            }
-            if (request.retainProcess)
-                retained.set(key, { runtime, scope, update: next => { const sink = next.detailChannel; if (sink)
-                        closeDiagnostics.bind(event => sink.record(event)); request = next; timing = next.timing ?? new StageTiming(); } });
-            return runtime;
+            request.signal?.throwIfAborted();
+            await channel.connect();
         }
         catch (error) {
-            active.delete(key);
+            await dispose();
             throw error;
         }
+        finally {
+            request.signal?.removeEventListener('abort', aborted);
+        }
+        return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, acpTransport: channel, dispose, detach: dispose };
     };
-    return open;
 }

package/dist/broker.d.ts

@@ -1,25 +1,18 @@
 import { type CloseCause, type CloseObserver } from './close-diagnostics.ts';
 import { type ChildProcessWithoutNullStreams } from 'node:child_process';
 import { NeedError, type Need } from './remote.ts';
-import { type ConnectTarget } from './provider.ts';
+import type { ConnectTarget } from './provider.ts';
 export type Attachment = ChildProcessWithoutNullStreams;
 export interface BrokerOptions {
     observeClose?: CloseObserver;
     maxFrameBytes: number;
-    initialSequence?: number;
     instanceId?: string;
     leased?: boolean;
     controlMaxBytes?: number;
-    maxMessageBytes?: number;
-    beforeInput?: () => Promise<void>;
-    recoverySessionId?: string;
-    onRecoveryUpdate?: (message: Record<string, unknown>) => void;
-    discardOutput?: boolean;
-    attach: (after: number) => Promise<Attachment>;
+    attach: () => Promise<Attachment>;
     onNeed?: (need: Need) => void;
-    onDisconnect?: () => Promise<void>;
 }
-/** One byte stream / SDK app, multiple SSH attachments. Input is never replayed. */
+/** One byte stream / SDK app over one SSH attachment of a new agent. Input is never replayed. */
 export declare class BrokerTransport {
     readonly readable: ReadableStream<Uint8Array>;
     readonly writable: WritableStream<Uint8Array>;
@@ -34,41 +27,24 @@ export declare class BrokerTransport {
     private lease;
     private listeners;
     private permits;
-    private approvalSent;
-    private unconfirmed;
+    private promptPermit?;
     private failure?;
     private heartbeat?;
-    private boundary?;
-    private recovering;
-    private promptSent;
-    private preparingInputs;
     private inputTail;
     private exclusive;
     constructor(options: BrokerOptions);
     get online(): boolean;
     get generation(): number;
     get signal(): AbortSignal;
-    get lastSequence(): number;
     get error(): NeedError | undefined;
-    get promptInFlight(): boolean;
-    processedMessage(message: Record<string, unknown>): void;
-    checkpointSequence(): number | null;
-    commitCheckpoint(commit: (cursor: number) => Promise<void>): Promise<boolean>;
-    finishRecovery(): void;
-    replayThrough(sequence: number, signal?: AbortSignal): Promise<void>;
     private stopHeartbeat;
-    private recoveryMessage;
-    authorizeResponse(id: string | number | null, generation: number): void;
-    /** Called only by the ACP protocol layer after a matching result or current-turn output. */
-    acknowledge(method: string): void;
-    /** A matching terminal prompt response settles all approval replies in that turn. */
-    completePrompt(): void;
+    authorizeResponse(id: string | number | null, generation: number, valid?: () => boolean): void;
+    authorizePrompt(valid: () => boolean): void;
     onChange(fn: () => void): () => void;
     private changed;
     private notice;
     fail(error: NeedError, cause?: CloseCause): void;
     close(cause?: CloseCause): void;
-    waitOnline(signal?: AbortSignal): Promise<void>;
     connect(): Promise<void>;
     private attach;
     private write;
@@ -82,7 +58,6 @@ export interface BrokerIo {
 export declare function controlNeed(stderr: string): NeedError;
 export declare function sshIo(target: ConnectTarget, argv: SshArgv, maxControlBytes: number): BrokerIo;
 export declare function brokerCommand(t: ConnectTarget, args: string[]): string;
-export declare function legacyBrokerId(sessionId: string, agentId?: string): string;
 export declare function brokerId(sessionId: string, agentId?: string): string;
 export declare function controlJson(text: string): unknown;
 export interface BrokerSettings {