@hydra-acp/cli 0.1.25 → 0.1.27

package/dist/cli.js

@@ -483,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, AmendPromptParams, AmendPromptResult, PromptAmendedParams, 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";
@@ -682,6 +705,23 @@ var init_types = __esm({
       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({
@@ -1020,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 ?? {};
@@ -1306,11 +1382,19 @@ 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 = [];
@@ -1346,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;
@@ -1383,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
@@ -1413,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;
@@ -1561,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
           });
         }
@@ -2205,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.
@@ -2252,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;
@@ -2275,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 ?? {};
@@ -2373,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.
@@ -2382,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);
       }
@@ -2407,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
@@ -2554,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);
@@ -3120,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";
@@ -3141,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(),
@@ -3187,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()
     });
@@ -3682,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)) {
@@ -5069,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}`, {
@@ -5139,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);
@@ -5247,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;
@@ -5364,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;
@@ -5436,6 +5767,52 @@ async function pickSession(term, opts) {
         renderFromScratch();
         return;
       }
+      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") {
+          mode = "normal";
+          pendingAction = null;
+          renameBuffer = "";
+          paintIndicator();
+          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";
@@ -5538,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) {
@@ -5668,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"],
@@ -6589,6 +6991,42 @@ var init_screen = __esm({
               return;
             }
           }
+          const csiUCtrlMap = {
+            97: "ctrl-a",
+            98: "ctrl-b",
+            99: "ctrl-c",
+            100: "ctrl-d",
+            101: "ctrl-e",
+            102: "ctrl-f",
+            103: "ctrl-g",
+            107: "ctrl-k",
+            108: "ctrl-l",
+            110: "ctrl-n",
+            111: "ctrl-o",
+            112: "ctrl-p",
+            114: "ctrl-r",
+            115: "ctrl-s",
+            116: "ctrl-t",
+            117: "ctrl-u",
+            118: "ctrl-v",
+            119: "ctrl-w",
+            121: "ctrl-y"
+          };
+          const csiUCtrlRe = /\x1b\[(\d+);5u/;
+          const m = csiUCtrlRe.exec(text);
+          if (m !== null) {
+            const keyName = csiUCtrlMap[parseInt(m[1], 10)];
+            if (keyName !== void 0) {
+              const parts = text.split(m[0]);
+              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: keyName }]);
+              }
+              return;
+            }
+          }
         }
         this.handleRawStdinSegment(text);
       }
@@ -7886,11 +8324,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);
             }
@@ -9267,8 +9710,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) {
@@ -9561,12 +10025,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) {
@@ -9665,7 +10139,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,
@@ -9727,8 +10202,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}`];
@@ -9754,6 +10230,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;
@@ -9771,34 +10254,46 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   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;
@@ -9819,6 +10314,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 ?? {};
@@ -10388,6 +10884,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   };
   const sessionbarAgent = resolvedAgentId || agentInfoName || "?";
   const usage = { ...initialUsage ?? {} };
+  installStatus.finalize();
   screen.start();
   screen.setSessionbar({
     agent: sessionbarAgent,
@@ -11270,7 +11767,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);
@@ -11281,7 +11778,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 ?? {
@@ -11298,6 +11795,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) {
@@ -11389,7 +11889,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;
     }
@@ -11404,7 +11904,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;
     }
@@ -11418,7 +11926,10 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (event.kind === "turn-complete") {
       currentHeadMessageId = void 0;
       closeAgentText();
-      const effectiveStopReason = event.amended ? "amended" : event.stopReason;
+      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) {
@@ -11448,6 +11959,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       toolsBlockEndedAt = null;
       toolsBlockStopReason = null;
       toolsExpanded = false;
+      upstreamInterruptedSeen = false;
       screen.ensureSeparator();
     }
   };
@@ -11557,9 +12069,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;
@@ -11685,6 +12198,95 @@ function writeDebugLine(payload) {
   } catch {
   }
 }
+function createInstallStatusLine(term, baseLabel) {
+  let finalized = false;
+  let lastText = "";
+  let osc94Active = false;
+  const writeOsc94 = (state) => {
+    if (finalized) {
+      return;
+    }
+    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);
@@ -11695,7 +12297,7 @@ function rotateIfBig(target) {
   } catch {
   }
 }
-var HELP_ENTRIES_TAIL, logMaxBytes;
+var STALL_THRESHOLD_MS, HELP_ENTRIES_TAIL, logMaxBytes;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -11717,8 +12319,10 @@ var init_app = __esm({
     init_attachments();
     init_clipboard();
     init_completion();
+    init_reconnect_state();
     init_render_update();
     init_format();
+    STALL_THRESHOLD_MS = 12e4;
     HELP_ENTRIES_TAIL = [
       ["Alt+Enter", "newline in prompt"],
       ["Shift+Tab", "cycle agent modes (plan / accept-edits / etc.)"],
@@ -11880,6 +12484,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();
@@ -11948,8 +12553,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(
@@ -11969,9 +12576,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 {
@@ -11982,16 +12596,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);
@@ -12004,17 +12637,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);
@@ -12029,6 +12679,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) {
@@ -12128,9 +12785,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(
@@ -12146,6 +12805,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,
@@ -12159,11 +12824,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
@@ -12171,44 +12846,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 {
@@ -12406,12 +13124,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,
@@ -12427,10 +13147,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 {
@@ -12848,7 +13570,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,
@@ -12865,7 +13588,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;
@@ -12910,7 +13634,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,
@@ -12968,6 +13695,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
@@ -12991,7 +13719,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd,
       agentArgs: params.agentArgs,
-      mcpServers: []
+      mcpServers: [],
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -13014,6 +13743,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
     });
@@ -13043,7 +13773,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,
@@ -13069,15 +13802,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);
@@ -13087,6 +13830,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
       };
@@ -13149,6 +13893,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);
@@ -13192,6 +13945,7 @@ var SessionManager = class {
       currentUsage: persistedUsageToSnapshot(record.currentUsage),
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
+      agentModels: record.agentModels,
       createdAt: record.createdAt
     };
   }
@@ -13435,6 +14189,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
@@ -13487,6 +14261,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()
       });
     });
@@ -13588,6 +14363,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(),
@@ -13604,6 +14391,7 @@ function mergeForPersistence(session, existing) {
     currentUsage: usageSnapshotToPersisted(session.currentUsage) ?? existing?.currentUsage,
     agentCommands,
     agentModes,
+    agentModels,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -13669,6 +14457,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) {
@@ -14646,6 +15468,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;
@@ -15188,7 +16039,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");
@@ -15204,6 +16056,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
@@ -15212,6 +16065,7 @@ function registerAcpWsEndpoint(app, deps) {
         // events without an extra round-trip.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -15247,7 +16101,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,
@@ -15273,6 +16130,7 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         clientId: client.clientId,
@@ -15284,6 +16142,7 @@ function registerAcpWsEndpoint(app, deps) {
         historyPolicy: appliedPolicy,
         replayed: replay.length,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -15439,15 +16298,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}`);
@@ -15470,6 +16353,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) {
@@ -15490,6 +16393,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,
@@ -15519,6 +16510,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;
   }
@@ -15754,6 +16749,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";
@@ -15984,6 +16980,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);
@@ -15991,6 +16989,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 {