@hydra-acp/cli 0.1.24 → 0.1.26

package/dist/cli.js

@@ -289,7 +289,15 @@ var init_config = __esm({
       // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
       // running. Set false if your terminal renders this obnoxiously or you
       // just don't want it.
-      progressIndicator: z.boolean().default(true)
+      progressIndicator: z.boolean().default(true),
+      // What the unmodified Enter key does in the prompt composer.
+      //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
+      //     when idle, queues behind an in-flight turn); Shift+Enter amends
+      //     the in-flight turn.
+      //   "amend" — flips the two: Enter amends the in-flight turn,
+      //     Shift+Enter enqueues. With no turn in flight either key just
+      //     enqueues, since there's nothing to amend.
+      defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -333,7 +341,8 @@ var init_config = __esm({
         mouse: true,
         logMaxBytes: 5 * 1024 * 1024,
         cwdColumnMaxWidth: 24,
-        progressIndicator: true
+        progressIndicator: true,
+        defaultEnterAction: "enqueue"
       })
     });
   }
@@ -413,6 +422,18 @@ function extractHydraMeta(meta) {
   if (typeof obj.promptQueueing === "boolean") {
     out.promptQueueing = obj.promptQueueing;
   }
+  if (typeof obj.promptCancelling === "boolean") {
+    out.promptCancelling = obj.promptCancelling;
+  }
+  if (typeof obj.promptUpdating === "boolean") {
+    out.promptUpdating = obj.promptUpdating;
+  }
+  if (typeof obj.promptAmending === "boolean") {
+    out.promptAmending = obj.promptAmending;
+  }
+  if (typeof obj.promptPipelining === "boolean") {
+    out.promptPipelining = obj.promptPipelining;
+  }
   if (Array.isArray(obj.queue)) {
     const entries = [];
     for (const raw of obj.queue) {
@@ -462,12 +483,35 @@ function extractHydraMeta(meta) {
       out.availableModes = modes;
     }
   }
+  if (Array.isArray(obj.availableModels)) {
+    const models = [];
+    for (const raw of obj.availableModels) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const m = raw;
+      if (typeof m.modelId !== "string") {
+        continue;
+      }
+      const model = { modelId: m.modelId };
+      if (typeof m.name === "string") {
+        model.name = m.name;
+      }
+      if (typeof m.description === "string") {
+        model.description = m.description;
+      }
+      models.push(model);
+    }
+    if (models.length > 0) {
+      out.availableModels = models;
+    }
+  }
   return out;
 }
 function mergeMeta(passthrough, ours) {
   return { ...passthrough ?? {}, [HYDRA_META_KEY]: ours };
 }
