@asm-agent/coding-agent 0.8.8 → 0.9.0

package/dist/modes/daemon/daemon-mode.js

@@ -14,7 +14,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { getLogger } from "@asm-agent/ai";
 import { createCliSubprocessEnv, createCliSubprocessLaunchSpec } from "../../cli/subprocess-launch.js";
 import { appendRotatingLog, getCronJobsPath, getDaemonLogPath, getDaemonUpdateRestartManifestPath, getSessionsDir, VERSION, } from "../../config.js";
-import { AGENT_FAMILY_REACH_ERROR, AGENT_MESSAGE_SOURCE, AgentSessionMessageRateLimiter, agentFamilyRelationship, assertAgentFamilyReach, assertAgentMessageQueueCapacity, assertAgentSessionNameAvailable, assertDirectAgentMessageTarget, buildAgentFamilyRoster, createAgentSessionMessage, createAgentSessionMessageId, createAgentSessionMessageReceipt, DEFAULT_AGENT_MESSAGE_MAX_CHARS, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION, DEFAULT_AGENT_MESSAGE_RATE_LIMIT_CAPACITY, DEFAULT_AGENT_MESSAGE_RATE_LIMIT_REFILL_MS, formatAgentSessionNameUnavailable, isAgentSessionMessagePrompt, normalizeAgentSessionMessage, sessionNameReservationKey, } from "../../core/agent-messages.js";
+import { AGENT_FAMILY_REACH_ERROR, AGENT_MESSAGE_SOURCE, AgentSessionMessageRateLimiter, agentFamilyRelationship, assertAgentFamilyReach, assertAgentSessionNameAvailable, assertDirectAgentMessageTarget, buildAgentFamilyRoster, createAgentSessionMessage, createAgentSessionMessageId, createAgentSessionMessageReceipt, DEFAULT_AGENT_MESSAGE_MAX_CHARS, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION, DEFAULT_AGENT_MESSAGE_RATE_LIMIT_CAPACITY, DEFAULT_AGENT_MESSAGE_RATE_LIMIT_REFILL_MS, formatAgentSessionNameUnavailable, normalizeAgentSessionMessage, sessionNameReservationKey, } from "../../core/agent-messages.js";
 import { createAgentObserveMessagePreview, normalizeObserveLimit, normalizeObserveMaxChars, } from "../../core/agent-observe.js";
 import { rlmChildLabel } from "../../core/agent-session.js";
 import { mergeAgentSessionRuntimeConfig } from "../../core/agent-session-config.js";
