@songsid/agend 2.1.4-beta.1 → 2.1.4-beta.10

package/dist/daemon.js

@@ -8,6 +8,8 @@ import { mcpServerState } from "./mcp-liveness.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
+import { createTranscriptSource } from "./transcript-sources.js";
+import { ProgressAccumulator, summarizeProgress } from "./tool-progress.js";
 import { ContextGuardian } from "./context-guardian.js";
 import { IpcServer } from "./channel/ipc-bridge.js";
 import { daemonBudgetMs } from "./channel/ipc-timeouts.js";
@@ -665,6 +667,7 @@ export class Daemon extends EventEmitter {
     instanceStateReadyPattern = null;
     instanceStateBusyPattern = null;
     instanceStateMonitorActive = false;
+    sessionCheckpointWarningEmitted = false;
     statePollInFlight = false;
     // ── Dead-MCP proxy reply: per-turn evidence ─────────────────────────────
     // Set when an inbound message lands in the CLI; cleared on the idle edge that
@@ -710,6 +713,17 @@ export class Daemon extends EventEmitter {
     lastBuiltInstructions = "";
     pasteQueueDepth = 0;
     firstDeliveryDelay = new FirstDeliveryDelay();
+    /** Orders /steer pastes against each other. Deliberately NOT pasteLock:
+     *  a steer must not queue behind the normal deliveries it exists to
+     *  overtake. Pane-level exclusion still comes from paneWriteLock inside
+     *  deliverMessage, so a steer and a normal delivery can never interleave
+     *  their PTY writes — the steer just doesn't wait for idle. */
+    steerLock = Promise.resolve();
+    /** Tool lines shown in the channel processing bubble for the current turn. */
+    turnProgress = new ProgressAccumulator();
+    lastProgressBroadcast = "";
+    progressBroadcastTimer = null;
+    lastProgressBroadcastAt = 0;
     // PTY error pattern monitoring
     errorMonitorTimer = null;
     interactivePromptDetector = new InteractivePromptDetector();
@@ -929,6 +943,10 @@ export class Daemon extends EventEmitter {
                     });
                 }
             }
