@songsid/agend 2.2.0-beta.6 → 2.2.0-beta.8

package/dist/fleet-manager.d.ts

@@ -1,3 +1,4 @@
+import { type HumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsExecution } from "./settings-transaction.js";
 import type { LoginCodeOwner } from "./web-login.js";
 import { type ProfileTicket } from "./runtime-cpu-profile.js";
@@ -52,6 +53,7 @@ export declare function applyTaskListCap<T extends {
     hint: string;
 } | T[];
 import { type PublicPreviewForUi } from "./web-api.js";
+import { type LogAnswer, type LogQuery } from "./log-service.js";
 import { WebChatHistory } from "./web-chat-history.js";
 import { SeenUsers, type MentionNames, type MentionQuery } from "./web-mentions.js";
 import { WebPrefsStore } from "./web-prefs.js";
@@ -63,6 +65,7 @@ import { type AgentEndpointContext } from "./agent-endpoint.js";
 import { ClassicChannelManager } from "./classic-channel-manager.js";
 import { type ExplicitInstanceRemoval } from "./instance-removal.js";
 import type { InstanceState, InteractionSnapshot } from "./backend/types.js";
+import { type Daemon } from "./daemon.js";
 import { WakeCoordinator } from "./wake-coordinator.js";
 import { TargetQueueWorker } from "./target-queue-worker.js";
 import { resolveDeliveryWorkerMode } from "./types.js";
@@ -218,7 +221,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private replyObligationTimer;
     private readonly activeDurableTargets;
     /** Live view of lifecycle.daemons — used throughout; not deprecated. */
-    get daemons(): Map<string, import("./daemon.js").Daemon>;
+    get daemons(): Map<string, Daemon>;
     fleetConfig: FleetConfig | null;
     private rawFleetConfig;
     private rawFleetDocument;
@@ -470,6 +473,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private webChatStore;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     readonly webFiles: WebFileLedger;
+    /** #1770: per instance, its last web reply still copying its files — the next one is shown after it, in order. */
+    private readonly webReplyOrder;
+    /** #1770: an instance's web-files byte cap (a field, so a test can make it small). */
+    private webReplyMaxBytes;
     /** #1682: the people seen on inbound messages (id → name), for the web chat's mention pills; bounded, in memory. */
     readonly seenUsers: SeenUsers;
     private webPrefsStore?;
@@ -555,10 +562,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         kind: string;
         correlationId: string;
         payload: Record<string, unknown>;
+        forwards?: readonly string[];
+        requestedKind?: string;
     }): {
         deliveryId: string;
         state: string;
         duplicate: boolean;
+        kind: string;
     };
     queryDurableDeliveryStatus(callerInstance: string, selector: DeliveryStatusSelector): DeliveryStatusPage;
     /** #1641: why a target is not taking queued work right now, or null when nothing known holds it. */
@@ -805,6 +815,17 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     getActiveBackendIds(): ReadonlySet<string>;
     isClassicInstance(name: string): boolean;
     /** #1523 N2: a ClassicBot room's own summary for its Details page (classicBot.yaml), or null. */
