@hydra-acp/cli 0.1.23 → 0.1.25

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/daemon/server.ts
 import * as fs14 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";
@@ -186,7 +186,15 @@ var TuiConfig = z.object({
   // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
   // running. Set false if your terminal renders this obnoxiously or you
   // just don't want it.
-  progressIndicator: z.boolean().default(true)
+  progressIndicator: z.boolean().default(true),
+  // What the unmodified Enter key does in the prompt composer.
+  //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
+  //     when idle, queues behind an in-flight turn); Shift+Enter amends
+  //     the in-flight turn.
+  //   "amend" — flips the two: Enter amends the in-flight turn,
+  //     Shift+Enter enqueues. With no turn in flight either key just
+  //     enqueues, since there's nothing to amend.
+  defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -230,7 +238,8 @@ var HydraConfig = z.object({
     mouse: true,
     logMaxBytes: 5 * 1024 * 1024,
     cwdColumnMaxWidth: 24,
-    progressIndicator: true
+    progressIndicator: true,
+    defaultEnterAction: "enqueue"
   })
 });
 function extensionList(config) {
@@ -693,10 +702,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)) {
@@ -746,7 +757,12 @@ var Registry = class {
     }
     const raw = await response.json();
     const data = RegistryDocument.parse(raw);
-    return { fetchedAt: Date.now(), raw, data };
+    const cached = { fetchedAt: Date.now(), raw, data };
+    const hook = this.options.onFetched;
+    if (hook) {
+      void Promise.resolve().then(() => hook(data)).catch(() => void 0);
+    }
+    return cached;
   }
   async readDiskCache() {
     let text;
@@ -808,6 +824,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 ?? [];
@@ -815,13 +832,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
@@ -829,7 +847,8 @@ async function planSpawn(agent, callerArgs = [], options = {}) {
     return {
       command: binPath,
       args: tail,
-      env: npx.env ?? {}
+      env: npx.env ?? {},
+      version
     };
   }
   if (agent.distribution.binary) {
@@ -841,14 +860,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) {
@@ -857,7 +877,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.`);
@@ -1012,6 +1033,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) {
@@ -1156,6 +1189,34 @@ var UpdatePromptResult = z3.object({
   updated: z3.boolean(),
   reason: z3.enum(["ok", "not_found", "already_running"])
 });
+var AmendPromptParams = z3.object({
+  sessionId: z3.string(),
+  targetMessageId: z3.string(),
+  prompt: z3.array(z3.unknown()),
+  replaceQueue: z3.boolean().optional(),
+  onTargetCompleted: z3.enum(["reject", "send_anyway"]).optional()
+});
+var AmendPromptResult = z3.object({
+  amended: z3.boolean(),
+  reason: z3.enum([
+    "ok",
+    "target_completed",
+    "target_cancelled",
+    "target_not_found"
+  ]),
+  // Present when a prompt was sent or replaced: the amendment's id on
+  // success, or the regular follow-up's id when onTargetCompleted is
+  // "send_anyway" and the daemon forwarded the prompt anyway.
+  messageId: z3.string().optional()
+});
+var PromptAmendedParams = z3.object({
+  sessionId: z3.string(),
+  cancelledMessageId: z3.string(),
+  newMessageId: z3.string(),
+  prompt: z3.array(z3.unknown()),
+  originator: PromptOriginatorSchema,
+  amendedAt: z3.number()
+});
 var ProxyInitializeParams = z3.object({
   protocolVersion: z3.number().optional(),
   proxyInfo: z3.object({
@@ -1443,6 +1504,9 @@ var JsonRpcConnection = class _JsonRpcConnection {
 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;
@@ -1454,6 +1518,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;
@@ -1630,6 +1695,7 @@ function stripHydraSessionPrefix(id) {
   return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
 }
 var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
+var RECENTLY_TERMINAL_LIMIT = 64;
 var Session = class {
   sessionId;
   cwd;
@@ -1729,6 +1795,20 @@ var Session = class {
   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;
@@ -2158,7 +2238,7 @@ var Session = class {
       );
     }
   }
-  broadcastTurnComplete(originatorClientId, response) {
+  broadcastTurnComplete(originatorClientId, response, promptMessageId, wasAmend) {
     const stopReason = response && typeof response === "object" && "stopReason" in response && typeof response.stopReason === "string" ? response.stopReason : void 0;
     const update = {
       sessionUpdate: "turn_complete",
@@ -2167,15 +2247,83 @@ var Session = class {
     if (stopReason !== void 0) {
       update.stopReason = stopReason;
     }
+    const amend = this.amendInProgress;
+    if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+      update._meta = {
+        "hydra-acp": {
+          amended: {
+            cancelledMessageId: amend.cancelledMessageId,
+            newMessageId: amend.newMessageId
+          }
+        }
+      };
+    }
     this.promptStartedAt = void 0;
+    if (promptMessageId !== void 0 && stopReason !== void 0) {
+      this.recordTerminal(promptMessageId, stopReason);
+    }
     this.recordAndBroadcast(
       "session/update",
       {
         sessionId: this.sessionId,
         update
       },
-      originatorClientId
+      wasAmend ? void 0 : originatorClientId
     );
+    if (amend && promptMessageId !== void 0 && amend.cancelledMessageId === promptMessageId) {
+      this.broadcastPromptAmended(amend);
+    }
+  }
+  // Record that a prompt's turn has ended, with its terminal stopReason.
+  // Used by amendPrompt to resolve targetMessageIds that completed/cancelled
+  // before the amend arrived. LRU-trimmed at RECENTLY_TERMINAL_LIMIT.
+  recordTerminal(messageId, stopReason) {
+    this.recentlyTerminal.set(messageId, {
+      stopReason,
+      terminatedAt: Date.now()
+    });
+    while (this.recentlyTerminal.size > RECENTLY_TERMINAL_LIMIT) {
+      const oldest = this.recentlyTerminal.keys().next().value;
+      if (oldest === void 0) {
+        break;
+      }
+      this.recentlyTerminal.delete(oldest);
+    }
+  }
+  // Fire hydra-acp/prompt_amended for the M1→M2 linkage. The amendment's
+  // current content is read live from the queue entry so any update_prompt
+  // calls during the amend window are reflected. Best-effort: if M2 has
+  // already been cancelled out of the queue by the time we get here, we
+  // skip — the amendInProgress clearing in cancelQueuedPrompt should have
+  // prevented this code path from running in that case.
+  broadcastPromptAmended(amend) {
+    const entry = this.findUserEntry(amend.newMessageId);
+    if (!entry) {
+      return;
+    }
+    const params = {
+      sessionId: this.sessionId,
+      cancelledMessageId: amend.cancelledMessageId,
+      newMessageId: amend.newMessageId,
+      prompt: entry.prompt,
+      originator: entry.originator,
+      amendedAt: Date.now()
+    };
+    this.broadcastQueueNotification(
+      "hydra-acp/prompt_amended",
+      params
+    );
+  }
+  // Look up a user-prompt queue entry by messageId, searching both the
+  // currentEntry slot and the waiting queue.
+  findUserEntry(messageId) {
+    if (this.currentEntry?.messageId === messageId && this.currentEntry.kind === "user") {
+      return this.currentEntry;
+    }
+    const queued = this.promptQueue.find(
+      (e) => e.messageId === messageId && e.kind === "user"
+    );
+    return queued?.kind === "user" ? queued : void 0;
   }
   // Total visible-or-running entries: the in-flight head (if any) plus
   // the queue's user-visible waiting entries. Internal entries don't
@@ -2188,9 +2336,9 @@ var Session = class {
     }
     return count;
   }
-  broadcastQueueAdded(entry) {
+  broadcastQueueAdded(entry, options) {
     const depth = this.visibleQueueDepth();
-    const position = Math.max(0, depth - 1);
+    const position = options?.position ?? Math.max(0, depth - 1);
     const params = {
       sessionId: this.sessionId,
       messageId: entry.messageId,
@@ -2200,6 +2348,11 @@ var Session = class {
       queueDepth: depth,
       enqueuedAt: entry.enqueuedAt
     };
+    if (options?.amending !== void 0) {
+      params._meta = {
+        "hydra-acp": { amending: options.amending }
+      };
+    }
     this.broadcastQueueNotification("hydra-acp/prompt_queue_added", params);
   }
   broadcastQueueUpdated(messageId, prompt) {
@@ -2322,6 +2475,9 @@ var Session = class {
       this.broadcastQueueRemoved(messageId, "cancelled");
       this.persistRewrite();
     }
+    if (this.amendInProgress?.newMessageId === messageId) {
+      this.amendInProgress = void 0;
+    }
     entry.resolve({ stopReason: "cancelled" });
     return { cancelled: true, reason: "ok" };
   }
@@ -2343,6 +2499,143 @@ var Session = class {
     this.persistRewrite();
     return { updated: true, reason: "ok" };
   }
+  // Amend the head prompt: cancel the in-flight turn and submit a
+  // replacement that sits at the head of the queue. Resolves the
+  // request immediately (the caller doesn't wait on cancel-settle).
+  // Honours race outcomes — if the target finished or was cancelled
+  // before this arrived, the request resolves with an outcome explaining
+  // why and (depending on onTargetCompleted) optionally forwards as a
+  // plain prompt. Queued targets are edited in place (same machinery
+  // as updateQueuedPrompt).
+  amendPrompt(clientId, params) {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      throw withCode(
+        new Error("client not attached"),
+        JsonRpcErrorCodes.SessionNotFound
+      );
+    }
+    const { targetMessageId, prompt, replaceQueue, onTargetCompleted } = params;
+    if (this.currentEntry?.messageId === targetMessageId && this.currentEntry.kind === "user" && !this.currentEntry.cancelled && this.amendInProgress === void 0) {
+      return this.amendOnHead(client, prompt, targetMessageId, replaceQueue);
+    }
+    const queuedEntry = this.promptQueue.find(
+      (e) => e.messageId === targetMessageId && e.kind === "user"
+    );
+    if (queuedEntry && queuedEntry.kind === "user" && !queuedEntry.cancelled) {
+      queuedEntry.prompt = prompt;
+      this.broadcastQueueUpdated(targetMessageId, prompt);
+      this.persistRewrite();
+      return { amended: true, reason: "ok", messageId: targetMessageId };
+    }
+    const terminal = this.recentlyTerminal.get(targetMessageId);
+    if (terminal) {
+      if (terminal.stopReason === "cancelled") {
+        return { amended: false, reason: "target_cancelled" };
+      }
+      if (onTargetCompleted === "send_anyway") {
+        const newMessageId = this.enqueueAmendmentAsFollowUp(client, prompt);
+        return {
+          amended: false,
+          reason: "target_completed",
+          messageId: newMessageId
+        };
+      }
+      return { amended: false, reason: "target_completed" };
+    }
+    return { amended: false, reason: "target_not_found" };
+  }
+  // Head-of-queue amendment: splice M2 in front of any waiting entries,
+  // broadcast the amend window's queue_added with the amending hint,
+  // mark amendInProgress so the cancelled turn's broadcastTurnComplete
+  // attaches the _meta marker and fires prompt_amended, then fire the
+  // upstream session/cancel without awaiting it. drainQueue is already
+  // running on the head; when its session/prompt returns, it advances
+  // to M2 in the normal way.
+  amendOnHead(client, prompt, targetMessageId, replaceQueue) {
+    const newMessageId = generateMessageId();
+    const originator = { clientId: client.clientId };
+    if (client.clientInfo?.name) {
+      originator.name = client.clientInfo.name;
+    }
+    if (client.clientInfo?.version) {
+      originator.version = client.clientInfo.version;
+    }
+    if (replaceQueue) {
+      const survivors = [];
+      for (const entry2 of this.promptQueue) {
+        if (entry2.kind === "user" && !entry2.cancelled) {
+          entry2.cancelled = true;
+          this.broadcastQueueRemoved(entry2.messageId, "cancelled");
+          entry2.resolve({ stopReason: "cancelled" });
+          continue;
+        }
+        survivors.push(entry2);
+      }
+      this.promptQueue = survivors;
+    }
+    const entry = {
+      kind: "user",
+      messageId: newMessageId,
+      originator,
+      clientId: client.clientId,
+      prompt,
+      enqueuedAt: Date.now(),
+      cancelled: false,
+      wasAmend: true,
+      // No-op resolve/reject: there's no client request awaiting M2's
+      // session/prompt response. The amend_prompt request has already
+      // returned by this point. drainQueue calls these unconditionally
+      // when runQueueEntry settles; making them no-ops is safe.
+      resolve: () => void 0,
+      reject: () => void 0
+    };
+    this.promptQueue.unshift(entry);
+    this.persistRewrite();
+    this.broadcastQueueAdded(entry, {
+      amending: targetMessageId,
+      position: 1
+    });
+    this.amendInProgress = {
+      cancelledMessageId: targetMessageId,
+      newMessageId
+    };
+    void this.agent.connection.notify("session/cancel", { sessionId: this.upstreamSessionId }).catch(() => void 0);
+    return {
+      amended: true,
+      reason: "ok",
+      messageId: newMessageId
+    };
+  }
+  // Send the amendment as a plain follow-up prompt — used when the
+  // target already completed and the caller opted in to send_anyway.
+  // Returns the new prompt's messageId so the result can surface it.
+  enqueueAmendmentAsFollowUp(client, prompt) {
+    const messageId = generateMessageId();
+    const originator = { clientId: client.clientId };
+    if (client.clientInfo?.name) {
+      originator.name = client.clientInfo.name;
+    }
+    if (client.clientInfo?.version) {
+      originator.version = client.clientInfo.version;
+    }
+    const entry = {
+      kind: "user",
+      messageId,
+      originator,
+      clientId: client.clientId,
+      prompt,
+      enqueuedAt: Date.now(),
+      cancelled: false,
+      resolve: () => void 0,
+      reject: () => void 0
+    };
+    this.promptQueue.push(entry);
+    this.persistRewrite();
+    this.broadcastQueueAdded(entry);
+    void this.drainQueue();
+    return messageId;
+  }
   async cancel(clientId) {
     const client = this.clients.get(clientId);
     if (!client) {
@@ -3201,6 +3494,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 {
@@ -3237,12 +3531,33 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
         }
       );
     } catch (err) {
-      this.broadcastTurnComplete(entry.clientId, { stopReason: "error" });
+      this.broadcastTurnComplete(
+        entry.clientId,
+        { stopReason: "error" },
+        entry.messageId,
+        entry.wasAmend
+      );
+      this.clearAmendIfMatches(entry.messageId);
       throw err;
     }
-    this.broadcastTurnComplete(entry.clientId, response);
+    this.broadcastTurnComplete(
+      entry.clientId,
+      response,
+      entry.messageId,
+      entry.wasAmend
+    );
+    this.clearAmendIfMatches(entry.messageId);
     return response;
   }
+  // Clear amendInProgress once the cancelled turn's task has fully
+  // settled. broadcastTurnComplete needs the marker still set when it
+  // fires, so the clear must happen *after*. Called from runQueueEntry's
+  // settle path for both success and error.
+  clearAmendIfMatches(messageId) {
+    if (this.amendInProgress?.cancelledMessageId === messageId) {
+      this.amendInProgress = void 0;
+    }
+  }
 };
 function withCode(err, code) {
   err.code = code;
@@ -4257,6 +4572,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
@@ -5230,9 +5562,85 @@ function withCode2(err, code) {
   return err;
 }
 
+// src/core/agent-prune.ts
+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/core/session-tokens.ts
 import * as fs12 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;
@@ -5240,7 +5648,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");
@@ -5883,7 +6291,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") {
@@ -6536,12 +6953,12 @@ import { z as z6 } from "zod";
 
 // src/core/password.ts
 import * as fs13 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 MAX_MEM = 128 * 1024 * 1024;
@@ -7002,6 +7419,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;
@@ -7154,10 +7587,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) {
@@ -7174,10 +7614,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
   );
@@ -7221,7 +7661,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)
@@ -7262,8 +7707,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,
@@ -7297,6 +7742,7 @@ async function startDaemon(config, serviceToken) {
     await manager.flushMetaWrites();
     setBinaryInstallLogger(null);
     setNpmInstallLogger(null);
+    setAgentPruneLogger(null);
     await app.close();
     try {
       fs14.unlinkSync(paths.pidFile());