@hydra-acp/cli 0.1.24 → 0.1.26

package/dist/index.js

@@ -186,7 +186,15 @@ var TuiConfig = z.object({
   // 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")
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -230,7 +238,8 @@ var HydraConfig = z.object({
     mouse: true,
     logMaxBytes: 5 * 1024 * 1024,
     cwdColumnMaxWidth: 24,
-    progressIndicator: true
+    progressIndicator: true,
+    defaultEnterAction: "enqueue"
   })
 });
 function extensionList(config) {
@@ -371,8 +380,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(
@@ -392,9 +403,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 {
@@ -405,16 +423,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);
@@ -427,17 +464,34 @@ async function downloadTo(args) {
   const total = Number(response.headers.get("content-length") ?? "0");
   const out = fs3.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((resolve3, reject) => {
     nodeStream.on("error", reject);
@@ -452,6 +506,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) {
@@ -550,9 +611,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(
@@ -568,6 +631,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,
@@ -581,11 +650,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
@@ -593,44 +672,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((resolve3, 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) {
-        resolve3();
+  return runNpmInstallOnce(args, 0);
+}
+async function runNpmInstallOnce(args, attempt) {
+  try {
+    await new Promise((resolve3, 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) {
+          resolve3();
+          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 {
@@ -828,12 +950,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,
@@ -849,10 +973,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 {
@@ -1024,6 +1150,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) {
@@ -1073,6 +1211,29 @@ 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) {
@@ -1168,6 +1329,51 @@ var UpdatePromptResult = z3.object({
   updated: z3.boolean(),
   reason: z3.enum(["ok", "not_found", "already_running"])
 });
+var 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()
+});
+var 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()
+});
+var PromptAmendedParams = z3.object({
+  sessionId: z3.string(),
+  cancelledMessageId: z3.string(),
+  newMessageId: z3.string(),
+  prompt: z3.array(z3.unknown()),
+  originator: PromptOriginatorSchema,
+  amendedAt: z3.number()
+});
+var 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()
+});
+var AGENT_INSTALL_PROGRESS_METHOD = "hydra-acp/agent_install_progress";
 var ProxyInitializeParams = z3.object({
   protocolVersion: z3.number().optional(),
   proxyInfo: z3.object({
@@ -1646,6 +1852,7 @@ function stripHydraSessionPrefix(id) {
   return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
 }
 var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
+var RECENTLY_TERMINAL_LIMIT = 64;
 var Session = class {
   sessionId;
   cwd;
@@ -1737,14 +1944,36 @@ var Session = class {
   // 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;
@@ -1763,6 +1992,9 @@ var Session = class {
     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;
@@ -1800,6 +2032,23 @@ var Session = class {
       }
     });
   }
+  // 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
@@ -1830,6 +2079,10 @@ var Session = class {
         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;
@@ -1978,16 +2231,19 @@ var Session = class {
         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
       });
     }
@@ -2174,7 +2430,7 @@ var Session = class {
       );
     }
   }
-  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",
@@ -2183,15 +2439,83 @@ var Session = class {
     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
@@ -2204,9 +2528,9 @@ var Session = class {
     }
     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,
@@ -2216,6 +2540,11 @@ var Session = class {
       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) {
@@ -2338,6 +2667,9 @@ var Session = class {
       this.broadcastQueueRemoved(messageId, "cancelled");
       this.persistRewrite();
     }
+    if (this.amendInProgress?.newMessageId === messageId) {
+      this.amendInProgress = void 0;
+    }
     entry.resolve({ stopReason: "cancelled" });
     return { cancelled: true, reason: "ok" };
   }
@@ -2359,6 +2691,143 @@ var Session = class {
     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) {
@@ -2409,6 +2878,18 @@ var Session = class {
   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.
@@ -2456,12 +2937,19 @@ var Session = class {
   // 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;
@@ -2479,6 +2967,55 @@ var Session = class {
     }
     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 ?? {};
@@ -2577,6 +3114,20 @@ var Session = class {
     }
     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.
@@ -2586,6 +3137,9 @@ var Session = class {
   onAgentModesChange(handler) {
     this.agentModesHandlers.push(handler);
   }
+  onAgentModelsChange(handler) {
+    this.agentModelsHandlers.push(handler);
+  }
   onModelChange(handler) {
     this.modelHandlers.push(handler);
   }
@@ -2611,6 +3165,15 @@ var Session = class {
   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
@@ -2758,6 +3321,12 @@ var Session = class {
       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);
@@ -3217,6 +3786,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 {
@@ -3253,12 +3823,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;
+    }
+  }
 };
 function withCode(err, code) {
   err.code = code;
@@ -3302,6 +3893,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 ?? {};
@@ -3506,6 +4133,11 @@ var PersistedAgentMode = z4.object({
   name: z4.string().optional(),
   description: z4.string().optional()
 });
+var PersistedAgentModel = z4.object({
+  modelId: z4.string(),
+  name: z4.string().optional(),
+  description: z4.string().optional()
+});
 var PersistedUsage = z4.object({
   used: z4.number().optional(),
   size: z4.number().optional(),
@@ -3552,6 +4184,7 @@ var SessionRecord = z4.object({
   currentUsage: PersistedUsage.optional(),
   agentCommands: z4.array(PersistedAgentCommand).optional(),
   agentModes: z4.array(PersistedAgentMode).optional(),
+  agentModels: z4.array(PersistedAgentModel).optional(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
@@ -3671,6 +4304,7 @@ function recordFromMemorySession(args) {
     currentUsage: args.currentUsage,
     agentCommands: args.agentCommands,
     agentModes: args.agentModes,
+    agentModels: args.agentModels,
     createdAt: args.createdAt ?? now,
     updatedAt: args.updatedAt ?? now
   };
@@ -3905,7 +4539,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,
@@ -3922,7 +4557,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;
@@ -3967,7 +4603,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,
@@ -4025,6 +4664,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
@@ -4048,7 +4688,8 @@ var SessionManager = class {
       agentId: params.agentId,
       cwd,
       agentArgs: params.agentArgs,
-      mcpServers: []
+      mcpServers: [],
+      onInstallProgress: params.onInstallProgress
     });
     const session = new Session({
       sessionId: params.hydraSessionId,
@@ -4071,6 +4712,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
     });
@@ -4100,7 +4742,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,
@@ -4126,15 +4771,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);
@@ -4144,6 +4799,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
       };
@@ -4206,6 +4862,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);
@@ -4249,6 +4914,7 @@ var SessionManager = class {
       currentUsage: persistedUsageToSnapshot(record.currentUsage),
       agentCommands: record.agentCommands,
       agentModes: record.agentModes,
+      agentModels: record.agentModels,
       createdAt: record.createdAt
     };
   }
@@ -4492,6 +5158,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
@@ -4544,6 +5230,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()
       });
     });
@@ -4645,6 +5332,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(),
@@ -4661,6 +5360,7 @@ function mergeForPersistence(session, existing) {
     currentUsage: usageSnapshotToPersisted(session.currentUsage) ?? existing?.currentUsage,
     agentCommands,
     agentModes,
+    agentModels,
     createdAt: existing?.createdAt ?? new Date(session.createdAt).toISOString()
   });
 }
@@ -4726,6 +5426,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) {
@@ -5948,8 +6682,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)) {
@@ -5992,7 +6773,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") {
@@ -6321,6 +7111,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;
@@ -6908,7 +7727,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");
@@ -6924,6 +7744,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
@@ -6932,6 +7753,7 @@ function registerAcpWsEndpoint(app, deps) {
         // events without an extra round-trip.
         clientId: client.clientId,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -6967,7 +7789,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,
@@ -6993,6 +7818,7 @@ function registerAcpWsEndpoint(app, deps) {
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);
+      const modelsPayload = buildModelsPayload(session);
       return {
         sessionId: session.sessionId,
         clientId: client.clientId,
@@ -7004,6 +7830,7 @@ function registerAcpWsEndpoint(app, deps) {
         historyPolicy: appliedPolicy,
         replayed: replay.length,
         ...modesPayload ? { modes: modesPayload } : {},
+        ...modelsPayload ? { models: modelsPayload } : {},
         _meta: buildResponseMeta(session)
       };
     });
@@ -7111,6 +7938,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;
@@ -7143,15 +7986,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}`);
@@ -7174,6 +8041,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) {
@@ -7194,6 +8081,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,
@@ -7223,6 +8198,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;
   }
@@ -7263,10 +8242,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) {