+    /** #1218: the Log tab's on-demand service — made on first use; with `web.log_tab` off it answers off and does nothing. */
+    private logService;
+    private get log();
+    /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
+    logSteps(name: string, q: LogQuery): Promise<LogAnswer | null>;
+    /**
+     * #1218: where an instance's steps are read from, resolved only when its Log asks: the transcript its daemon follows
+     * now; for claude-code, also the path its statusline last named (so a stopped instance's Log still shows its last
+     * work). kiro comes with its own reader later in phase 1; other backends have no transcript AgEnD can read.
+     */
+    private logSource;
     classicRoomFor(name: string): {
         name: string;
         channel_id: string;
@@ -902,6 +923,17 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     hasPendingIdleGatedDelivery(instanceName: string): boolean;
     /** The running launch's own steer capability (#1405); undefined for a backend without one, or no running Daemon. */
     instanceLaunchSupportsSteer(instanceName: string): boolean | undefined;
+    private humanReceiptDaemons;
+    /** Cached FM + lifecycle + Daemon + tmux owner; unknown ownership grants nothing. */
+    private humanReceiptOwner;
+    private listenForHumanReceipt;
+    /** Evidence-only admission. Bots/system/agent payloads have no trusted origin. */
+    private humanReceiptPayload;
+    /** Bind at the actual IPC send, after all wake/reconnect waits. No human retry lane. */
+    private bindHumanReceiptPayload;
+    deliverHumanToInstance(instanceName: string, payload: Record<string, unknown>, origin: HumanOrigin | undefined, originalBody: string, options?: DeliveryOptions): Promise<boolean | void>;
+    /** Synchronous steer/btw handoff, using the same evidence and owner binding. */
+    sendHumanControl(instanceName: string, payload: Record<string, unknown>, origin: HumanOrigin | undefined, originalBody: string): boolean;
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     deliverToInstance(instanceName: string, payload: Record<string, unknown>, options?: DeliveryOptions): Promise<boolean | void>;
     /**
@@ -1580,7 +1612,14 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private isWebOnlyFleet;
     /** On a fleet with no chat platform, the dashboard is where an instance-health prompt is posted (#1307 item 6). */
     private webOnlyPromptPlace;
+    /** Resolves when the reply is in the web chat (#1770: after its files are copied); the caller need not wait. */
     private afterReplyRouted;
+    /**
+     * #1770: a reply's files as the web chat shows them. Each is copied into the instance's web-files/ and served from
+     * the copy. One the copy refuses (a symlink, not a regular file, over 50 MB, a state file, missing) is not shown;
+     * one that could not be copied (I/O) is served from the agent's own path, as before — until the fleet restarts.
+     */
+    private webReplyAttachments;
     private handleScheduleTrigger;
     /**
      * The adapter that can actually post into a chat, found by its group.

package/dist/fleet-manager.js

@@ -1,3 +1,4 @@
+import { humanOwnerObjectId, webHumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsBaselines } from "./settings-baseline.js";
 import { SettingsConfirmationStore } from "./settings-confirmation.js";
 import { SettingsHttpConfirmation } from "./settings-http-confirmation.js";
@@ -131,6 +132,7 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
     return tasks;
 }
 import { handleWebRequest, broadcastSseEvent, SSE_HEARTBEAT_MS } from "./web-api.js";
+import { LogService } from "./log-service.js";
 import { WebChatHistory, WEB_CHAT_TEXT_MAX, isWebMessageId, newWebMessageId } from "./web-chat-history.js";
 import { WebChatDiskStore } from "./web-chat-store.js";
 import { SeenUsers, resolveMentions } from "./web-mentions.js";
@@ -138,6 +140,7 @@ import { WebPrefsStore } from "./web-prefs.js";
 import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtonsFallbackText, REPLY_BUTTON_PREFIX } from "./reply-buttons.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { publicAttachment, sweepOrphanedUploads, WebFileLedger } from "./web-upload.js";
+import { REPLY_FILES_MAX_BYTES, snapshotReplyFile, sweepReplySnapshots, webFilesDir } from "./web-reply-files.js";
 import { handleViewRequest, isViewPath, profileIdentities, resolveInstanceIdentity } from "./view-api.js";
 import { downloadStickerImage } from "./channel/sticker-download.js";
 import { WebImageCache, imageMimeForFile, WEB_IMAGE_MAX_AGE_MS, WEB_IMAGE_MAX_BYTES, WEB_IMAGE_RETRY_MS } from "./web-images.js";
@@ -789,6 +792,10 @@ export class FleetManager {
     webChatStore = null;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     webFiles = new WebFileLedger();
+    /** #1770: per instance, its last web reply still copying its files — the next one is shown after it, in order. */
+    webReplyOrder = new Map();
+    /** #1770: an instance's web-files byte cap (a field, so a test can make it small). */
+    webReplyMaxBytes = REPLY_FILES_MAX_BYTES;
     /** #1682: the people seen on inbound messages (id → name), for the web chat's mention pills; bounded, in memory. */
     seenUsers = new SeenUsers();
     webPrefsStore;
@@ -1189,7 +1196,7 @@ export class FleetManager {
         const reactions = this.pendingReactionsMeta(set.instance);
         let accepted = false;
         try {
-            accepted = (await this.deliverToInstance(set.instance, {
+            accepted = (await this.deliverHumanToInstance(set.instance, {
                 type: "fleet_inbound",
                 content,
                 targetSession: set.instance,
@@ -1198,7 +1205,7 @@ export class FleetManager {
                     thread_id: set.threadId, adapter_id: inbound.adapterId, source: inbound.source,
                     ...reactions.meta,
                 },
-            })) !== false;
+            }, by.humanOrigin, button.label)) !== false;
         }
         finally {
             // Both false and throw reopen the choice in the controller. Finish the
@@ -1317,6 +1324,7 @@ export class FleetManager {
             deliveryId: admitted.delivery.deliveryId,
             state: admitted.delivery.state,
             duplicate: !admitted.inserted,
+            kind: admitted.delivery.kind,
         };
     }
     queryDurableDeliveryStatus(callerInstance, selector) {
@@ -2688,6 +2696,49 @@ export class FleetManager {
         return this.classicChannels?.getAll().some(channel => channel.instanceName === name) ?? false;
     }
     /** #1523 N2: a ClassicBot room's own summary for its Details page (classicBot.yaml), or null. */
+    /** #1218: the Log tab's on-demand service — made on first use; with `web.log_tab` off it answers off and does nothing. */
+    logService = null;
+    get log() {
+        return this.logService ??= new LogService({
+            enabled: () => this.fleetConfig?.web?.log_tab === true,
+            known: (name) => Object.prototype.hasOwnProperty.call(this.fleetConfig?.instances ?? {}, name) || this.classicRoomFor(name) !== null,
+            source: (name) => this.logSource(name),
+            events: (name, limit) => (this.eventLog?.query({ instance: name, limit }) ?? []),
+            emit: (event, data) => this.emitSseEvent(event, data),
+        });
+    }
+    /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
+    logSteps(name, q) { return this.log.steps(name, q); }
+    /**
+     * #1218: where an instance's steps are read from, resolved only when its Log asks: the transcript its daemon follows
+     * now; for claude-code, also the path its statusline last named (so a stopped instance's Log still shows its last
+     * work). kiro comes with its own reader later in phase 1; other backends have no transcript AgEnD can read.
+     */
+    logSource(name) {
+        const instances = this.fleetConfig?.instances ?? {};
+        const config = Object.prototype.hasOwnProperty.call(instances, name) ? instances[name] : undefined;
+        const backend = config?.backend ?? (config ? null : this.classicRoomFor(name)?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+        const live = this.lifecycle.daemons.get(name)?.logTranscriptPath() ?? null;
+        if (backend === "claude-code") {
+            let path = live;
+            if (!path) {
+                try {
+                    path = JSON.parse(readFileSync(join(this.getInstanceDir(name), "statusline.json"), "utf-8")).transcript_path ?? null;
+                }
+                catch {
+                    path = null;
+                }
+                if (typeof path !== "string" || !path)
+                    path = null;
+            }
+            return { backend, path, format: "claude", ...(path ? {} : { reason: "no_transcript" }) };
+        }
+        if (backend === "codex")
+            return { backend, path: live, format: "codex", ...(live ? {} : { reason: "not_running" }) };
+        if (backend === "kiro-cli")
+            return { backend, path: null, format: null, reason: "coming" };
+        return { backend, path: null, format: null, reason: "unsupported" };
+    }
     classicRoomFor(name) {
         const ch = this.classicChannels?.getAll().find(channel => channel.instanceName === name);
         if (!ch)
@@ -2989,7 +3040,7 @@ export class FleetManager {
         const queued = this.ipcWaitTails.get(instanceName);
         if (!queued) {
             const ipc = this.instanceIpcClients.get(instanceName);
-            if (ipc?.connected && ipc.send(payload))
+            if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
                 return true;
         }
         const attempt = (queued ?? Promise.resolve())
@@ -3024,7 +3075,7 @@ export class FleetManager {
             // Re-read every round: a reconnect replaces the IpcClient object entirely,
             // so a cached reference would stay dead forever.
             const ipc = this.instanceIpcClients.get(instanceName);
-            if (ipc?.connected && ipc.send(payload))
+            if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
                 return true;
             if (Date.now() >= deadline) {
                 throw new Error(`Instance '${instanceName}' IPC is unavailable`);
@@ -3242,6 +3293,101 @@ export class FleetManager {
     instanceLaunchSupportsSteer(instanceName) {
         return this.daemons.get(instanceName)?.launchSupportsSteer();
     }
+    humanReceiptDaemons = new WeakSet();
+    /** Cached FM + lifecycle + Daemon + tmux owner; unknown ownership grants nothing. */
+    humanReceiptOwner(instanceName, daemon = this.daemons.get(instanceName)) {
+        try {
+            if (this.shuttingDown || !daemon || this.daemons.get(instanceName) !== daemon)
+                return null;
+            const epoch = this.lifecycle.epochOf(instanceName);
+            const owner = daemon.captureHumanReceiptOwner();
+            if (!Number.isSafeInteger(epoch) || !owner)
+                return null;
+            return JSON.stringify([this.managerBootId, epoch, this.getDeliveryEpoch(instanceName), humanOwnerObjectId(daemon), owner]);
+        }
+        catch {
+            return null;
+        }
+    }
+    listenForHumanReceipt(instanceName, daemon) {
+        // Lazy initialization also supports narrow prototype-based integration fixtures.
+        this.humanReceiptDaemons ??= new WeakSet();
+        if (this.humanReceiptDaemons.has(daemon))
+            return;
+        this.humanReceiptDaemons.add(daemon);
+        daemon.on("human_receipt_result", (result) => {
+            try {
+                this.deliveryOutbox?.settleHumanReceipt(result.receipt_id, instanceName, result.owner_key, result.proof, this.humanReceiptOwner(instanceName, daemon));
+            }
+            catch (err) {
+                this.logger.error({ err, instanceName }, "Could not persist human delivery evidence");
+            }
+        });
+    }
+    /** Evidence-only admission. Bots/system/agent payloads have no trusted origin. */
+    humanReceiptPayload(instanceName, payload, origin, originalBody) {
+        if (!origin || !this.deliveryOutbox)
+            return payload;
+        const row = this.deliveryOutbox.createHumanReceipt({ targetInstance: instanceName, originalBody,
+            origin: { ...origin }, inputKind: String(payload.type), managerBootId: this.managerBootId });
+        return { ...payload, meta: { ...(payload.meta ?? {}),
+                human_receipt_id: row.receipt_id, verification_id: row.message_id } };
+    }
+    /** Bind at the actual IPC send, after all wake/reconnect waits. No human retry lane. */
+    bindHumanReceiptPayload(instanceName, payload) {
+        const meta = payload.meta;
+        if (!meta?.human_receipt_id || !this.deliveryOutbox)
+            return payload;
+        const daemon = this.daemons.get(instanceName);
+        const owner = this.humanReceiptOwner(instanceName, daemon);
+        if (!daemon || !owner) {
+            this.deliveryOutbox.markHumanReceiptUncertain(meta.human_receipt_id, instanceName);
+            return payload;
+        }
+        this.listenForHumanReceipt(instanceName, daemon);
+        const daemonOwner = daemon.captureHumanReceiptOwner();
+        const wire = daemon.humanReceiptWire(String(payload.content ?? ""), meta, String(payload.type));
+        const row = this.deliveryOutbox.bindHumanReceipt(meta.human_receipt_id, instanceName, owner, wire, this.managerBootId);
+        if (!daemonOwner || this.humanReceiptOwner(instanceName, daemon) !== owner)
+            throw new Error("Human delivery ownership changed");
+        // /raw retains exact bytes and never acquires a positive verification capability.
+        if (payload.type === "raw_paste" || String(payload.content ?? "").startsWith("/raw ")) {
+            this.deliveryOutbox.markHumanReceiptUncertain(row.receipt_id, instanceName);
+            return payload;
+        }
+        return { ...payload, meta: { ...meta, human_owner_key: owner, human_daemon_owner: daemonOwner, human_wire_sha256: row.wire_sha256 } };
+    }
+    async deliverHumanToInstance(instanceName, payload, origin, originalBody, options) {
+        const admitted = this.humanReceiptPayload(instanceName, payload, origin, originalBody);
+        const id = admitted.meta?.human_receipt_id;
+        let sent = false;
+        try {
+            const result = options ? await this.deliverToInstance(instanceName, admitted, options) : await this.deliverToInstance(instanceName, admitted);
+            sent = result !== false;
+            return result;
+        }
+        finally {
+            if (!sent && id)
+                this.deliveryOutbox?.markHumanReceiptUncertain(id, instanceName);
+        }
+    }
+    /** Synchronous steer/btw handoff, using the same evidence and owner binding. */
+    sendHumanControl(instanceName, payload, origin, originalBody) {
+        const ipc = this.instanceIpcClients.get(instanceName);
+        if (this.shuttingDown || !ipc?.connected)
+            return false;
+        const admitted = this.humanReceiptPayload(instanceName, payload, origin, originalBody);
+        const id = admitted.meta?.human_receipt_id;
+        let sent = false;
+        try {
+            sent = ipc.send(this.bindHumanReceiptPayload(instanceName, admitted));
+            return sent;
+        }
+        finally {
+            if (!sent && id)
+                this.deliveryOutbox?.markHumanReceiptUncertain(id, instanceName);
+        }
+    }
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     async deliverToInstance(instanceName, payload, options = {}) {
         const deliveryEpoch = this.getDeliveryEpoch(instanceName);
@@ -3434,7 +3580,7 @@ export class FleetManager {
                 userId: data.userId,
                 username,
                 source: "discord",
-                timestamp: new Date(),
+                timestamp: new Date(), adapterId, humanOrigin: data.humanOrigin, humanOriginalBody: text,
             });
         }
         else if (data.command === "save") {
@@ -3579,7 +3725,8 @@ export class FleetManager {
                 await data.respond(t("classic.no_agent"));
                 return;
             }
-            const steerText = String(data.options?.message ?? "").trim();
+            const originalSteerText = String(data.options?.message ?? "");
+            const steerText = originalSteerText.trim();
             if (!steerText) {
                 await data.respond(t("steer.usage"));
                 return;
@@ -3589,7 +3736,7 @@ export class FleetManager {
             // rerouting the instance's replies to the slash context.
             const result = this.topicCommands.sendSteer(name, steerText, {
                 chatId: "", messageId: "", username: data.username ?? "user",
-                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord", humanOrigin: data.humanOrigin, humanOriginalBody: originalSteerText,
             });
             await data.respond(result);
         }
@@ -3599,14 +3746,15 @@ export class FleetManager {
                 await data.respond(t("classic.no_agent"));
                 return;
             }
-            const btwText = String(data.options?.message ?? "").trim();
+            const originalBtwText = String(data.options?.message ?? "");
+            const btwText = originalBtwText.trim();
             if (!btwText) {
                 await data.respond(t("btw.usage"));
                 return;
             }
             const result = this.topicCommands.sendBtw(name, btwText, {
                 chatId: "", messageId: "", username: data.username ?? "user",
-                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord", humanOrigin: data.humanOrigin, humanOriginalBody: originalBtwText,
             });
             await data.respond(result);
         }
@@ -4959,13 +5107,13 @@ export class FleetManager {
                 if (result && !result.durable)
                     this.logger.warn("Public session revocation could not be saved; exposure remains closed");
             },
-            log: (event, exposureId) => this.logger.info({ event, exposureId }, "Public web link"),
+            log: (event, exposureId, detail) => this.logger.info({ event, exposureId, ...(detail ? { detail } : {}) }, "Public web link"),
             createPreview: ({ id, expiresAt, binary, protocol, dashboardOrigin, isCurrent }) => {
                 if (!publicPreviewWanted(this.fleetConfig?.web))
                     return null;
                 return new PublicPreview({ exposureId: id, expiresAt, dashboardOrigin, isCurrent, manager: this.getPreviewTunnel(),
                     provider: () => new CloudflaredProvider({ binaryName: binary, protocol }),
-                    log: event => this.logger.info({ event, exposureId: id }, "Public web link") });
+                    log: (event, detail) => this.logger.info({ event, exposureId: id, ...(detail ? { detail } : {}) }, "Public web link") });
             },
             onCleanupUnconfirmed: (result, owner) => {
                 this.logger.warn({ pid: result.confirmed ? null : result.pid }, "Public web access closed; tunnel cleanup unconfirmed");
@@ -7509,6 +7657,7 @@ export class FleetManager {
         });
     }
     async handleInboundMessage(msg) {
+        msg = { ...msg, humanOriginalBody: msg.humanOriginalBody ?? msg.text, humanOrigin: msg.isBotMessage ? undefined : msg.humanOrigin && { ...msg.humanOrigin } };
         if (msg.isBotMessage)
             return withSpawnHoldReply(undefined, () => this.handleInboundMessageCore(msg));
         return withSpawnHoldReply(text => this.inboundNoticeAdapter(msg)?.sendText(msg.chatId, text, { threadId: msg.threadId }) ?? Promise.resolve(), () => this.handleInboundMessageCore(msg));
@@ -7967,7 +8116,7 @@ export class FleetManager {
                 const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, generalInstance);
                 const generalReactions = this.pendingReactionsMeta(generalInstance);
                 try {
-                    await this.deliverToInstance(generalInstance, {
+                    await this.deliverHumanToInstance(generalInstance, {
                         type: "fleet_inbound",
                         content: text,
                         targetSession: generalInstance,
@@ -7988,7 +8137,7 @@ export class FleetManager {
                             ...generalReactions.meta,
                             ...extraMeta,
                         },
-                    });
+                    }, msg.humanOrigin, msg.humanOriginalBody ?? msg.text);
                     generalReactions.consume();
                     this.afterUserInboundDelivered(generalInstance, msg);
                     this.logger.info(`${msg.username} → ${generalInstance}: ${(text ?? "").slice(0, 100)}`);
@@ -8068,7 +8217,7 @@ export class FleetManager {
         const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, instanceName);
         const reactions = this.pendingReactionsMeta(instanceName);
         try {
-            await this.deliverToInstance(instanceName, {
+            await this.deliverHumanToInstance(instanceName, {
                 type: "fleet_inbound",
                 content: text,
                 targetSession: instanceName, // Channel messages → instance's own session
@@ -8087,7 +8236,7 @@ export class FleetManager {
                     ...reactions.meta,
                     ...extraMeta,
                 },
-            });
+            }, msg.humanOrigin, msg.humanOriginalBody ?? msg.text);
             // Only after the message actually went out. A failed delivery keeps the
             // reactions queued for the retry / the next message.
             reactions.consume();
@@ -8395,7 +8544,7 @@ export class FleetManager {
                 // an agent cannot invent it to suppress the normal completion marker.
                 if (!error && result != null && msg.statusOnly !== true) {
                     try {
-                        this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView);
+                        void this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView);
                     }
                     catch (err) {
                         this.logger.warn({ err, instanceName }, "Reply delivered but post-delivery bookkeeping failed");
@@ -8448,6 +8597,7 @@ export class FleetManager {
     webOnlyPromptPlace() {
         return this.worlds.size === 0 && this.isWebOnlyFleet() ? { adapter: WEB_ONLY_PROMPT_SINK, adapterId: "web", chatId: "web" } : null;
     }
+    /** Resolves when the reply is in the web chat (#1770: after its files are copied); the caller need not wait. */
     afterReplyRouted(instanceName, args, senderSessionName, buttons = null) {
         // A reply is NOT proof the turn is over (#410) — but it is not proof of
         // more work either. Split the difference: an instance that is clearly
@@ -8465,27 +8615,74 @@ export class FleetManager {
         this.reactDone(instanceName);
         const replyTo = this.lastInboundUser.get(instanceName) ?? "user";
         this.logger.info(`${instanceName} → ${replyTo}: ${(args.text ?? "").slice(0, 100)}`);
-        // Files the agent attached are shown in the web chat too: registered for fetching by id (the path
-        // already passed the reply tool's sendability check, and is resolved once more here), never by path.
-        const replyFiles = Array.isArray(args.files) ? args.files.filter((f) => typeof f === "string") : [];
-        const attachments = replyFiles
-            .map(path => this.webFiles.registerServed({ path, instance: instanceName }))
-            .filter((f) => f !== null)
-            .map(publicAttachment);
-        // The one place a delivered agent reply reaches the web chat: the server marks it `agent` (#1306) — the only
-        // role that may get HTML preview cards. Never inferred from the sender name or the text.
-        this.emitSseEvent("message", {
-            instance: instanceName, sender: senderSessionName ?? instanceName, role: "agent",
-            text: (args.text ?? "").slice(0, WEB_CHAT_TEXT_MAX),
-            ts: new Date().toISOString(),
-            ...(attachments.length ? { attachments } : {}),
-            ...(buttons ? { buttons } : {}), // #1266
-        });
         // Log bot reply to classic instance chat-log
         const isClassic = this.classicChannels?.getChannelIdByInstance(instanceName) !== undefined;
         if (isClassic) {
             ClassicChannelManager.logMessage(instanceName, "bot", args.text ?? "", new Date());
         }
+        // Files the agent attached are shown in the web chat too, fetched by id, never by path. #1770: each is copied
+        // first (web-reply-files.ts), and the copy is what the chat serves and keeps — so the message is shown once the
+        // copies are done, and an instance's replies wait for the one before them: they reach the chat in order.
+        const replyFiles = Array.isArray(args.files) ? args.files.filter((f) => typeof f === "string") : [];
+        const ts = new Date().toISOString();
+        const show = (attachments) => {
+            // The one place a delivered agent reply reaches the web chat: the server marks it `agent` (#1306) — the only
+            // role that may get HTML preview cards. Never inferred from the sender name or the text.
+            this.emitSseEvent("message", {
+                instance: instanceName, sender: senderSessionName ?? instanceName, role: "agent",
+                text: (args.text ?? "").slice(0, WEB_CHAT_TEXT_MAX),
+                ts,
+                ...(attachments.length ? { attachments } : {}),
+                ...(buttons ? { buttons } : {}), // #1266
+            });
+        };
+        const before = this.webReplyOrder.get(instanceName);
+        if (!replyFiles.length && !before) {
+            show([]);
+            return Promise.resolve();
+        }
+        const done = (before ?? Promise.resolve())
+            .then(() => this.webReplyAttachments(instanceName, replyFiles))
+            .catch((err) => { this.logger.warn({ err, instanceName }, "Reply files could not be prepared for the web chat"); return []; })
+            .then((attachments) => { try {
+            show(attachments);
+        }
+        catch (err) {
+            this.logger.warn({ err, instanceName }, "Reply could not be shown in the web chat");
+        } })
+            .finally(() => { if (this.webReplyOrder.get(instanceName) === done)
+            this.webReplyOrder.delete(instanceName); });
+        this.webReplyOrder.set(instanceName, done);
+        return done;
+    }
+    /**
+     * #1770: a reply's files as the web chat shows them. Each is copied into the instance's web-files/ and served from
+     * the copy. One the copy refuses (a symlink, not a regular file, over 50 MB, a state file, missing) is not shown;
+     * one that could not be copied (I/O) is served from the agent's own path, as before — until the fleet restarts.
+     */
+    async webReplyAttachments(instanceName, paths) {
+        const home = getAgendHome();
+        const dir = webFilesDir(home, instanceName);
+        const out = [];
+        for (const path of paths) {
+            const id = randomBytes(16).toString("hex");
+            const got = dir ? await snapshotReplyFile(path, dir, id, { stateDir: home, maxDirBytes: this.webReplyMaxBytes }) : null;
+            if (got && "evicted" in got && got.evicted.length)
+                this.webFiles.dropServed(got.evicted);
+            let file = null;
+            if (got?.ok)
+                file = this.webFiles.registerServed({ id, path: got.path, name: basename(path), instance: instanceName, snapshot: true });
+            else if (got?.refused)
+                this.logger.info({ instanceName, file: basename(path), reason: got.reason }, "Reply file not shown in the web chat");
+            else {
+                if (got)
+                    this.logger.warn({ instanceName, file: basename(path), reason: got.reason }, "Reply file could not be copied for the web chat; served from its own path until a restart");
+                file = this.webFiles.registerServed({ path, instance: instanceName });
+            }
+            if (file)
+                out.push(publicAttachment(file));
+        }
+        return out;
     }
     // ===================== Scheduler =====================
     async handleScheduleTrigger(schedule, stableRunId = randomUUID(), retry) {
@@ -12254,7 +12451,7 @@ export class FleetManager {
             const topicId = this.fleetConfig?.instances[instance]?.topic_id;
             return {
                 chatId: this.getGroupIdForInstance(instance) || "", messageId: newWebMessageId(), username: "web-user", userId: "web-user",
-                threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web",
+                threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web", humanOrigin: webHumanOrigin(true),
             };
         };
         const choicesFromCache = (instance) => {
@@ -12285,8 +12482,8 @@ export class FleetManager {
                 return { current, options: levels.map(l => ({ id: l, label: this.effortChoiceLabel(l, current) })) };
             },
             cancel: (instance) => this.cancelInstance(instance),
-            steer: (instance, text) => this.topicCommands.sendSteer(instance, text, webMeta(instance)),
-            btw: (instance, text) => this.topicCommands.sendBtw(instance, text, webMeta(instance)),
+            steer: (instance, text, originalBody) => this.topicCommands.sendSteer(instance, text, { ...webMeta(instance), humanOriginalBody: originalBody }),
+            btw: (instance, text, originalBody) => this.topicCommands.sendBtw(instance, text, { ...webMeta(instance), humanOriginalBody: originalBody }),
             pauseWake: (instance, action) => this.topicCommands.runPauseWake(instance, action),
             save: (instance, filename) => this.topicCommands.sendSave(instance, filename),
             clearAsk: (instance) => {
@@ -14082,16 +14279,26 @@ export class FleetManager {
         try {
             const store = new WebChatDiskStore({ home: getAgendHome(), logger: this.logger, ownerOf: (name) => this.webChatOwner(name) });
             const names = new Set([...Object.keys(fleet.instances ?? {}), ...(this.classicChannels?.getAll().map(c => c.instanceName) ?? [])]);
-            // A kept message's files are served again under their ids only from the instance's own inbox, by the ledger's
-            // checks (web-upload.ts restoreServed); they leave the ledger with their message.
+            // A kept message's files are served again under their ids only from the instance's own inbox or (#1770) its reply
+            // snapshots, by the ledger's checks (web-upload.ts restoreServed); they leave the ledger with their message.
             this.webChatHistory.setFiles({
                 storablePath: (id) => this.webFiles.storablePath(id),
-                restore: (entry, instance) => this.webFiles.restoreServed(entry, instance, join(getAgendHome(), "workspaces", instance, "inbox")),
+                restore: (entry, instance) => this.webFiles.restoreServed(entry, instance, join(getAgendHome(), "workspaces", instance, "inbox"), webFilesDir(getAgendHome(), instance) ?? undefined),
                 drop: (ids) => this.webFiles.dropServed(ids),
             });
             let restored = 0;
             for (const name of names)
                 restored += this.webChatHistory.restore(name, store.load(name));
+            // #1770: before any instance replies, the snapshots no restored message holds (it left the history while the
+            // fleet was down, or a copy stopped midway) are removed.
+            let swept = 0;
+            for (const name of names) {
+                const dir = webFilesDir(getAgendHome(), name);
+                if (dir)
+                    swept += sweepReplySnapshots(dir, this.webFiles.heldSnapshots(name));
+            }
+            if (swept)
+                this.logger.info({ swept }, "Removed web reply snapshots no message holds");
             this.webChatStore = store;
             this.webChatHistory.setStore(store);
             if (restored)
@@ -14882,12 +15089,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const reactions = this.pendingReactionsMeta(instanceName);
         Object.assign(meta, reactions.meta);
         try {
-            await this.deliverToInstance(instanceName, {
+            await this.deliverHumanToInstance(instanceName, {
                 type: "fleet_inbound",
                 content: fullText,
                 targetSession: instanceName,
                 meta,
-            });
+            }, msg.humanOrigin, msg.humanOriginalBody ?? text);
             reactions.consume();
         }
         catch (err) {
@@ -16496,6 +16703,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             clearInterval(this.eventLogPruneTimer);
             this.eventLogPruneTimer = null;
         }
+        this.logService?.unwatchAll(); // #1218: a Log's watch timers end with the fleet
         if (this.outboxPruneTimer) {
             clearInterval(this.outboxPruneTimer);
             this.outboxPruneTimer = null;