@songsid/agend 2.1.7-beta.3 → 2.1.7-beta.4

package/dist/daemon.js

@@ -1,7 +1,7 @@
 import { join, dirname, basename, resolve } from "node:path";
 import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, renameSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { createHash, randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { rotateLogIfNeeded } from "./logger.js";
 import { mcpServerState } from "./mcp-liveness.js";
@@ -33,7 +33,7 @@ import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Tool routing sets — module-level to avoid re-creation on every handleToolCall
-const CROSS_INSTANCE_TOOLS = new Set(["send_to_instance", "list_instances", "start_instance", "restart_instance", "create_instance", "delete_instance", "replace_instance", "request_information", "delegate_task", "report_result", "describe_instance"]);
+const CROSS_INSTANCE_TOOLS = new Set(["send_to_instance", "broadcast", "list_instances", "start_instance", "restart_instance", "create_instance", "delete_instance", "replace_instance", "request_information", "delegate_task", "report_result", "describe_instance"]);
 const SCHEDULE_TOOLS = new Set(["create_schedule", "list_schedules", "update_schedule", "delete_schedule"]);
 const DECISION_TOOLS = new Set(["post_decision", "list_decisions", "update_decision"]);
 const TASK_TOOL = "task";
@@ -95,6 +95,8 @@ export const DEFAULT_STATE_SAFETY_SWEEP_MS = 60_000;
 export const PERIODIC_REDRAW_PROBE_MS = 25;
 /** Do not turn a streaming Codex turn into one capture-pane per burst. */
 export const STRUCTURED_IDLE_PROBE_MS = 500;
+/** How long an unrecognised-but-empty composer must stay unchanged before it counts as idle (#978). */
+export const UNKNOWN_LAYOUT_STABLE_MS = 10_000;
 /** A foreground server/port-forward should hand control back or be acknowledged. */
 export const DEFAULT_BLOCKING_PROCESS_GRACE_MS = 2 * 60_000;
 const LAST_INBOUND_FILE = "last-inbound-at";
@@ -326,9 +328,12 @@ export class PaneStateMachine {
      *   the caller has them.
      * @param opts.forceBusy the backend has positively identified a still-running
      *   foreground tool even though its TUI keeps an old ready footer visible.
+     * @param opts.forceReady the backend has positively proved an idle composer
+     *   the ready pattern cannot read (an unknown footer layout); the busy
+     *   pattern still vetoes it.
      */
     observe(pane, now = Date.now(), opts = {}) {
-        const { settled = false, changeAt = now, forceBusy = false } = opts;
+        const { settled = false, changeAt = now, forceBusy = false, forceReady = false } = opts;
         const paneHash = createHash("sha256").update(pane).digest("hex");
         const firstObservation = this.lastPaneHash === null;
         const paneChanged = this.lastPaneHash !== paneHash;
@@ -340,7 +345,9 @@ export class PaneStateMachine {
         // Some TUIs keep their ready footer visible while a foreground tool owns
         // stdin. Backends can positively identify that tool from the pane; in that
         // case the old prompt must not clear pending work or retire Cancel.
-        const ready = !forceBusy && this.isReady(pane);
+        // forceReady: the backend proved readiness itself (#978 stable unknown
+        // footer); a visible busy marker still vetoes it.
+        const ready = !forceBusy && (forceReady ? !this.busyPattern?.test(pane) : this.isReady(pane));
         const nextState = firstObservation
             ? ready ? "idle" : "working"
             : paneChanged && !settled
@@ -908,6 +915,9 @@ export class Daemon extends EventEmitter {
     spawnGate;
     stormWindow;
     backendOutage;
+    /** Identity of this live Daemon object; changes on object stop/restart. */
+    bootId = randomUUID();
+    deliveryOutbox;
     logger;
     tmuxSessionName;
     tmux = null;
@@ -996,6 +1006,10 @@ export class Daemon extends EventEmitter {
     /** Consecutive structural idle captures for a noisy, periodically-redrawing
      * pane.  Two are required before a working -> idle transition. */
     instanceStatePeriodicIdleConfirmations = 0;
+    /** #978: last unrecognised-but-empty-composer capture and since when it has been unchanged. */
+    unknownLayoutPaneKey = null;
+    unknownLayoutStableSince = 0;
+    unknownLayoutWarned = false;
     instanceStateStuckTimer = null;
     instanceStateOutputListener = null;
     instanceStateOutputEventName = null;
@@ -1313,6 +1327,65 @@ export class Daemon extends EventEmitter {
         const autoPauseMinutes = isGeneral ? 0 : (typeof config.auto_pause_after === "number" ? config.auto_pause_after : 0); // default: disabled
         this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000, readLastInboundAt(instanceDir) ?? Date.now());
     }
+    /** FleetManager and this daemon share a process, so durable begin/ACK is a direct synchronous store call. */
+    setDeliveryOutboxPort(port) {
+        this.deliveryOutbox = port;
+    }
+    durableDeliveryAttempt(meta) {
+        const deliveryId = meta.delivery_id;
+        if (!deliveryId)
+            return null;
+        const attemptNo = Number(meta.delivery_attempt);
+        if (!Number.isSafeInteger(attemptNo) || attemptNo < 1)
+            return false;
+        return { deliveryId, attemptNo };
+    }
+    beginDurableDelivery(delivery) {
+        if (!this.deliveryOutbox) {
+            this.emit("durable_delivery_deferred", { ...delivery, targetBootId: this.bootId, reason: "outbox port unavailable before pane write" });
+            return false;
+        }
+        const outcome = this.deliveryOutbox.begin(delivery.deliveryId, this.bootId, delivery.attemptNo);
+        // A repeated begin is idempotent at the store but must not authorize a
+        // second pane write. Only the first caller that acquired the permit acts.
+        return outcome === "begun";
+    }
+    abortDurableDelivery(delivery, reason) {
+        if (!delivery)
+            return;
+        this.deliveryOutbox?.abort(delivery.deliveryId, this.bootId, delivery.attemptNo, reason);
+    }
+    retryDurableDeliveryBeforeBegin(delivery, reason) {
+        if (!delivery)
+            return;
+        if (this.deliveryOutbox) {
+            this.deliveryOutbox.retryBeforeBegin(delivery.deliveryId, this.bootId, delivery.attemptNo, reason, 5_000);
+        }
+        else {
+            this.emit("durable_delivery_deferred", { ...delivery, targetBootId: this.bootId, reason });
+        }
+    }
+    finishDurableDelivery(delivery, outcome, evidence) {
+        if (!delivery)
+            return;
+        this.deliveryOutbox?.complete(delivery.deliveryId, this.bootId, delivery.attemptNo, outcome, evidence);
+    }
+    finishDurableSubmission(delivery, verdict) {
+        // Legacy backends may accept a pane write without enough pane evidence to
+        // claim submission. Keep that row inspectable instead of recording a false
+        // delivered state; reconciliation can classify it in a later phase.
+        if (verdict.proof === "unverified") {
+            this.finishDurableDelivery(delivery, "uncertain", `${verdict.phase ?? "submission"}:unverified`);
+            return;
+        }
+        this.finishDurableDelivery(delivery, "delivered", "positive submission proof");
+    }
+    deferDurableDelivery(meta, reason) {
+        const delivery = this.durableDeliveryAttempt(meta);
+        if (delivery === null || delivery === false)
+            return;
+        this.retryDurableDeliveryBeforeBegin(delivery, reason);
+    }
     async start() {
         mkdirSync(this.instanceDir, { recursive: true });
         writeFileSync(join(this.instanceDir, "daemon.pid"), String(process.pid));
@@ -1411,6 +1484,7 @@ export class Daemon extends EventEmitter {
                 void this.wake().then(() => {
                     this.pushChannelMessage(msg.content, meta, targetSession, deliveryEpoch);
                 }).catch(err => {
+                    this.deferDurableDelivery(meta, `target wake failed before pane submission: ${err.message}`);
                     this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
                 });
             }
@@ -3699,9 +3773,39 @@ export class Daemon extends EventEmitter {
                 }
                 else {
                     // A live busy marker or an unfamiliar layout outranks the broad Codex
-                    // ready pattern during the noisy-redraw path. Unknown is working.
+                    // ready pattern during the noisy-redraw path. Unknown is working —
+                    // but not forever (#978): a footer the proof does not recognise
+                    // would otherwise pin an idle CLI in `working` and queue every
+                    // delivery indefinitely. If the backend still sees its own live,
+                    // empty composer and the pane has not changed (cosmetic glyphs
+                    // aside) for UNKNOWN_LAYOUT_STABLE_MS, read it as settled and ready.
                     this.instanceStatePeriodicIdleConfirmations = 0;
-                    snapshot = this.instanceStateMachine.recordOutput(observedChangeAt);
+                    const stableFallback = this.backend?.isStableUnknownLayoutIdlePane;
+                    const now = Date.now();
+                    if (stableFallback?.call(this.backend, pane)) {
+                        const key = pane.replace(/⋆/gu, "").replace(/[ \t]+$/gmu, "");
+                        if (key !== this.unknownLayoutPaneKey) {
+                            this.unknownLayoutPaneKey = key;
+                            this.unknownLayoutStableSince = now;
+                        }
+                    }
+                    else {
+                        this.unknownLayoutPaneKey = null;
+                    }
+                    if (this.unknownLayoutPaneKey !== null && now - this.unknownLayoutStableSince >= UNKNOWN_LAYOUT_STABLE_MS) {
+                        if (!this.unknownLayoutWarned) {
+                            this.unknownLayoutWarned = true;
+                            this.logger.warn({ backend: this.backend?.binaryName }, "Unrecognised idle footer layout; falling back to a stable empty composer for readiness");
+                        }
+                        snapshot = this.instanceStateMachine.observe(pane, now, {
+                            settled: true,
+                            changeAt: observedChangeAt,
+                            forceReady: true,
+                        });
+                    }
+                    else {
+                        snapshot = this.instanceStateMachine.recordOutput(observedChangeAt);
+                    }
                 }
             }
             else if (structuredPeriodicIdle && reason !== "idle_debounce" && !settled) {
@@ -4182,6 +4286,9 @@ export class Daemon extends EventEmitter {
         if (meta.reply_to_text) {
             formatted += `\n(reply_to: "${meta.reply_to_text}")`;
         }
+        if (meta.delivery_id) {
+            formatted = `[agend-delivery-id:${meta.delivery_id}]\n${formatted}`;
+        }
         return formatted;
     }
     /**
@@ -4204,7 +4311,10 @@ export class Daemon extends EventEmitter {
         verdict.reached = true;
         verdict.phase = phase;
         verdict.proof = proof;
-        if (status)
+        // Durable cross-instance rows are still retryable before a pane write. Their
+        // terminal state is announced by the outbox only after its retry/TTL policy
+        // is exhausted; emitting ❌ here would expose a transient gate timeout.
+        if (status && !verdict.durableAttempt)
             this.emit("message_failed", status); // ❌
         return false;
     }
@@ -4240,8 +4350,10 @@ export class Daemon extends EventEmitter {
      * normal inbound message, with a steering notice prepended for context.
      */
     steerMessage(content, meta, deliveryEpoch = this.deliveryEpoch) {
-        if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+        if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+            this.deferDurableDelivery(meta, "delivery epoch changed before steer began");
             return;
+        }
         // The fleet facade prevents a steer from overtaking an item still in its
         // idle queue. Close the second race window here: an earlier item may already
         // have reached this daemon's paste queue by the time the steer IPC arrives.
@@ -4256,25 +4368,60 @@ export class Daemon extends EventEmitter {
         const formatted = "[STEERING — mid-task course correction. Fold this into the CURRENT work if one is active.]\n"
             + this.formatInboundMessage(content, meta);
         const status = channelStatus(meta);
+        const durableAttempt = this.durableDeliveryAttempt(meta);
+        if (durableAttempt === false) {
+            this.deferDurableDelivery(meta, "invalid durable delivery attempt metadata");
+            return;
+        }
         this.steerLock = this.steerLock.then(async () => {
-            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+                this.deferDurableDelivery(meta, "delivery epoch changed before steer began");
                 return;
+            }
             await this.wake();
-            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+                this.deferDurableDelivery(meta, "delivery epoch changed while waking for steer");
                 return;
+            }
             const verdict = { reached: false };
-            if (await this.deliverMessage(formatted, status, { steer: true, deliveryEpoch, submissionId: meta.message_id, verdict })) {
-                this.markTurnStarted(meta, formatted);
+            try {
+                if (await this.deliverMessage(formatted, status, {
+                    steer: true,
+                    deliveryEpoch,
+                    submissionId: meta.message_id,
+                    verdict,
+                    durableAttempt: durableAttempt || undefined,
+                })) {
+                    this.finishDurableSubmission(durableAttempt, verdict);
+                    this.markTurnStarted(meta, formatted);
+                }
+                else if (durableAttempt && verdict.paneWriteStarted) {
+                    this.finishDurableDelivery(durableAttempt, "uncertain", `${verdict.phase ?? "post-submit"}:${verdict.proof ?? "unproven"}`);
+                }
+                else if (durableAttempt && verdict.durableBeginCommitted) {
+                    this.abortDurableDelivery(durableAttempt, `${verdict.phase ?? "delivery"}:${verdict.proof ?? "no-pane-write"}`);
+                }
+                else if (durableAttempt) {
+                    this.retryDurableDeliveryBeforeBegin(durableAttempt, `${verdict.phase ?? "delivery"}:${verdict.proof ?? "deferred"}`);
+                }
+                else if (verdict.reached && this.isDeliveryEpochCurrent(deliveryEpoch)) {
+                    // Legacy non-outbox path retains its existing failure surface.
+                    this.reportCrossInstanceDeliveryFailure(meta, verdict);
+                }
             }
-            else if (verdict.reached && this.isDeliveryEpochCurrent(deliveryEpoch)) {
-                // Same rule as the queued path: a steer that never got to try is not a
-                // delivery failure. This holder is the steer's own, which is the point
-                // — it runs on steerLock while a queued delivery runs on pasteLock.
-                this.reportCrossInstanceDeliveryFailure(meta, verdict);
+            catch (err) {
+                if (durableAttempt && verdict.paneWriteStarted)
+                    this.finishDurableDelivery(durableAttempt, "uncertain", err.message);
+                else if (durableAttempt && verdict.durableBeginCommitted)
+                    this.abortDurableDelivery(durableAttempt, err.message);
+                else if (durableAttempt)
+                    this.retryDurableDeliveryBeforeBegin(durableAttempt, err.message);
+                throw err;
             }
         }).catch(err => {
+            this.deferDurableDelivery(meta, `target wake/steer failed before pane submission: ${err.message}`);
             this.logger.warn({ err: err.message }, "steer delivery error");
-            if (this.isDeliveryEpochCurrent(deliveryEpoch)) {
+            if (!durableAttempt && this.isDeliveryEpochCurrent(deliveryEpoch)) {
                 this.reportCrossInstanceDeliveryFailure(meta, undefined, err.message);
             }
         });
@@ -4315,10 +4462,12 @@ export class Daemon extends EventEmitter {
     pushChannelMessage(content, meta, _targetSession, deliveryEpoch = this.deliveryEpoch) {
         if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
             this.logger.info("Pending channel delivery dropped by user cancel");
+            this.deferDurableDelivery(meta, "delivery epoch changed before queue admission");
             return;
         }
         if (!this.tmux) {
             this.logger.warn("Cannot push channel message: tmux not running");
+            this.deferDurableDelivery(meta, "target tmux is unavailable");
             return;
         }
         // Remember (and persist) the reply target. Only real channel messages have a
@@ -4375,9 +4524,12 @@ export class Daemon extends EventEmitter {
                 this.emit("message_queued", queuedStatus);
         }
         this.pasteLock = this.pasteLock.then(async () => {
+            let durable = null;
+            let verdict = { reached: false };
             try {
                 if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
                     this.logger.info("Pending channel delivery dropped by user cancel");
+                    this.deferDurableDelivery(meta, "delivery epoch changed while queued");
                     return;
                 }
                 if (this.config.pre_task_command) {
@@ -4395,18 +4547,60 @@ export class Daemon extends EventEmitter {
                 // A fresh delivery begins a fresh turn — its bubble must not inherit
                 // the previous turn's tool list.
                 this.resetToolProgress();
-                const verdict = { reached: false };
-                if (await this.deliverMessage(formatted, status, { deliveryEpoch, submissionId: meta.message_id, verdict })) {
+                verdict = { reached: false };
+                const durableAttempt = this.durableDeliveryAttempt(meta);
+                if (durableAttempt === false) {
+                    this.deferDurableDelivery(meta, "invalid durable delivery attempt metadata");
+                    return;
+                }
+                durable = durableAttempt;
+                if (await this.deliverMessage(formatted, status, {
+                    deliveryEpoch,
+                    submissionId: meta.message_id,
+                    verdict,
+                    durableAttempt: durableAttempt || undefined,
+                })) {
+                    this.finishDurableSubmission(durable, verdict);
                     this.markTurnStarted(meta, formatted);
                 }
+                else if (durableAttempt && verdict.paneWriteStarted) {
+                    this.finishDurableDelivery(durable, "uncertain", `${verdict.phase ?? "post-submit"}:${verdict.proof ?? "unproven"}`);
+                }
+                else if (durableAttempt && verdict.durableBeginCommitted) {
+                    this.abortDurableDelivery(durable, `${verdict.phase ?? "delivery"}:${verdict.proof ?? "no-pane-write"}`);
+                }
+                else if (durableAttempt) {
+                    this.retryDurableDeliveryBeforeBegin(durableAttempt, `${verdict.phase ?? "delivery"}:${verdict.proof ?? "deferred"}`);
+                }
                 else if (meta.from_instance && verdict.reached
                     && this.isDeliveryEpochCurrent(deliveryEpoch)) {
                     // Only a delivery that reached a verdict is reported. A pane that is
                     // not ready yet, a cancel, a storm hold or a shutdown all return
                     // false without one, and telling the sender its message was lost
                     // there would be the false ❌ of #826 in its other form.
+                    this.finishDurableDelivery(durable, "failed", `${verdict.phase ?? "delivery"}:${verdict.proof ?? "failed"}`);
                     this.reportCrossInstanceDeliveryFailure(meta, verdict);
                 }
+                else if (verdict.reached) {
+                    this.finishDurableDelivery(durable, "failed", `${verdict.phase ?? "delivery"}:${verdict.proof ?? "failed"}`);
+                }
+                else if (verdict.paneWriteStarted) {
+                    this.finishDurableDelivery(durable, "uncertain", `${verdict.phase ?? "post-submit"}:${verdict.proof ?? "unproven"}`);
+                }
+                else {
+                    this.abortDurableDelivery(durable, "delivery did not reach pane submission");
+                }
+            }
+            catch (err) {
+                if (durable && verdict.paneWriteStarted)
+                    this.finishDurableDelivery(durable, "uncertain", err.message);
+                else if (durable && verdict.durableBeginCommitted)
+                    this.abortDurableDelivery(durable, err.message);
+                else if (durable)
+                    this.retryDurableDeliveryBeforeBegin(durable, err.message);
+                else
+                    throw err;
+                this.logger.warn({ err: err.message }, "Durable pane delivery deferred after exception");
             }
             finally {
                 this.pasteQueueDepth--;
@@ -4439,6 +4633,8 @@ export class Daemon extends EventEmitter {
         // The caller passes its own holder when it needs the answer; a system paste
         // that ignores the outcome gets a throwaway.
         const verdict = opts?.verdict ?? { reached: false };
+        if (opts?.durableAttempt)
+            verdict.durableAttempt = true;
         const cancelled = () => opts?.deliveryEpoch !== undefined
             && !this.isDeliveryEpochCurrent(opts.deliveryEpoch);
         if (cancelled() || this.stormWindow?.isStopped())
@@ -4513,7 +4709,9 @@ export class Daemon extends EventEmitter {
                     // The pane never freed up. Report the failure instead of pasting into a
                     // wedged CLI (where the text would sit unsubmitted and the next message
                     // would land on top of it) — and instead of holding the queue silently.
-                    this.logger.error("Pane still busy after the idle wait — reporting delivery failure");
+                    this.logger[verdict.durableAttempt ? "warn" : "error"](verdict.durableAttempt
+                        ? "Pane still busy after the idle wait — durable delivery remains retryable"
+                        : "Pane still busy after the idle wait — reporting delivery failure");
                     return this.failDelivery(verdict, status, "readiness", "timeout-before-write");
                 }
             }
@@ -4591,7 +4789,7 @@ export class Daemon extends EventEmitter {
                 }
                 if (!(await this.hasPositiveDeliveryInput()))
                     return "dialog";
-                return this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status, opts?.submissionId, verdict);
+                return this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status, opts?.submissionId, verdict, opts?.durableAttempt);
             });
             if (outcome === "spawn-started") {
                 // The pane changed under this delivery: its queued paste must not land
@@ -5364,17 +5562,31 @@ export class Daemon extends EventEmitter {
     async writeMessageToPane(formatted, initialWindowId, handingOffToNativeQueue, status, submissionId, 
     // Last and defaulted so the positional callers that ignore the outcome stay
     // readable; deliverMessage, the only one that reports, always passes its own.
-    verdict = { reached: false }) {
+    verdict = { reached: false }, durableAttempt) {
         const signature = this.submissionSignature(formatted, submissionId);
         let windowId = initialWindowId;
         // Bug A: paste with backoff. Transient failures are usually a stale window id
         // after a crash/respawn — recover by name and retry (max 3 attempts, 2s apart).
         const maxAttempts = 3;
+        let beginChecked = false;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             const pasteStartedAt = Date.now();
             // Read the pane BEFORE writing to it, so the submission check can require
             // evidence this paste ADDED rather than evidence that was already there.
             const pasteBaseline = await this.capturePaneEvidence(signature);
+            // Readiness, idle-gate, dialog, spawn and pane-lock waits have all ended.
+            // Commit the submission fence at the last possible point before the
+            // first side effect; a crash during those waits remains safely replayable.
+            if (durableAttempt && !beginChecked) {
+                beginChecked = true;
+                if (!this.beginDurableDelivery(durableAttempt)) {
+                    verdict.durableBeginRejected = true;
+                    verdict.phase = "submission-begin";
+                    verdict.proof = "permit-rejected";
+                    return false;
+                }
+                verdict.durableBeginCommitted = true;
+            }
             const pasted = await this.tmux.pasteBuffer(formatted);
             if (!pasted) {
                 const tmuxError = this.tmux.getLastPasteError?.() ?? "unknown tmux paste failure";
@@ -5392,6 +5604,10 @@ export class Daemon extends EventEmitter {
                     await new Promise(r => setTimeout(r, 2000));
                 continue;
             }
+            // From this point a process/window transition can leave the user payload
+            // in the pane even if later proof is cancelled or unreadable. Such a row
+            // must be uncertain, never aborted back to replayable queued state.
+            verdict.paneWriteStarted = true;
             // Settle the bracketed paste, then submit. When control mode can observe
             // the pane, wait for the paste's own render to go quiet instead of
             // trusting a fixed delay (see waitForPasteSettle). The fixed delays —
@@ -5475,6 +5691,8 @@ export class Daemon extends EventEmitter {
                     // Re-pasting on a backend without structured Codex pane evidence
                     // would risk duplication; retain its legacy best-effort behavior.
                     this.logger.warn("Paste reached the pane but could not be verified as submitted — accepting without proof");
+                    verdict.phase = "best-effort-submission";
+                    verdict.proof = "unverified";
                     if (status)
                         this.emit("message_confirmed", status); // ✅ (best-effort)
                     return true;
@@ -6081,6 +6299,7 @@ export class Daemon extends EventEmitter {
         const tool = msg.tool;
         const args = (msg.args ?? {});
         const requestId = msg.requestId;
+        const operationId = typeof msg.operationId === "string" ? msg.operationId : undefined;
         this.logger.debug({ tool, requestId }, "Tool call from MCP server");
         // A tool call can only come from a live MCP server of ours — proof of life
         // that outranks whatever the pid slot says.
@@ -6103,10 +6322,13 @@ export class Daemon extends EventEmitter {
             if (!error && result != null && TURN_OUTBOUND_TOOLS.has(tool)) {
                 this.turnReplyGuard.settleToolAttempt(replyAttempt, true);
             }
-            const sent = this.ipcServer?.send(socket, { requestId, result, error }) ?? false;
+            const sent = this.ipcServer?.send(socket, { requestId, result, error, operationId }) ?? false;
             if (!sent) {
                 this.logger.warn({ tool, requestId }, "Tool result could not be returned — originating MCP socket is closed");
             }
+            else if (operationId) {
+                this.emit("mcp_tool_response_written", { operationId, daemonBootId: this.bootId });
+            }
         };
         // Repo checkout — handled locally in daemon (no fleet-manager)
         if (tool === "checkout_repo") {
@@ -6231,6 +6453,7 @@ export class Daemon extends EventEmitter {
                     type: "fleet_outbound",
                     tool,
                     args,
+                    ...(operationId ? { operationId, sourceDaemonBootId: this.bootId } : {}),
                     fleetRequestId: fleetReqId,
                     senderSessionName,
                 });
@@ -6289,6 +6512,7 @@ export class Daemon extends EventEmitter {
                 type: "fleet_outbound",
                 tool,
                 args,
+                ...(operationId ? { operationId, sourceDaemonBootId: this.bootId } : {}),
                 fleetRequestId: fleetReqId,
                 // Preserve the exact adapter world that supplied the chat context. An
                 // instance binding is only a fallback: persisted/runtime context can be