@hydra-acp/cli 0.1.24 → 0.1.25

package/dist/index.d.ts

@@ -102,6 +102,7 @@ declare const HydraConfig: z.ZodObject<{
         logMaxBytes: z.ZodDefault<z.ZodNumber>;
         cwdColumnMaxWidth: z.ZodDefault<z.ZodNumber>;
         progressIndicator: z.ZodDefault<z.ZodBoolean>;
+        defaultEnterAction: z.ZodDefault<z.ZodEnum<["enqueue", "amend"]>>;
     }, "strip", z.ZodTypeAny, {
         repaintThrottleMs: number;
         maxScrollbackLines: number;
@@ -109,6 +110,7 @@ declare const HydraConfig: z.ZodObject<{
         logMaxBytes: number;
         cwdColumnMaxWidth: number;
         progressIndicator: boolean;
+        defaultEnterAction: "enqueue" | "amend";
     }, {
         repaintThrottleMs?: number | undefined;
         maxScrollbackLines?: number | undefined;
@@ -116,6 +118,7 @@ declare const HydraConfig: z.ZodObject<{
         logMaxBytes?: number | undefined;
         cwdColumnMaxWidth?: number | undefined;
         progressIndicator?: boolean | undefined;
+        defaultEnterAction?: "enqueue" | "amend" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     daemon: {
@@ -143,6 +146,7 @@ declare const HydraConfig: z.ZodObject<{
         logMaxBytes: number;
         cwdColumnMaxWidth: number;
         progressIndicator: boolean;
+        defaultEnterAction: "enqueue" | "amend";
     };
     registry: {
         url: string;
@@ -179,6 +183,7 @@ declare const HydraConfig: z.ZodObject<{
         logMaxBytes?: number | undefined;
         cwdColumnMaxWidth?: number | undefined;
         progressIndicator?: boolean | undefined;
+        defaultEnterAction?: "enqueue" | "amend" | undefined;
     } | undefined;
     registry?: {
         url?: string | undefined;
@@ -1534,6 +1539,40 @@ declare const UpdatePromptResult: z.ZodObject<{
     updated: boolean;
 }>;
 type UpdatePromptResult = z.infer<typeof UpdatePromptResult>;
+declare const AmendPromptParams: z.ZodObject<{
+    sessionId: z.ZodString;
+    targetMessageId: z.ZodString;
+    prompt: z.ZodArray<z.ZodUnknown, "many">;
+    replaceQueue: z.ZodOptional<z.ZodBoolean>;
+    onTargetCompleted: z.ZodOptional<z.ZodEnum<["reject", "send_anyway"]>>;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    prompt: unknown[];
+    targetMessageId: string;
+    replaceQueue?: boolean | undefined;
+    onTargetCompleted?: "reject" | "send_anyway" | undefined;
+}, {
+    sessionId: string;
+    prompt: unknown[];
+    targetMessageId: string;
+    replaceQueue?: boolean | undefined;
+    onTargetCompleted?: "reject" | "send_anyway" | undefined;
+}>;
+type AmendPromptParams = z.infer<typeof AmendPromptParams>;
+declare const AmendPromptResult: z.ZodObject<{
+    amended: z.ZodBoolean;
+    reason: z.ZodEnum<["ok", "target_completed", "target_cancelled", "target_not_found"]>;
+    messageId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reason: "ok" | "target_completed" | "target_cancelled" | "target_not_found";
+    amended: boolean;
+    messageId?: string | undefined;
+}, {
+    reason: "ok" | "target_completed" | "target_cancelled" | "target_not_found";
+    amended: boolean;
+    messageId?: string | undefined;
+}>;
+type AmendPromptResult = z.infer<typeof AmendPromptResult>;
 interface SessionCapabilities {
     attach?: Record<string, never>;
     list?: boolean;
@@ -1783,6 +1822,8 @@ declare class Session {
     private modelHandlers;
     private modeHandlers;
     private usageHandlers;
+    private amendInProgress;
+    private recentlyTerminal;
     constructor(init: SessionInit);
     private broadcastMergedCommands;
     private broadcastAvailableModes;
@@ -1814,6 +1855,9 @@ declare class Session {
     prompt(clientId: string, params: unknown): Promise<unknown>;
     private broadcastPromptReceived;
     private broadcastTurnComplete;
+    private recordTerminal;
+    private broadcastPromptAmended;
+    private findUserEntry;
     private visibleQueueDepth;
     private broadcastQueueAdded;
     private broadcastQueueUpdated;
@@ -1824,6 +1868,9 @@ declare class Session {
     replayPersistedQueue(entries: PersistedQueueEntry[]): void;
     cancelQueuedPrompt(messageId: string): CancelPromptResult;
     updateQueuedPrompt(messageId: string, prompt: unknown[]): UpdatePromptResult;
+    amendPrompt(clientId: string, params: AmendPromptParams): AmendPromptResult;
+    private amendOnHead;
+    private enqueueAmendmentAsFollowUp;
     cancel(clientId: string): Promise<void>;
     forwardRequest(method: string, params: unknown): Promise<unknown>;
     private rewriteForAgent;
@@ -1872,6 +1919,7 @@ declare class Session {
     private persistedFromEntry;
     private drainQueue;
     private runQueueEntry;
+    private clearAmendIfMatches;
 }
 
 declare const SessionRecord: z.ZodObject<{

package/dist/index.js

@@ -186,7 +186,15 @@ var TuiConfig = z.object({
   // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
   // running. Set false if your terminal renders this obnoxiously or you
   // just don't want it.
-  progressIndicator: z.boolean().default(true)
+  progressIndicator: z.boolean().default(true),
+  // What the unmodified Enter key does in the prompt composer.
+  //   "enqueue" (default) — Enter enqueues the prompt (sends immediately
+  //     when idle, queues behind an in-flight turn); Shift+Enter amends
+  //     the in-flight turn.
+  //   "amend" — flips the two: Enter amends the in-flight turn,
+  //     Shift+Enter enqueues. With no turn in flight either key just
+  //     enqueues, since there's nothing to amend.
+  defaultEnterAction: z.enum(["enqueue", "amend"]).default("enqueue")
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -230,7 +238,8 @@ var HydraConfig = z.object({
     mouse: true,
     logMaxBytes: 5 * 1024 * 1024,
     cwdColumnMaxWidth: 24,
-    progressIndicator: true
+    progressIndicator: true,
+    defaultEnterAction: "enqueue"
   })
 });
 function extensionList(config) {
@@ -1024,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) {
@@ -1168,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({
@@ -1646,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;
@@ -1745,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;
@@ -2174,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",
@@ -2183,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
@@ -2204,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,
@@ -2216,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) {
@@ -2338,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" };
   }
@@ -2359,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) {
@@ -3217,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 {
@@ -3253,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;
@@ -5992,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") {
@@ -7111,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;
@@ -7263,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",