@hydra-acp/cli 0.1.23 → 0.1.25

package/dist/cli.js

@@ -289,7 +289,15 @@ var init_config = __esm({
       // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
       // running. Set false if your terminal renders this obnoxiously or you
       // just don't want it.
-      progressIndicator: z.boolean().default(true)
+      progressIndicator: z.boolean().default(true),
+      // What the unmodified Enter key does in the prompt composer.
+      //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
+      //     when idle, queues behind an in-flight turn); Shift+Enter amends
+      //     the in-flight turn.
+      //   "amend" — flips the two: Enter amends the in-flight turn,
+      //     Shift+Enter enqueues. With no turn in flight either key just
+      //     enqueues, since there's nothing to amend.
+      defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
     });
     ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
     ExtensionBody = z.object({
@@ -333,7 +341,8 @@ var init_config = __esm({
         mouse: true,
         logMaxBytes: 5 * 1024 * 1024,
         cwdColumnMaxWidth: 24,
-        progressIndicator: true
+        progressIndicator: true,
+        defaultEnterAction: "enqueue"
       })
     });
   }
@@ -413,6 +422,18 @@ function extractHydraMeta(meta) {
   if (typeof obj.promptQueueing === "boolean") {
     out.promptQueueing = obj.promptQueueing;
   }
+  if (typeof obj.promptCancelling === "boolean") {
+    out.promptCancelling = obj.promptCancelling;
+  }
+  if (typeof obj.promptUpdating === "boolean") {
+    out.promptUpdating = obj.promptUpdating;
+  }
+  if (typeof obj.promptAmending === "boolean") {
+    out.promptAmending = obj.promptAmending;
+  }
+  if (typeof obj.promptPipelining === "boolean") {
+    out.promptPipelining = obj.promptPipelining;
+  }
   if (Array.isArray(obj.queue)) {
     const entries = [];
     for (const raw of obj.queue) {
@@ -467,7 +488,7 @@ function extractHydraMeta(meta) {
 function mergeMeta(passthrough, ours) {
   return { ...passthrough ?? {}, [HYDRA_META_KEY]: ours };
 }
-var ACP_PROTOCOL_VERSION, JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, PromptOriginatorSchema, PromptQueueAddedParams, PromptQueueUpdatedParams, PromptQueueRemovedParams, CancelPromptParams, CancelPromptResult, UpdatePromptParams, UpdatePromptResult, ProxyInitializeParams;
+var ACP_PROTOCOL_VERSION, JsonRpcErrorCodes, InitializeParams, HistoryPolicy, SessionNewParams, SessionResumeHints, SessionAttachParams, HYDRA_META_KEY, SessionDetachParams, SessionListParams, SessionListUsage, SessionListEntry, SessionListResult, SessionPromptParams, SessionCancelParams, PromptOriginatorSchema, PromptQueueAddedParams, PromptQueueUpdatedParams, PromptQueueRemovedParams, CancelPromptParams, CancelPromptResult, UpdatePromptParams, UpdatePromptResult, AmendPromptParams, AmendPromptResult, PromptAmendedParams, ProxyInitializeParams;
 var init_types = __esm({
   "src/acp/types.ts"() {
     "use strict";
@@ -633,6 +654,34 @@ var init_types = __esm({
       updated: z3.boolean(),
       reason: z3.enum(["ok", "not_found", "already_running"])
     });
+    AmendPromptParams = z3.object({
+      sessionId: z3.string(),
+      targetMessageId: z3.string(),
+      prompt: z3.array(z3.unknown()),
+      replaceQueue: z3.boolean().optional(),
+      onTargetCompleted: z3.enum(["reject", "send_anyway"]).optional()
+    });
+    AmendPromptResult = z3.object({
+      amended: z3.boolean(),
+      reason: z3.enum([
+        "ok",
+        "target_completed",
+        "target_cancelled",
+        "target_not_found"
+      ]),
+      // Present when a prompt was sent or replaced: the amendment's id on
+      // success, or the regular follow-up's id when onTargetCompleted is
+      // "send_anyway" and the daemon forwarded the prompt anyway.
+      messageId: z3.string().optional()
+    });
+    PromptAmendedParams = z3.object({
+      sessionId: z3.string(),
+      cancelledMessageId: z3.string(),
+      newMessageId: z3.string(),
+      prompt: z3.array(z3.unknown()),
+      originator: PromptOriginatorSchema,
+      amendedAt: z3.number()
+    });
     ProxyInitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
       proxyInfo: z3.object({
@@ -1154,7 +1203,7 @@ function firstLine(text, max) {
   }
   return void 0;
 }
-var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, DEFAULT_HISTORY_MAX_ENTRIES, Session, STATE_UPDATE_KINDS;
+var HYDRA_ID_ALPHABET, generateHydraId, HYDRA_SESSION_PREFIX, DEFAULT_HISTORY_MAX_ENTRIES, RECENTLY_TERMINAL_LIMIT, Session, STATE_UPDATE_KINDS;
 var init_session = __esm({
   "src/core/session.ts"() {
     "use strict";
@@ -1165,6 +1214,7 @@ var init_session = __esm({
     generateHydraId = customAlphabet(HYDRA_ID_ALPHABET, 16);
     HYDRA_SESSION_PREFIX = "hydra_session_";
     DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
+    RECENTLY_TERMINAL_LIMIT = 64;
     Session = class {
       sessionId;
       cwd;
@@ -1264,6 +1314,20 @@ var init_session = __esm({
       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;
@@ -1693,7 +1757,7 @@ var init_session = __esm({
           );
         }
       }
-      broadcastTurnComplete(originatorClientId, response) {
+      broadcastTurnComplete(originatorClientId, response, promptMessageId, wasAmend) {
         const stopReason = response && typeof response === "object" && "stopReason" in response && typeof response.stopReason === "string" ? response.stopReason : void 0;
         const update = {
           sessionUpdate: "turn_complete",
@@ -1702,15 +1766,83 @@ var init_session = __esm({
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
         }
+        const amend = this.amendInProgress;
+        if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+          update._meta = {
+            "hydra-acp": {
+              amended: {
+                cancelledMessageId: amend.cancelledMessageId,
+                newMessageId: amend.newMessageId
+              }
+            }
+          };
+        }
         this.promptStartedAt = void 0;
+        if (promptMessageId !== void 0 && stopReason !== void 0) {
+          this.recordTerminal(promptMessageId, stopReason);
+        }
         this.recordAndBroadcast(
           "session/update",
           {
             sessionId: this.sessionId,
             update
           },
-          originatorClientId
+          wasAmend ? void 0 : originatorClientId
+        );
+        if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+          this.broadcastPromptAmended(amend);
+        }
+      }
+      // Record that a prompt's turn has ended, with its terminal stopReason.
+      // Used by amendPrompt to resolve targetMessageIds that completed/cancelled
+      // before the amend arrived. LRU-trimmed at RECENTLY_TERMINAL_LIMIT.
+      recordTerminal(messageId, stopReason) {
+        this.recentlyTerminal.set(messageId, {
+          stopReason,
+          terminatedAt: Date.now()
+        });
+        while (this.recentlyTerminal.size > RECENTLY_TERMINAL_LIMIT) {
+          const oldest = this.recentlyTerminal.keys().next().value;
+          if (oldest === void 0) {
+            break;
+          }
+          this.recentlyTerminal.delete(oldest);
+        }
+      }
+      // Fire hydra-acp/prompt_amended for the M1→M2 linkage. The amendment's
+      // current content is read live from the queue entry so any update_prompt
+      // calls during the amend window are reflected. Best-effort: if M2 has
+      // already been cancelled out of the queue by the time we get here, we
+      // skip — the amendInProgress clearing in cancelQueuedPrompt should have
+      // prevented this code path from running in that case.
+      broadcastPromptAmended(amend) {
+        const entry = this.findUserEntry(amend.newMessageId);
+        if (!entry) {
+          return;
+        }
+        const params = {
+          sessionId: this.sessionId,
+          cancelledMessageId: amend.cancelledMessageId,
+          newMessageId: amend.newMessageId,
+          prompt: entry.prompt,
+          originator: entry.originator,
+          amendedAt: Date.now()
+        };
+        this.broadcastQueueNotification(
+          "hydra-acp/prompt_amended",
+          params
+        );
+      }
+      // Look up a user-prompt queue entry by messageId, searching both the
+      // currentEntry slot and the waiting queue.
+      findUserEntry(messageId) {
+        if (this.currentEntry?.messageId === messageId && this.currentEntry.kind === "user") {
+          return this.currentEntry;
+        }
+        const queued = this.promptQueue.find(
+          (e) => e.messageId === messageId && e.kind === "user"
         );
+        return queued?.kind === "user" ? queued : void 0;
       }
       // Total visible-or-running entries: the in-flight head (if any) plus
       // the queue's user-visible waiting entries. Internal entries don't
@@ -1723,9 +1855,9 @@ var init_session = __esm({
         }
         return count;
       }
-      broadcastQueueAdded(entry) {
+      broadcastQueueAdded(entry, options) {
         const depth = this.visibleQueueDepth();
-        const position = Math.max(0, depth - 1);
+        const position = options?.position ?? Math.max(0, depth - 1);
         const params = {
           sessionId: this.sessionId,
           messageId: entry.messageId,
@@ -1735,6 +1867,11 @@ var init_session = __esm({
           queueDepth: depth,
           enqueuedAt: entry.enqueuedAt
         };
+        if (options?.amending !== void 0) {
+          params._meta = {
+            "hydra-acp": { amending: options.amending }
+          };
+        }
         this.broadcastQueueNotification("hydra-acp/prompt_queue_added", params);
       }
       broadcastQueueUpdated(messageId, prompt) {
@@ -1857,6 +1994,9 @@ var init_session = __esm({
           this.broadcastQueueRemoved(messageId, "cancelled");
           this.persistRewrite();
         }
+        if (this.amendInProgress?.newMessageId === messageId) {
+          this.amendInProgress = void 0;
+        }
         entry.resolve({ stopReason: "cancelled" });
         return { cancelled: true, reason: "ok" };
       }
@@ -1878,6 +2018,143 @@ var init_session = __esm({
         this.persistRewrite();
         return { updated: true, reason: "ok" };
       }
+      // Amend the head prompt: cancel the in-flight turn and submit a
+      // replacement that sits at the head of the queue. Resolves the
+      // request immediately (the caller doesn't wait on cancel-settle).
+      // Honours race outcomes — if the target finished or was cancelled
+      // before this arrived, the request resolves with an outcome explaining
+      // why and (depending on onTargetCompleted) optionally forwards as a
+      // plain prompt. Queued targets are edited in place (same machinery
+      // as updateQueuedPrompt).
+      amendPrompt(clientId, params) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+          throw withCode(
+            new Error("client not attached"),
+            JsonRpcErrorCodes.SessionNotFound
+          );
+        }
+        const { targetMessageId, prompt, replaceQueue, onTargetCompleted } = params;
+        if (this.currentEntry?.messageId === targetMessageId && this.currentEntry.kind === "user" && !this.currentEntry.cancelled && this.amendInProgress === void 0) {
+          return this.amendOnHead(client, prompt, targetMessageId, replaceQueue);
+        }
+        const queuedEntry = this.promptQueue.find(
+          (e) => e.messageId === targetMessageId && e.kind === "user"
+        );
+        if (queuedEntry && queuedEntry.kind === "user" && !queuedEntry.cancelled) {
+          queuedEntry.prompt = prompt;
+          this.broadcastQueueUpdated(targetMessageId, prompt);
+          this.persistRewrite();
+          return { amended: true, reason: "ok", messageId: targetMessageId };
+        }
+        const terminal = this.recentlyTerminal.get(targetMessageId);
+        if (terminal) {
+          if (terminal.stopReason === "cancelled") {
+            return { amended: false, reason: "target_cancelled" };
+          }
+          if (onTargetCompleted === "send_anyway") {
+            const newMessageId = this.enqueueAmendmentAsFollowUp(client, prompt);
+            return {
+              amended: false,
+              reason: "target_completed",
+              messageId: newMessageId
+            };
+          }
+          return { amended: false, reason: "target_completed" };
+        }
+        return { amended: false, reason: "target_not_found" };
+      }
+      // Head-of-queue amendment: splice M2 in front of any waiting entries,
+      // broadcast the amend window's queue_added with the amending hint,
+      // mark amendInProgress so the cancelled turn's broadcastTurnComplete
+      // attaches the _meta marker and fires prompt_amended, then fire the
+      // upstream session/cancel without awaiting it. drainQueue is already
+      // running on the head; when its session/prompt returns, it advances
+      // to M2 in the normal way.
+      amendOnHead(client, prompt, targetMessageId, replaceQueue) {
+        const newMessageId = generateMessageId();
+        const originator = { clientId: client.clientId };
+        if (client.clientInfo?.name) {
+          originator.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          originator.version = client.clientInfo.version;
+        }
+        if (replaceQueue) {
+          const survivors = [];
+          for (const entry2 of this.promptQueue) {
+            if (entry2.kind === "user" && !entry2.cancelled) {
+              entry2.cancelled = true;
+              this.broadcastQueueRemoved(entry2.messageId, "cancelled");
+              entry2.resolve({ stopReason: "cancelled" });
+              continue;
+            }
+            survivors.push(entry2);
+          }
+          this.promptQueue = survivors;
+        }
+        const entry = {
+          kind: "user",
+          messageId: newMessageId,
+          originator,
+          clientId: client.clientId,
+          prompt,
+          enqueuedAt: Date.now(),
+          cancelled: false,
+          wasAmend: true,
+          // No-op resolve/reject: there's no client request awaiting M2's
+          // session/prompt response. The amend_prompt request has already
+          // returned by this point. drainQueue calls these unconditionally
+          // when runQueueEntry settles; making them no-ops is safe.
+          resolve: () => void 0,
+          reject: () => void 0
+        };
+        this.promptQueue.unshift(entry);
+        this.persistRewrite();
+        this.broadcastQueueAdded(entry, {
+          amending: targetMessageId,
+          position: 1
+        });
+        this.amendInProgress = {
+          cancelledMessageId: targetMessageId,
+          newMessageId
+        };
+        void this.agent.connection.notify("session/cancel", { sessionId: this.upstreamSessionId }).catch(() => void 0);
+        return {
+          amended: true,
+          reason: "ok",
+          messageId: newMessageId
+        };
+      }
+      // Send the amendment as a plain follow-up prompt — used when the
+      // target already completed and the caller opted in to send_anyway.
+      // Returns the new prompt's messageId so the result can surface it.
+      enqueueAmendmentAsFollowUp(client, prompt) {
+        const messageId = generateMessageId();
+        const originator = { clientId: client.clientId };
+        if (client.clientInfo?.name) {
+          originator.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          originator.version = client.clientInfo.version;
+        }
+        const entry = {
+          kind: "user",
+          messageId,
+          originator,
+          clientId: client.clientId,
+          prompt,
+          enqueuedAt: Date.now(),
+          cancelled: false,
+          resolve: () => void 0,
+          reject: () => void 0
+        };
+        this.promptQueue.push(entry);
+        this.persistRewrite();
+        this.broadcastQueueAdded(entry);
+        void this.drainQueue();
+        return messageId;
+      }
       async cancel(clientId) {
         const client = this.clients.get(clientId);
         if (!client) {
@@ -2736,6 +3013,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             try {
               const result = await this.runQueueEntry(next);
               next.resolve(result);
+              await Promise.resolve();
             } catch (err) {
               next.reject(err);
             } finally {
@@ -2772,12 +3050,33 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             }
           );
         } catch (err) {
-          this.broadcastTurnComplete(entry.clientId, { stopReason: "error" });
+          this.broadcastTurnComplete(
+            entry.clientId,
+            { stopReason: "error" },
+            entry.messageId,
+            entry.wasAmend
+          );
+          this.clearAmendIfMatches(entry.messageId);
           throw err;
         }
-        this.broadcastTurnComplete(entry.clientId, response);
+        this.broadcastTurnComplete(
+          entry.clientId,
+          response,
+          entry.messageId,
+          entry.wasAmend
+        );
+        this.clearAmendIfMatches(entry.messageId);
         return response;
       }
+      // Clear amendInProgress once the cancelled turn's task has fully
+      // settled. broadcastTurnComplete needs the marker still set when it
+      // fires, so the clear must happen *after*. Called from runQueueEntry's
+      // settle path for both success and error.
+      clearAmendIfMatches(messageId) {
+        if (this.amendInProgress?.cancelledMessageId === messageId) {
+          this.amendInProgress = void 0;
+        }
+      }
     };
     STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
       "session_info_update",
@@ -3427,7 +3726,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") {
@@ -4067,7 +4375,7 @@ var init_session_row = __esm({
 
 // src/cli/commands/sessions.ts
 import * as fs17 from "fs/promises";
-import * as path10 from "path";
+import * as path11 from "path";
 async function runSessionsList(opts = {}) {
   const config = await loadConfig();
   const serviceToken = await loadServiceToken();
@@ -4195,7 +4503,7 @@ async function runSessionsExport(id, outPath) {
     return;
   }
   const resolved = outPath === "." ? deriveFilenameFrom(response, id) : outPath;
-  await fs17.mkdir(path10.dirname(path10.resolve(resolved)), { recursive: true });
+  await fs17.mkdir(path11.dirname(path11.resolve(resolved)), { recursive: true });
   await fs17.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
   process.stdout.write(`Wrote ${resolved}
 `);
@@ -4214,7 +4522,7 @@ async function runSessionsTranscript(idOrFile, outPath) {
     const bundle = decodeBundleOrExit(localFile.raw);
     body = bundleToMarkdown(bundle);
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    defaultName = `${path10.basename(idOrFile, path10.extname(idOrFile))}-${stamp}.md`;
+    defaultName = `${path11.basename(idOrFile, path11.extname(idOrFile))}-${stamp}.md`;
   } else {
     const config = await loadConfig();
     const serviceToken = await loadServiceToken();
@@ -4243,7 +4551,7 @@ async function runSessionsTranscript(idOrFile, outPath) {
     return;
   }
   const resolved = outPath === "." ? defaultName : outPath;
-  await fs17.mkdir(path10.dirname(path10.resolve(resolved)), { recursive: true });
+  await fs17.mkdir(path11.dirname(path11.resolve(resolved)), { recursive: true });
   await fs17.writeFile(resolved, body, { encoding: "utf8", mode: 384 });
   process.stdout.write(`Wrote ${resolved}
 `);
@@ -4284,7 +4592,7 @@ async function runSessionsImport(file, opts = {}) {
   }
   let cwdOverride;
   if (opts.cwd !== void 0) {
-    const resolved = path10.resolve(opts.cwd);
+    const resolved = path11.resolve(opts.cwd);
     try {
       const stat4 = await fs17.stat(resolved);
       if (!stat4.isDirectory()) {
@@ -4955,6 +5263,10 @@ async function pickSession(term, opts) {
   const indicatorRow = () => startRow + 3 + viewportSize;
   const sessionRow = (sessionIdx) => startRow + 3 + (sessionIdx - scrollOffset);
   const renderFromScratch = () => {
+    if (mode === "help") {
+      renderHelp();
+      return;
+    }
     computeLayout();
     adjustScroll();
     startRow = 1;
@@ -4969,6 +5281,21 @@ async function pickSession(term, opts) {
     paintIndicator();
     term("\n");
   };
+  const renderHelp = () => {
+    term.moveTo(1, 1).eraseDisplayBelow();
+    term.brightWhite.bold.noFormat("  Picker hotkeys")("\n\n");
+    for (const entry of HELP_ENTRIES) {
+      if (entry === null) {
+        term("\n");
+        continue;
+      }
+      const [keys, desc] = entry;
+      term.brightCyan.noFormat(`  ${keys.padEnd(HELP_KEYS_WIDTH)}`);
+      term.noFormat(desc)("\n");
+    }
+    term("\n");
+    term.dim.noFormat("  press any key to dismiss")("\n");
+  };
   const repaintNewItem = () => {
     term.moveTo(1, startRow).eraseLineAfter();
     paintNewItem();
@@ -5099,6 +5426,16 @@ async function pickSession(term, opts) {
       if (mode === "busy") {
         return;
       }
+      if (mode === "help") {
+        if (name === "CTRL_C") {
+          cleanup();
+          resolve5({ kind: "abort" });
+          return;
+        }
+        mode = "normal";
+        renderFromScratch();
+        return;
+      }
       if (mode === "confirm-kill" || mode === "confirm-delete") {
         if (data?.isCharacter && (name === "y" || name === "Y")) {
           const kind = mode === "confirm-kill" ? "kill" : "delete";
@@ -5114,6 +5451,11 @@ async function pickSession(term, opts) {
         return;
       }
       clearTransient();
+      if (!searchActive && data?.isCharacter && name === "?") {
+        mode = "help";
+        renderHelp();
+        return;
+      }
       if (searchActive) {
         if (data?.isCharacter) {
           searchTerm += name;
@@ -5262,6 +5604,7 @@ async function pickSession(term, opts) {
         }
         case "ESCAPE":
         case "CTRL_C":
+        case "CTRL_D":
           cleanup();
           resolve5({ kind: "abort" });
           return;
@@ -5303,7 +5646,7 @@ function matchesSearch(s, term) {
   }
   return false;
 }
-var ROW_PREFIX_WIDTH;
+var ROW_PREFIX_WIDTH, HELP_KEYS_WIDTH, HELP_ENTRIES;
 var init_picker = __esm({
   "src/tui/picker.ts"() {
     "use strict";
@@ -5312,13 +5655,31 @@ var init_picker = __esm({
     init_session();
     init_discovery();
     ROW_PREFIX_WIDTH = 2;
+    HELP_KEYS_WIDTH = 20;
+    HELP_ENTRIES = [
+      ["\u2191 / \u2193 or n / p", "navigate"],
+      ["PgUp / PgDn", "page up / page down"],
+      ["Home / End", "first / last"],
+      ["Enter", "open selected session (or create new)"],
+      null,
+      ["/", "search sessions"],
+      ["o", "toggle cwd-only filter"],
+      ["r", "refresh from daemon"],
+      null,
+      ["k", "kill the selected live session"],
+      ["d", "delete the selected cold session"],
+      null,
+      ["c", "create new session"],
+      ["?", "toggle this help"],
+      ["q / Esc / ^C / ^D", "quit picker (detach)"]
+    ];
   }
 });
 
 // src/tui/attachments.ts
-import path11 from "path";
+import path12 from "path";
 function mimeFromExtension(p) {
-  return EXTENSION_TO_MIME[path11.extname(p).toLowerCase()] ?? null;
+  return EXTENSION_TO_MIME[path12.extname(p).toLowerCase()] ?? null;
 }
 function isSupportedImagePath(p) {
   return mimeFromExtension(p) !== null;
@@ -5894,6 +6255,18 @@ function mapKeyName(name) {
     case "ALT_ENTER":
     case "META_ENTER":
       return "alt-enter";
+    case "SHIFT_ENTER":
+      return "shift-enter";
+    case "CTRL_ENTER":
+      return "ctrl-enter";
+    case "CTRL_J":
+      return "ctrl-enter";
+    case "ALT_B":
+    case "META_B":
+      return "alt-b";
+    case "ALT_F":
+    case "META_F":
+      return "alt-f";
     case "CTRL_T":
       return "ctrl-t";
     case "SHIFT_TAB":
@@ -5928,6 +6301,8 @@ function mapKeyName(name) {
       return "ctrl-e";
     case "CTRL_F":
       return "ctrl-f";
+    case "CTRL_G":
+      return "ctrl-g";
     case "CTRL_K":
       return "ctrl-k";
     case "CTRL_L":
@@ -5956,7 +6331,7 @@ function mapKeyName(name) {
       return null;
   }
 }
-var SESSIONBAR_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, BARE_URL_RE, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
+var SESSIONBAR_ROWS, BANNER_ROWS, SEPARATOR_ROWS, MAX_PROMPT_ROWS, MAX_QUEUED_ROWS, MAX_PERMISSION_ROWS, MAX_HELP_ROWS, MAX_COMPLETION_ROWS, MAX_CHIP_ROWS, CONFIRM_PROMPT_ROWS, DEFAULT_CONTENT_REPAINT_THROTTLE_MS, DEFAULT_MAX_SCROLLBACK_LINES, BARE_URL_RE, Screen, NON_ASCII, SEGMENTER, TK_MARKUP_STYLE_CHAR, shortId;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
     "use strict";
@@ -5970,6 +6345,7 @@ var init_screen = __esm({
     MAX_PROMPT_ROWS = 8;
     MAX_QUEUED_ROWS = 5;
     MAX_PERMISSION_ROWS = 12;
+    MAX_HELP_ROWS = 30;
     MAX_COMPLETION_ROWS = 6;
     MAX_CHIP_ROWS = 4;
     CONFIRM_PROMPT_ROWS = 2;
@@ -6032,6 +6408,7 @@ var init_screen = __esm({
       lastFrameH = 0;
       permissionPrompt = null;
       confirmPrompt = null;
+      helpPrompt = null;
       completions = [];
       // Scrollback offset: 0 = pinned to bottom (live), N = N wrapped lines
       // above the bottom. Mouse wheel and PgUp/PgDn adjust this; new content
@@ -6060,7 +6437,7 @@ var init_screen = __esm({
       banner = {
         status: "ready",
         currentMode: void 0,
-        hint: "\u21E7\u21E5 mode \xB7 \u2303V paste \xB7 \u2303P pick \xB7 \u2303C cancel \xB7 \u2303D detach",
+        hint: "\u21E7\u21E5 mode \xB7 \u2303P pick \xB7 \u2303G guide \xB7 \u2303D detach",
         queued: 0
       };
       sessionbar = { agent: "?", cwd: "?", sessionId: "?" };
@@ -6153,12 +6530,15 @@ var init_screen = __esm({
         this.term.fullscreen(false);
         this.term("\n");
       }
-      // Enables bracketed paste mode on the terminal and rewires stdin so we
-      // see the \x1b[200~/\x1b[201~ markers BEFORE terminal-kit's key
-      // parser. Non-paste data is forwarded to terminal-kit unchanged; paste
-      // content is buffered and dispatched as a single "paste" KeyEvent.
+      // Enables bracketed paste mode + modifyOtherKeys on the terminal and
+      // rewires stdin so we see the \x1b[200~/\x1b[201~ paste markers and
+      // CSI-u modified-key sequences (Shift+Enter etc.) BEFORE terminal-kit's
+      // key parser. Non-special data is forwarded to terminal-kit unchanged.
       installBracketedPaste() {
         process.stdout.write("\x1B[?2004h");
+        process.stdout.write("\x1B[>4;2m");
+        process.stdout.write("\x1B[>5;1m");
+        process.stdout.write("\x1B[>1u");
         const t = this.term;
         if (!t.stdin || typeof t.onStdin !== "function") {
           return;
@@ -6169,6 +6549,9 @@ var init_screen = __esm({
       }
       uninstallBracketedPaste() {
         process.stdout.write("\x1B[?2004l");
+        process.stdout.write("\x1B[>4;0m");
+        process.stdout.write("\x1B[>5;0m");
+        process.stdout.write("\x1B[<u");
         const t = this.term;
         if (!t.stdin || this.terminalKitStdinHandler === null) {
           return;
@@ -6181,6 +6564,38 @@ var init_screen = __esm({
       }
       handleRawStdin(chunk) {
         let text = chunk.toString("binary");
+        if (!this.pasteActive) {
+          const markers = [
+            { seq: "\x1B[13;2u", name: "shift-enter" },
+            { seq: "\x1B[27;2;13~", name: "shift-enter" },
+            { seq: "\x1B[13;5u", name: "ctrl-enter" },
+            { seq: "\x1B[27;5;13~", name: "ctrl-enter" },
+            // Bare LF — universal fallback for terminals without
+            // modifyOtherKeys / kitty protocol. Last so the longer escape
+            // sequences match first and we don't double-fire.
+            { seq: "\n", name: "ctrl-enter" }
+          ];
+          for (const { seq, name } of markers) {
+            if (text.includes(seq)) {
+              const parts = text.split(seq);
+              for (let i = 0; i < parts.length; i++) {
+                if (parts[i].length > 0) {
+                  this.handleRawStdin(Buffer.from(parts[i], "binary"));
+                }
+                if (i < parts.length - 1) {
+                  this.onKey([{ type: "key", name }]);
+                }
+              }
+              return;
+            }
+          }
+        }
+        this.handleRawStdinSegment(text);
+      }
+      // Inner stdin-segment handler — paste-marker detection and forwarding
+      // to terminal-kit. Split out so shift-enter interception can call it
+      // for the non-shift-enter portions of a mixed chunk.
+      handleRawStdinSegment(text) {
         const startMarker = "\x1B[200~";
         const endMarker = "\x1B[201~";
         while (text.length > 0) {
@@ -6623,6 +7038,16 @@ var init_screen = __esm({
         this.confirmPrompt = spec ? { ...spec } : null;
         this.repaint();
       }
+      // Multi-row help cheatsheet that takes over the prompt area. Used by
+      // the ^G hotkey to surface every binding without dropping the user
+      // out of the session. Pass null to dismiss.
+      setHelpPrompt(spec) {
+        this.helpPrompt = spec ? { ...spec, entries: [...spec.entries] } : null;
+        this.repaint();
+      }
+      isHelpPromptActive() {
+        return this.helpPrompt !== null;
+      }
       // Slash-command completion list shown directly above the separator. App
       // calls this after each keystroke; pass [] to dismiss. Suppressed when
       // the permission modal is active (the modal owns the prompt area).
@@ -7158,7 +7583,7 @@ var init_screen = __esm({
         this.repaint();
       }
       completionRows() {
-        if (this.permissionPrompt) {
+        if (this.permissionPrompt || this.confirmPrompt || this.helpPrompt) {
           return 0;
         }
         return Math.min(MAX_COMPLETION_ROWS, this.completions.length);
@@ -7302,6 +7727,10 @@ var init_screen = __esm({
           this.drawConfirmPrompt();
           return;
         }
+        if (this.helpPrompt) {
+          this.drawHelpPrompt();
+          return;
+        }
         const w = this.term.width;
         const room = Math.max(1, w - 2);
         const state = this.dispatcher.state();
@@ -7351,6 +7780,58 @@ var init_screen = __esm({
           this.term.dim(` ${truncate(spec.hint, w - 2)}`);
         });
       }
+      drawHelpPrompt() {
+        const spec = this.helpPrompt;
+        if (!spec) {
+          return;
+        }
+        const w = this.term.width;
+        const rows = this.helpRows();
+        const top = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
+        let row = top;
+        const writeRow = (sig, paint) => {
+          if (row >= top + rows) {
+            return;
+          }
+          this.paintRow(row, sig, paint);
+          row += 1;
+        };
+        writeRow(`help|t|${w}|${spec.title}`, () => {
+          this.term.brightYellow(` \u2753 ${truncate(spec.title, w - 5)}`);
+        });
+        const keysWidth = Math.min(
+          24,
+          Math.max(
+            ...spec.entries.map((e) => e === null ? 0 : e[0].length),
+            4
+          )
+        );
+        for (const entry of spec.entries) {
+          if (row >= top + rows - 1) {
+            break;
+          }
+          if (entry === null) {
+            writeRow(`help|sep|${w}|${row}`, () => void 0);
+            continue;
+          }
+          const [keys, desc] = entry;
+          const paddedKeys = keys.padEnd(keysWidth);
+          writeRow(`help|e|${w}|${keys}|${desc}`, () => {
+            this.term(" ");
+            this.term.brightCyan.noFormat(paddedKeys);
+            this.term.noFormat(` ${truncate(desc, w - 2 - keysWidth - 1)}`);
+          });
+        }
+        writeRow(`help|hint|${w}|${spec.hint}`, () => {
+          this.term.dim(` ${truncate(spec.hint, w - 2)}`);
+        });
+      }
+      helpRows() {
+        if (!this.helpPrompt) {
+          return 0;
+        }
+        return Math.min(MAX_HELP_ROWS, 2 + this.helpPrompt.entries.length);
+      }
       drawPermissionPrompt() {
         const spec = this.permissionPrompt;
         if (!spec) {
@@ -7460,6 +7941,12 @@ var init_screen = __esm({
           this.term.moveTo(2, top2);
           return;
         }
+        if (this.helpPrompt) {
+          const rows = this.helpRows();
+          const top2 = this.term.height - rows - BANNER_ROWS - SEPARATOR_ROWS - SESSIONBAR_ROWS + 1;
+          this.term.moveTo(2, top2);
+          return;
+        }
         if (this.scrollbackSearch) {
           this.term.hideCursor(true);
           return;
@@ -7486,6 +7973,9 @@ var init_screen = __esm({
         if (this.confirmPrompt) {
           return CONFIRM_PROMPT_ROWS;
         }
+        if (this.helpPrompt) {
+          return this.helpRows();
+        }
         const w = this.term.width;
         const room = Math.max(1, w - 2);
         const state = this.dispatcher.state();
@@ -7806,6 +8296,9 @@ var init_input = __esm({
         switch (name) {
           case "enter":
             return this.send();
+          case "shift-enter":
+          case "ctrl-enter":
+            return this.amend();
           case "alt-enter":
             this.insertNewline();
             return [];
@@ -7844,6 +8337,14 @@ var init_input = __esm({
           case "ctrl-f":
             this.moveRight();
             return [];
+          case "ctrl-g":
+            return [{ type: "show-help" }];
+          case "alt-b":
+            this.moveWordBackward();
+            return [];
+          case "alt-f":
+            this.moveWordForward();
+            return [];
           case "ctrl-k":
             this.killToEnd();
             return [];
@@ -7984,22 +8485,64 @@ var init_input = __esm({
           this.setCurrentLine(line + next);
         }
       }
+      // ^U: kill from cursor to start of current line. At col 0 with a line
+      // above:
+      //   - If the current line is empty, collapse it (kill just the
+      //     newline) so the cursor lands at the end of the previous line.
+      //     Don't slurp that line's contents.
+      //   - Otherwise, kill the previous line entirely + the joining
+      //     newline, so ^U from the start of a non-empty line walks up
+      //     line-by-line.
+      // Single-line behavior is unchanged.
       killLine() {
-        const line = this.currentLine();
-        const killed = line.slice(0, this.col);
-        if (killed.length > 0) {
-          this.killBuffer = killed;
+        if (this.col > 0) {
+          const line = this.currentLine();
+          this.killBuffer = line.slice(0, this.col);
+          this.setCurrentLine(line.slice(this.col));
+          this.col = 0;
+          return;
         }
-        this.setCurrentLine(line.slice(this.col));
-        this.col = 0;
+        if (this.row === 0) {
+          return;
+        }
+        if (this.currentLine().length === 0) {
+          this.killBuffer = "\n";
+          this.buffer.splice(this.row, 1);
+          this.row -= 1;
+          this.col = this.currentLine().length;
+          return;
+        }
+        const prev = this.buffer[this.row - 1] ?? "";
+        this.killBuffer = prev + "\n";
+        this.buffer.splice(this.row - 1, 1);
+        this.row -= 1;
       }
+      // ^K: kill from cursor to end of current line. At end-of-line with a
+      // line below:
+      //   - If the current line is empty, collapse it (kill just the
+      //     newline) so what was the next line takes its place. Don't slurp
+      //     that line's contents.
+      //   - Otherwise, kill the joining newline + the entire next line, so
+      //     ^K from the end of a non-empty line walks down line-by-line.
+      // Single-line behavior is unchanged.
       killToEnd() {
         const line = this.currentLine();
-        const killed = line.slice(this.col);
-        if (killed.length > 0) {
-          this.killBuffer = killed;
+        if (this.col < line.length) {
+          this.killBuffer = line.slice(this.col);
+          this.setCurrentLine(line.slice(0, this.col));
+          return;
+        }
+        if (this.row >= this.buffer.length - 1) {
+          return;
         }
-        this.setCurrentLine(line.slice(0, this.col));
+        if (line.length === 0) {
+          this.killBuffer = "\n";
+          this.buffer.splice(this.row, 1);
+          return;
+        }
+        const next = this.buffer[this.row + 1] ?? "";
+        this.killBuffer = "\n" + next;
+        this.buffer.splice(this.row + 1, 1);
       }
       killWord() {
         const line = this.currentLine();
@@ -8047,6 +8590,44 @@ var init_input = __esm({
           this.col = 0;
         }
       }
+      moveWordBackward() {
+        if (this.col === 0) {
+          if (this.row === 0) {
+            return;
+          }
+          this.row -= 1;
+          this.col = this.currentLine().length;
+          return;
+        }
+        const line = this.currentLine();
+        let i = this.col;
+        while (i > 0 && /\s/.test(line[i - 1] ?? "")) {
+          i -= 1;
+        }
+        while (i > 0 && !/\s/.test(line[i - 1] ?? "")) {
+          i -= 1;
+        }
+        this.col = i;
+      }
+      moveWordForward() {
+        const line = this.currentLine();
+        if (this.col >= line.length) {
+          if (this.row >= this.buffer.length - 1) {
+            return;
+          }
+          this.row += 1;
+          this.col = 0;
+          return;
+        }
+        let i = this.col;
+        while (i < line.length && /\s/.test(line[i] ?? "")) {
+          i += 1;
+        }
+        while (i < line.length && !/\s/.test(line[i] ?? "")) {
+          i += 1;
+        }
+        this.col = i;
+      }
       // Up walks the navigation stack from newest to oldest: pending queue
       // items first (so the user can edit something they just enqueued),
       // then prompt history. Cursor movement within a multi-line buffer
@@ -8310,6 +8891,31 @@ var init_input = __esm({
         this.clearBuffer();
         return [{ type: "send", text, planMode, attachments }];
       }
+      // Shift+Enter: amend the in-flight turn. Editing a queued slot
+      // delegates to the existing queue-edit / queue-remove path — Shift+Enter
+      // there has no special meaning since the entry is already queued (not
+      // running). With an empty draft and no attachments we emit nothing
+      // (no-op). Otherwise emit an "amend" effect; the app decides whether
+      // to route through amend_prompt or fall through to a regular send.
+      amend() {
+        const text = this.bufferText();
+        if (this.queueIndex >= 0 && this.queueIndex < this.queue.length) {
+          const index = this.queueIndex;
+          const attachments2 = [...this.attachments];
+          this.clearBuffer();
+          if (text.trim().length === 0) {
+            return [{ type: "queue-remove", index }];
+          }
+          return [{ type: "queue-edit", index, text, attachments: attachments2 }];
+        }
+        if (text.trim().length === 0 && this.attachments.length === 0) {
+          return [];
+        }
+        const planMode = this.planMode;
+        const attachments = [...this.attachments];
+        this.clearBuffer();
+        return [{ type: "amend", text, planMode, attachments }];
+      }
       // Home: jump to the very start of the prompt buffer. If we're already
       // there, fall through to scrolling the scrollback to its top.
       handleHome() {
@@ -8362,7 +8968,7 @@ var init_input = __esm({
 import { spawn as nodeSpawn } from "child_process";
 import fs18 from "fs/promises";
 import os4 from "os";
-import path12 from "path";
+import path13 from "path";
 async function readClipboard(envIn = {}) {
   const env = { ...defaultEnv, ...envIn };
   if (env.platform === "darwin") {
@@ -8377,7 +8983,7 @@ async function readClipboard(envIn = {}) {
   };
 }
 async function readMacOS(env) {
-  const tmpPath = path12.join(
+  const tmpPath = path13.join(
     env.tmpdir(),
     `hydra-clipboard-${Date.now()}-${process.pid}.png`
   );
@@ -8421,26 +9027,34 @@ async function readLinux(env) {
       reason: "install wl-clipboard (Wayland) or xclip (X11) to paste from the clipboard"
     };
   }
-  try {
-    const buf = await runCapture(env.spawn, tool.cmd, tool.imageArgs);
-    if (buf.length > 0) {
-      if (buf.length > MAX_ATTACHMENT_BYTES) {
+  const targets = await listTargets(env, tool);
+  const imageMime = pickImageTarget(targets);
+  if (imageMime) {
+    try {
+      const buf = await runCapture(
+        env.spawn,
+        tool.cmd,
+        tool.imageArgs(imageMime)
+      );
+      if (buf.length > 0) {
+        if (buf.length > MAX_ATTACHMENT_BYTES) {
+          return {
+            ok: false,
+            reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+          };
+        }
         return {
-          ok: false,
-          reason: `clipboard image is ${formatSize(buf.length)}, max ${formatSize(MAX_ATTACHMENT_BYTES)}`
+          ok: true,
+          kind: "image",
+          attachment: {
+            mimeType: imageMime,
+            data: buf.toString("base64"),
+            sizeBytes: buf.length
+          }
         };
       }
-      return {
-        ok: true,
-        kind: "image",
-        attachment: {
-          mimeType: "image/png",
-          data: buf.toString("base64"),
-          sizeBytes: buf.length
-        }
-      };
+    } catch {
     }
-  } catch {
   }
   try {
     const buf = await runCapture(env.spawn, tool.cmd, tool.textArgs);
@@ -8460,7 +9074,8 @@ async function detectLinuxTool(env) {
   if (env.env.WAYLAND_DISPLAY && await which(env, "wl-paste")) {
     return {
       cmd: "wl-paste",
-      imageArgs: ["-t", "image/png"],
+      listTargetsArgs: ["--list-types"],
+      imageArgs: (mime) => ["-t", mime],
       // -n: drop trailing newline wl-paste adds by default. We further
       // normalize line endings below, but this avoids a spurious
       // empty trailing row from a single-line clipboard text.
@@ -8470,12 +9085,30 @@ async function detectLinuxTool(env) {
   if (env.env.DISPLAY && await which(env, "xclip")) {
     return {
       cmd: "xclip",
-      imageArgs: ["-selection", "clipboard", "-t", "image/png", "-o"],
+      listTargetsArgs: ["-selection", "clipboard", "-t", "TARGETS", "-o"],
+      imageArgs: (mime) => ["-selection", "clipboard", "-t", mime, "-o"],
       textArgs: ["-selection", "clipboard", "-o"]
     };
   }
   return null;
 }
+function pickImageTarget(targets) {
+  const offered = new Set(targets.map((t) => t.toLowerCase()));
+  for (const mime of SUPPORTED_IMAGE_MIMES) {
+    if (offered.has(mime)) {
+      return mime;
+    }
+  }
+  return null;
+}
+async function listTargets(env, tool) {
+  try {
+    const buf = await runCapture(env.spawn, tool.cmd, tool.listTargetsArgs);
+    return buf.toString("utf-8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
 function normalizeText(text) {
   return text.replace(/\r\n?/g, "\n");
 }
@@ -8570,7 +9203,7 @@ function runCapture(spawn6, cmd, args) {
     });
   });
 }
-var defaultEnv;
+var defaultEnv, SUPPORTED_IMAGE_MIMES;
 var init_clipboard = __esm({
   "src/tui/clipboard.ts"() {
     "use strict";
@@ -8581,6 +9214,12 @@ var init_clipboard = __esm({
       spawn: nodeSpawn,
       tmpdir: os4.tmpdir
     };
+    SUPPORTED_IMAGE_MIMES = [
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "image/webp"
+    ];
   }
 });
 
@@ -8721,7 +9360,8 @@ function parseAgentMarkdown(text) {
     codeBuffer = [];
     codeLang = "";
   };
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     const fence = line.match(/^\s*```\s*(\w*)\s*$/);
     if (fence) {
       if (!inCode) {
@@ -8749,6 +9389,19 @@ function parseAgentMarkdown(text) {
       });
       continue;
     }
+    const next = lines[i + 1];
+    if (line.includes("|") && next !== void 0 && isTableSeparatorLine(next) && parseTableRow(line).length === parseTableRow(next).length) {
+      const header = parseTableRow(line);
+      const body = [];
+      let j = i + 2;
+      while (j < lines.length && lines[j].includes("|")) {
+        body.push(parseTableRow(lines[j]));
+        j++;
+      }
+      out.push(...formatTable(header, body));
+      i = j - 1;
+      continue;
+    }
     const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
     if (bullet) {
       const indent = bullet[1] ?? "";
@@ -8783,6 +9436,70 @@ function parseAgentMarkdown(text) {
   }
   return out;
 }
+function parseTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) {
+    s = s.slice(1);
+  }
+  if (s.endsWith("|")) {
+    s = s.slice(0, -1);
+  }
+  return s.split("|").map((c) => c.trim());
+}
+function isTableSeparatorLine(line) {
+  if (!line.includes("|")) {
+    return false;
+  }
+  const cells = parseTableRow(line);
+  if (cells.length === 0) {
+    return false;
+  }
+  return cells.every((c) => /^:?-+:?$/.test(c));
+}
+function formatTable(header, body) {
+  const cols = header.length;
+  const widths = new Array(cols).fill(0);
+  for (let c = 0; c < cols; c++) {
+    widths[c] = header[c]?.length ?? 0;
+  }
+  for (const row of body) {
+    for (let c = 0; c < cols; c++) {
+      const cell = row[c] ?? "";
+      if (cell.length > widths[c]) {
+        widths[c] = cell.length;
+      }
+    }
+  }
+  const renderRow = (cells, style) => {
+    const padded = [];
+    for (let c = 0; c < cols; c++) {
+      const cell = cells[c] ?? "";
+      const w = widths[c];
+      const marked = applyInlineMarkup(cell);
+      padded.push(marked + " ".repeat(Math.max(0, w - cell.length)));
+    }
+    return {
+      prefix: "  ",
+      body: padded.join(" \u2502 "),
+      bodyStyle: style
+    };
+  };
+  const out = [];
+  out.push(renderRow(header, "heading-3"));
+  const rules = [];
+  for (let c = 0; c < cols; c++) {
+    rules.push("\u2500".repeat(widths[c]));
+  }
+  out.push({
+    prefix: "  ",
+    body: rules.join("\u2500\u253C\u2500"),
+    bodyStyle: "dim"
+  });
+  for (const row of body) {
+    out.push(renderRow(row, "agent"));
+  }
+  return out;
+}
 function highlightFencedBlock(lang, lines) {
   if (lang.length === 0 || !supportsLanguage(lang)) {
     return lines.map((body) => ({ body, ansi: false }));
@@ -8981,7 +9698,7 @@ import { appendFileSync, statSync, renameSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 import termkit from "terminal-kit";
 import fs19 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 async function runTuiApp(opts) {
   const config = await loadConfig();
   const serviceToken = await ensureServiceToken();
@@ -9051,6 +9768,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
   };
   let pendingTurns = 0;
+  let currentHeadMessageId;
   let sessionBusySince = null;
   let sessionElapsedTimer = null;
   const adjustPendingTurns = (delta) => {
@@ -9087,14 +9805,27 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   };
   let screenRef = null;
   let dispatcherRef = null;
-  conn.onNotification("session/update", (params) => {
-    if (teardownStarted) {
-      return;
-    }
+  let lastSeenMessageId = void 0;
+  let reconnectReplayBuffer = null;
+  const STATE_UPDATE_KINDS2 = /* @__PURE__ */ new Set([
+    "session_info_update",
+    "current_model_update",
+    "current_mode_update",
+    "available_commands_update",
+    "available_modes_update",
+    "usage_update"
+  ]);
+  const handleSessionUpdate = (params) => {
     const { update } = params ?? {};
     const event = mapUpdate(update);
     debugLogUpdate(update, event);
     const rawTag = update?.sessionUpdate;
+    if (typeof rawTag === "string" && !STATE_UPDATE_KINDS2.has(rawTag)) {
+      const u = update ?? {};
+      if (typeof u.messageId === "string") {
+        lastSeenMessageId = u.messageId;
+      }
+    }
     if (rawTag === "prompt_received") {
       adjustPendingTurns(1);
     } else if (event?.kind === "turn-complete") {
@@ -9106,6 +9837,16 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     appendRender(event);
     maybeDismissPermissionByToolUpdate(update);
+  };
+  conn.onNotification("session/update", (params) => {
+    if (teardownStarted) {
+      return;
+    }
+    if (reconnectReplayBuffer !== null) {
+      reconnectReplayBuffer.push(params);
+      return;
+    }
+    handleSessionUpdate(params);
   });
   conn.onNotification("hydra-acp/session_closed", () => {
     if (teardownStarted) {
@@ -9119,13 +9860,29 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screenRef.setBanner({ status: "cold", elapsedMs: void 0 });
     }
   });
+  const amendPendingPaintTimers = /* @__PURE__ */ new Map();
+  const AMEND_CHIP_DISPLAY_DELAY_MS = 200;
   conn.onNotification("hydra-acp/prompt_queue_added", (params) => {
     if (teardownStarted) return;
     const p = params ?? {};
     if (typeof p.messageId !== "string") return;
-    queueCache.set(p.messageId, chipFromPrompt(p.messageId, p.prompt));
-    if (screenRef && dispatcherRef) {
-      refreshQueueDisplay();
+    const isAmendPending = typeof p._meta?.["hydra-acp"]?.amending === "string";
+    if (isAmendPending) {
+      const mid = p.messageId;
+      const prompt = p.prompt;
+      const timer = setTimeout(() => {
+        amendPendingPaintTimers.delete(mid);
+        queueCache.set(mid, chipFromPrompt(mid, prompt));
+        if (screenRef && dispatcherRef) {
+          refreshQueueDisplay();
+        }
+      }, AMEND_CHIP_DISPLAY_DELAY_MS);
+      amendPendingPaintTimers.set(mid, timer);
+    } else {
+      queueCache.set(p.messageId, chipFromPrompt(p.messageId, p.prompt));
+      if (screenRef && dispatcherRef) {
+        refreshQueueDisplay();
+      }
     }
     if (ownClientId !== void 0 && p.originator?.clientId === ownClientId) {
       const echo = pendingEchoes.shift();
@@ -9170,6 +9927,14 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (teardownStarted) return;
     const p = params ?? {};
     if (typeof p.messageId !== "string") return;
+    if (p.reason === "started") {
+      currentHeadMessageId = p.messageId;
+    }
+    const pendingTimer = amendPendingPaintTimers.get(p.messageId);
+    if (pendingTimer !== void 0) {
+      clearTimeout(pendingTimer);
+      amendPendingPaintTimers.delete(p.messageId);
+    }
     const hadChip = queueCache.delete(p.messageId);
     if (hadChip && screenRef && dispatcherRef) {
       refreshQueueDisplay();
@@ -9184,9 +9949,26 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
           text: echo.text,
           attachments: echo.attachments
         });
+        currentTurnEcho = echo;
       }
     }
   });
+  conn.onNotification("hydra-acp/prompt_amended", (params) => {
+    if (teardownStarted) return;
+    const p = params ?? {};
+    if (typeof p.cancelledMessageId !== "string") return;
+    const cancelledId = p.cancelledMessageId;
+    amendedMessageIds.add(cancelledId);
+    if (currentTurnEcho !== null && currentTurnEcho.messageId !== void 0 && currentTurnEcho.messageId === cancelledId) {
+      appendRender({
+        kind: "turn-complete",
+        stopReason: "cancelled",
+        amended: true
+      });
+      currentTurnEcho = null;
+      amendedMessageIds.delete(cancelledId);
+    }
+  });
   const handlePermissionResolved = (update) => {
     const u = update ?? {};
     const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
@@ -9294,6 +10076,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   let upstreamSessionId;
   let agentInfoName;
   let agentAcceptsImages = true;
+  let daemonSupportsAmend = false;
   try {
     const initResult = await conn.request("initialize", {
       protocolVersion: ACP_PROTOCOL_VERSION,
@@ -9308,6 +10091,8 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     if (imageCap === false) {
       agentAcceptsImages = false;
     }
+    const hydraMeta = extractHydraMeta(initResult?._meta ?? void 0);
+    daemonSupportsAmend = hydraMeta.promptAmending === true;
   } catch {
   }
   let resolvedSessionId = ctx.sessionId;
@@ -9420,6 +10205,9 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         if (exitConfirmation && tryHandleExitConfirmKey(ev)) {
           continue;
         }
+        if (tryHandleHelpKey(ev)) {
+          continue;
+        }
         if (tryHandleScrollbackSearchKey(ev)) {
           continue;
         }
@@ -9705,6 +10493,40 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     return true;
   };
+  const buildHelpEntries = () => {
+    const enqueueDesc = "enqueue prompt (sends now, or queues during a turn)";
+    const amendDesc = "amend the in-flight turn (cancel + replace)";
+    const head = config.tui.defaultEnterAction === "amend" ? [
+      ["Enter", amendDesc],
+      ["Ctrl+Enter / Shift+Enter", enqueueDesc]
+    ] : [
+      ["Enter", enqueueDesc],
+      ["Ctrl+Enter / Shift+Enter", amendDesc]
+    ];
+    return [...head, ...HELP_ENTRIES_TAIL];
+  };
+  const toggleHelpModal = () => {
+    if (screen.isHelpPromptActive()) {
+      screen.setHelpPrompt(null);
+      return;
+    }
+    screen.setHelpPrompt({
+      title: "Hotkeys",
+      entries: buildHelpEntries(),
+      hint: "any key dismisses \xB7 /help lists commands"
+    });
+  };
+  const tryHandleHelpKey = (ev) => {
+    if (!screen.isHelpPromptActive()) {
+      return false;
+    }
+    if (ev.type === "key" && ev.name === "ctrl-g") {
+      screen.setHelpPrompt(null);
+      return true;
+    }
+    screen.setHelpPrompt(null);
+    return true;
+  };
   const teardown = () => {
     teardownStarted = true;
     process.off("SIGINT", sigintHandler);
@@ -9793,7 +10615,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   const handleEffect = (effect) => {
     switch (effect.type) {
       case "send":
-        enqueuePrompt(effect.text, effect.attachments);
+        if (config.tui.defaultEnterAction === "amend") {
+          amendPrompt(effect.text, effect.attachments);
+        } else {
+          enqueuePrompt(effect.text, effect.attachments);
+        }
+        return;
+      case "amend":
+        if (config.tui.defaultEnterAction === "amend") {
+          enqueuePrompt(effect.text, effect.attachments);
+        } else {
+          amendPrompt(effect.text, effect.attachments);
+        }
         return;
       case "queue-edit": {
         const mid = queueMessageIdAt(effect.index);
@@ -9885,6 +10718,9 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         toolsExpanded = !toolsExpanded;
         renderToolsBlock();
         return;
+      case "show-help":
+        toggleHelpModal();
+        return;
       case "escalate-search":
         screen.enterScrollbackSearch();
         screen.updateScrollbackSearchTerm(effect.query);
@@ -9924,7 +10760,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       }
       const mimeType = mimeFromExtension(token);
       if (!mimeType) {
-        screen.notify(`unsupported image type: ${path13.basename(token)}`);
+        screen.notify(`unsupported image type: ${path14.basename(token)}`);
         continue;
       }
       try {
@@ -9938,13 +10774,13 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         dispatcher.addAttachment({
           mimeType,
           data: buf.toString("base64"),
-          name: path13.basename(token),
+          name: path14.basename(token),
           sizeBytes: buf.length
         });
         added++;
       } catch (err) {
         screen.notify(
-          `cannot read ${path13.basename(token)}: ${err.message}`
+          `cannot read ${path14.basename(token)}: ${err.message}`
         );
       }
     }
@@ -9998,6 +10834,8 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   const queueCache = /* @__PURE__ */ new Map();
   const pendingEchoes = [];
   const ownPendingByMid = /* @__PURE__ */ new Map();
+  const amendedMessageIds = /* @__PURE__ */ new Set();
+  let currentTurnEcho = null;
   const refreshQueueDisplay = () => {
     const entries = [...queueCache.values()];
     const displayTexts = entries.map(formatQueueChipText);
@@ -10031,6 +10869,75 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     saveHistory(historyFile, history).catch(() => void 0);
     void runPrompt(text, attachments);
   };
+  const amendPrompt = (text, attachments) => {
+    screen.scrollToBottom();
+    if (handleBuiltinCommand(text)) {
+      return;
+    }
+    history = appendEntry(history, text);
+    dispatcher.setHistory(history);
+    saveHistory(historyFile, history).catch(() => void 0);
+    if (!daemonSupportsAmend || currentHeadMessageId === void 0) {
+      void runPrompt(text, attachments);
+      return;
+    }
+    const target = currentHeadMessageId;
+    const blocks = [];
+    if (text.length > 0) {
+      blocks.push({ type: "text", text });
+    }
+    for (const a of attachments) {
+      blocks.push({ type: "image", data: a.data, mimeType: a.mimeType });
+    }
+    const echo = { text, attachments, flushed: false };
+    pendingEchoes.push(echo);
+    const popEcho = () => {
+      const idx = pendingEchoes.indexOf(echo);
+      if (idx >= 0) {
+        pendingEchoes.splice(idx, 1);
+      }
+      if (echo.messageId !== void 0) {
+        ownPendingByMid.delete(echo.messageId);
+      }
+    };
+    conn.request("hydra-acp/amend_prompt", {
+      sessionId: resolvedSessionId,
+      targetMessageId: target,
+      prompt: blocks
+    }).then((raw) => {
+      const res = raw;
+      if (res.amended && res.reason === "ok") {
+        adjustPendingTurns(1);
+        return;
+      }
+      popEcho();
+      if (res.reason === "target_completed") {
+        screen.notify(
+          "previous response finished \u2014 press Enter to send as a new turn"
+        );
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+      if (res.reason === "target_cancelled") {
+        screen.notify("amend skipped \u2014 previous turn was cancelled");
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+      if (res.reason === "target_not_found") {
+        screen.notify("amend skipped \u2014 no matching prompt");
+        dispatcher.setBuffer(text, attachments);
+        screen.refreshPrompt();
+        return;
+      }
+    }).catch((err) => {
+      popEcho();
+      screen.notify(`amend failed: ${err.message}`);
+      dispatcher.setBuffer(text, attachments);
+      screen.refreshPrompt();
+    });
+  };
   const handleModeToggle = async (_on) => {
     if (agentModes.length === 0) {
       screen.notify("no modes advertised by agent");
@@ -10254,10 +11161,20 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     } finally {
       turnInFlight = null;
       adjustPendingTurns(-1);
-      if (echo.flushed) {
-        appendRender(
-          stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" }
-        );
+      if (echo.flushed && currentTurnEcho === echo) {
+        const wasAmended = echo.messageId !== void 0 && amendedMessageIds.has(echo.messageId);
+        if (wasAmended && echo.messageId !== void 0) {
+          amendedMessageIds.delete(echo.messageId);
+        }
+        const tc = { kind: "turn-complete" };
+        if (stopReason !== void 0) {
+          tc.stopReason = stopReason;
+        }
+        if (wasAmended) {
+          tc.amended = true;
+        }
+        appendRender(tc);
+        currentTurnEcho = null;
       }
       if (pendingPrefill !== null) {
         const { text: pt, attachments: pa } = pendingPrefill;
@@ -10440,6 +11357,11 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     if (event.kind === "user-text") {
       closeAgentText();
+      if (toolsBlockStartedAt !== null) {
+        toolsBlockEndedAt = Date.now();
+        renderToolsBlock();
+      }
+      currentTurnEcho = null;
       screen.ensureSeparator();
       const formatted2 = formatEvent(event);
       if (formatted2.length > 0) {
@@ -10494,8 +11416,10 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screen.appendLines(formatted);
     }
     if (event.kind === "turn-complete") {
+      currentHeadMessageId = void 0;
       closeAgentText();
-      if (lastPlanEvent !== null && event.stopReason !== void 0 && event.stopReason !== "end_turn") {
+      const effectiveStopReason = event.amended ? "amended" : event.stopReason;
+      if (lastPlanEvent !== null && effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
         const lines = formatEvent({ ...lastPlanEvent, stopped: true });
         if (lines.length > 0) {
           screen.upsertLines("plan", lines);
@@ -10505,9 +11429,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screen.clearKey("plan");
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
-        toolsBlockStopReason = event.stopReason ?? null;
+        toolsBlockStopReason = effectiveStopReason ?? null;
         renderToolsBlock();
         screen.clearKey("tools");
+      } else if (effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
+        screen.appendLines([
+          {
+            prefix: "\u26A0 ",
+            prefixStyle: "tool-status-fail",
+            body: `turn ended: ${effectiveStopReason}`,
+            bodyStyle: "tool-status-fail"
+          }
+        ]);
       }
       toolStates.clear();
       toolCallOrder.length = 0;
@@ -10555,23 +11488,21 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       resolve5({ outcome: { outcome: "cancelled" } });
     }
     closeAgentText();
-    if (toolsBlockStartedAt !== null) {
-      toolsBlockEndedAt = Date.now();
-      toolsBlockStopReason = null;
-      renderToolsBlock();
-      screen.clearKey("tools");
-      toolStates.clear();
-      toolCallOrder.length = 0;
-      toolsBlockStartedAt = null;
-      toolsBlockEndedAt = null;
-      toolsBlockStopReason = null;
-      toolsExpanded = false;
-    }
-    screen.clearKey("plan");
-    lastPlanEvent = null;
-    if (pendingTurns > 0) {
-      adjustPendingTurns(-pendingTurns);
+  };
+  const markToolsBlockRecoveryFailed = () => {
+    if (toolsBlockStartedAt === null) {
+      return;
     }
+    toolsBlockEndedAt = Date.now();
+    toolsBlockStopReason = "reconnect-recovery-failed";
+    renderToolsBlock();
+    screen.clearKey("tools");
+    toolStates.clear();
+    toolCallOrder.length = 0;
+    toolsBlockStartedAt = null;
+    toolsBlockEndedAt = null;
+    toolsBlockStopReason = null;
+    toolsExpanded = false;
   };
   onDisconnectHook = () => {
     screen.setBanner({ status: "disconnected", elapsedMs: void 0 });
@@ -10595,13 +11526,15 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       await stream.request(initReq);
     } catch {
     }
+    const useAfterMessage = lastSeenMessageId !== void 0;
     const attachReq = {
       jsonrpc: "2.0",
       id: `tui-reattach-${nanoid3()}`,
       method: "session/attach",
       params: {
         sessionId: resolvedSessionId,
-        historyPolicy: "none",
+        historyPolicy: useAfterMessage ? "after_message" : "none",
+        ...useAfterMessage ? { afterMessageId: lastSeenMessageId } : {},
         clientInfo: { name: "hydra-acp-tui", version: HYDRA_VERSION },
         ...upstreamSessionId !== void 0 ? {
           _meta: {
@@ -10616,19 +11549,46 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
         } : {}
       }
     };
+    reconnectReplayBuffer = [];
+    let appliedPolicy;
+    let attachErr;
     try {
       const resp = await stream.request(attachReq);
       if (resp.error) {
         throw new Error(resp.error.message);
       }
+      const result = resp.result ?? {};
+      if (typeof result.historyPolicy === "string") {
+        appliedPolicy = result.historyPolicy;
+      }
     } catch (err) {
+      attachErr = err;
+    }
+    const buffered2 = reconnectReplayBuffer ?? [];
+    reconnectReplayBuffer = null;
+    if (attachErr) {
+      markToolsBlockRecoveryFailed();
       screen.appendLines([
         {
           prefix: "  ",
-          body: `reattach failed: ${err.message}`,
+          body: `reattach failed: ${attachErr.message}`,
+          bodyStyle: "tool-status-fail"
+        }
+      ]);
+    } else if (useAfterMessage && appliedPolicy !== "after_message") {
+      markToolsBlockRecoveryFailed();
+      screen.appendLines([
+        {
+          prefix: "\u26A0 ",
+          prefixStyle: "tool-status-fail",
+          body: "reconnect couldn't replay events since last seen \u2014 scrollback may be incomplete",
           bodyStyle: "tool-status-fail"
         }
       ]);
+    } else {
+      for (const params of buffered2) {
+        handleSessionUpdate(params);
+      }
     }
     screen.setBanner({
       status: pendingTurns > 0 ? "busy" : "ready",
@@ -10735,7 +11695,7 @@ function rotateIfBig(target) {
   } catch {
   }
 }
-var logMaxBytes;
+var HELP_ENTRIES_TAIL, logMaxBytes;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -10759,6 +11719,33 @@ var init_app = __esm({
     init_completion();
     init_render_update();
     init_format();
+    HELP_ENTRIES_TAIL = [
+      ["Alt+Enter", "newline in prompt"],
+      ["Shift+Tab", "cycle agent modes (plan / accept-edits / etc.)"],
+      ["Tab", "indent \xB7 slash-command completion"],
+      null,
+      ["\u2191 / \u2193", "prompt history \xB7 queue navigation"],
+      ["\u2190/\u2192 Home/End", "cursor movement"],
+      ["Alt+B / Alt+F", "word back / forward"],
+      ["^A / ^E", "line start / end"],
+      ["^W / ^U / ^K", "kill word / line / to end"],
+      ["^Y", "yank last kill"],
+      null,
+      ["^P", "switch session (picker)"],
+      ["^T", "next live session"],
+      ["^V", "paste image from clipboard"],
+      ["^O", "expand / collapse tools block"],
+      null,
+      ["^R / ^S", "history reverse / forward search"],
+      ["PgUp / PgDn", "scroll scrollback"],
+      ["Mouse wheel", "scroll scrollback (when mouse capture is on)"],
+      null,
+      ["^C", "cancel turn (twice to exit)"],
+      ["Esc", "cancel turn and prefill draft"],
+      ["^D", "exit (or delete-forward in prompt)"],
+      ["^L", "force full redraw"],
+      ["^G", "toggle this help"]
+    ];
     logMaxBytes = 5 * 1024 * 1024;
   }
 });
@@ -10891,13 +11878,13 @@ New token: ${newToken}
 init_paths();
 init_config();
 init_service_token();
-import * as fsp6 from "fs/promises";
+import * as fsp7 from "fs/promises";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/daemon/server.ts
 init_config();
 import * as fs15 from "fs";
-import * as fsp4 from "fs/promises";
+import * as fsp5 from "fs/promises";
 import Fastify from "fastify";
 import websocketPlugin from "@fastify/websocket";
 import pino from "pino";
@@ -11284,10 +12271,12 @@ var RegistryDocument = z2.object({
   extensions: z2.array(z2.unknown()).optional()
 });
 var Registry = class {
-  constructor(config) {
+  constructor(config, options = {}) {
     this.config = config;
+    this.options = options;
   }
   config;
+  options;
   cache;
   async load() {
     if (this.cache && this.isFresh(this.cache.fetchedAt)) {
@@ -11337,7 +12326,12 @@ var Registry = class {
     }
     const raw = await response.json();
     const data = RegistryDocument.parse(raw);
-    return { fetchedAt: Date.now(), raw, data };
+    const cached2 = { fetchedAt: Date.now(), raw, data };
+    const hook = this.options.onFetched;
+    if (hook) {
+      void Promise.resolve().then(() => hook(data)).catch(() => void 0);
+    }
+    return cached2;
   }
   async readDiskCache() {
     let text;
@@ -11399,6 +12393,7 @@ function npxPackageBasename(agent) {
   return atIdx <= 0 ? afterSlash : afterSlash.slice(0, atIdx);
 }
 async function planSpawn(agent, callerArgs = [], options = {}) {
+  const version = agent.version ?? "current";
   if (agent.distribution.npx) {
     const npx = agent.distribution.npx;
     const tail = callerArgs.length > 0 ? callerArgs : npx.args ?? [];
@@ -11406,13 +12401,14 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
       return {
         command: "npx",
         args: ["-y", npx.package, ...tail],
-        env: npx.env ?? {}
+        env: npx.env ?? {},
+        version
       };
     }
     const bin = npx.bin ?? npxPackageBasename(agent) ?? npx.package;
     const binPath = await ensureNpmPackage({
       agentId: agent.id,
-      version: agent.version ?? "current",
+      version,
       packageSpec: npx.package,
       bin,
       registry: options.npmRegistry
@@ -11420,7 +12416,8 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     return {
       command: binPath,
       args: tail,
-      env: npx.env ?? {}
+      env: npx.env ?? {},
+      version
     };
   }
   if (agent.distribution.binary) {
@@ -11432,14 +12429,15 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     }
     const cmdPath = await ensureBinary({
       agentId: agent.id,
-      version: agent.version ?? "current",
+      version,
       target
     });
     const tail = callerArgs.length > 0 ? callerArgs : target.args ?? [];
     return {
       command: cmdPath,
       args: tail,
-      env: target.env ?? {}
+      env: target.env ?? {},
+      version
     };
   }
   if (agent.distribution.uvx) {
@@ -11448,7 +12446,8 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     return {
       command: "uvx",
       args: [uvx.package, ...tail],
-      env: uvx.env ?? {}
+      env: uvx.env ?? {},
+      version
     };
   }
   throw new Error(`Agent ${agent.id} has no usable distribution method.`);
@@ -11539,6 +12538,9 @@ init_connection();
 var DEFAULT_STDERR_TAIL_BYTES = 4096;
 var AgentInstance = class _AgentInstance {
   agentId;
+  // Version this process was spawned from — used by the registry-fetch
+  // prune sweep to skip install dirs belonging to a live agent.
+  version;
   cwd;
   connection;
   child;
@@ -11550,6 +12552,7 @@ var AgentInstance = class _AgentInstance {
   exitHandlers = [];
   constructor(opts, child) {
     this.agentId = opts.agentId;
+    this.version = opts.plan.version;
     this.cwd = opts.cwd;
     this.child = child;
     this.stderrTailBytes = opts.stderrTailBytes ?? DEFAULT_STDERR_TAIL_BYTES;
@@ -12213,6 +13216,23 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  // Snapshot of which agent versions are currently in use by live
+  // sessions, keyed by agentId. Read by the registry-fetch prune sweep
+  // so it can skip install dirs that still back a running process.
+  activeAgentVersions() {
+    const out = /* @__PURE__ */ new Map();
+    for (const session of this.sessions.values()) {
+      const id = session.agent.agentId;
+      const version = session.agent.version;
+      let set = out.get(id);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        out.set(id, set);
+      }
+      set.add(version);
+    }
+    return out;
+  }
   // Resolve a user-typed session id (which may have the hydra_session_
   // prefix stripped — that's what `sessions list` and the picker show) to
   // the canonical form that actually exists. Tries the input as-given
@@ -13189,12 +14209,91 @@ function withCode2(err, code) {
 
 // src/daemon/server.ts
 init_paths();
+
+// src/core/agent-prune.ts
+init_paths();
+import * as fsp4 from "fs/promises";
+import * as path8 from "path";
+var logSink3 = (msg) => {
+  process.stderr.write(msg + "\n");
+};
+function setAgentPruneLogger(log) {
+  logSink3 = log ?? ((msg) => process.stderr.write(msg + "\n"));
+}
+async function pruneStaleAgentVersions(registry, sessionManager) {
+  const platformKey = currentPlatformKey();
+  if (!platformKey) {
+    return;
+  }
+  const doc = await registry.load();
+  const desiredByAgent = /* @__PURE__ */ new Map();
+  for (const a of doc.agents) {
+    desiredByAgent.set(a.id, a.version ?? "current");
+  }
+  const activeByAgent = sessionManager.activeAgentVersions();
+  const platformDir = path8.join(paths.agentsDir(), platformKey);
+  let agentEntries;
+  try {
+    agentEntries = await fsp4.readdir(platformDir, { withFileTypes: true });
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return;
+    }
+    logSink3(`hydra-acp: prune: failed to read ${platformDir}: ${e.message}`);
+    return;
+  }
+  for (const agentEntry of agentEntries) {
+    if (!agentEntry.isDirectory()) {
+      continue;
+    }
+    const agentId = agentEntry.name;
+    const desired = desiredByAgent.get(agentId);
+    if (desired === void 0) {
+      continue;
+    }
+    const activeVersions = activeByAgent.get(agentId) ?? /* @__PURE__ */ new Set();
+    const agentDir = path8.join(platformDir, agentId);
+    let versionEntries;
+    try {
+      versionEntries = await fsp4.readdir(agentDir, { withFileTypes: true });
+    } catch (err) {
+      logSink3(
+        `hydra-acp: prune: failed to read ${agentDir}: ${err.message}`
+      );
+      continue;
+    }
+    for (const versionEntry of versionEntries) {
+      if (!versionEntry.isDirectory()) {
+        continue;
+      }
+      const version = versionEntry.name;
+      if (version === desired) {
+        continue;
+      }
+      if (activeVersions.has(version)) {
+        continue;
+      }
+      const versionDir = path8.join(agentDir, version);
+      try {
+        await fsp4.rm(versionDir, { recursive: true, force: true });
+        logSink3(`hydra-acp: pruned stale ${agentId} ${version} (${versionDir})`);
+      } catch (err) {
+        logSink3(
+          `hydra-acp: prune: failed to remove ${versionDir}: ${err.message}`
+        );
+      }
+    }
+  }
+}
+
+// src/daemon/server.ts
 init_hydra_version();
 
 // src/core/session-tokens.ts
 init_paths();
 import * as fs13 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 var TOKEN_PREFIX = "hydra_session_";
 var DEFAULT_TTL_SEC = 60 * 60 * 24 * 30;
@@ -13202,7 +14301,7 @@ var ID_LENGTH = 12;
 var TOKEN_BYTES = 32;
 var WRITE_DEBOUNCE_MS = 50;
 function tokensFilePath() {
-  return path8.join(paths.home(), "session-tokens.json");
+  return path9.join(paths.home(), "session-tokens.json");
 }
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -13872,12 +14971,12 @@ import { z as z6 } from "zod";
 // src/core/password.ts
 init_paths();
 import * as fs14 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 import { randomBytes as randomBytes2, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { promisify } from "util";
 var scryptAsync = promisify(scrypt);
 function passwordHashPath() {
-  return path9.join(paths.home(), "password-hash");
+  return path10.join(paths.home(), "password-hash");
 }
 var DEFAULT_N = 1 << 15;
 var DEFAULT_R = 8;
@@ -14292,6 +15391,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;
@@ -14444,10 +15559,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) {
@@ -14464,10 +15586,10 @@ function bindClientToSession(connection, session, state, clientInfo, callerClien
 async function startDaemon(config, serviceToken) {
   ensureLoopbackOrTls(config);
   const httpsOptions = config.daemon.tls ? {
-    key: await fsp4.readFile(config.daemon.tls.key),
-    cert: await fsp4.readFile(config.daemon.tls.cert)
+    key: await fsp5.readFile(config.daemon.tls.key),
+    cert: await fsp5.readFile(config.daemon.tls.cert)
   } : void 0;
-  await fsp4.mkdir(paths.home(), { recursive: true });
+  await fsp5.mkdir(paths.home(), { recursive: true });
   const { stream: logStream, fileStream } = await buildLogStream(
     config.daemon.logLevel
   );
@@ -14511,7 +15633,12 @@ async function startDaemon(config, serviceToken) {
     5 * 60 * 1e3
   );
   sweepInterval.unref();
-  const registry = new Registry(config);
+  const registry = new Registry(config, {
+    onFetched: () => {
+      void pruneStaleAgentVersions(registry, manager);
+    }
+  });
+  setAgentPruneLogger((msg) => app.log.info(msg));
   const agentLogger = {
     info: (msg) => app.log.info(msg),
     warn: (msg) => app.log.warn(msg)
@@ -14552,8 +15679,8 @@ async function startDaemon(config, serviceToken) {
   await app.listen({ host: config.daemon.host, port: config.daemon.port });
   const address = app.server.address();
   const boundPort = address && typeof address === "object" ? address.port : config.daemon.port;
-  await fsp4.mkdir(paths.home(), { recursive: true });
-  await fsp4.writeFile(
+  await fsp5.mkdir(paths.home(), { recursive: true });
+  await fsp5.writeFile(
     paths.pidFile(),
     JSON.stringify({
       pid: process.pid,
@@ -14587,6 +15714,7 @@ async function startDaemon(config, serviceToken) {
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
     setNpmInstallLogger(null);
+    setAgentPruneLogger(null);
     await app.close();
     try {
       fs15.unlinkSync(paths.pidFile());
@@ -14629,12 +15757,12 @@ init_daemon_bootstrap();
 
 // src/cli/commands/log-tail.ts
 import * as fs16 from "fs";
-import * as fsp5 from "fs/promises";
+import * as fsp6 from "fs/promises";
 async function runLogTail(logPath, argv, notFoundMessage) {
   const opts = parseLogTailFlags(argv);
   let stat4;
   try {
-    stat4 = await fsp5.stat(logPath);
+    stat4 = await fsp6.stat(logPath);
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -14660,14 +15788,14 @@ async function runLogTail(logPath, argv, notFoundMessage) {
     setImmediate(async () => {
       pending = false;
       try {
-        const s = await fsp5.stat(logPath);
+        const s = await fsp6.stat(logPath);
         if (s.size <= position) {
           if (s.size < position) {
             position = s.size;
           }
           return;
         }
-        const fd = await fsp5.open(logPath, "r");
+        const fd = await fsp6.open(logPath, "r");
         try {
           const buf = Buffer.alloc(s.size - position);
           await fd.read(buf, 0, buf.length, position);
@@ -14694,7 +15822,7 @@ async function printTail(logPath, fileSize, lines) {
     return fileSize;
   }
   const CHUNK = 64 * 1024;
-  const fd = await fsp5.open(logPath, "r");
+  const fd = await fsp6.open(logPath, "r");
   try {
     let position = fileSize;
     let collected = "";
@@ -14866,7 +15994,7 @@ async function runDaemonStatus() {
 }
 async function readPidFile() {
   try {
-    const raw = await fsp6.readFile(paths.pidFile(), "utf8");
+    const raw = await fsp7.readFile(paths.pidFile(), "utf8");
     return JSON.parse(raw);
   } catch (err) {
     const e = err;
@@ -14892,7 +16020,7 @@ init_sessions();
 init_config();
 init_service_token();
 init_paths();
-import * as fsp7 from "fs/promises";
+import * as fsp8 from "fs/promises";
 init_sessions();
 async function runExtensionsList() {
   const config = await loadConfig();
@@ -15091,11 +16219,11 @@ async function runExtensionsRemove(name) {
   }
 }
 async function readRawConfig() {
-  const raw = await fsp7.readFile(paths.config(), "utf8");
+  const raw = await fsp8.readFile(paths.config(), "utf8");
   return JSON.parse(raw);
 }
 async function writeRawConfig(raw) {
-  await fsp7.writeFile(
+  await fsp8.writeFile(
     paths.config(),
     JSON.stringify(raw, null, 2) + "\n",
     { encoding: "utf8", mode: 384 }