-var ACP_PROTOCOL_VERSION, JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, PromptOriginatorSchema, PromptQueueAddedParams, PromptQueueUpdatedParams, PromptQueueRemovedParams, CancelPromptParams, CancelPromptResult, UpdatePromptParams, UpdatePromptResult, ProxyInitializeParams;
+var ACP_PROTOCOL_VERSION, JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, PromptOriginatorSchema, PromptQueueAddedParams, PromptQueueUpdatedParams, PromptQueueRemovedParams, CancelPromptParams, CancelPromptResult, UpdatePromptParams, UpdatePromptResult, AmendPromptParams, AmendPromptResult, PromptAmendedParams, AgentInstallProgressParams, AGENT_INSTALL_PROGRESS_METHOD, ProxyInitializeParams;
 var init_types = __esm({
   "src/acp/types.ts"() {
     "use strict";
@@ -633,6 +677,51 @@ var init_types = __esm({
       updated: z3.boolean(),
       reason: z3.enum(["ok", "not_found", "already_running"])
     });
+    AmendPromptParams = z3.object({
+      sessionId: z3.string(),
+      targetMessageId: z3.string(),
+      prompt: z3.array(z3.unknown()),
+      replaceQueue: z3.boolean().optional(),
+      onTargetCompleted: z3.enum(["reject", "send_anyway"]).optional()
+    });
+    AmendPromptResult = z3.object({
+      amended: z3.boolean(),
+      reason: z3.enum([
+        "ok",
+        "target_completed",
+        "target_cancelled",
+        "target_not_found"
+      ]),
+      // Present when a prompt was sent or replaced: the amendment's id on
+      // success, or the regular follow-up's id when onTargetCompleted is
+      // "send_anyway" and the daemon forwarded the prompt anyway.
+      messageId: z3.string().optional()
+    });
+    PromptAmendedParams = z3.object({
+      sessionId: z3.string(),
+      cancelledMessageId: z3.string(),
+      newMessageId: z3.string(),
+      prompt: z3.array(z3.unknown()),
+      originator: PromptOriginatorSchema,
+      amendedAt: z3.number()
+    });
+    AgentInstallProgressParams = z3.object({
+      agentId: z3.string(),
+      version: z3.string(),
+      source: z3.enum(["binary", "npm"]),
+      phase: z3.enum([
+        "download_start",
+        "download_progress",
+        "download_done",
+        "extract",
+        "install_start",
+        "installed"
+      ]),
+      receivedBytes: z3.number().optional(),
+      totalBytes: z3.number().optional(),
+      packageSpec: z3.string().optional()
+    });
+    AGENT_INSTALL_PROGRESS_METHOD = "hydra-acp/agent_install_progress";
     ProxyInitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
       proxyInfo: z3.object({
@@ -971,6 +1060,42 @@ function sameAdvertisedModes(a, b) {
   }
   return true;
 }
+function sameAdvertisedModels(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i]?.modelId !== b[i]?.modelId || a[i]?.name !== b[i]?.name || a[i]?.description !== b[i]?.description) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseModelsList(list) {
+  if (!Array.isArray(list)) {
+    return [];
+  }
+  const out = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      continue;
+    }
+    const r = raw;
+    const modelId = typeof r.modelId === "string" && r.modelId.trim() || typeof r.value === "string" && r.value.trim() || typeof r.id === "string" && r.id.trim() || void 0;
+    if (!modelId) {
+      continue;
+    }
+    const model = { modelId };
+    if (typeof r.name === "string" && r.name.length > 0) {
+      model.name = r.name;
+    }
+    if (typeof r.description === "string" && r.description.length > 0) {
+      model.description = r.description;
+    }
+    out.push(model);
+  }
+  return out;
+}
 function extractAdvertisedModes(params) {
   const obj = params ?? {};
   const update = obj.update ?? {};
@@ -1154,7 +1279,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, DEFAULT_HISTORY_MAX_ENTRIES, Session, STATE_UPDATE_KINDS;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, DEFAULT_HISTORY_MAX_ENTRIES, RECENTLY_TERMINAL_LIMIT, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -1165,6 +1290,7 @@ var init_session = __esm({
     generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
     HYDRA_SESSION_PREFIX = "hydra_session_";
     DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
+    RECENTLY_TERMINAL_LIMIT = 64;
     Session = class {
       sessionId;
       cwd;
@@ -1256,14 +1382,36 @@ var init_session = __esm({
       // Last available_modes_update we observed from the agent. Same
       // pattern as commands: cache, persist, broadcast on change.
       agentAdvertisedModes = [];
+      // Last availableModels payload we observed (from current_model_update,
+      // a session/new / session/load response, or — for opencode — a
+      // config_option_update where configOptions[i].id === "model").
+      // Cached so a mid-session attach can synthesize a model picker
+      // snapshot, and so session/set_model can validate the requested id
+      // against what the agent claims to support.
+      agentAdvertisedModels = [];
       // Persist hooks for snapshot-shaped state. SessionManager hooks these
       // to mirror changes into meta.json so cold-resurrect attaches can
       // surface the latest snapshot via the attach response _meta.
       agentCommandsHandlers = [];
       agentModesHandlers = [];
+      agentModelsHandlers = [];
       modelHandlers = [];
       modeHandlers = [];
       usageHandlers = [];
+      // Set by amendPrompt at the start of a cancel-and-resubmit dance.
+      // broadcastTurnComplete reads it to attach the _meta.amended marker
+      // to the cancelled turn's turn_complete notification, and to fire the
+      // dedicated prompt_amended notification. Cleared when the cancelled
+      // turn's task completes (runQueueEntry) OR if the amendment is
+      // cancelled mid-window via cancel_prompt(M2) before drainQueue picks
+      // it up.
+      amendInProgress;
+      // LRU of recently-terminal messageIds → stopReason. Used by
+      // amendPrompt to resolve targets that completed/cancelled before
+      // the amend arrived. Capped at RECENTLY_TERMINAL_LIMIT entries;
+      // older entries fall out and resolve to target_not_found, which is
+      // the correct behavior.
+      recentlyTerminal = /* @__PURE__ */ new Map();
       constructor(init) {
         this.sessionId = init.sessionId ?? `${HYDRA_SESSION_PREFIX}${generateHydraId()}`;
         this.cwd = init.cwd;
@@ -1282,6 +1430,9 @@ var init_session = __esm({
         if (init.agentModes && init.agentModes.length > 0) {
           this.agentAdvertisedModes = [...init.agentModes];
         }
+        if (init.agentModels && init.agentModels.length > 0) {
+          this.agentAdvertisedModels = [...init.agentModels];
+        }
         this.idleTimeoutMs = init.idleTimeoutMs ?? 0;
         this.spawnReplacementAgent = init.spawnReplacementAgent;
         this.logger = init.logger;
@@ -1319,6 +1470,23 @@ var init_session = __esm({
           }
         });
       }
+      // Re-broadcast our cached availableModels via current_model_update.
+      // Spec shape: { currentModel, availableModels } — we only include the
+      // currentModel field when we know it, so this broadcast can also fire
+      // model-list updates standalone before any current model is set.
+      broadcastAvailableModels() {
+        const update = {
+          sessionUpdate: "current_model_update",
+          availableModels: [...this.agentAdvertisedModels]
+        };
+        if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+          update.currentModel = this.currentModel;
+        }
+        this.recordAndBroadcast("session/update", {
+          sessionId: this.upstreamSessionId,
+          update
+        });
+      }
       // Register session/update, session/request_permission, and onExit
       // handlers on an agent connection. Re-run on every /hydra agent so
       // the new agent is plumbed identically. The exit handler's identity
@@ -1349,6 +1517,10 @@ var init_session = __esm({
             this.recordAndBroadcast("session/update", params);
             return;
           }
+          if (this.maybeApplyAgentConfigOption(params)) {
+            this.recordAndBroadcast("session/update", params);
+            return;
+          }
           if (this.maybeApplyAgentUsage(params)) {
             this.recordAndBroadcast("session/update", params);
             return;
@@ -1497,16 +1669,19 @@ var init_session = __esm({
             recordedAt
           });
         }
-        if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+        if (this.currentModel !== void 0 && this.currentModel.length > 0 || this.agentAdvertisedModels.length > 0) {
+          const update = {
+            sessionUpdate: "current_model_update"
+          };
+          if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+            update.currentModel = this.currentModel;
+          }
+          if (this.agentAdvertisedModels.length > 0) {
+            update.availableModels = [...this.agentAdvertisedModels];
+          }
           out.push({
             method: "session/update",
-            params: {
-              sessionId,
-              update: {
-                sessionUpdate: "current_model_update",
-                currentModel: this.currentModel
-              }
-            },
+            params: { sessionId, update },
             recordedAt
           });
         }
@@ -1693,7 +1868,7 @@ var init_session = __esm({
           );
         }
       }
-      broadcastTurnComplete(originatorClientId, response) {
+      broadcastTurnComplete(originatorClientId, response, promptMessageId, wasAmend) {
         const stopReason = response && typeof response === "object" && "stopReason" in response && typeof response.stopReason === "string" ? response.stopReason : void 0;
         const update = {
           sessionUpdate: "turn_complete",
@@ -1702,16 +1877,84 @@ var init_session = __esm({
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
         }
+        const amend = this.amendInProgress;
+        if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+          update._meta = {
+            "hydra-acp": {
+              amended: {
+                cancelledMessageId: amend.cancelledMessageId,
+                newMessageId: amend.newMessageId
+              }
+            }
+          };
+        }
         this.promptStartedAt = void 0;
+        if (promptMessageId !== void 0 && stopReason !== void 0) {
+          this.recordTerminal(promptMessageId, stopReason);
+        }
         this.recordAndBroadcast(
           "session/update",
           {
             sessionId: this.sessionId,
             update
           },
-          originatorClientId
+          wasAmend ? void 0 : originatorClientId
+        );
+        if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+          this.broadcastPromptAmended(amend);
+        }
+      }
+      // Record that a prompt's turn has ended, with its terminal stopReason.
+      // Used by amendPrompt to resolve targetMessageIds that completed/cancelled
+      // before the amend arrived. LRU-trimmed at RECENTLY_TERMINAL_LIMIT.
+      recordTerminal(messageId, stopReason) {
+        this.recentlyTerminal.set(messageId, {
+          stopReason,
+          terminatedAt: Date.now()
+        });
+        while (this.recentlyTerminal.size > RECENTLY_TERMINAL_LIMIT) {
+          const oldest = this.recentlyTerminal.keys().next().value;
+          if (oldest === void 0) {
+            break;
+          }
+          this.recentlyTerminal.delete(oldest);
+        }
+      }
+      // Fire hydra-acp/prompt_amended for the M1→M2 linkage. The amendment's
+      // current content is read live from the queue entry so any update_prompt
+      // calls during the amend window are reflected. Best-effort: if M2 has
+      // already been cancelled out of the queue by the time we get here, we
+      // skip — the amendInProgress clearing in cancelQueuedPrompt should have
+      // prevented this code path from running in that case.
+      broadcastPromptAmended(amend) {
+        const entry = this.findUserEntry(amend.newMessageId);
+        if (!entry) {
+          return;
+        }
+        const params = {
+          sessionId: this.sessionId,
+          cancelledMessageId: amend.cancelledMessageId,
+          newMessageId: amend.newMessageId,
+          prompt: entry.prompt,
+          originator: entry.originator,
+          amendedAt: Date.now()
+        };
+        this.broadcastQueueNotification(
+          "hydra-acp/prompt_amended",
+          params
         );
       }
+      // Look up a user-prompt queue entry by messageId, searching both the
+      // currentEntry slot and the waiting queue.
+      findUserEntry(messageId) {
+        if (this.currentEntry?.messageId === messageId && this.currentEntry.kind === "user") {
+          return this.currentEntry;
+        }
+        const queued = this.promptQueue.find(
+          (e) => e.messageId === messageId && e.kind === "user"
+        );
+        return queued?.kind === "user" ? queued : void 0;
+      }
       // Total visible-or-running entries: the in-flight head (if any) plus
       // the queue's user-visible waiting entries. Internal entries don't
       // count — they're an implementation detail and the wire never
@@ -1723,9 +1966,9 @@ var init_session = __esm({
         }
         return count;
       }
-      broadcastQueueAdded(entry) {
+      broadcastQueueAdded(entry, options) {
         const depth = this.visibleQueueDepth();
-        const position = Math.max(0, depth - 1);
+        const position = options?.position ?? Math.max(0, depth - 1);
         const params = {
           sessionId: this.sessionId,
           messageId: entry.messageId,
@@ -1735,6 +1978,11 @@ var init_session = __esm({
           queueDepth: depth,
           enqueuedAt: entry.enqueuedAt
         };
+        if (options?.amending !== void 0) {
+          params._meta = {
+            "hydra-acp": { amending: options.amending }
+          };
+        }
         this.broadcastQueueNotification("hydra-acp/prompt_queue_added", params);
       }
       broadcastQueueUpdated(messageId, prompt) {
@@ -1857,6 +2105,9 @@ var init_session = __esm({
           this.broadcastQueueRemoved(messageId, "cancelled");
           this.persistRewrite();
         }
+        if (this.amendInProgress?.newMessageId === messageId) {
+          this.amendInProgress = void 0;
+        }
         entry.resolve({ stopReason: "cancelled" });
         return { cancelled: true, reason: "ok" };
       }
@@ -1878,6 +2129,143 @@ var init_session = __esm({
         this.persistRewrite();
         return { updated: true, reason: "ok" };
       }
+      // Amend the head prompt: cancel the in-flight turn and submit a
+      // replacement that sits at the head of the queue. Resolves the
+      // request immediately (the caller doesn't wait on cancel-settle).
+      // Honours race outcomes — if the target finished or was cancelled
+      // before this arrived, the request resolves with an outcome explaining
+      // why and (depending on onTargetCompleted) optionally forwards as a
+      // plain prompt. Queued targets are edited in place (same machinery
+      // as updateQueuedPrompt).
+      amendPrompt(clientId, params) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+          throw withCode(
+            new Error("client not attached"),
+            JsonRpcErrorCodes.SessionNotFound
+          );
+        }
+        const { targetMessageId, prompt, replaceQueue, onTargetCompleted } = params;
+        if (this.currentEntry?.messageId === targetMessageId && this.currentEntry.kind === "user" && !this.currentEntry.cancelled && this.amendInProgress === void 0) {
+          return this.amendOnHead(client, prompt, targetMessageId, replaceQueue);
+        }
+        const queuedEntry = this.promptQueue.find(
+          (e) => e.messageId === targetMessageId && e.kind === "user"
+        );
+        if (queuedEntry && queuedEntry.kind === "user" && !queuedEntry.cancelled) {
+          queuedEntry.prompt = prompt;
+          this.broadcastQueueUpdated(targetMessageId, prompt);
+          this.persistRewrite();
+          return { amended: true, reason: "ok", messageId: targetMessageId };
+        }
+        const terminal = this.recentlyTerminal.get(targetMessageId);
+        if (terminal) {
+          if (terminal.stopReason === "cancelled") {
+            return { amended: false, reason: "target_cancelled" };
+          }
+          if (onTargetCompleted === "send_anyway") {
+            const newMessageId = this.enqueueAmendmentAsFollowUp(client, prompt);
+            return {
+              amended: false,
+              reason: "target_completed",
+              messageId: newMessageId
+            };
+          }
+          return { amended: false, reason: "target_completed" };
+        }
+        return { amended: false, reason: "target_not_found" };
+      }
+      // Head-of-queue amendment: splice M2 in front of any waiting entries,
+      // broadcast the amend window's queue_added with the amending hint,
+      // mark amendInProgress so the cancelled turn's broadcastTurnComplete
+      // attaches the _meta marker and fires prompt_amended, then fire the
+      // upstream session/cancel without awaiting it. drainQueue is already
+      // running on the head; when its session/prompt returns, it advances
+      // to M2 in the normal way.
+      amendOnHead(client, prompt, targetMessageId, replaceQueue) {
+        const newMessageId = generateMessageId();
+        const originator = { clientId: client.clientId };
+        if (client.clientInfo?.name) {
+          originator.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          originator.version = client.clientInfo.version;
+        }
+        if (replaceQueue) {
+          const survivors = [];
+          for (const entry2 of this.promptQueue) {
+            if (entry2.kind === "user" && !entry2.cancelled) {
+              entry2.cancelled = true;
+              this.broadcastQueueRemoved(entry2.messageId, "cancelled");
+              entry2.resolve({ stopReason: "cancelled" });
+              continue;
+            }
+            survivors.push(entry2);
+          }
+          this.promptQueue = survivors;
+        }
+        const entry = {
+          kind: "user",
+          messageId: newMessageId,
+          originator,
+          clientId: client.clientId,
+          prompt,
+          enqueuedAt: Date.now(),
+          cancelled: false,
+          wasAmend: true,
+          // No-op resolve/reject: there's no client request awaiting M2's
+          // session/prompt response. The amend_prompt request has already
+          // returned by this point. drainQueue calls these unconditionally
+          // when runQueueEntry settles; making them no-ops is safe.
+          resolve: () => void 0,
+          reject: () => void 0
+        };
+        this.promptQueue.unshift(entry);
+        this.persistRewrite();
+        this.broadcastQueueAdded(entry, {
+          amending: targetMessageId,
+          position: 1
+        });
+        this.amendInProgress = {
+          cancelledMessageId: targetMessageId,
+          newMessageId
+        };
+        void this.agent.connection.notify("session/cancel", { sessionId: this.upstreamSessionId }).catch(() => void 0);
+        return {
+          amended: true,
+          reason: "ok",
+          messageId: newMessageId
+        };
+      }
+      // Send the amendment as a plain follow-up prompt — used when the
+      // target already completed and the caller opted in to send_anyway.
+      // Returns the new prompt's messageId so the result can surface it.
+      enqueueAmendmentAsFollowUp(client, prompt) {
+        const messageId = generateMessageId();
+        const originator = { clientId: client.clientId };
+        if (client.clientInfo?.name) {
+          originator.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          originator.version = client.clientInfo.version;
+        }
+        const entry = {
+          kind: "user",
+          messageId,
+          originator,
+          clientId: client.clientId,
+          prompt,
+          enqueuedAt: Date.now(),
+          cancelled: false,
+          resolve: () => void 0,
+          reject: () => void 0
+        };
+        this.promptQueue.push(entry);
+        this.persistRewrite();
+        this.broadcastQueueAdded(entry);
+        void this.drainQueue();
+        return messageId;
+      }
       async cancel(clientId) {
         const client = this.clients.get(clientId);
         if (!client) {
@@ -1928,6 +2316,18 @@ var init_session = __esm({
       onTitleChange(handler) {
         this.titleHandlers.push(handler);
       }
+      // External entry point for retitling a live session from outside the
+      // ACP slash-command path (e.g. PATCH /v1/sessions/:id from the picker).
+      // Goes through the same enqueuePrompt path as /hydra title so it
+      // serializes after any in-flight turn and shares broadcast/persistence.
+      retitle(title) {
+        return this.runTitleCommand(title);
+      }
+      // External entry point for the LLM-regen title path (T in the picker,
+      // equivalent to bare /hydra title with no arg).
+      retitleFromAgent() {
+        return this.runTitleCommand("");
+      }
       // Update the canonical title and broadcast a session_info_update to
       // every attached client. Clients that already speak the spec's
       // session_info_update need no hydra-specific wiring to pick this up.
@@ -1975,12 +2375,19 @@ var init_session = __esm({
       // Apply an agent-emitted current_model_update. Returns true if the
       // notification was a model update (caller still needs to broadcast
       // it). Returns false otherwise so the caller can try the next kind.
+      // current_model_update can carry availableModels in the same payload
+      // (per ACP spec); we cache that list too so session/set_model can
+      // validate against it.
       maybeApplyAgentModel(params) {
         const obj = params ?? {};
         const update = obj.update ?? {};
         if (update.sessionUpdate !== "current_model_update") {
           return false;
         }
+        const models = parseModelsList(update.availableModels);
+        if (models.length > 0) {
+          this.setAgentAdvertisedModels(models);
+        }
         const raw = typeof update.currentModel === "string" ? update.currentModel : typeof update.model === "string" ? update.model : void 0;
         if (raw === void 0) {
           return true;
@@ -1998,6 +2405,55 @@ var init_session = __esm({
         }
         return true;
       }
+      // Apply an opencode-style config_option_update. opencode emits this
+      // (not the spec-shaped current_model_update / available_models_update)
+      // to carry both the current model and the list of available models.
+      // The payload is `configOptions: [{ id: "model", currentValue, options:
+      // [{ value, name }] }, ...]`. We harvest only the entry whose id is
+      // "model" — other ids ("mode", "effort", etc.) are opencode-internal
+      // and not consumed by hydra. Returns true when we recognized and
+      // handled the notification so the wireAgent loop can stop trying
+      // further extractors (the broadcast still fires; clients that grok
+      // config_option_update render it directly).
+      maybeApplyAgentConfigOption(params) {
+        const obj = params ?? {};
+        const update = obj.update ?? {};
+        if (update.sessionUpdate !== "config_option_update") {
+          return false;
+        }
+        const list = update.configOptions;
+        if (!Array.isArray(list)) {
+          return true;
+        }
+        for (const raw of list) {
+          if (!raw || typeof raw !== "object") {
+            continue;
+          }
+          const opt = raw;
+          if (opt.id !== "model") {
+            continue;
+          }
+          const models = parseModelsList(opt.options);
+          if (models.length > 0) {
+            this.setAgentAdvertisedModels(models);
+          }
+          const cv = opt.currentValue;
+          if (typeof cv === "string") {
+            const trimmed = cv.trim();
+            if (trimmed && trimmed !== this.currentModel) {
+              this.currentModel = trimmed;
+              for (const handler of this.modelHandlers) {
+                try {
+                  handler(trimmed);
+                } catch {
+                }
+              }
+            }
+          }
+          break;
+        }
+        return true;
+      }
       maybeApplyAgentMode(params) {
         const obj = params ?? {};
         const update = obj.update ?? {};
@@ -2096,6 +2552,20 @@ var init_session = __esm({
         }
         this.broadcastAvailableModes();
       }
+      setAgentAdvertisedModels(models) {
+        if (sameAdvertisedModels(this.agentAdvertisedModels, models)) {
+          this.broadcastAvailableModels();
+          return;
+        }
+        this.agentAdvertisedModels = models;
+        for (const handler of this.agentModelsHandlers) {
+          try {
+            handler(models);
+          } catch {
+          }
+        }
+        this.broadcastAvailableModels();
+      }
       // Subscribe to snapshot-state updates. SessionManager wires these to
       // persist the new value into meta.json so cold resurrect can restore
       // them via the attach response _meta.
@@ -2105,6 +2575,9 @@ var init_session = __esm({
       onAgentModesChange(handler) {
         this.agentModesHandlers.push(handler);
       }
+      onAgentModelsChange(handler) {
+        this.agentModelsHandlers.push(handler);
+      }
       onModelChange(handler) {
         this.modelHandlers.push(handler);
       }
@@ -2130,6 +2603,15 @@ var init_session = __esm({
       availableModes() {
         return [...this.agentAdvertisedModes];
       }
+      // The agent's advertised models list. Used by acp-ws.ts's dedicated
+      // session/set_model handler to validate the requested modelId before
+      // forwarding to the agent (catches cross-agent set_model storms from
+      // clients that assume a different agent is on the other end). When
+      // the agent never advertised any models, returns [] and the
+      // set_model handler falls back to pass-through.
+      availableModels() {
+        return [...this.agentAdvertisedModels];
+      }
       // Pick up an agent-emitted session_info_update and store its title
       // as our canonical record. The notification is also forwarded to
       // clients via the surrounding recordAndBroadcast call. Authoritative
@@ -2277,6 +2759,12 @@ var init_session = __esm({
           this.agentMeta = fresh.agentMeta;
           this.agentAdvertisedCommands = [];
           this.broadcastMergedCommands();
+          if (this.agentAdvertisedModels.length > 0) {
+            this.setAgentAdvertisedModels([]);
+          }
+          if (this.agentAdvertisedModes.length > 0) {
+            this.setAgentAdvertisedModes([]);
+          }
           await oldAgent.kill().catch(() => void 0);
           if (transcript) {
             await this.runInternalPrompt(transcript).catch(() => void 0);
@@ -2736,6 +3224,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             try {
               const result = await this.runQueueEntry(next);
               next.resolve(result);
+              await Promise.resolve();
             } catch (err) {
               next.reject(err);
             } finally {
@@ -2772,12 +3261,33 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             }
           );
         } catch (err) {
-          this.broadcastTurnComplete(entry.clientId, { stopReason: "error" });
+          this.broadcastTurnComplete(
+            entry.clientId,
+            { stopReason: "error" },
+            entry.messageId,
+            entry.wasAmend
+          );
+          this.clearAmendIfMatches(entry.messageId);
           throw err;
         }
-        this.broadcastTurnComplete(entry.clientId, response);
+        this.broadcastTurnComplete(
+          entry.clientId,
+          response,
+          entry.messageId,
+          entry.wasAmend
+        );
+        this.clearAmendIfMatches(entry.messageId);
         return response;
       }
+      // Clear amendInProgress once the cancelled turn's task has fully
+      // settled. broadcastTurnComplete needs the marker still set when it
+      // fires, so the clear must happen *after*. Called from runQueueEntry's
+      // settle path for both success and error.
+      clearAmendIfMatches(messageId) {
+        if (this.amendInProgress?.cancelledMessageId === messageId) {
+          this.amendInProgress = void 0;
+        }
+      }
     };
     STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
       "session_info_update",
@@ -2821,11 +3331,12 @@ function recordFromMemorySession(args) {
     currentUsage: args.currentUsage,
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
+    agentModels: args.agentModels,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
 }
-var HYDRA_ID_ALPHABET2, generateRawId, HYDRA_LINEAGE_PREFIX, PersistedAgentCommand, PersistedAgentMode, PersistedUsage, SessionRecord, SESSION_ID_PATTERN, SessionStore;
+var HYDRA_ID_ALPHABET2, generateRawId, HYDRA_LINEAGE_PREFIX, PersistedAgentCommand, PersistedAgentMode, PersistedAgentModel, PersistedUsage, SessionRecord, SESSION_ID_PATTERN, SessionStore;
 var init_session_store = __esm({
   "src/core/session-store.ts"() {
     "use strict";
@@ -2842,6 +3353,11 @@ var init_session_store = __esm({
       name: z4.string().optional(),
       description: z4.string().optional()
     });
+    PersistedAgentModel = z4.object({
+      modelId: z4.string(),
+      name: z4.string().optional(),
+      description: z4.string().optional()
+    });
     PersistedUsage = z4.object({
       used: z4.number().optional(),
       size: z4.number().optional(),
@@ -2888,6 +3404,7 @@ var init_session_store = __esm({
       currentUsage: PersistedUsage.optional(),
       agentCommands: z4.array(PersistedAgentCommand).optional(),
       agentModes: z4.array(PersistedAgentMode).optional(),
+      agentModels: z4.array(PersistedAgentModel).optional(),
       createdAt: z4.string(),
       updatedAt: z4.string()
     });
@@ -3383,8 +3900,55 @@ function mapToolCallUpdate(u) {
   if (status !== void 0) {
     event.status = status;
   }
+  if (status === "failed") {
+    const errorText = extractToolFailureText(u);
+    if (errorText !== null) {
+      event.errorText = errorText;
+    }
+    if (isUpstreamInterrupted(u, errorText)) {
+      event.upstreamInterrupted = true;
+    }
+  }
   return event;
 }
+function extractToolFailureText(u) {
+  const content = u.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") {
+        continue;
+      }
+      const b = block;
+      const text = extractContentText(b.content);
+      if (text !== null && text.length > 0) {
+        return text;
+      }
+    }
+  }
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object") {
+    const err = rawOutput.error;
+    if (typeof err === "string" && err.length > 0) {
+      return sanitizeWireText(err);
+    }
+  }
+  return null;
+}
+function isUpstreamInterrupted(u, errorText) {
+  const rawOutput = u.rawOutput;
+  if (rawOutput && typeof rawOutput === "object") {
+    const meta = rawOutput.metadata;
+    if (meta && typeof meta === "object") {
+      if (meta.interrupted === true) {
+        return true;
+      }
+    }
+  }
+  if (errorText !== null && errorText.toLowerCase().includes("tool execution aborted")) {
+    return true;
+  }
+  return false;
+}
 function mapPlan(u) {
   const entries = u.entries;
   if (!Array.isArray(entries)) {
@@ -3427,7 +3991,16 @@ function mapModel(u) {
 }
 function mapTurnComplete(u) {
   const stopReason = readString(u, "stopReason");
-  return stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" };
+  const meta = u._meta;
+  const amended = meta?.["hydra-acp"]?.amended !== void 0 && meta["hydra-acp"].amended !== null;
+  const out = { kind: "turn-complete" };
+  if (stopReason !== void 0) {
+    out.stopReason = stopReason;
+  }
+  if (amended) {
+    out.amended = true;
+  }
+  return out;
 }
 function extractContentText(content) {
   if (typeof content === "string") {
@@ -4761,6 +5334,34 @@ async function killSession(config, serviceToken, id, fetchImpl = fetch) {
     throw new Error(`daemon returned HTTP ${response.status}`);
   }
 }
+async function renameSession(config, serviceToken, id, title, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}`, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${serviceToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ title })
+  });
+  if (!response.ok && response.status !== 204 && response.status !== 404) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
+async function regenSessionTitle(config, serviceToken, id, fetchImpl = fetch) {
+  const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
+  const response = await fetchImpl(`${base}/v1/sessions/${id}`, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${serviceToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ regen: true })
+  });
+  if (!response.ok && response.status !== 202 && response.status !== 204 && response.status !== 404 && response.status !== 409) {
+    throw new Error(`daemon returned HTTP ${response.status}`);
+  }
+}
 async function deleteSession(config, serviceToken, id, fetchImpl = fetch) {
   const base = httpBase(config.daemon.host, config.daemon.port, !!config.daemon.tls);
   const response = await fetchImpl(`${base}/v1/sessions/${id}`, {
@@ -4831,6 +5432,7 @@ async function pickSession(term, opts) {
   let cwdOnly = false;
   let mode = "normal";
   let pendingAction = null;
+  let renameBuffer = "";
   let transientStatus = null;
   let termHeight = readTermHeight(term);
   let termWidth = readTermWidth(term);
@@ -4939,6 +5541,12 @@ async function pickSession(term, opts) {
       term.dim.noFormat(`  working on ${shortId2(pendingAction.sessionId)}\u2026`);
       return;
     }
+    if (mode === "rename" && pendingAction) {
+      term.brightYellow.noFormat(`  title: ${renameBuffer}`);
+      term.bgBrightYellow(" ");
+      term.dim.noFormat("  Enter saves \xB7 Esc cancels");
+      return;
+    }
     if (transientStatus !== null) {
       term.dim.noFormat(`  ${transientStatus}`);
       return;
@@ -5056,6 +5664,37 @@ async function pickSession(term, opts) {
         renderFromScratch();
       }
     };
+    const performRename = async (title) => {
+      if (!pendingAction) {
+        return;
+      }
+      const target = pendingAction;
+      mode = "busy";
+      paintIndicator();
+      try {
+        await renameSession(opts.config, opts.serviceToken, target.sessionId, title);
+        mode = "normal";
+        pendingAction = null;
+        renameBuffer = "";
+        await refresh(target.sessionId);
+      } catch (err) {
+        mode = "normal";
+        pendingAction = null;
+        renameBuffer = "";
+        transientStatus = `rename failed: ${err.message}`;
+        paintIndicator();
+      }
+    };
+    const performRegen = async (target) => {
+      try {
+        await regenSessionTitle(opts.config, opts.serviceToken, target.sessionId);
+        transientStatus = "title regen queued (press r to refresh)";
+        paintIndicator();
+      } catch (err) {
+        transientStatus = `regen failed: ${err.message}`;
+        paintIndicator();
+      }
+    };
     const performAction = async (kind) => {
       if (!pendingAction) {
         return;
@@ -5128,19 +5767,65 @@ async function pickSession(term, opts) {
         renderFromScratch();
         return;
       }
-      if (mode === "confirm-kill" || mode === "confirm-delete") {
-        if (data?.isCharacter && (name === "y" || name === "Y")) {
-          const kind = mode === "confirm-kill" ? "kill" : "delete";
-          void performAction(kind);
+      if (mode === "rename") {
+        if (name === "ENTER" || name === "KP_ENTER") {
+          const trimmed = renameBuffer.trim();
+          if (trimmed.length === 0) {
+            mode = "normal";
+            pendingAction = null;
+            renameBuffer = "";
+            paintIndicator();
+            return;
+          }
+          void performRename(trimmed);
           return;
         }
-        if (name === "ESCAPE" || name === "CTRL_C" || name === "ENTER" || name === "KP_ENTER" || data?.isCharacter && (name === "n" || name === "N")) {
+        if (name === "ESCAPE" || name === "CTRL_C") {
           mode = "normal";
           pendingAction = null;
+          renameBuffer = "";
           paintIndicator();
           return;
         }
-        return;
+        if (name === "BACKSPACE") {
+          if (renameBuffer.length > 0) {
+            renameBuffer = renameBuffer.slice(0, -1);
+            paintIndicator();
+          }
+          return;
+        }
+        if (name === "CTRL_U") {
+          renameBuffer = "";
+          paintIndicator();
+          return;
+        }
+        if (name === "CTRL_W") {
+          const trimmedRight = renameBuffer.replace(/\s+$/, "");
+          const lastSpace = trimmedRight.lastIndexOf(" ");
+          renameBuffer = lastSpace >= 0 ? trimmedRight.slice(0, lastSpace) : "";
+          paintIndicator();
+          return;
+        }
+        if (data?.isCharacter) {
+          renameBuffer += name;
+          paintIndicator();
+          return;
+        }
+        return;
+      }
+      if (mode === "confirm-kill" || mode === "confirm-delete") {
+        if (data?.isCharacter && (name === "y" || name === "Y")) {
+          const kind = mode === "confirm-kill" ? "kill" : "delete";
+          void performAction(kind);
+          return;
+        }
+        if (name === "ESCAPE" || name === "CTRL_C" || name === "ENTER" || name === "KP_ENTER" || data?.isCharacter && (name === "n" || name === "N")) {
+          mode = "normal";
+          pendingAction = null;
+          paintIndicator();
+          return;
+        }
+        return;
       }
       clearTransient();
       if (!searchActive && data?.isCharacter && name === "?") {
@@ -5230,6 +5915,29 @@ async function pickSession(term, opts) {
           paintIndicator();
           return;
         }
+        if (name === "t" && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session) {
+            return;
+          }
+          pendingAction = {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            status: session.status
+          };
+          renameBuffer = session.title ?? "";
+          mode = "rename";
+          paintIndicator();
+          return;
+        }
+        if (name === "T" && selectedIdx > 0) {
+          const session = visible[selectedIdx - 1];
+          if (!session || session.status !== "live") {
+            return;
+          }
+          void performRegen({ sessionId: session.sessionId });
+          return;
+        }
         if ((name === "d" || name === "D") && selectedIdx > 0) {
           const session = visible[selectedIdx - 1];
           if (!session) {
@@ -5360,6 +6068,8 @@ var init_picker = __esm({
       null,
       ["k", "kill the selected live session"],
       ["d", "delete the selected cold session"],
+      ["t", "retitle the selected session"],
+      ["T", "regenerate title via agent (live session)"],
       null,
       ["c", "create new session"],
       ["?", "toggle this help"],
@@ -5947,6 +6657,12 @@ function mapKeyName(name) {
     case "ALT_ENTER":
     case "META_ENTER":
       return "alt-enter";
+    case "SHIFT_ENTER":
+      return "shift-enter";
+    case "CTRL_ENTER":
+      return "ctrl-enter";
+    case "CTRL_J":
+      return "ctrl-enter";
     case "ALT_B":
     case "META_B":
       return "alt-b";
@@ -6216,12 +6932,15 @@ var init_screen = __esm({
         this.term.fullscreen(false);
         this.term("\n");
       }
-      // Enables bracketed paste mode on the terminal and rewires stdin so we
-      // see the \x1b[200~/\x1b[201~ markers BEFORE terminal-kit's key
-      // parser. Non-paste data is forwarded to terminal-kit unchanged; paste
-      // content is buffered and dispatched as a single "paste" KeyEvent.
+      // Enables bracketed paste mode + modifyOtherKeys on the terminal and
+      // rewires stdin so we see the \x1b[200~/\x1b[201~ paste markers and
+      // CSI-u modified-key sequences (Shift+Enter etc.) BEFORE terminal-kit's
+      // key parser. Non-special data is forwarded to terminal-kit unchanged.
       installBracketedPaste() {
         process.stdout.write("\x1B[?2004h");
+        process.stdout.write("\x1B[>4;2m");
+        process.stdout.write("\x1B[>5;1m");
+        process.stdout.write("\x1B[>1u");
         const t = this.term;
         if (!t.stdin || typeof t.onStdin !== "function") {
           return;
@@ -6232,6 +6951,9 @@ var init_screen = __esm({
       }
       uninstallBracketedPaste() {
         process.stdout.write("\x1B[?2004l");
+        process.stdout.write("\x1B[>4;0m");
+        process.stdout.write("\x1B[>5;0m");
+        process.stdout.write("\x1B[<u");
         const t = this.term;
         if (!t.stdin || this.terminalKitStdinHandler === null) {
           return;
@@ -6244,6 +6966,38 @@ var init_screen = __esm({
       }
       handleRawStdin(chunk) {
         let text = chunk.toString("binary");
+        if (!this.pasteActive) {
+          const markers = [
+            { seq: "\x1B[13;2u", name: "shift-enter" },
+            { seq: "\x1B[27;2;13~", name: "shift-enter" },
+            { seq: "\x1B[13;5u", name: "ctrl-enter" },
+            { seq: "\x1B[27;5;13~", name: "ctrl-enter" },
+            // Bare LF — universal fallback for terminals without
+            // modifyOtherKeys / kitty protocol. Last so the longer escape
+            // sequences match first and we don't double-fire.
+            { seq: "\n", name: "ctrl-enter" }
+          ];
+          for (const { seq, name } of markers) {
+            if (text.includes(seq)) {
+              const parts = text.split(seq);
+              for (let i = 0; i < parts.length; i++) {
+                if (parts[i].length > 0) {
+                  this.handleRawStdin(Buffer.from(parts[i], "binary"));
+                }
+                if (i < parts.length - 1) {
+                  this.onKey([{ type: "key", name }]);
+                }
+              }
+              return;
+            }
+          }
+        }
+        this.handleRawStdinSegment(text);
+      }
+      // Inner stdin-segment handler — paste-marker detection and forwarding
+      // to terminal-kit. Split out so shift-enter interception can call it
+      // for the non-shift-enter portions of a mixed chunk.
+      handleRawStdinSegment(text) {
         const startMarker = "\x1B[200~";
         const endMarker = "\x1B[201~";
         while (text.length > 0) {
@@ -7534,11 +8288,16 @@ var init_screen = __esm({
         const elapsedStr = this.banner.status === "busy" && this.banner.elapsedMs !== void 0 && this.banner.elapsedMs >= 1e3 ? formatElapsed(this.banner.elapsedMs) : "";
         const right = this.bannerRightContent();
         const rightSig = right ? `${right.kind}|${right.text}` : "";
-        const sig = `bnr|${w}|${this.banner.status}|${elapsedStr}|${this.banner.queued}|${this.scrollOffset}|${this.banner.currentMode ?? ""}|${this.banner.hint}|` + rightSig;
+        const stalled = this.banner.status === "busy" && this.banner.stalled === true;
+        const sig = `bnr|${w}|${this.banner.status}|${elapsedStr}|${stalled ? "1" : "0"}|${this.banner.queued}|${this.scrollOffset}|${this.banner.currentMode ?? ""}|${this.banner.hint}|` + rightSig;
         this.paintRow(row, sig, () => {
           const dot = this.banner.status === "busy" ? "\u25CF" : "\u25CB";
           if (this.banner.status === "busy") {
-            this.term.brightYellow(`${dot} ${this.banner.status}`);
+            if (stalled) {
+              this.term.brightRed(`${dot} stalled`);
+            } else {
+              this.term.brightYellow(`${dot} ${this.banner.status}`);
+            }
             if (elapsedStr) {
               this.term(" ").dim(elapsedStr);
             }
@@ -7944,6 +8703,9 @@ var init_input = __esm({
         switch (name) {
           case "enter":
             return this.send();
+          case "shift-enter":
+          case "ctrl-enter":
+            return this.amend();
           case "alt-enter":
             this.insertNewline();
             return [];
@@ -8130,22 +8892,64 @@ var init_input = __esm({
           this.setCurrentLine(line + next);
         }
       }
+      // ^U: kill from cursor to start of current line. At col 0 with a line
+      // above:
+      //   - If the current line is empty, collapse it (kill just the
+      //     newline) so the cursor lands at the end of the previous line.
+      //     Don't slurp that line's contents.
+      //   - Otherwise, kill the previous line entirely + the joining
+      //     newline, so ^U from the start of a non-empty line walks up
+      //     line-by-line.
+      // Single-line behavior is unchanged.
       killLine() {
-        const line = this.currentLine();
-        const killed = line.slice(0, this.col);
-        if (killed.length > 0) {
-          this.killBuffer = killed;
+        if (this.col > 0) {
+          const line = this.currentLine();
+          this.killBuffer = line.slice(0, this.col);
+          this.setCurrentLine(line.slice(this.col));
+          this.col = 0;
+          return;
         }
-        this.setCurrentLine(line.slice(this.col));
-        this.col = 0;
+        if (this.row === 0) {
+          return;
+        }
+        if (this.currentLine().length === 0) {
+          this.killBuffer = "\n";
+          this.buffer.splice(this.row, 1);
+          this.row -= 1;
+          this.col = this.currentLine().length;
+          return;
+        }
+        const prev = this.buffer[this.row - 1] ?? "";
+        this.killBuffer = prev + "\n";
+        this.buffer.splice(this.row - 1, 1);
+        this.row -= 1;
       }
+      // ^K: kill from cursor to end of current line. At end-of-line with a
+      // line below:
+      //   - If the current line is empty, collapse it (kill just the
+      //     newline) so what was the next line takes its place. Don't slurp
+      //     that line's contents.
+      //   - Otherwise, kill the joining newline + the entire next line, so
+      //     ^K from the end of a non-empty line walks down line-by-line.
+      // Single-line behavior is unchanged.
       killToEnd() {
         const line = this.currentLine();
-        const killed = line.slice(this.col);
-        if (killed.length > 0) {
-          this.killBuffer = killed;
+        if (this.col < line.length) {
+          this.killBuffer = line.slice(this.col);
+          this.setCurrentLine(line.slice(0, this.col));
+          return;
+        }
+        if (this.row >= this.buffer.length - 1) {
+          return;
         }
-        this.setCurrentLine(line.slice(0, this.col));
+        if (line.length === 0) {
+          this.killBuffer = "\n";
+          this.buffer.splice(this.row, 1);
+          return;
+        }
+        const next = this.buffer[this.row + 1] ?? "";
+        this.killBuffer = "\n" + next;
+        this.buffer.splice(this.row + 1, 1);
       }
       killWord() {
         const line = this.currentLine();
@@ -8494,6 +9298,31 @@ var init_input = __esm({
         this.clearBuffer();
         return [{ type: "send", text, planMode, attachments }];
       }
+      // Shift+Enter: amend the in-flight turn. Editing a queued slot
+      // delegates to the existing queue-edit / queue-remove path — Shift+Enter
+      // there has no special meaning since the entry is already queued (not
+      // running). With an empty draft and no attachments we emit nothing
+      // (no-op). Otherwise emit an "amend" effect; the app decides whether
+      // to route through amend_prompt or fall through to a regular send.
+      amend() {
+        const text = this.bufferText();
+        if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
+          const index = this.queueIndex;
+          const attachments2 = [...this.attachments];
+          this.clearBuffer();
+          if (text.trim().length === 0) {
+            return [{ type: "queue-remove", index }];
+          }
+          return [{ type: "queue-edit", index, text, attachments: attachments2 }];
+        }
+        if (text.trim().length === 0 && this.attachments.length === 0) {
+          return [];
+        }
+        const planMode = this.planMode;
+        const attachments = [...this.attachments];
+        this.clearBuffer();
+        return [{ type: "amend", text, planMode, attachments }];
+      }
       // Home: jump to the very start of the prompt buffer. If we're already
       // there, fall through to scrolling the scrollback to its top.
       handleHome() {
@@ -8605,26 +9434,34 @@ async function readLinux(env) {
       reason: "install wl-clipboard (Wayland) or xclip (X11) to paste from the clipboard"
     };
   }
-  try {
-    const buf = await runCapture(env.spawn, tool.cmd, tool.imageArgs);
-    if (buf.length > 0) {
-      if (buf.length > MAX_ATTACHMENT_BYTES) {
+  const targets = await listTargets(env, tool);
+  const imageMime = pickImageTarget(targets);
+  if (imageMime) {
+    try {
+      const buf = await runCapture(
+        env.spawn,
+        tool.cmd,
+        tool.imageArgs(imageMime)
+      );
+      if (buf.length > 0) {
+        if (buf.length > MAX_ATTACHMENT_BYTES) {
+          return {
+            ok: false,
+            reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+          };
+        }
         return {
-          ok: false,
-          reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+          ok: true,
+          kind: "image",
+          attachment: {
+            mimeType: imageMime,
+            data: buf.toString("base64"),
+            sizeBytes: buf.length
+          }
         };
       }
-      return {
-        ok: true,
-        kind: "image",
-        attachment: {
-          mimeType: "image/png",
-          data: buf.toString("base64"),
-          sizeBytes: buf.length
-        }
-      };
+    } catch {
     }
-  } catch {
   }
   try {
     const buf = await runCapture(env.spawn, tool.cmd, tool.textArgs);
@@ -8644,7 +9481,8 @@ async function detectLinuxTool(env) {
   if (env.env.WAYLAND_DISPLAY && await which(env, "wl-paste")) {
     return {
       cmd: "wl-paste",
-      imageArgs: ["-t", "image/png"],
+      listTargetsArgs: ["--list-types"],
+      imageArgs: (mime) => ["-t", mime],
       // -n: drop trailing newline wl-paste adds by default. We further
       // normalize line endings below, but this avoids a spurious
       // empty trailing row from a single-line clipboard text.
@@ -8654,12 +9492,30 @@ async function detectLinuxTool(env) {
   if (env.env.DISPLAY && await which(env, "xclip")) {
     return {
       cmd: "xclip",
-      imageArgs: ["-selection", "clipboard", "-t", "image/png", "-o"],
+      listTargetsArgs: ["-selection", "clipboard", "-t", "TARGETS", "-o"],
+      imageArgs: (mime) => ["-selection", "clipboard", "-t", mime, "-o"],
       textArgs: ["-selection", "clipboard", "-o"]
     };
   }
   return null;
 }
+function pickImageTarget(targets) {
+  const offered = new Set(targets.map((t) => t.toLowerCase()));
+  for (const mime of SUPPORTED_IMAGE_MIMES) {
+    if (offered.has(mime)) {
+      return mime;
+    }
+  }
+  return null;
+}
+async function listTargets(env, tool) {
+  try {
+    const buf = await runCapture(env.spawn, tool.cmd, tool.listTargetsArgs);
+    return buf.toString("utf-8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
 function normalizeText(text) {
   return text.replace(/\r\n?/g, "\n");
 }
@@ -8754,7 +9610,7 @@ function runCapture(spawn6, cmd, args) {
     });
   });
 }
-var defaultEnv;
+var defaultEnv, SUPPORTED_IMAGE_MIMES;
 var init_clipboard = __esm({
   "src/tui/clipboard.ts"() {
     "use strict";
@@ -8765,6 +9621,12 @@ var init_clipboard = __esm({
       spawn: nodeSpawn,
       tmpdir: os4.tmpdir
     };
+    SUPPORTED_IMAGE_MIMES = [
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "image/webp"
+    ];
   }
 });
 
@@ -8812,8 +9674,29 @@ var init_completion = __esm({
   }
 });
 
+// src/tui/reconnect-state.ts
+function parseReattachResponse(result) {
+  const out = {};
+  if (!result || typeof result !== "object") {
+    return out;
+  }
+  const r = result;
+  if (typeof r.historyPolicy === "string") {
+    out.appliedPolicy = r.historyPolicy;
+  }
+  if (typeof r.clientId === "string" && r.clientId.length > 0) {
+    out.clientId = r.clientId;
+  }
+  return out;
+}
+var init_reconnect_state = __esm({
+  "src/tui/reconnect-state.ts"() {
+    "use strict";
+  }
+});
+
 // src/tui/format.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import { highlight, supportsLanguage } from "cli-highlight";
 function formatEvent(event) {
   switch (event.kind) {
@@ -8905,7 +9788,8 @@ function parseAgentMarkdown(text) {
     codeBuffer = [];
     codeLang = "";
   };
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     const fence = line.match(/^\s*```\s*(\w*)\s*$/);
     if (fence) {
       if (!inCode) {
@@ -8933,6 +9817,19 @@ function parseAgentMarkdown(text) {
       });
       continue;
     }
+    const next = lines[i + 1];
+    if (line.includes("|") && next !== void 0 && isTableSeparatorLine(next) && parseTableRow(line).length === parseTableRow(next).length) {
+      const header = parseTableRow(line);
+      const body = [];
+      let j = i + 2;
+      while (j < lines.length && lines[j].includes("|")) {
+        body.push(parseTableRow(lines[j]));
+        j++;
+      }
+      out.push(...formatTable(header, body));
+      i = j - 1;
+      continue;
+    }
     const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
     if (bullet) {
       const indent = bullet[1] ?? "";
@@ -8967,6 +9864,70 @@ function parseAgentMarkdown(text) {
   }
   return out;
 }
+function parseTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) {
+    s = s.slice(1);
+  }
+  if (s.endsWith("|")) {
+    s = s.slice(0, -1);
+  }
+  return s.split("|").map((c) => c.trim());
+}
+function isTableSeparatorLine(line) {
+  if (!line.includes("|")) {
+    return false;
+  }
+  const cells = parseTableRow(line);
+  if (cells.length === 0) {
+    return false;
+  }
+  return cells.every((c) => /^:?-+:?$/.test(c));
+}
+function formatTable(header, body) {
+  const cols = header.length;
+  const widths = new Array(cols).fill(0);
+  for (let c = 0; c < cols; c++) {
+    widths[c] = header[c]?.length ?? 0;
+  }
+  for (const row of body) {
+    for (let c = 0; c < cols; c++) {
+      const cell = row[c] ?? "";
+      if (cell.length > widths[c]) {
+        widths[c] = cell.length;
+      }
+    }
+  }
+  const renderRow = (cells, style) => {
+    const padded = [];
+    for (let c = 0; c < cols; c++) {
+      const cell = cells[c] ?? "";
+      const w = widths[c];
+      const marked = applyInlineMarkup(cell);
+      padded.push(marked + " ".repeat(Math.max(0, w - cell.length)));
+    }
+    return {
+      prefix: "  ",
+      body: padded.join(" \u2502 "),
+      bodyStyle: style
+    };
+  };
+  const out = [];
+  out.push(renderRow(header, "heading-3"));
+  const rules = [];
+  for (let c = 0; c < cols; c++) {
+    rules.push("\u2500".repeat(widths[c]));
+  }
+  out.push({
+    prefix: "  ",
+    body: rules.join("\u2500\u253C\u2500"),
+    bodyStyle: "dim"
+  });
+  for (const row of body) {
+    out.push(renderRow(row, "agent"));
+  }
+  return out;
+}
 function highlightFencedBlock(lang, lines) {
   if (lang.length === 0 || !supportsLanguage(lang)) {
     return lines.map((body) => ({ body, ansi: false }));
@@ -9028,12 +9989,22 @@ function formatToolLine2(state) {
   } else {
     title = `${initial} \xB7 ${latest}`;
   }
-  return {
-    prefix: `  ${toolStatusIcon(state.status)} `,
-    prefixStyle: toolIconStyle(state.status),
-    body: title,
-    bodyStyle: toolStatusStyle(state.status)
-  };
+  const lines = [
+    {
+      prefix: `  ${toolStatusIcon(state.status)} `,
+      prefixStyle: toolIconStyle(state.status),
+      body: title,
+      bodyStyle: toolStatusStyle(state.status)
+    }
+  ];
+  if (state.status === "failed" && state.errorText) {
+    lines.push({
+      prefix: "     ",
+      body: sanitizeSingleLine(state.errorText),
+      bodyStyle: "tool-status-fail"
+    });
+  }
+  return lines;
 }
 function toolStatusIcon(status) {
   switch (status) {
@@ -9132,7 +10103,8 @@ var highlightChalk, HIGHLIGHT_THEME;
 var init_format = __esm({
   "src/tui/format.ts"() {
     "use strict";
-    highlightChalk = new chalk.Instance({ level: 3 });
+    init_render_update();
+    highlightChalk = new chalk2.Instance({ level: 3 });
     HIGHLIGHT_THEME = {
       keyword: highlightChalk.blueBright,
       built_in: highlightChalk.cyan,
@@ -9194,8 +10166,9 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     term.grabInput(false);
     process.exit(0);
   }
-  const launchLabel = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
-  term.brightYellow(launchLabel)("\n");
+  const launchLabelBase = ctx.sessionId === "__new__" ? "Starting new session\u2026" : "Resuming session\u2026";
+  const installStatus = createInstallStatusLine(term, launchLabelBase);
+  installStatus.write(launchLabelBase);
   const protocol = config.daemon.tls ? "wss" : "ws";
   const wsUrl = `${protocol}://${config.daemon.host}:${config.daemon.port}/acp`;
   const subprotocols = ["acp.v1", `hydra-acp-token.${serviceToken}`];
@@ -9221,6 +10194,13 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   });
   const conn = new JsonRpcConnection(stream);
   await stream.start();
+  conn.onNotification(AGENT_INSTALL_PROGRESS_METHOD, (raw) => {
+    const parsed = AgentInstallProgressParams.safeParse(raw);
+    if (!parsed.success) {
+      return;
+    }
+    installStatus.applyProgress(parsed.data);
+  });
   let bufferedEvents = [];
   let applyRenderEvent = null;
   let teardownStarted = false;
@@ -9235,36 +10215,49 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
   };
   let pendingTurns = 0;
+  let currentHeadMessageId;
   let sessionBusySince = null;
   let sessionElapsedTimer = null;
+  let lastUpdateAt = null;
+  let upstreamInterruptedSeen = false;
   const adjustPendingTurns = (delta) => {
     const before = pendingTurns;
     pendingTurns = Math.max(0, pendingTurns + delta);
     const screenReady = typeof screenRef !== "undefined" && screenRef !== null;
     if (before === 0 && pendingTurns > 0) {
       sessionBusySince = Date.now();
+      lastUpdateAt = Date.now();
       dispatcherRef?.setTurnRunning(true);
       if (screenReady) {
-        screenRef.setBanner({ status: "busy", elapsedMs: 0 });
+        screenRef.setBanner({ status: "busy", elapsedMs: 0, stalled: false });
       }
       if (sessionElapsedTimer === null && screenReady) {
         sessionElapsedTimer = setInterval(() => {
           if (sessionBusySince === null || screenRef === null) {
             return;
           }
-          screenRef.setBanner({ elapsedMs: Date.now() - sessionBusySince });
+          const idleMs = lastUpdateAt === null ? 0 : Date.now() - lastUpdateAt;
+          screenRef.setBanner({
+            elapsedMs: Date.now() - sessionBusySince,
+            stalled: idleMs >= STALL_THRESHOLD_MS
+          });
           renderToolsBlock();
         }, 1e3);
       }
     } else if (before > 0 && pendingTurns === 0) {
       sessionBusySince = null;
+      lastUpdateAt = null;
       dispatcherRef?.setTurnRunning(false);
       if (sessionElapsedTimer !== null) {
         clearInterval(sessionElapsedTimer);
         sessionElapsedTimer = null;
       }
       if (screenReady) {
-        screenRef.setBanner({ status: "ready", elapsedMs: void 0 });
+        screenRef.setBanner({
+          status: "ready",
+          elapsedMs: void 0,
+          stalled: false
+        });
       }
     }
     void delta;
@@ -9285,6 +10278,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     const { update } = params ?? {};
     const event = mapUpdate(update);
     debugLogUpdate(update, event);
+    lastUpdateAt = Date.now();
     const rawTag = update?.sessionUpdate;
     if (typeof rawTag === "string" && !STATE_UPDATE_KINDS2.has(rawTag)) {
       const u = update ?? {};
@@ -9326,13 +10320,29 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screenRef.setBanner({ status: "cold", elapsedMs: void 0 });
     }
   });
+  const amendPendingPaintTimers = /* @__PURE__ */ new Map();
+  const AMEND_CHIP_DISPLAY_DELAY_MS = 200;
   conn.onNotification("hydra-acp/prompt_queue_added", (params) => {
     if (teardownStarted) return;
     const p = params ?? {};
     if (typeof p.messageId !== "string") return;
-    queueCache.set(p.messageId, chipFromPrompt(p.messageId, p.prompt));
-    if (screenRef && dispatcherRef) {
-      refreshQueueDisplay();
+    const isAmendPending = typeof p._meta?.["hydra-acp"]?.amending === "string";
+    if (isAmendPending) {
+      const mid = p.messageId;
+      const prompt = p.prompt;
+      const timer = setTimeout(() => {
+        amendPendingPaintTimers.delete(mid);
+        queueCache.set(mid, chipFromPrompt(mid, prompt));
+        if (screenRef && dispatcherRef) {
+          refreshQueueDisplay();
+        }
+      }, AMEND_CHIP_DISPLAY_DELAY_MS);
+      amendPendingPaintTimers.set(mid, timer);
+    } else {
+      queueCache.set(p.messageId, chipFromPrompt(p.messageId, p.prompt));
+      if (screenRef && dispatcherRef) {
+        refreshQueueDisplay();
+      }
     }
     if (ownClientId !== void 0 && p.originator?.clientId === ownClientId) {
       const echo = pendingEchoes.shift();
@@ -9377,6 +10387,14 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (teardownStarted) return;
     const p = params ?? {};
     if (typeof p.messageId !== "string") return;
+    if (p.reason === "started") {
+      currentHeadMessageId = p.messageId;
+    }
+    const pendingTimer = amendPendingPaintTimers.get(p.messageId);
+    if (pendingTimer !== void 0) {
+      clearTimeout(pendingTimer);
+      amendPendingPaintTimers.delete(p.messageId);
+    }
     const hadChip = queueCache.delete(p.messageId);
     if (hadChip && screenRef && dispatcherRef) {
       refreshQueueDisplay();
@@ -9395,6 +10413,22 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       }
     }
   });
+  conn.onNotification("hydra-acp/prompt_amended", (params) => {
+    if (teardownStarted) return;
+    const p = params ?? {};
+    if (typeof p.cancelledMessageId !== "string") return;
+    const cancelledId = p.cancelledMessageId;
+    amendedMessageIds.add(cancelledId);
+    if (currentTurnEcho !== null && currentTurnEcho.messageId !== void 0 && currentTurnEcho.messageId === cancelledId) {
+      appendRender({
+        kind: "turn-complete",
+        stopReason: "cancelled",
+        amended: true
+      });
+      currentTurnEcho = null;
+      amendedMessageIds.delete(cancelledId);
+    }
+  });
   const handlePermissionResolved = (update) => {
     const u = update ?? {};
     const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
@@ -9502,6 +10536,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   let upstreamSessionId;
   let agentInfoName;
   let agentAcceptsImages = true;
+  let daemonSupportsAmend = false;
   try {
     const initResult = await conn.request("initialize", {
       protocolVersion: ACP_PROTOCOL_VERSION,
@@ -9516,6 +10551,8 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (imageCap === false) {
       agentAcceptsImages = false;
     }
+    const hydraMeta = extractHydraMeta(initResult?._meta ?? void 0);
+    daemonSupportsAmend = hydraMeta.promptAmending === true;
   } catch {
   }
   let resolvedSessionId = ctx.sessionId;
@@ -9811,6 +10848,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   };
   const sessionbarAgent = resolvedAgentId || agentInfoName || "?";
   const usage = { ...initialUsage ?? {} };
+  installStatus.finalize();
   screen.start();
   screen.setSessionbar({
     agent: sessionbarAgent,
@@ -9916,6 +10954,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     return true;
   };
+  const buildHelpEntries = () => {
+    const enqueueDesc = "enqueue prompt (sends now, or queues during a turn)";
+    const amendDesc = "amend the in-flight turn (cancel + replace)";
+    const head = config.tui.defaultEnterAction === "amend" ? [
+      ["Enter", amendDesc],
+      ["Ctrl+Enter / Shift+Enter", enqueueDesc]
+    ] : [
+      ["Enter", enqueueDesc],
+      ["Ctrl+Enter / Shift+Enter", amendDesc]
+    ];
+    return [...head, ...HELP_ENTRIES_TAIL];
+  };
   const toggleHelpModal = () => {
     if (screen.isHelpPromptActive()) {
       screen.setHelpPrompt(null);
@@ -9923,7 +10973,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     screen.setHelpPrompt({
       title: "Hotkeys",
-      entries: HELP_ENTRIES2,
+      entries: buildHelpEntries(),
       hint: "any key dismisses \xB7 /help lists commands"
     });
   };
@@ -10026,7 +11076,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   const handleEffect = (effect) => {
     switch (effect.type) {
       case "send":
-        enqueuePrompt(effect.text, effect.attachments);
+        if (config.tui.defaultEnterAction === "amend") {
+          amendPrompt(effect.text, effect.attachments);
+        } else {
+          enqueuePrompt(effect.text, effect.attachments);
+        }
+        return;
+      case "amend":
+        if (config.tui.defaultEnterAction === "amend") {
+          enqueuePrompt(effect.text, effect.attachments);
+        } else {
+          amendPrompt(effect.text, effect.attachments);
+        }
         return;
       case "queue-edit": {
         const mid = queueMessageIdAt(effect.index);
@@ -10234,6 +11295,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   const queueCache = /* @__PURE__ */ new Map();
   const pendingEchoes = [];
   const ownPendingByMid = /* @__PURE__ */ new Map();
+  const amendedMessageIds = /* @__PURE__ */ new Set();
   let currentTurnEcho = null;
   const refreshQueueDisplay = () => {
     const entries = [...queueCache.values()];
@@ -10268,6 +11330,75 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     saveHistory(historyFile, history).catch(() => void 0);
     void runPrompt(text, attachments);
   };
+  const amendPrompt = (text, attachments) => {
+    screen.scrollToBottom();
+    if (handleBuiltinCommand(text)) {
+      return;
+    }
+    history = appendEntry(history, text);
+    dispatcher.setHistory(history);
+    saveHistory(historyFile, history).catch(() => void 0);
+    if (!daemonSupportsAmend || currentHeadMessageId === void 0) {
+      void runPrompt(text, attachments);
+      return;
+    }
+    const target = currentHeadMessageId;
+    const blocks = [];
+    if (text.length > 0) {
+      blocks.push({ type: "text", text });
+    }
+    for (const a of attachments) {
+      blocks.push({ type: "image", data: a.data, mimeType: a.mimeType });
+    }
+    const echo = { text, attachments, flushed: false };
+    pendingEchoes.push(echo);
+    const popEcho = () => {
+      const idx = pendingEchoes.indexOf(echo);
+      if (idx >= 0) {
+        pendingEchoes.splice(idx, 1);
+      }
+      if (echo.messageId !== void 0) {
+        ownPendingByMid.delete(echo.messageId);
+      }
+    };
+    conn.request("hydra-acp/amend_prompt", {
+      sessionId: resolvedSessionId,
+      targetMessageId: target,
+      prompt: blocks
+    }).then((raw) => {
+      const res = raw;
+      if (res.amended && res.reason === "ok") {
+        adjustPendingTurns(1);
+        return;
+      }
+      popEcho();
+      if (res.reason === "target_completed") {
+        screen.notify(
+          "previous response finished \u2014 press Enter to send as a new turn"
+        );
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+      if (res.reason === "target_cancelled") {
+        screen.notify("amend skipped \u2014 previous turn was cancelled");
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+      if (res.reason === "target_not_found") {
+        screen.notify("amend skipped \u2014 no matching prompt");
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+    }).catch((err) => {
+      popEcho();
+      screen.notify(`amend failed: ${err.message}`);
+      dispatcher.setBuffer(text, attachments);
+      screen.refreshPrompt();
+    });
+  };
   const handleModeToggle = async (_on) => {
     if (agentModes.length === 0) {
       screen.notify("no modes advertised by agent");
@@ -10492,9 +11623,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       turnInFlight = null;
       adjustPendingTurns(-1);
       if (echo.flushed && currentTurnEcho === echo) {
-        appendRender(
-          stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" }
-        );
+        const wasAmended = echo.messageId !== void 0 && amendedMessageIds.has(echo.messageId);
+        if (wasAmended && echo.messageId !== void 0) {
+          amendedMessageIds.delete(echo.messageId);
+        }
+        const tc = { kind: "turn-complete" };
+        if (stopReason !== void 0) {
+          tc.stopReason = stopReason;
+        }
+        if (wasAmended) {
+          tc.amended = true;
+        }
+        appendRender(tc);
         currentTurnEcho = null;
       }
       if (pendingPrefill !== null) {
@@ -10591,7 +11731,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     for (const id of visibleIds) {
       const state = toolStates.get(id);
       if (state) {
-        lines.push(formatToolLine2(state));
+        lines.push(...formatToolLine2(state));
       }
     }
     screen.upsertLines("tools", lines);
@@ -10602,7 +11742,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     toolsBlockStopReason = null;
     renderToolsBlock();
   };
-  const recordToolCall = (id, title, status) => {
+  const recordToolCall = (id, title, status, errorText) => {
     const wasNew = !toolStates.has(id);
     const existing = toolStates.get(id);
     const state = existing ?? {
@@ -10619,6 +11759,9 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (!existing) {
       state.status = status ?? "pending";
     }
+    if (errorText !== void 0) {
+      state.errorText = errorText;
+    }
     toolStates.set(id, state);
     if (wasNew) {
       if (toolsBlockStartedAt === null) {
@@ -10710,7 +11853,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     if (event.kind === "tool-call") {
       closeAgentText();
-      recordToolCall(event.toolCallId, event.title, event.status);
+      recordToolCall(event.toolCallId, event.title, event.status, void 0);
       renderToolsBlock();
       return;
     }
@@ -10725,7 +11868,15 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     if (event.kind === "tool-call-update") {
       closeAgentText();
-      recordToolCall(event.toolCallId, event.title, event.status);
+      recordToolCall(
+        event.toolCallId,
+        event.title,
+        event.status,
+        event.errorText
+      );
+      if (event.upstreamInterrupted) {
+        upstreamInterruptedSeen = true;
+      }
       renderToolsBlock();
       return;
     }
@@ -10737,8 +11888,13 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screen.appendLines(formatted);
     }
     if (event.kind === "turn-complete") {
+      currentHeadMessageId = void 0;
       closeAgentText();
-      if (lastPlanEvent !== null && event.stopReason !== void 0 && event.stopReason !== "end_turn") {
+      let effectiveStopReason = event.amended ? "amended" : event.stopReason;
+      if (!event.amended && upstreamInterruptedSeen && (effectiveStopReason === void 0 || effectiveStopReason === "end_turn")) {
+        effectiveStopReason = "error";
+      }
+      if (lastPlanEvent !== null && effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
         const lines = formatEvent({ ...lastPlanEvent, stopped: true });
         if (lines.length > 0) {
           screen.upsertLines("plan", lines);
@@ -10748,15 +11904,15 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screen.clearKey("plan");
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
-        toolsBlockStopReason = event.stopReason ?? null;
+        toolsBlockStopReason = effectiveStopReason ?? null;
         renderToolsBlock();
         screen.clearKey("tools");
-      } else if (event.stopReason !== void 0 && event.stopReason !== "end_turn") {
+      } else if (effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
         screen.appendLines([
           {
             prefix: "\u26A0 ",
             prefixStyle: "tool-status-fail",
-            body: `turn ended: ${event.stopReason}`,
+            body: `turn ended: ${effectiveStopReason}`,
             bodyStyle: "tool-status-fail"
           }
         ]);
@@ -10767,6 +11923,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       toolsBlockEndedAt = null;
       toolsBlockStopReason = null;
       toolsExpanded = false;
+      upstreamInterruptedSeen = false;
       screen.ensureSeparator();
     }
   };
@@ -10876,9 +12033,10 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       if (resp.error) {
         throw new Error(resp.error.message);
       }
-      const result = resp.result ?? {};
-      if (typeof result.historyPolicy === "string") {
-        appliedPolicy = result.historyPolicy;
+      const fields = parseReattachResponse(resp.result);
+      appliedPolicy = fields.appliedPolicy;
+      if (fields.clientId !== void 0) {
+        ownClientId = fields.clientId;
       }
     } catch (err) {
       attachErr = err;
@@ -11004,21 +12162,110 @@ function writeDebugLine(payload) {
   } catch {
   }
 }
-function rotateIfBig(target) {
-  try {
-    const stat4 = statSync(target);
-    if (stat4.size < logMaxBytes) {
+function createInstallStatusLine(term, baseLabel) {
+  let finalized = false;
+  let lastText = "";
+  let osc94Active = false;
+  const writeOsc94 = (state) => {
+    if (finalized) {
       return;
     }
-    renameSync(target, `${target}.0`);
-  } catch {
-  }
-}
-var HELP_ENTRIES2, logMaxBytes;
-var init_app = __esm({
-  "src/tui/app.ts"() {
-    "use strict";
-    init_connection();
+    if (state === 3 && osc94Active) {
+      return;
+    }
+    if (state === 0 && !osc94Active) {
+      return;
+    }
+    osc94Active = state === 3;
+    process.stdout.write(`\x1B]9;4;${state}\x1B\\`);
+  };
+  const redraw = (text) => {
+    if (finalized) {
+      return;
+    }
+    process.stdout.write("\r");
+    term.eraseLineAfter();
+    term.brightYellow(text);
+    lastText = text;
+  };
+  const formatProgressText = (event) => {
+    const idVer = `${event.agentId}@${event.version}`;
+    if (event.source === "npm") {
+      if (event.phase === "install_start" || event.phase === "download_start") {
+        return `${baseLabel} installing ${idVer} via npm\u2026`;
+      }
+      if (event.phase === "installed") {
+        return `${baseLabel} ${idVer} installed`;
+      }
+      return `${baseLabel} installing ${idVer} via npm\u2026`;
+    }
+    if (event.phase === "download_start" || event.phase === "download_progress") {
+      const received = event.receivedBytes ?? 0;
+      const total = event.totalBytes ?? 0;
+      const rxMb = (received / 1e6).toFixed(1);
+      if (total > 0) {
+        const totalMb = (total / 1e6).toFixed(1);
+        const pct = Math.min(100, Math.floor(received / total * 100));
+        return `${baseLabel} downloading ${idVer} ${rxMb}/${totalMb} MB (${pct}%)`;
+      }
+      return `${baseLabel} downloading ${idVer} ${rxMb} MB`;
+    }
+    if (event.phase === "download_done") {
+      return `${baseLabel} downloaded ${idVer}, verifying\u2026`;
+    }
+    if (event.phase === "extract") {
+      return `${baseLabel} extracting ${idVer}\u2026`;
+    }
+    if (event.phase === "installed") {
+      return `${baseLabel} ${idVer} installed`;
+    }
+    return lastText || baseLabel;
+  };
+  return {
+    write(text) {
+      if (finalized) {
+        return;
+      }
+      term.brightYellow(text);
+      lastText = text;
+    },
+    applyProgress(event) {
+      if (finalized) {
+        return;
+      }
+      const isActive = event.phase === "download_start" || event.phase === "download_progress" || event.phase === "install_start" || event.phase === "extract" || event.phase === "download_done";
+      if (isActive) {
+        writeOsc94(3);
+      } else if (event.phase === "installed") {
+        writeOsc94(0);
+      }
+      redraw(formatProgressText(event));
+    },
+    finalize() {
+      if (finalized) {
+        return;
+      }
+      finalized = true;
+      writeOsc94(0);
+      process.stdout.write("\n");
+    }
+  };
+}
+function rotateIfBig(target) {
+  try {
+    const stat4 = statSync(target);
+    if (stat4.size < logMaxBytes) {
+      return;
+    }
+    renameSync(target, `${target}.0`);
+  } catch {
+  }
+}
+var STALL_THRESHOLD_MS, HELP_ENTRIES_TAIL, logMaxBytes;
+var init_app = __esm({
+  "src/tui/app.ts"() {
+    "use strict";
+    init_connection();
     init_types();
     init_resilient_ws();
     init_config();
@@ -11036,10 +12283,11 @@ var init_app = __esm({
     init_attachments();
     init_clipboard();
     init_completion();
+    init_reconnect_state();
     init_render_update();
     init_format();
-    HELP_ENTRIES2 = [
-      ["Enter", "send prompt (or queue while a turn is running)"],
+    STALL_THRESHOLD_MS = 12e4;
+    HELP_ENTRIES_TAIL = [
       ["Alt+Enter", "newline in prompt"],
       ["Shift+Tab", "cycle agent modes (plan / accept-edits / etc.)"],
       ["Tab", "indent \xB7 slash-command completion"],
@@ -11200,6 +12448,7 @@ init_config();
 init_service_token();
 import * as fsp7 from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
+import chalk from "chalk";
 
 // src/daemon/server.ts
 init_config();
@@ -11268,8 +12517,10 @@ async function ensureBinary(args) {
   }
   await downloadAndExtract({
     agentId: args.agentId,
+    version: args.version,
     archiveUrl: args.target.archive,
-    installDir
+    installDir,
+    onProgress: args.onProgress
   });
   if (!await fileExists(cmdPath)) {
     throw new Error(
@@ -11289,9 +12540,16 @@ async function downloadAndExtract(args) {
     const archivePath = await downloadTo({
       url: args.archiveUrl,
       dir: tempDir,
-      agentId: args.agentId
+      agentId: args.agentId,
+      version: args.version,
+      onProgress: args.onProgress
     });
     logSink(`hydra-acp: extracting ${args.agentId}`);
+    safeEmit(args.onProgress, {
+      phase: "extract",
+      agentId: args.agentId,
+      version: args.version
+    });
     await extract(archivePath, tempDir);
     await fsp.unlink(archivePath).catch(() => void 0);
     try {
@@ -11302,16 +12560,35 @@ async function downloadAndExtract(args) {
         await fsp.rm(tempDir, { recursive: true, force: true }).catch(
           () => void 0
         );
+        safeEmit(args.onProgress, {
+          phase: "installed",
+          agentId: args.agentId,
+          version: args.version
+        });
         return;
       }
       throw err;
     }
     logSink(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+    safeEmit(args.onProgress, {
+      phase: "installed",
+      agentId: args.agentId,
+      version: args.version
+    });
   } catch (err) {
     await fsp.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
     throw err;
   }
 }
+function safeEmit(cb, event) {
+  if (!cb) {
+    return;
+  }
+  try {
+    cb(event);
+  } catch {
+  }
+}
 async function downloadTo(args) {
   const filename = inferArchiveName(args.url);
   const dest = path2.join(args.dir, filename);
@@ -11324,17 +12601,34 @@ async function downloadTo(args) {
   const total = Number(response.headers.get("content-length") ?? "0");
   const out = fs4.createWriteStream(dest);
   const nodeStream = Readable.fromWeb(response.body);
+  safeEmit(args.onProgress, {
+    phase: "download_start",
+    agentId: args.agentId,
+    version: args.version,
+    totalBytes: total
+  });
   let received = 0;
-  let lastEmit = Date.now();
-  const EMIT_INTERVAL_MS = 2e3;
+  let lastLogEmit = Date.now();
+  let lastCbEmit = 0;
+  const LOG_INTERVAL_MS = 2e3;
+  const CB_INTERVAL_MS = 150;
   nodeStream.on("data", (chunk) => {
     received += chunk.length;
     const now = Date.now();
-    if (now - lastEmit < EMIT_INTERVAL_MS) {
-      return;
+    if (now - lastCbEmit >= CB_INTERVAL_MS) {
+      lastCbEmit = now;
+      safeEmit(args.onProgress, {
+        phase: "download_progress",
+        agentId: args.agentId,
+        version: args.version,
+        receivedBytes: received,
+        totalBytes: total
+      });
+    }
+    if (now - lastLogEmit >= LOG_INTERVAL_MS) {
+      lastLogEmit = now;
+      logSink(formatProgress(args.agentId, received, total));
     }
-    lastEmit = now;
-    logSink(formatProgress(args.agentId, received, total));
   });
   await new Promise((resolve5, reject) => {
     nodeStream.on("error", reject);
@@ -11349,6 +12643,13 @@ async function downloadTo(args) {
     /* done */
     true
   ));
+  safeEmit(args.onProgress, {
+    phase: "download_done",
+    agentId: args.agentId,
+    version: args.version,
+    receivedBytes: received,
+    totalBytes: total
+  });
   return dest;
 }
 function formatProgress(agentId, received, total, done = false) {
@@ -11448,9 +12749,11 @@ async function ensureNpmPackage(args) {
   }
   await installInto({
     agentId: args.agentId,
+    version: args.version,
     packageSpec: args.packageSpec,
     installDir,
-    registry: args.registry
+    registry: args.registry,
+    onProgress: args.onProgress
   });
   if (!await fileExists2(binPath)) {
     throw new Error(
@@ -11466,6 +12769,12 @@ async function installInto(args) {
     logSink2(
       `hydra-acp: installing ${args.packageSpec} for ${args.agentId} into ${tempDir}`
     );
+    safeEmit2(args.onProgress, {
+      phase: "install_start",
+      agentId: args.agentId,
+      version: args.version,
+      packageSpec: args.packageSpec
+    });
     await runNpmInstall({
       packageSpec: args.packageSpec,
       cwd: tempDir,
@@ -11479,11 +12788,21 @@ async function installInto(args) {
         await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
           () => void 0
         );
+        safeEmit2(args.onProgress, {
+          phase: "installed",
+          agentId: args.agentId,
+          version: args.version
+        });
         return;
       }
       throw err;
     }
     logSink2(`hydra-acp: installed ${args.agentId} to ${args.installDir}`);
+    safeEmit2(args.onProgress, {
+      phase: "installed",
+      agentId: args.agentId,
+      version: args.version
+    });
   } catch (err) {
     await fsp2.rm(tempDir, { recursive: true, force: true }).catch(
       () => void 0
@@ -11491,44 +12810,87 @@ async function installInto(args) {
     throw err;
   }
 }
+function safeEmit2(cb, event) {
+  if (!cb) {
+    return;
+  }
+  try {
+    cb(event);
+  } catch {
+  }
+}
+var ETXTBSY_RETRIES = 5;
+var ETXTBSY_BACKOFF_MS = 25;
 function runNpmInstall(args) {
-  return new Promise((resolve5, reject) => {
-    const registryArgs = args.registry ? ["--registry", args.registry] : [];
-    const child = spawn2(
-      "npm",
-      ["install", "--no-audit", "--no-fund", "--silent", ...registryArgs, args.packageSpec],
-      {
-        cwd: args.cwd,
-        stdio: ["ignore", "pipe", "pipe"]
-      }
-    );
-    let stderrTail = "";
-    child.stdout?.on("data", (chunk) => {
-      void chunk;
-    });
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-      stderrTail = (stderrTail + chunk).slice(-4096);
-    });
-    child.on("error", (err) => {
-      const msg = err.code === "ENOENT" ? `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)` : err.message;
-      reject(new Error(msg));
-    });
-    child.on("exit", (code, signal) => {
-      if (code === 0) {
-        resolve5();
+  return runNpmInstallOnce(args, 0);
+}
+async function runNpmInstallOnce(args, attempt) {
+  try {
+    await new Promise((resolve5, reject) => {
+      const registryArgs = args.registry ? ["--registry", args.registry] : [];
+      let child;
+      try {
+        child = spawn2(
+          "npm",
+          [
+            "install",
+            "--no-audit",
+            "--no-fund",
+            "--silent",
+            ...registryArgs,
+            args.packageSpec
+          ],
+          { cwd: args.cwd, stdio: ["ignore", "pipe", "pipe"] }
+        );
+      } catch (err) {
+        reject(err);
         return;
       }
-      const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
-      const tail = stderrTail.trim();
-      reject(
-        new Error(
-          tail ? `npm install ${args.packageSpec} failed (${reason})
+      let stderrTail = "";
+      child.stdout?.on("data", (chunk) => {
+        void chunk;
+      });
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk) => {
+        stderrTail = (stderrTail + chunk).slice(-4096);
+      });
+      child.on("error", (err) => {
+        const e = err;
+        if (e.code === "ENOENT") {
+          reject(
+            new Error(
+              `npm not found on PATH (install Node.js / npm, or use a binary-distributed agent)`
+            )
+          );
+          return;
+        }
+        reject(err);
+      });
+      child.on("exit", (code, signal) => {
+        if (code === 0) {
+          resolve5();
+          return;
+        }
+        const reason = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
+        const tail = stderrTail.trim();
+        reject(
+          new Error(
+            tail ? `npm install ${args.packageSpec} failed (${reason})
 stderr: ${tail}` : `npm install ${args.packageSpec} failed (${reason})`
-        )
-      );
+          )
+        );
+      });
     });
-  });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ETXTBSY" && attempt < ETXTBSY_RETRIES) {
+      await new Promise(
+        (r) => setTimeout(r, ETXTBSY_BACKOFF_MS * (attempt + 1))
+      );
+      return runNpmInstallOnce(args, attempt + 1);
+    }
+    throw err;
+  }
 }
 async function fileExists2(p) {
   try {
@@ -11726,12 +13088,14 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
       };
     }
     const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
+    const npmCb = options.onInstallProgress;
     const binPath = await ensureNpmPackage({
       agentId: agent.id,
       version,
       packageSpec: npx.package,
       bin,
-      registry: options.npmRegistry
+      registry: options.npmRegistry,
+      onProgress: npmCb ? (e) => npmCb({ source: "npm", ...e }) : void 0
     });
     return {
       command: binPath,
@@ -11747,10 +13111,12 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
         `Agent ${agent.id} has no binary distribution for ${currentPlatformKey() ?? "this platform"}.`
       );
     }
+    const binCb = options.onInstallProgress;
     const cmdPath = await ensureBinary({
       agentId: agent.id,
       version,
-      target
+      target,
+      onProgress: binCb ? (e) => binCb({ source: "binary", ...e }) : void 0
     });
     const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
@@ -12168,7 +13534,8 @@ var SessionManager = class {
       cwd: params.cwd,
       agentArgs: params.agentArgs,
       mcpServers: params.mcpServers,
-      model: params.model
+      model: params.model,
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       cwd: params.cwd,
@@ -12185,7 +13552,8 @@ var SessionManager = class {
       historyMaxEntries: this.sessionHistoryMaxEntries,
       currentModel: fresh.initialModel,
       currentMode: fresh.initialMode,
-      agentModes: fresh.initialModes
+      agentModes: fresh.initialModes,
+      agentModels: fresh.initialModels
     });
     await this.attachManagerHooks(session);
     return session;
@@ -12230,7 +13598,10 @@ var SessionManager = class {
     if (params.upstreamSessionId === "") {
       return this.doResurrectFromImport(params);
     }
-    const plan = await planSpawn(agentDef, params.agentArgs ?? [], { npmRegistry: this.npmRegistry });
+    const plan = await planSpawn(agentDef, params.agentArgs ?? [], {
+      npmRegistry: this.npmRegistry,
+      onInstallProgress: params.onInstallProgress
+    });
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -12288,6 +13659,7 @@ var SessionManager = class {
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: params.agentModes ?? nonEmptyOrUndefined(extractInitialModes(loadResult ?? {})),
+      agentModels: params.agentModels ?? nonEmptyOrUndefined(extractInitialModels(loadResult ?? {})),
       // Only gate the first-prompt title heuristic when we actually have
       // a title to preserve. A title-less session (lost to a write race
       // or never seeded) should re-derive from the next prompt rather
@@ -12311,7 +13683,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd,
       agentArgs: params.agentArgs,
-      mcpServers: []
+      mcpServers: [],
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -12334,6 +13707,7 @@ var SessionManager = class {
       currentUsage: params.currentUsage,
       agentCommands: params.agentCommands,
       agentModes: params.agentModes ?? fresh.initialModes,
+      agentModels: params.agentModels ?? fresh.initialModels,
       firstPromptSeeded: !!params.title,
       createdAt: params.createdAt ? new Date(params.createdAt).getTime() : void 0
     });
@@ -12363,7 +13737,10 @@ var SessionManager = class {
       err.code = JsonRpcErrorCodes.AgentNotInstalled;
       throw err;
     }
-    const plan = await planSpawn(agentDef, params.agentArgs ?? [], { npmRegistry: this.npmRegistry });
+    const plan = await planSpawn(agentDef, params.agentArgs ?? [], {
+      npmRegistry: this.npmRegistry,
+      onInstallProgress: params.onInstallProgress
+    });
     const agent = this.spawner({
       agentId: params.agentId,
       cwd: params.cwd,
@@ -12389,15 +13766,25 @@ var SessionManager = class {
         );
       }
       let initialModel = extractInitialModel(newResult);
+      const initialModels = extractInitialModels(newResult);
       const desired = params.model ?? this.defaultModels[params.agentId];
       if (desired && desired !== initialModel) {
-        try {
-          await agent.connection.request("session/set_model", {
-            sessionId: sessionIdRaw,
-            modelId: desired
-          });
-          initialModel = desired;
-        } catch {
+        const validates = initialModels.length === 0 || initialModels.some((m) => m.modelId === desired);
+        if (validates) {
+          try {
+            await agent.connection.request("session/set_model", {
+              sessionId: sessionIdRaw,
+              modelId: desired
+            });
+            initialModel = desired;
+          } catch {
+          }
+        } else {
+          const known = initialModels.map((m) => m.modelId).join(", ");
+          process.stderr.write(
+            `hydra-acp: defaultModels[${params.agentId}]=${JSON.stringify(desired)} is not in the agent's availableModels (${known}); skipping session/set_model
+`
+          );
         }
       }
       const initialModes = extractInitialModes(newResult);
@@ -12407,6 +13794,7 @@ var SessionManager = class {
         upstreamSessionId: sessionIdRaw,
         agentMeta: newResult._meta,
         initialModel,
+        initialModels: initialModels.length > 0 ? initialModels : void 0,
         initialModes: initialModes.length > 0 ? initialModes : void 0,
         initialMode
       };
@@ -12469,6 +13857,15 @@ var SessionManager = class {
         }))
       }).catch(() => void 0);
     });
+    session.onAgentModelsChange((models) => {
+      void this.persistSnapshot(session.sessionId, {
+        agentModels: models.map((m) => ({
+          modelId: m.modelId,
+          ...m.name !== void 0 ? { name: m.name } : {},
+          ...m.description !== void 0 ? { description: m.description } : {}
+        }))
+      }).catch(() => void 0);
+    });
     this.sessions.set(session.sessionId, session);
     await this.enqueueMetaWrite(session.sessionId, async () => {
       const existing = await this.store.read(session.sessionId);
@@ -12512,6 +13909,7 @@ var SessionManager = class {
       currentUsage: persistedUsageToSnapshot(record.currentUsage),
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
+      agentModels: record.agentModels,
       createdAt: record.createdAt
     };
   }
@@ -12755,6 +14153,26 @@ var SessionManager = class {
     const record = await this.store.read(sessionId).catch(() => void 0);
     return record !== void 0;
   }
+  // Public retitle entry point that works on live AND cold sessions.
+  // - Live: routes through Session.retitle so attached clients receive
+  //   a session_info_update broadcast (and persistTitle fires from the
+  //   onTitleChange handler, just like /hydra title).
+  // - Cold: writes the new title straight into meta.json — there's
+  //   nothing in memory to broadcast to, but a later resurrect / list
+  //   will pick up the new title.
+  // Returns false when no record exists at all (live or on disk).
+  async setTitle(sessionId, title) {
+    const live = this.get(sessionId);
+    if (live) {
+      await live.retitle(title);
+      return true;
+    }
+    if (!await this.hasRecord(sessionId)) {
+      return false;
+    }
+    await this.persistTitle(sessionId, title);
+    return true;
+  }
   // Persist a title update from Session.setTitle. The on-disk record
   // was written at create time; updating it here keeps the session
   // record's title in sync with what was broadcast to clients so a
@@ -12807,6 +14225,7 @@ var SessionManager = class {
         ...update.currentUsage !== void 0 ? { currentUsage: update.currentUsage } : {},
         ...update.agentCommands !== void 0 ? { agentCommands: update.agentCommands } : {},
         ...update.agentModes !== void 0 ? { agentModes: update.agentModes } : {},
+        ...update.agentModels !== void 0 ? { agentModels: update.agentModels } : {},
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     });
@@ -12908,6 +14327,18 @@ function mergeForPersistence(session, existing) {
     return out;
   }) : void 0;
   const agentModes = persistedModes ?? existing?.agentModes;
+  const sessionModels = session.availableModels();
+  const persistedModels = sessionModels.length > 0 ? sessionModels.map((m) => {
+    const out = { modelId: m.modelId };
+    if (m.name !== void 0) {
+      out.name = m.name;
+    }
+    if (m.description !== void 0) {
+      out.description = m.description;
+    }
+    return out;
+  }) : void 0;
+  const agentModels = persistedModels ?? existing?.agentModels;
   return recordFromMemorySession({
     sessionId: session.sessionId,
     lineageId: existing?.lineageId ?? generateLineageId(),
@@ -12924,6 +14355,7 @@ function mergeForPersistence(session, existing) {
     currentUsage: usageSnapshotToPersisted(session.currentUsage) ?? existing?.currentUsage,
     agentCommands,
     agentModes,
+    agentModels,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -12989,6 +14421,40 @@ function asString(value) {
 function nonEmptyOrUndefined(arr) {
   return arr.length > 0 ? arr : void 0;
 }
+function extractInitialModels(result) {
+  const direct = parseModelsList(result.availableModels);
+  if (direct.length > 0) {
+    return direct;
+  }
+  const models = result.models;
+  if (models && typeof models === "object" && !Array.isArray(models)) {
+    const fromModelsObj = parseModelsList(
+      models.availableModels
+    );
+    if (fromModelsObj.length > 0) {
+      return fromModelsObj;
+    }
+  }
+  const meta = result._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    for (const [key, value] of Object.entries(
+      meta
+    )) {
+      if (key === "hydra-acp") {
+        continue;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const fromMeta = parseModelsList(
+          value.availableModels
+        );
+        if (fromMeta.length > 0) {
+          return fromMeta;
+        }
+      }
+    }
+  }
+  return [];
+}
 function extractInitialModes(result) {
   const direct = parseModesList(result.availableModes);
   if (direct.length > 0) {
@@ -13966,6 +15432,35 @@ function registerSessionRoutes(app, manager, defaults) {
     }
     reply.code(204).send();
   });
+  app.patch("/v1/sessions/:id", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const body = request.body ?? {};
+    if (body.regen === true) {
+      const session = manager.get(id);
+      if (!session) {
+        reply.code(409).send({ error: "regen requires a live session" });
+        return;
+      }
+      void session.retitleFromAgent().catch((err) => {
+        app.log.warn(
+          `title regen failed for ${id}: ${err.message}`
+        );
+      });
+      reply.code(202).send();
+      return;
+    }
+    if (typeof body.title !== "string" || body.title.trim().length === 0) {
+      reply.code(400).send({ error: "title must be a non-empty string" });
+      return;
+    }
+    const ok = await manager.setTitle(id, body.title);
+    if (!ok) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    reply.code(204).send();
+  });
   app.delete("/v1/sessions/:id", async (request, reply) => {
     const raw = request.params.id;
     const id = await manager.resolveCanonicalId(raw) ?? raw;
@@ -14508,7 +16003,8 @@ function registerAcpWsEndpoint(app, deps) {
         mcpServers: params.mcpServers,
         title: hydraMeta.name,
         agentArgs: hydraMeta.agentArgs,
-        model: hydraMeta.model
+        model: hydraMeta.model,
+        onInstallProgress: makeInstallProgressForwarder(connection)
       });
       const client = bindClientToSession(connection, session, state);
       const { entries: replay } = await session.attach(client, "full");
@@ -14524,6 +16020,7 @@ function registerAcpWsEndpoint(app, deps) {
         })();
       });
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         // session/new is implicitly an attach; mirror session/attach's
@@ -14532,6 +16029,7 @@ function registerAcpWsEndpoint(app, deps) {
         // events without an extra round-trip.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -14567,7 +16065,10 @@ function registerAcpWsEndpoint(app, deps) {
           err.code = JsonRpcErrorCodes.SessionNotFound;
           throw err;
         }
-        session = await deps.manager.resurrect(resurrectParams);
+        session = await deps.manager.resurrect({
+          ...resurrectParams,
+          onInstallProgress: makeInstallProgressForwarder(connection)
+        });
       }
       const client = bindClientToSession(
         connection,
@@ -14593,6 +16094,7 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         clientId: client.clientId,
@@ -14604,6 +16106,7 @@ function registerAcpWsEndpoint(app, deps) {
         historyPolicy: appliedPolicy,
         replayed: replay.length,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -14711,6 +16214,22 @@ function registerAcpWsEndpoint(app, deps) {
       }
       return session.updateQueuedPrompt(params.messageId, params.prompt);
     });
+    connection.onRequest("hydra-acp/amend_prompt", async (raw) => {
+      const params = AmendPromptParams.parse(raw);
+      const att = state.attached.get(params.sessionId);
+      if (!att) {
+        const err = new Error("not attached to session");
+        err.code = JsonRpcErrorCodes.SessionNotFound;
+        throw err;
+      }
+      const session = deps.manager.get(params.sessionId);
+      if (!session) {
+        const err = new Error(`session ${params.sessionId} not found`);
+        err.code = JsonRpcErrorCodes.SessionNotFound;
+        throw err;
+      }
+      return session.amendPrompt(att.clientId, params);
+    });
     connection.onRequest("session/load", async (raw) => {
       const rawObj = raw ?? {};
       const rawSessionId = typeof rawObj.sessionId === "string" ? rawObj.sessionId : void 0;
@@ -14743,15 +16262,39 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         // Same as session/new: include clientId so the deferred-echo
         // path in queue-aware clients can recognize own broadcasts.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
+    connection.onRequest("session/set_model", async (rawParams) => {
+      const decision = decideSetModel(rawParams, deps.manager);
+      if (decision.kind === "error") {
+        app.log.warn(decision.logMessage);
+        const err = new Error(decision.message);
+        err.code = decision.code;
+        throw err;
+      }
+      if (decision.kind === "no_op") {
+        app.log.warn(decision.logMessage);
+        await connection.notify("session/update", {
+          sessionId: decision.sessionId,
+          update: {
+            sessionUpdate: "current_model_update",
+            currentModel: decision.currentModel
+          }
+        }).catch(() => void 0);
+        return null;
+      }
+      app.log.info(decision.logMessage);
+      return decision.session.forwardRequest("session/set_model", rawParams);
+    });
     connection.setDefaultHandler(async (rawParams, method) => {
       if (!method.startsWith("session/") || rawParams === null || typeof rawParams !== "object") {
         const err = new Error(`Method not found: ${method}`);
@@ -14774,6 +16317,26 @@ function registerAcpWsEndpoint(app, deps) {
     });
   });
 }
+function makeInstallProgressForwarder(connection) {
+  return (event) => {
+    const payload = {
+      agentId: event.agentId,
+      version: event.version,
+      source: event.source,
+      phase: event.phase
+    };
+    if ("receivedBytes" in event) {
+      payload.receivedBytes = event.receivedBytes;
+    }
+    if ("totalBytes" in event) {
+      payload.totalBytes = event.totalBytes;
+    }
+    if ("packageSpec" in event) {
+      payload.packageSpec = event.packageSpec;
+    }
+    void connection.notify(AGENT_INSTALL_PROGRESS_METHOD, payload).catch(() => void 0);
+  };
+}
 function buildModesPayload(session) {
   const modes = session.availableModes();
   if (modes.length === 0) {
@@ -14794,6 +16357,94 @@ function buildModesPayload(session) {
   const currentModeId = session.currentMode ?? modes[0].id;
   return { currentModeId, availableModes };
 }
+function buildModelsPayload(session) {
+  const models = session.availableModels();
+  if (models.length === 0) {
+    return void 0;
+  }
+  const availableModels = models.map((m) => {
+    const out = {
+      modelId: m.modelId
+    };
+    if (m.name !== void 0) {
+      out.name = m.name;
+    }
+    if (m.description !== void 0) {
+      out.description = m.description;
+    }
+    return out;
+  });
+  const currentModelId = session.currentModel ?? models[0].modelId;
+  return { currentModelId, availableModels };
+}
+function decideSetModel(rawParams, manager) {
+  if (!rawParams || typeof rawParams !== "object") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires params",
+      logMessage: "session/set_model rejected: params not an object"
+    };
+  }
+  const params = rawParams;
+  if (typeof params.sessionId !== "string") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires string sessionId",
+      logMessage: "session/set_model rejected: missing/non-string sessionId"
+    };
+  }
+  if (typeof params.modelId !== "string") {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: "session/set_model requires string modelId",
+      logMessage: `session/set_model rejected: missing/non-string modelId sessionId=${params.sessionId}`
+    };
+  }
+  const session = manager.get(params.sessionId);
+  if (!session) {
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.SessionNotFound,
+      message: `session ${params.sessionId} not found`,
+      logMessage: `session/set_model rejected: session not found sessionId=${params.sessionId}`
+    };
+  }
+  const advertised = session.availableModels();
+  if (advertised.length === 0) {
+    return {
+      kind: "ok",
+      session,
+      logMessage: `session/set_model passthrough (no availableModels) sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+    };
+  }
+  const match = advertised.find((m) => m.modelId === params.modelId);
+  if (!match) {
+    const known = advertised.map((m) => m.modelId).join(", ");
+    if (session.currentModel !== void 0 && session.currentModel.length > 0) {
+      return {
+        kind: "no_op",
+        session,
+        sessionId: params.sessionId,
+        currentModel: session.currentModel,
+        logMessage: `session/set_model no_op (resyncing client) sessionId=${params.sessionId} requested=${JSON.stringify(params.modelId)} actual=${JSON.stringify(session.currentModel)} agentId=${session.agentId} known=[${known}]`
+      };
+    }
+    return {
+      kind: "error",
+      code: JsonRpcErrorCodes.InvalidParams,
+      message: `model "${params.modelId}" is not in this session's availableModels (agent ${session.agentId}); known models: ${known}`,
+      logMessage: `session/set_model rejected sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)} agentId=${session.agentId} known=[${known}] (no current model to fall back to)`
+    };
+  }
+  return {
+    kind: "ok",
+    session,
+    logMessage: `session/set_model accepted sessionId=${params.sessionId} modelId=${JSON.stringify(params.modelId)}`
+  };
+}
 function buildResponseMeta(session) {
   const ours = {
     upstreamSessionId: session.upstreamSessionId,
@@ -14823,6 +16474,10 @@ function buildResponseMeta(session) {
   if (modes.length > 0) {
     ours.availableModes = modes;
   }
+  const models = session.availableModels();
+  if (models.length > 0) {
+    ours.availableModels = models;
+  }
   if (session.turnStartedAt !== void 0) {
     ours.turnStartedAt = session.turnStartedAt;
   }
@@ -14863,10 +16518,17 @@ function buildInitializeResult() {
     ],
     // Advertise hydra-only capabilities via _meta["hydra-acp"]. Generic
     // ACP clients ignore the field; capability-aware clients learn here
-    // that hydra accepts concurrent session/prompt requests and emits
-    // prompt_queue_* notifications so they can stop running their own
-    // local queue.
-    _meta: mergeMeta(void 0, { promptQueueing: true })
+    // which hydra-acp extensions the daemon supports so they can gate
+    // UI surface accordingly. promptPipelining is false until the
+    // streaming-input probe lands (Option A in the steering brief);
+    // the others are unconditional method-availability flags.
+    _meta: mergeMeta(void 0, {
+      promptQueueing: true,
+      promptCancelling: true,
+      promptUpdating: true,
+      promptAmending: true,
+      promptPipelining: false
+    })
   };
 }
 function bindClientToSession(connection, session, state, clientInfo, callerClientId) {
@@ -15051,6 +16713,7 @@ function ensureLoopbackOrTls(config) {
 
 // src/cli/commands/daemon.ts
 init_daemon_bootstrap();
+init_hydra_version();
 
 // src/cli/commands/log-tail.ts
 import * as fs16 from "fs";
@@ -15281,6 +16944,8 @@ async function runDaemonStatus() {
   const info = await readPidFile();
   if (!info) {
     process.stdout.write("Daemon: not running\n");
+    process.stdout.write(`CLI version: ${HYDRA_VERSION}
+`);
     return;
   }
   const alive = isProcessAlive(info.pid);
@@ -15288,6 +16953,52 @@ async function runDaemonStatus() {
     `Daemon: ${alive ? "running" : "stale pid file"} pid=${info.pid} host=${info.host} port=${info.port} started=${info.startedAt}
 `
   );
+  let daemonVersion;
+  if (alive) {
+    try {
+      const config = await loadConfig();
+      daemonVersion = await fetchDaemonVersion(config);
+    } catch {
+    }
+  }
+  if (daemonVersion === void 0) {
+    process.stdout.write(`CLI version: ${HYDRA_VERSION}
+`);
+    if (alive) {
+      process.stdout.write(
+        "Daemon version: unknown (health endpoint unreachable)\n"
+      );
+    }
+    return;
+  }
+  if (daemonVersion === HYDRA_VERSION) {
+    process.stdout.write(`Version: ${HYDRA_VERSION}
+`);
+    return;
+  }
+  process.stdout.write(`CLI version:    ${HYDRA_VERSION}
+`);
+  process.stdout.write(`Daemon version: ${daemonVersion}
+`);
+  process.stdout.write(
+    chalk.yellow(
+      "Version mismatch \u2014 run `hydra-acp daemon restart` to upgrade the daemon.\n"
+    )
+  );
+}
+async function fetchDaemonVersion(config) {
+  const protocol = config.daemon.tls ? "https" : "http";
+  const url = `${protocol}://${config.daemon.host}:${config.daemon.port}/v1/health`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(1e3) });
+    if (!response.ok) {
+      return void 0;
+    }
+    const body = await response.json();
+    return typeof body.version === "string" ? body.version : void 0;
+  } catch {
+    return void 0;
+  }
 }
 async function readPidFile() {
   try {