@@ -245,13 +245,6 @@ export class AgentDaemon {
     agentDir;
     cronScheduler;
     agentMessageRateLimiter = new AgentSessionMessageRateLimiter();
-    remoteAgentPeers = new Map();
-    agentMessagePendingReservations = new Map();
-    agentMessageTargetLocks = new Map();
-    agentMessageAcceptingTargets = new Set();
-    // Refcount of prompts in preflight (accepted but not yet streaming); >0 makes
-    // concurrent agent messages queue instead of racing agent.prompt.
-    agentMessagePreparingTargets = new Map();
     asmCmDriver = new AsmCmDriver();
     phase76AddressHead = new Phase76AddressHeadDriver();
     asmRuntimePersistence = new AsmRuntimePersistence();
@@ -1368,16 +1361,10 @@ export class AgentDaemon {
             return "skipped";
         }
         const session = state.runtime.session;
-        const isAgentMessagePromptInProgress = this.agentMessageAcceptingTargets.has(state.activeSessionId) ||
-            this.agentMessagePreparingTargets.has(state.activeSessionId);
-        if (isHeartbeatCronJob(runnableJob) && isAgentMessagePromptInProgress) {
-            return "skipped";
-        }
         if (shouldDeferHeartbeatCronJob(runnableJob, session)) {
             return "skipped";
         }
-        const shouldQueueCronPrompt = isAgentMessagePromptInProgress ||
-            session.isStreaming ||
+        const shouldQueueCronPrompt = session.isStreaming ||
             session.isCompacting ||
             session.isRetrying ||
             session.isBashRunning ||
@@ -1395,104 +1382,44 @@ export class AgentDaemon {
             const current = requirePersistedJob ? this.getRunnableCronJob(job.id) : runnableJob;
             return current && this.isCronJobRunnableForState(current, state, requirePersistedJob) ? current : undefined;
         };
-        if (isHeartbeatCronJob(runnableJob)) {
-            const streamingBehavior = resolveHeartbeatStreamingBehavior(runnableJob.deliveryMode);
-            const didPrompt = await this.promptHeartbeatWithAgentMessagePreparingGuard(state, runnableJob, {
-                streamingBehavior,
-                followUpQueueKey: `heartbeat:${runnableJob.id}`,
-                source: "rpc",
-            }, getRunnableJob);
-            return didPrompt ? undefined : "skipped";
+        const current = getRunnableJob();
+        if (!current) {
+            return "skipped";
         }
-        const canPrompt = () => getRunnableJob() !== undefined;
-        const didPrompt = await this.promptWithAgentMessagePreparingGuard(state, runnableJob.prompt, {
-            streamingBehavior: "followUp",
-            source: "rpc",
-        }, canPrompt, false);
-        return didPrompt ? undefined : "skipped";
-    }
-    getRunnableCronJob(jobId) {
-        return this.cronStore.getClaimedJob(jobId) ?? this.cronStore.getDueJob(jobId);
-    }
-    // Wraps session.prompt so the target counts as "preparing" until the turn
-    // starts streaming (or the prompt settles); concurrent agent messages queue
-    // instead of racing agent.prompt during the preflight awaits. Refcounted so
-    // overlapping prompts each hold their own registration.
-    async promptWithAgentMessagePreparingGuard(state, message, options, canPrompt, waitForCompletion = true) {
-        return this.withAgentMessagePreparingGuard(state, (session, clearPreparing) => {
-            const prompt = options?.agentMessageId !== undefined && options.expandPromptTemplates === false
-                ? session.acceptAgentMessagePrompt.bind(session)
-                : waitForCompletion
-                    ? (session.promptAndWait ?? session.prompt).bind(session)
-                    : (session.promptUntilAccepted ?? session.prompt).bind(session);
-            return prompt(message, {
-                ...options,
-                preflightResult: (didSucceed, queued) => {
-                    if (didSucceed && session.isStreaming) {
-                        clearPreparing();
-                    }
-                    options?.preflightResult?.(didSucceed, queued);
-                },
-            });
-        }, canPrompt, options?.signal);
-    }
-    async promptHeartbeatWithAgentMessagePreparingGuard(state, job, options, getPromptJob) {
-        let promptJob = job;
-        return this.withAgentMessagePreparingGuard(state, (session, clearPreparing) => session.promptHeartbeat(promptJob, {
-            ...options,
-            preflightResult: (didSucceed) => {
-                if (didSucceed && session.isStreaming) {
-                    clearPreparing();
-                }
-                options?.preflightResult?.(didSucceed);
-            },
-        }), () => {
-            if (!getPromptJob) {
-                return true;
-            }
-            const current = getPromptJob();
-            if (!current) {
-                return false;
-            }
-            promptJob = current;
-            return true;
-        });
-    }
-    async withAgentMessagePreparingGuard(state, run, canRun, signal) {
-        const activeSessionId = state.activeSessionId;
-        this.agentMessagePreparingTargets.set(activeSessionId, (this.agentMessagePreparingTargets.get(activeSessionId) ?? 0) + 1);
-        let cleared = false;
-        const clearPreparing = () => {
-            if (cleared) {
-                return;
-            }
-            cleared = true;
-            const next = (this.agentMessagePreparingTargets.get(activeSessionId) ?? 1) - 1;
-            if (next <= 0) {
-                this.agentMessagePreparingTargets.delete(activeSessionId);
-            }
-            else {
-                this.agentMessagePreparingTargets.set(activeSessionId, next);
+        // Re-check after the session admission fence wait: the job may have been cancelled, completed, or updated meanwhile.
+        const unrunnableAtAdmission = new Error("Cron job became unrunnable before admission");
+        const admissionCommitted = () => {
+            const refreshed = getRunnableJob();
+            if (!refreshed || refreshed.prompt !== current.prompt || refreshed.deliveryMode !== current.deliveryMode) {
+                throw unrunnableAtAdmission;
             }
         };
         try {
-            const targetLock = this.agentMessageTargetLocks.get(activeSessionId);
-            if (targetLock)
-                await waitForPromptAdmission(targetLock.catch(() => undefined), signal);
-            if (this.sessions.get(activeSessionId) !== state || this.closingSessions.has(activeSessionId)) {
-                throw new Error("Target session is closing before prompt delivery");
-            }
-            if (canRun && !canRun()) {
-                return false;
+            if (isHeartbeatCronJob(current)) {
+                await session.promptHeartbeat(current, {
+                    streamingBehavior: resolveHeartbeatStreamingBehavior(current.deliveryMode),
+                    followUpQueueKey: `heartbeat:${current.id}`,
+                    source: "rpc",
+                    admissionCommitted,
+                });
+                return;
             }
-            const session = state.runtime.session;
-            await run(session, clearPreparing);
-            return true;
+            await session.promptUntilAccepted(current.prompt, {
+                streamingBehavior: "followUp",
+                source: "rpc",
+                admissionCommitted,
+            });
         }
-        finally {
-            clearPreparing();
+        catch (error) {
+            if (error === unrunnableAtAdmission) {
+                return "skipped";
+            }
+            throw error;
         }
     }
+    getRunnableCronJob(jobId) {
+        return this.cronStore.getClaimedJob(jobId) ?? this.cronStore.getDueJob(jobId);
+    }
     createCronJobForState(state, schedule, prompt) {
         const session = state.runtime.session;
         const sessionFile = session.sessionFile;
@@ -2150,11 +2077,7 @@ export class AgentDaemon {
             .filter((job) => job.activeSessionId === state.activeSessionId &&
             job.status !== "cancelled" &&
             job.status !== "completed");
-        const hasPendingAdmission = this.agentMessageAcceptingTargets.has(state.activeSessionId) ||
-            this.agentMessagePreparingTargets.has(state.activeSessionId) ||
-            this.agentMessageTargetLocks.has(state.activeSessionId) ||
-            [...this.promptAdmissions.values()].some((admission) => admission.activeSessionId === state.activeSessionId && admission.status !== "cancelled") ||
-            state.runtime.session.hasPendingAdmissionWaiters;
+        const hasPendingAdmission = [...this.promptAdmissions.values()].some((admission) => admission.activeSessionId === state.activeSessionId && admission.status !== "cancelled") || state.runtime.session.hasPendingAdmissionWaiters;
         return {
             isSessionActive: summary.isSessionActive || summary.hasRunningRlmChildren === true || hasPendingAdmission,
             attachedClients: state.clients.size + state.pendingAttaches,
@@ -3022,13 +2945,6 @@ export class AgentDaemon {
                     this.write(client, success(command.id, "detach"));
                     return;
                 }
-                case "worker_sync_agent_peers":
-                    this.remoteAgentPeers.clear();
-                    for (const peer of command.peers) {
-                        this.remoteAgentPeers.set(peer.activeSessionId, peer);
-                    }
-                    this.writeWorkerSuccess(client, command);
-                    return;
                 case "worker_archive_and_shutdown": {
                     for (const state of [...this.sessions.values()]) {
                         await this.closeSession(state, "killed");
@@ -3103,6 +3019,12 @@ export class AgentDaemon {
                     this.writeWorkerSuccess(client, command);
                     return;
                 }
+                default: {
+                    // Legacy commands from older supervisors (e.g. worker_sync_agent_peers) must fail fast, not time out.
+                    const unknown = command;
+                    this.write(client, failure(unknown.id, unknown.type, `Unknown worker command: ${unknown.type}`));
+                    return;
+                }
             }
         }
         catch (error) {
@@ -3453,7 +3375,7 @@ export class AgentDaemon {
                 };
                 if (command.type === "prompt_and_wait") {
                     try {
-                        await this.promptWithAgentMessagePreparingGuard(state, promptMessage, {
+                        await state.runtime.session.promptAndWait(promptMessage, {
                             ...options,
                             preflightResult: (didSucceed) => {
                                 if (didSucceed)
@@ -3474,7 +3396,10 @@ export class AgentDaemon {
                     responseSent = true;
                     this.write(client, success(command.id, "prompt"));
                 };
-                void this.promptWithAgentMessagePreparingGuard(state, promptMessage, {
+                const prompt = command.agentMessageId !== undefined && command.expandPromptTemplates === false
+                    ? state.runtime.session.acceptAgentMessagePrompt.bind(state.runtime.session)
+                    : state.runtime.session.promptUntilAccepted.bind(state.runtime.session);
+                void prompt(promptMessage, {
                     ...options,
                     agentMessageId: command.agentMessageId,
                     customMessage: command.customMessage,
@@ -3487,7 +3412,7 @@ export class AgentDaemon {
                             preflightRejected = true;
                         }
                     },
-                }, undefined, false)
+                })
                     .then(() => {
                     if (preflightRejected) {
                         const error = new Error("Prompt was not accepted by the session.");
@@ -3610,10 +3535,8 @@ export class AgentDaemon {
             }
             case "agent_messages_clear": {
                 const state = this.getSessionState(command.activeSessionId);
-                const cleared = await this.withAgentMessageTargetLock(state.activeSessionId, async () => {
-                    this.agentMessageRateLimiter.clearMatching((key) => key.endsWith(`->${state.activeSessionId}`));
-                    return state.runtime.session.clearQueuedUserMessagesMatching(isAgentSessionMessagePrompt);
-                });
+                this.agentMessageRateLimiter.clearMatching((key) => key.endsWith(`->${state.activeSessionId}`));
+                const cleared = state.runtime.session.clearQueuedAgentMessages();
                 return success(command.id, "agent_messages_clear", cleared);
             }
             case "abort": {
@@ -4538,7 +4461,29 @@ export class AgentDaemon {
             ...(session.sessionFile ? { sessionPath: session.sessionFile } : {}),
         };
     }
-    async createAgentMessageListResult(current) {
+    async listSupervisorAgentPeers() {
+        const supervisorSocketPath = this.supervisorSocketPathFromEnv();
+        if (!this.options.worker || !supervisorSocketPath)
+            return [];
+        const client = new DaemonClient(supervisorSocketPath);
+        try {
+            await client.connect(1000);
+            await client.waitForHello(1000);
+            const response = await client.request({ type: "list_agent_peers", workerToken: this.options.worker.authenticationToken }, 5000);
+            if (!response.success)
+                throw deserializeDaemonError(response);
+            // SAFETY: The authenticated supervisor constructs the peer response.
+            return response.data.peers;
+        }
+        catch {
+            return [];
+        }
+        finally {
+            client.close();
+        }
+    }
+    async createAgentMessageListResult(current, peers) {
+        peers ??= await this.listSupervisorAgentPeers();
         const localAgents = this.listTargetableSessionStates(current).map((state) => this.createAgentMessageAgentSummary(state));
         for (const passive of await this.listPassiveRlmSubagents()) {
             const { entry, info } = passive;
@@ -4568,23 +4513,20 @@ export class AgentDaemon {
             });
         }
         const localIds = new Set(localAgents.map((agent) => agent.activeSessionId));
+        const remoteAgents = peers.filter((peer) => !localIds.has(peer.activeSessionId) && !this.closingSessions.has(peer.activeSessionId));
         return {
             current: this.createAgentSessionMessageEndpoint(current),
-            agents: [
-                ...localAgents,
-                ...[...this.remoteAgentPeers.values()].filter((peer) => peer.status !== "inactive" &&
-                    !localIds.has(peer.activeSessionId) &&
-                    !this.closingSessions.has(peer.activeSessionId)),
-            ],
+            agents: [...localAgents, ...remoteAgents],
         };
     }
     async createAgentFamilyCatalog(currentState) {
         const current = currentState ?? [...this.sessions.values()].find((state) => !this.bindingSessions.has(state.activeSessionId));
-        const listed = current ? await this.createAgentMessageListResult(current) : { agents: [] };
-        const remotePeers = new Set(this.remoteAgentPeers.values());
+        const remotePeers = current ? await this.listSupervisorAgentPeers() : [];
+        const listed = current ? await this.createAgentMessageListResult(current, remotePeers) : { agents: [] };
+        const remotePeerSet = new Set(remotePeers);
         const localAgents = current
-            ? [this.createAgentMessageAgentSummary(current), ...listed.agents.filter((agent) => !remotePeers.has(agent))]
-            : listed.agents.filter((agent) => !remotePeers.has(agent));
+            ? [this.createAgentMessageAgentSummary(current), ...listed.agents.filter((agent) => !remotePeerSet.has(agent))]
+            : listed.agents;
         const activePaths = new Set(localAgents.flatMap((agent) => (agent.sessionPath ? [canonicalSessionPath(agent.sessionPath)] : [])));
         const savedRoots = (await SessionManager.listAll(undefined, this.options.defaultSessionConfig.sessionDir))
             .filter((info) => (info.rlmDepth ?? (info.parentSessionPath ? -1 : 0)) === 0 &&
@@ -4618,7 +4560,7 @@ export class AgentDaemon {
                 ...(agent.sessionPath ? { sessionPath: canonicalSessionPath(agent.sessionPath) } : {}),
             });
         };
-        for (const peer of this.remoteAgentPeers.values())
+        for (const peer of remotePeers)
             addAgent(peer);
         for (const agent of localAgents)
             addAgent(agent);
@@ -4752,50 +4694,11 @@ export class AgentDaemon {
         return `cli:${this.socketPath}`;
     }
     async clearQueuedAgentSessionMessagesForState(state) {
-        return this.withAgentMessageTargetLock(state.activeSessionId, async () => state.runtime.session.clearQueuedUserMessagesMatching(isAgentSessionMessagePrompt));
+        return state.runtime.session.clearQueuedAgentMessages();
     }
     async clearQueuedAgentSessionMessagesForAllStates() {
         await Promise.all([...this.sessions.values()].map((state) => this.clearQueuedAgentSessionMessagesForState(state)));
     }
-    reserveAgentMessageQueueSlot(targetState) {
-        const activeSessionId = targetState.activeSessionId;
-        const reserved = this.agentMessagePendingReservations.get(activeSessionId) ?? 0;
-        assertAgentMessageQueueCapacity(targetState.runtime.session.unfinishedActionCount + reserved, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION);
-        this.agentMessagePendingReservations.set(activeSessionId, reserved + 1);
-        let released = false;
-        return () => {
-            if (released) {
-                return;
-            }
-            released = true;
-            const next = (this.agentMessagePendingReservations.get(activeSessionId) ?? 1) - 1;
-            if (next <= 0) {
-                this.agentMessagePendingReservations.delete(activeSessionId);
-            }
-            else {
-                this.agentMessagePendingReservations.set(activeSessionId, next);
-            }
-        };
-    }
-    async withAgentMessageTargetLock(activeSessionId, run) {
-        const previous = this.agentMessageTargetLocks.get(activeSessionId) ?? Promise.resolve();
-        let releaseCurrent = () => { };
-        const current = new Promise((resolve) => {
-            releaseCurrent = resolve;
-        });
-        const next = previous.catch(() => undefined).then(() => current);
-        this.agentMessageTargetLocks.set(activeSessionId, next);
-        await previous.catch(() => undefined);
-        try {
-            return await run();
-        }
-        finally {
-            releaseCurrent();
-            if (this.agentMessageTargetLocks.get(activeSessionId) === next) {
-                this.agentMessageTargetLocks.delete(activeSessionId);
-            }
-        }
-    }
     agentFamilyEntry(state) {
         const metadata = state.runtime.metadata;
         const depth = state.runtime.session.rlmDepth ?? 0;
@@ -4946,12 +4849,10 @@ export class AgentDaemon {
         if (options.origin === "agent" && options.fromState) {
             this.assertAgentFamilyReachable(options.fromState, targetState);
         }
-        const releaseQueueSlot = this.reserveAgentMessageQueueSlot(targetState);
         const senderKey = options.senderKey ?? options.fromState?.activeSessionId ?? `client:${options.clientId ?? "unknown"}`;
         const rateLimitKey = `${senderKey}->${targetState.activeSessionId}`;
         const rateLimit = this.agentMessageRateLimiter.tryConsume(rateLimitKey);
         if (!rateLimit.ok) {
-            releaseQueueSlot();
             throw new Error(`Agent messaging rate limit exceeded; retry after ${rateLimit.retryAfterMs}ms`);
         }
         const payload = {
@@ -4964,29 +4865,13 @@ export class AgentDaemon {
             target: this.createAgentSessionMessageEndpoint(targetState),
         };
         try {
-            const { status } = await this.withAgentMessageTargetLock(targetState.activeSessionId, async () => {
-                if (this.agentMessagesPaused) {
-                    throw new Error("Agent messaging is paused");
-                }
-                if (!this.sessions.has(targetState.activeSessionId) ||
-                    this.closingSessions.has(targetState.activeSessionId)) {
-                    throw new Error("Target session is closing before agent message delivery");
-                }
-                if (targetState.runtime.session.sessionId !== payload.target.sessionId) {
-                    throw new Error("Target session changed before agent message delivery");
-                }
-                return this.acceptAgentSessionMessage(targetState, payload, releaseQueueSlot);
-            });
+            const { status } = await this.acceptAgentSessionMessage(targetState, payload);
             return createAgentSessionMessageReceipt(payload, status);
         }
         catch (error) {
             this.agentMessageRateLimiter.refund(rateLimitKey);
             throw error;
         }
-        finally {
-            // Error-path backstop; success paths release inside acceptAgentSessionMessage.
-            releaseQueueSlot();
-        }
     }
     async sendRemoteAgentSessionMessage(fromState, targetSelector, message) {
         const supervisorSocketPath = this.supervisorSocketPathFromEnv();
@@ -4994,100 +4879,75 @@ export class AgentDaemon {
             throw new Error(`Unknown active session: ${targetSelector}`);
         }
         const deadline = Date.now() + 30_000;
+        let client;
         let lastError;
         while (Date.now() < deadline && !this.shuttingDown) {
-            const client = new DaemonClient(supervisorSocketPath);
-            let receivedResponse = false;
+            const candidate = new DaemonClient(supervisorSocketPath);
             try {
-                await client.connect(1000);
-                await client.waitForHello(1000);
-                const response = await client.request({
-                    type: "send_message",
-                    targetActiveSessionId: targetSelector,
-                    message,
-                    fromActiveSessionId: fromState.activeSessionId,
-                    agentOrigin: true,
-                }, 30_000);
-                receivedResponse = true;
-                if (!response.success) {
-                    throw deserializeDaemonError(response);
-                }
-                if (!response.data || typeof response.data !== "object") {
-                    throw new Error("Supervisor returned an invalid agent-message receipt");
-                }
-                return response.data;
+                await candidate.connect(1000);
+                await candidate.waitForHello(1000);
+                client = candidate;
+                break;
             }
             catch (error) {
                 lastError = error;
-                if (receivedResponse) {
-                    throw error;
-                }
-            }
-            finally {
-                client.close();
+                candidate.close();
             }
             await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
         }
-        throw lastError instanceof Error ? lastError : new Error(`Unknown active session: ${targetSelector}`);
-    }
-    async acceptAgentSessionMessage(targetState, payload, releaseReservation) {
-        const session = targetState.runtime.session;
-        const reserved = this.agentMessagePendingReservations.get(targetState.activeSessionId) ?? 0;
-        const otherReservations = Math.max(0, reserved - 1);
-        assertAgentMessageQueueCapacity(session.unfinishedActionCount + otherReservations, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION);
-        const shouldQueue = this.agentMessageAcceptingTargets.has(targetState.activeSessionId) ||
-            this.agentMessagePreparingTargets.has(targetState.activeSessionId) ||
-            session.isStreaming ||
-            session.isCompacting ||
-            session.isRetrying ||
-            session.isBashRunning ||
-            session.unfinishedActionCount > 0;
-        const streamingBehavior = "steer";
-        const message = createAgentSessionMessage(payload);
-        const prompt = message.content;
-        if (shouldQueue) {
-            const didQueue = await session.queueAgentMessagePrompt(prompt, streamingBehavior, message);
-            if (!didQueue) {
-                throw new Error("Agent message was not queued");
-            }
-            // The queued message now counts in unfinishedActionCount.
-            releaseReservation();
-            // Do not await delivery: a queued message delivers only when the target's
-            // turn progresses, and the sender is blocked inside its own turn — awaiting
-            // here deadlocks mutual sends between busy sessions.
-            return { status: "queued" };
-        }
-        this.agentMessageAcceptingTargets.add(targetState.activeSessionId);
-        let preflightFailed = false;
-        let preflightQueued = false;
+        if (!client) {
+            throw lastError instanceof Error ? lastError : new Error(`Unknown active session: ${targetSelector}`);
+        }
         try {
-            const promptOptions = {
-                expandPromptTemplates: false,
-                streamingBehavior,
-                queueIfBusy: true,
-                preflightResult: (didSucceed, didQueue) => {
-                    preflightFailed = !didSucceed;
-                    preflightQueued = didSucceed && didQueue === true;
-                },
-            };
-            if (typeof session.acceptAgentMessagePrompt === "function") {
-                await session.acceptAgentMessagePrompt(prompt, {
-                    ...promptOptions,
-                    customMessage: message,
-                });
-            }
-            else {
-                await session.prompt(prompt, promptOptions);
+            const response = await client.request({
+                type: "send_message",
+                targetActiveSessionId: targetSelector,
+                message,
+                fromActiveSessionId: fromState.activeSessionId,
+                agentOrigin: true,
+            }, 30_000);
+            if (!response.success) {
+                throw deserializeDaemonError(response);
             }
-            if (preflightFailed) {
-                throw new Error("Agent message was not accepted");
+            if (!response.data || typeof response.data !== "object") {
+                throw new Error("Supervisor returned an invalid agent-message receipt");
             }
-            releaseReservation();
-            return { status: preflightQueued ? "queued" : "delivered" };
+            return response.data;
         }
         finally {
-            this.agentMessageAcceptingTargets.delete(targetState.activeSessionId);
+            client.close();
+        }
+    }
+    async acceptAgentSessionMessage(targetState, payload) {
+        const message = createAgentSessionMessage(payload);
+        let preflightFailed = false;
+        let preflightQueued = false;
+        await targetState.runtime.session.acceptAgentMessagePrompt(message.content, {
+            expandPromptTemplates: false,
+            streamingBehavior: "steer",
+            queueIfBusy: true,
+            customMessage: message,
+            admissionCommitted: () => {
+                if (this.agentMessagesPaused) {
+                    throw new Error("Agent messaging is paused");
+                }
+                if (!this.sessions.has(targetState.activeSessionId) ||
+                    this.closingSessions.has(targetState.activeSessionId)) {
+                    throw new Error("Target session is closing before agent message delivery");
+                }
+                if (targetState.runtime.session.sessionId !== payload.target.sessionId) {
+                    throw new Error("Target session changed before agent message delivery");
+                }
+            },
+            preflightResult: (didSucceed, didQueue) => {
+                preflightFailed = !didSucceed;
+                preflightQueued = didSucceed && didQueue === true;
+            },
+        });
+        if (preflightFailed) {
+            throw new Error("Agent message was not accepted");
         }
+        return { status: preflightQueued ? "queued" : "delivered" };
     }
     detachClientFromSession(client, state) {
         const acpMcpOwner = this.acpMcpOwners.get(state.activeSessionId);