+            else if (msg.type === "steer") {
+                const meta = (msg.meta ?? {});
+                this.steerMessage(msg.content, meta);
+            }
             else if (msg.type === "fleet_schedule_trigger") {
                 const payload = msg.payload;
                 const meta = msg.meta;
@@ -1032,8 +1050,11 @@ export class Daemon extends EventEmitter {
             const outputLog = join(this.instanceDir, "output.log");
             rotateLogIfNeeded(outputLog);
             await this.tmux.pipeOutput(outputLog).catch(() => { });
-            // 4. Transcript monitor
-            this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger);
+            // 4. Transcript monitor. claude-code is handled inside the monitor
+            // (statusline transcript); codex/kiro/opencode read their CLI's own
+            // conversation store via a pluggable source. Backends with no known
+            // source stay inert exactly as before.
+            this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger, createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory));
             // 5. Wire transcript events
             const ackIfPending = () => {
                 if (!this.pendingAckMessage || !this.adapter)
@@ -1049,6 +1070,7 @@ export class Daemon extends EventEmitter {
                 this.recordRecentEvent({ type: "tool_use", name, preview: this.summarizeTool(name, input) });
                 this.recordRecentToolActivity(this.summarizeTool(name, input));
                 this.publishActivity(this.summarizeTool(name, input));
+                this.recordToolProgress(name, input);
             });
             this.transcriptMonitor.on("tool_result", (name, _output) => {
                 this.recordRecentEvent({ type: "tool_result", name });
@@ -1260,7 +1282,7 @@ export class Daemon extends EventEmitter {
                         this.logger.info("CLI exited normally (code 0) — pausing health check");
                         await this.tmux.killWindow();
                         this.healthCheckPaused = true;
-                        this.emitSupervisionEnded("the CLI exited normally (code 0)", "Nothing crashed — start it again when you need it.");
+                        this.emitSupervisionEnded("the CLI exited normally (code 0)", "Nothing crashed — start it again when you need it.", 0);
                         return;
                     }
                     // Distinguish tmux server crash from single window crash.
@@ -1357,6 +1379,17 @@ export class Daemon extends EventEmitter {
                             catch (err) {
                                 this.logger.error({ err: err.message }, "Recovery from background session conflict failed");
                             }
+                            // Keep the loop alive: every health-check exit must either
+                            // scheduleNext() or deliberately set healthCheckPaused. This one
+                            // did neither, so a recovered instance ran UNMONITORED (while
+                            // isHealthCheckEffectivelyPaused still said monitoring was on)
+                            // until the next pause→wake cycle or fleet restart. The next tick
+                            // does the right thing in both outcomes: a healthy new window
+                            // passes the alive check, and a failed recovery hits the dead
+                            // window again with backgroundSessionRecoveryAttempted set — so
+                            // it falls through to the normal crash handling (crash counting,
+                            // backoff, supervision_ended when retries are exhausted).
+                            scheduleNext();
                             return; // Don't count as crash
                         }
                         // Already attempted recovery — fall through to normal crash handling
@@ -1506,8 +1539,13 @@ export class Daemon extends EventEmitter {
      * `crash_loop` already had this treatment; this is the same bridge for the other
      * four, carrying a human-readable cause and the operator's next step.
      */
-    emitSupervisionEnded(reason, remedy) {
-        this.emit("supervision_ended", { name: this.name, reason, remedy });
+    emitSupervisionEnded(reason, remedy, exitCode) {
+        this.emit("supervision_ended", {
+            name: this.name,
+            reason,
+            remedy,
+            ...(exitCode !== undefined ? { exitCode } : {}),
+        });
     }
     setProcessStatus(status) {
         if (this.processStatus === status)
@@ -1988,6 +2026,14 @@ export class Daemon extends EventEmitter {
     applyInstanceStateSnapshot(snapshot, pane) {
         const previous = this.instanceState;
         this.instanceState = snapshot.state;
+        // OpenCode creates its session lazily on the first submitted message.
+        // Waiting until stop/pause to persist that id loses resume state when the
+        // fleet is SIGKILLed or the host reboots.
+        // Idle observations are safe checkpoints; the 60s safety sweep also gives
+        // us a bounded retry if session creation produced no visible state edge.
+        if (snapshot.state === "idle" && this.backend?.binaryName === "opencode") {
+            this.saveSessionId();
+        }
         // Only a transition back to idle completes pending work. Repeated idle
         // observations between enqueue and paste must not clear a newer inbound.
         if (snapshot.state === "idle" && previous !== "idle") {
@@ -1996,6 +2042,7 @@ export class Daemon extends EventEmitter {
             // tool_result (interrupted, crashed, cancelled), which would otherwise leave
             // the last tool pinned to the progress line for the rest of the session.
             this.publishActivity(null);
+            this.resetToolProgress();
             // Must run before the mcpRestartPending branch below: the pane text is the
             // only copy of the answer, and the revival restart is about to clear it.
             this.maybeProxyReplyOnTurnEnd(pane);
@@ -2393,6 +2440,69 @@ export class Daemon extends EventEmitter {
             activity: next,
         });
     }
+    /** Effective tool_progress level, hardened against junk config values.
+     *  Off unless explicitly enabled: an update must never make bubbles start
+     *  listing tool activity the operator did not ask to broadcast. */
+    toolProgressLevel() {
+        const raw = this.config.tool_progress;
+        return raw === "standard" || raw === "verbose" ? raw : "off";
+    }
+    /**
+     * Accumulate one semantic progress line for the channel bubble and schedule
+     * a coalesced broadcast. Separate from publishActivity on purpose: that one
+     * is the single-line statusline detail (terse, operator-facing), this is the
+     * multi-line channel list (semantic, argument-free at `standard`) — see
+     * tool-progress.ts for why the two labellers must not merge.
+     */
+    recordToolProgress(name, input) {
+        const level = this.toolProgressLevel();
+        if (level === "off")
+            return;
+        if (this.turnProgress.add(summarizeProgress(name, input, level))) {
+            this.scheduleProgressBroadcast();
+        }
+    }
+    /** Coalesce progress broadcasts: at most one per 3s, trailing edge kept. */
+    scheduleProgressBroadcast() {
+        const MIN_INTERVAL_MS = 3_000;
+        const since = Date.now() - this.lastProgressBroadcastAt;
+        if (since >= MIN_INTERVAL_MS) {
+            this.broadcastToolProgress();
+            return;
+        }
+        if (this.progressBroadcastTimer)
+            return;
+        this.progressBroadcastTimer = setTimeout(() => {
+            this.progressBroadcastTimer = null;
+            this.broadcastToolProgress();
+        }, MIN_INTERVAL_MS - since);
+        this.progressBroadcastTimer.unref?.();
+    }
+    broadcastToolProgress() {
+        const rendered = this.turnProgress.render();
+        if (rendered === this.lastProgressBroadcast)
+            return;
+        this.lastProgressBroadcast = rendered;
+        this.lastProgressBroadcastAt = Date.now();
+        this.ipcServer?.broadcast({
+            type: "instance_progress",
+            instanceName: this.name,
+            progress: rendered,
+        });
+    }
+    /** New turn (or turn over): drop the list and tell the fleet to clear it. */
+    resetToolProgress() {
+        if (this.progressBroadcastTimer) {
+            clearTimeout(this.progressBroadcastTimer);
+            this.progressBroadcastTimer = null;
+        }
+        this.turnProgress.reset();
+        if (this.lastProgressBroadcast !== "") {
+            this.lastProgressBroadcast = "";
+            this.lastProgressBroadcastAt = Date.now();
+            this.ipcServer?.broadcast({ type: "instance_progress", instanceName: this.name, progress: "" });
+        }
+    }
     /**
      * Options for every system-initiated paste (startup notice, session snapshot,
      * runtime-dialog keys).
@@ -2428,6 +2538,82 @@ export class Daemon extends EventEmitter {
             return ""; // skip channel tools
         return name;
     }
+    /**
+     * The one place an inbound message grows its metadata wrapper ([user:]/
+     * [from:] prefix, pending reactions, handoff metadata, reply instructions).
+     * Both the normal queued path (pushChannelMessage) and /steer go through
+     * here — a steered message must read EXACTLY like a queued one to the
+     * agent, or the two drift apart in what the agent is told about replying.
+     */
+    formatInboundMessage(content, meta) {
+        const user = meta.user || "unknown";
+        const fromInstance = meta.from_instance;
+        let formatted;
+        if (fromInstance) {
+            // #77: show the sender's display name for readability, keeping the machine
+            // instance name in parens so the recipient's send_to_instance target is valid.
+            const fromLabel = meta.from_display ? `${meta.from_display} (${fromInstance})` : fromInstance;
+            formatted = `[from:${fromLabel}] ${content}`;
+            formatted += renderHandoffMetadata(meta);
+            // A delegated task that requires a reply must not read like a chatty FYI —
+            // the "you may stay silent" line is for the latter only.
+            formatted += meta.requires_reply === "true"
+                ? "\n(A reply IS required: use report_result with the correlation_id above — or send_to_instance. Not direct text.)"
+                : "\n(If you need to reply, use send_to_instance tool, NOT direct text. If there is nothing to add, you may stay silent.)";
+        }
+        else {
+            const via = meta.source ? ` via ${meta.source}` : "";
+            const idTag = meta.user_id ? `, id:${meta.user_id}` : "";
+            formatted = `[user:${user}${via}${idTag}] ${content}`;
+            // Reactions queued since the last real message (#432). One leading line of
+            // context, present only when something is pending — a reaction no longer
+            // costs a turn of its own.
+            if (meta.pending_reactions) {
+                formatted = `[Recent reactions: ${meta.pending_reactions}]\n${formatted}`;
+            }
+            formatted += renderHandoffMetadata(meta);
+            formatted += "\n(Reply using the reply tool — do NOT respond with direct text)";
+        }
+        if (meta.reply_to_text) {
+            formatted += `\n(reply_to: "${meta.reply_to_text}")`;
+        }
+        return formatted;
+    }
+    /**
+     * /steer: interject into the CURRENT turn instead of queueing for idle.
+     *
+     * Differences from pushChannelMessage, and nothing else:
+     *  - serialized on steerLock, not pasteLock — it must overtake, not queue
+     *  - deliverMessage runs with { steer: true }, which takes the busy branch
+     *    that pastes immediately (the codex native-queue transaction) instead of
+     *    waiting for idle. Verification and silent-loss fallback are the ones
+     *    that path already has: pane-capture visibility check, then one
+     *    idle-gated redelivery — so on a TUI that swallows busy input the steer
+     *    degrades to "next message after this turn", never silently vanishes.
+     *
+     * The steered text goes through formatInboundMessage so the agent sees a
+     * normal inbound message, with a steering notice prepended for context.
+     */
+    steerMessage(content, meta) {
+        this.updateLastChat(meta.chat_id, meta.thread_id, meta.adapter_id);
+        this.pendingWork.recordInbound();
+        this.recordRecentUserMessage(content, meta);
+        const formatted = "[STEERING — mid-task course correction from the user. Fold this into the CURRENT work.]\n"
+            + this.formatInboundMessage(content, meta);
+        const chatId = meta.chat_id;
+        const messageId = meta.message_id;
+        const status = (chatId && messageId)
+            ? { chatId: meta.thread_id || chatId, messageId }
+            : undefined;
+        this.steerLock = this.steerLock.then(async () => {
+            await this.wake();
+            if (await this.deliverMessage(formatted, status, { steer: true })) {
+                this.markTurnStarted(meta, formatted);
+            }
+        }).catch(err => {
+            this.logger.warn({ err: err.message }, "steer delivery error");
+        });
+    }
     /**
      * Push an inbound channel message to a specific MCP session.
      * If targetSession is provided, only send to the matching socket.
@@ -2474,35 +2660,7 @@ export class Daemon extends EventEmitter {
             });
             return;
         }
-        let formatted;
-        if (fromInstance) {
-            // #77: show the sender's display name for readability, keeping the machine
-            // instance name in parens so the recipient's send_to_instance target is valid.
-            const fromLabel = meta.from_display ? `${meta.from_display} (${fromInstance})` : fromInstance;
-            formatted = `[from:${fromLabel}] ${content}`;
-            formatted += renderHandoffMetadata(meta);
-            // A delegated task that requires a reply must not read like a chatty FYI —
-            // the "you may stay silent" line is for the latter only.
-            formatted += meta.requires_reply === "true"
-                ? "\n(A reply IS required: use report_result with the correlation_id above — or send_to_instance. Not direct text.)"
-                : "\n(If you need to reply, use send_to_instance tool, NOT direct text. If there is nothing to add, you may stay silent.)";
-        }
-        else {
-            const via = meta.source ? ` via ${meta.source}` : "";
-            const idTag = meta.user_id ? `, id:${meta.user_id}` : "";
-            formatted = `[user:${user}${via}${idTag}] ${content}`;
-            // Reactions queued since the last real message (#432). One leading line of
-            // context, present only when something is pending — a reaction no longer
-            // costs a turn of its own.
-            if (meta.pending_reactions) {
-                formatted = `[Recent reactions: ${meta.pending_reactions}]\n${formatted}`;
-            }
-            formatted += renderHandoffMetadata(meta);
-            formatted += "\n(Reply using the reply tool — do NOT respond with direct text)";
-        }
-        if (meta.reply_to_text) {
-            formatted += `\n(reply_to: "${meta.reply_to_text}")`;
-        }
+        const formatted = this.formatInboundMessage(content, meta);
         // Serialize deliveries: each message waits for the previous to complete,
         // and each waits for the CLI to be idle before pasting. Messages are never
         // dropped for age — a long-busy CLI just queues them until it frees up
@@ -2529,6 +2687,9 @@ export class Daemon extends EventEmitter {
                 const status = (chatId && messageId)
                     ? { chatId: meta.thread_id || chatId, messageId }
                     : undefined;
+                // A fresh delivery begins a fresh turn — its bubble must not inherit
+                // the previous turn's tool list.
+                this.resetToolProgress();
                 if (await this.deliverMessage(formatted, status))
                     this.markTurnStarted(meta, formatted);
             }
@@ -2556,7 +2717,7 @@ export class Daemon extends EventEmitter {
      * immediately and own the application-level queue themselves. The pasteLock remains
      * serial in both cases so separate PTY writes can never overlap.
      */
-    async deliverMessage(formatted, status) {
+    async deliverMessage(formatted, status, opts) {
         // Sanitize unclosed code fences — they cause CLI to wait for closure on Enter
         const fenceCount = (formatted.match(/```/g) || []).length;
         if (fenceCount % 2 !== 0) {
@@ -2574,9 +2735,14 @@ export class Daemon extends EventEmitter {
         if (windowId && this.controlClient && !this.controlClient.isIdle(windowId)) {
             if (status)
                 this.emit("message_queued", status);
-            if (supportsQueuedInput) {
+            if (supportsQueuedInput || opts?.steer) {
+                // Native queue (codex), or an explicit /steer: hand the complete
+                // paste+Enter transaction to the busy CLI now. For steer this is the
+                // point — the user asked to interject, and the transaction's
+                // visibility check + idle-gated fallback catch TUIs that swallow
+                // busy input (see steerMessage).
                 handingOffToNativeQueue = true;
-                this.logger.debug("CLI busy — handing message to backend-native input queue");
+                this.logger.debug(opts?.steer ? "CLI busy — steering into the running turn" : "CLI busy — handing message to backend-native input queue");
             }
             else {
                 this.logger.debug("CLI busy — queuing message until idle");
@@ -3229,6 +3395,8 @@ export class Daemon extends EventEmitter {
             });
         }
         const agentPort = parseInt(process.env.AGEND_PORT ?? "19280", 10);
+        const backendName = this.config.backend ?? "claude-code";
+        const backendOptions = this.config.backend_options?.[backendName];
         return {
             workingDirectory: this.config.working_directory,
             instanceDir: this.instanceDir,
@@ -3248,6 +3416,7 @@ export class Daemon extends EventEmitter {
             instructions,
             agentMode: isCliMode ? "cli" : "mcp",
             agentPort: isCliMode ? agentPort : undefined,
+            backendOptions,
         };
     }
     /**
@@ -3611,9 +3780,29 @@ export class Daemon extends EventEmitter {
         // back from statusline.json — that would re-arm --continue and re-loop.
         if (this.skipResume)
             return;
-        const sid = this.backend?.getSessionId();
-        if (sid) {
-            writeFileSync(join(this.instanceDir, "session-id"), sid);
+        try {
+            const sid = this.backend?.getSessionId();
+            if (!sid)
+                return;
+            const path = join(this.instanceDir, "session-id");
+            // Idle observations happen after turns. Avoid needless writes (and mtime
+            // churn) while still updating the marker when /new changes the session.
+            try {
+                if (readFileSync(path, "utf-8").trim() === sid)
+                    return;
+            }
+            catch { /* first checkpoint */ }
+            writeFileSync(path, sid);
+            this.sessionCheckpointWarningEmitted = false;
+            this.logger.debug("Session id checkpointed");
+        }
+        catch (err) {
+            // Session discovery is best-effort and must never break the pane state
+            // monitor. Existing stop/pause checkpoints get another chance later.
+            if (!this.sessionCheckpointWarningEmitted) {
+                this.sessionCheckpointWarningEmitted = true;
+                this.logger.warn({ err: err.message }, "Session id checkpoint failed");
+            }
         }
     }
     readContextPercentage() {