@hydra-acp/cli 0.1.24 → 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") {
@@ -5947,6 +6255,12 @@ function mapKeyName(name) {
     case "ALT_ENTER":
     case "META_ENTER":
       return "alt-enter";
+    case "SHIFT_ENTER":
+      return "shift-enter";
+    case "CTRL_ENTER":
+      return "ctrl-enter";
+    case "CTRL_J":
+      return "ctrl-enter";
     case "ALT_B":
     case "META_B":
       return "alt-b";
@@ -6216,12 +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;
@@ -6232,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;
@@ -6244,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) {
@@ -7944,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 [];
@@ -8130,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;
         }
-        this.setCurrentLine(line.slice(0, this.col));
+        if (this.row >= this.buffer.length - 1) {
+          return;
+        }
+        if (line.length === 0) {
+          this.killBuffer = "\n";
+          this.buffer.splice(this.row, 1);
+          return;
+        }
+        const next = this.buffer[this.row + 1] ?? "";
+        this.killBuffer = "\n" + next;
+        this.buffer.splice(this.row + 1, 1);
       }
       killWord() {
         const line = this.currentLine();
@@ -8494,6 +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() {
@@ -8605,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);
@@ -8644,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.
@@ -8654,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");
 }
@@ -8754,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";
@@ -8765,6 +9214,12 @@ var init_clipboard = __esm({
       spawn: nodeSpawn,
       tmpdir: os4.tmpdir
     };
+    SUPPORTED_IMAGE_MIMES = [
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "image/webp"
+    ];
   }
 });
 
@@ -8905,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) {
@@ -8933,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] ?? "";
@@ -8967,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 }));
@@ -9235,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) => {
@@ -9326,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();
@@ -9377,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();
@@ -9395,6 +9953,22 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       }
     }
   });
+  conn.onNotification("hydra-acp/prompt_amended", (params) => {
+    if (teardownStarted) return;
+    const p = params ?? {};
+    if (typeof p.cancelledMessageId !== "string") return;
+    const cancelledId = p.cancelledMessageId;
+    amendedMessageIds.add(cancelledId);
+    if (currentTurnEcho !== null && currentTurnEcho.messageId !== void 0 && currentTurnEcho.messageId === cancelledId) {
+      appendRender({
+        kind: "turn-complete",
+        stopReason: "cancelled",
+        amended: true
+      });
+      currentTurnEcho = null;
+      amendedMessageIds.delete(cancelledId);
+    }
+  });
   const handlePermissionResolved = (update) => {
     const u = update ?? {};
     const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
@@ -9502,6 +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,
@@ -9516,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;
@@ -9916,6 +10493,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     return true;
   };
+  const buildHelpEntries = () => {
+    const enqueueDesc = "enqueue prompt (sends now, or queues during a turn)";
+    const amendDesc = "amend the in-flight turn (cancel + replace)";
+    const head = config.tui.defaultEnterAction === "amend" ? [
+      ["Enter", amendDesc],
+      ["Ctrl+Enter / Shift+Enter", enqueueDesc]
+    ] : [
+      ["Enter", enqueueDesc],
+      ["Ctrl+Enter / Shift+Enter", amendDesc]
+    ];
+    return [...head, ...HELP_ENTRIES_TAIL];
+  };
   const toggleHelpModal = () => {
     if (screen.isHelpPromptActive()) {
       screen.setHelpPrompt(null);
@@ -9923,7 +10512,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
     }
     screen.setHelpPrompt({
       title: "Hotkeys",
-      entries: HELP_ENTRIES2,
+      entries: buildHelpEntries(),
       hint: "any key dismisses \xB7 /help lists commands"
     });
   };
@@ -10026,7 +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);
@@ -10234,6 +10834,7 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
   const queueCache = /* @__PURE__ */ new Map();
   const pendingEchoes = [];
   const ownPendingByMid = /* @__PURE__ */ new Map();
+  const amendedMessageIds = /* @__PURE__ */ new Set();
   let currentTurnEcho = null;
   const refreshQueueDisplay = () => {
     const entries = [...queueCache.values()];
@@ -10268,6 +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");
@@ -10492,9 +11162,18 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       turnInFlight = null;
       adjustPendingTurns(-1);
       if (echo.flushed && currentTurnEcho === echo) {
-        appendRender(
-          stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" }
-        );
+        const wasAmended = echo.messageId !== void 0 && amendedMessageIds.has(echo.messageId);
+        if (wasAmended && echo.messageId !== void 0) {
+          amendedMessageIds.delete(echo.messageId);
+        }
+        const tc = { kind: "turn-complete" };
+        if (stopReason !== void 0) {
+          tc.stopReason = stopReason;
+        }
+        if (wasAmended) {
+          tc.amended = true;
+        }
+        appendRender(tc);
         currentTurnEcho = null;
       }
       if (pendingPrefill !== null) {
@@ -10737,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);
@@ -10748,15 +11429,15 @@ async function runSession(term, config, serviceToken, opts, exitHint) {
       screen.clearKey("plan");
       if (toolsBlockStartedAt !== null) {
         toolsBlockEndedAt = Date.now();
-        toolsBlockStopReason = event.stopReason ?? null;
+        toolsBlockStopReason = effectiveStopReason ?? null;
         renderToolsBlock();
         screen.clearKey("tools");
-      } else if (event.stopReason !== void 0 && event.stopReason !== "end_turn") {
+      } else if (effectiveStopReason !== void 0 && effectiveStopReason !== "end_turn") {
         screen.appendLines([
           {
             prefix: "\u26A0 ",
             prefixStyle: "tool-status-fail",
-            body: `turn ended: ${event.stopReason}`,
+            body: `turn ended: ${effectiveStopReason}`,
             bodyStyle: "tool-status-fail"
           }
         ]);
@@ -11014,7 +11695,7 @@ function rotateIfBig(target) {
   } catch {
   }
 }
-var HELP_ENTRIES2, logMaxBytes;
+var HELP_ENTRIES_TAIL, logMaxBytes;
 var init_app = __esm({
   "src/tui/app.ts"() {
     "use strict";
@@ -11038,8 +11719,7 @@ var init_app = __esm({
     init_completion();
     init_render_update();
     init_format();
-    HELP_ENTRIES2 = [
-      ["Enter", "send prompt (or queue while a turn is running)"],
+    HELP_ENTRIES_TAIL = [
       ["Alt+Enter", "newline in prompt"],
       ["Shift+Tab", "cycle agent modes (plan / accept-edits / etc.)"],
       ["Tab", "indent \xB7 slash-command completion"],
@@ -14711,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;
@@ -14863,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) {