@hydra-acp/cli 0.1.8 → 0.1.9

package/dist/cli.js

@@ -392,11 +392,22 @@ var init_types = __esm({
       MethodNotFound: -32601,
       InvalidParams: -32602,
       InternalError: -32603,
+      // -32001…-32003 reserved for RFD #533 attach semantics:
+      //   -32001 Session not found
+      //   -32002 Not authorised to attach
+      //   -32003 Session does not support multi-client attach
+      // We emit -32001 (matching); the other two are reserved for spec
+      // alignment even though we don't currently emit them (we bearer-auth
+      // at WS upgrade time and always support multi-client attach).
       SessionNotFound: -32001,
-      PermissionDenied: -32002,
-      AlreadyAttached: -32003,
+      NotAuthorisedToAttach: -32002,
+      MultiClientNotSupported: -32003,
       AgentNotInstalled: -32005,
-      BundleAlreadyImported: -32010
+      // Hydra-internal codes — outside the RFD's reserved range so they
+      // can't collide with future spec assignments.
+      BundleAlreadyImported: -32010,
+      PermissionDenied: -32011,
+      AlreadyAttached: -32012
     };
     InitializeParams = z3.object({
       protocolVersion: z3.number().optional(),
@@ -406,7 +417,12 @@ var init_types = __esm({
         version: z3.string().optional()
       }).optional()
     });
-    HistoryPolicy = z3.enum(["full", "pending_only", "none"]);
+    HistoryPolicy = z3.enum([
+      "full",
+      "pending_only",
+      "none",
+      "after_message"
+    ]);
     SessionNewParams = z3.object({
       cwd: z3.string(),
       agentId: z3.string().optional(),
@@ -422,6 +438,18 @@ var init_types = __esm({
     SessionAttachParams = z3.object({
       sessionId: z3.string(),
       historyPolicy: HistoryPolicy.default("full"),
+      // Required when historyPolicy is "after_message"; ignored otherwise.
+      // The proxy replays history entries strictly after the entry whose
+      // messageId matches this value. If the id isn't found in the buffer,
+      // the response.historyPolicy field surfaces "full" so the caller
+      // knows we fell back. Per RFD #533.
+      afterMessageId: z3.string().optional(),
+      // Caller-assigned opaque id (e.g. a UUID). When provided, the proxy
+      // echoes it in resolvedBy/sentBy and lifecycle events so other
+      // clients can disambiguate multiple instances of the same
+      // clientInfo.name. When omitted, the proxy assigns one and returns
+      // it in the response. Per RFD #533.
+      clientId: z3.string().optional(),
       clientInfo: z3.object({
         name: z3.string(),
         version: z3.string().optional()
@@ -708,6 +736,9 @@ var init_hydra_commands = __esm({
 
 // src/core/session.ts
 import { customAlphabet } from "nanoid";
+function generateMessageId() {
+  return `m_${generateHydraId()}`;
+}
 function stripHydraSessionPrefix(id) {
   return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
 }
@@ -772,6 +803,97 @@ function extractAdvertisedCommands(params) {
   }
   return out;
 }
+function ensureMessageIdOnUpdate(method, params) {
+  if (method !== "session/update" || !params || typeof params !== "object") {
+    return params;
+  }
+  const p = params;
+  if (!p.update || typeof p.update !== "object" || Array.isArray(p.update)) {
+    return params;
+  }
+  const u = p.update;
+  if (typeof u.messageId === "string") {
+    return params;
+  }
+  return {
+    ...params,
+    update: { ...p.update, messageId: generateMessageId() }
+  };
+}
+function findMessageIdIndex(history, target) {
+  for (let i = 0; i < history.length; i++) {
+    const entry = history[i];
+    if (!entry || entry.method !== "session/update") {
+      continue;
+    }
+    const params = entry.params;
+    if (params?.update?.messageId === target) {
+      return i;
+    }
+  }
+  return -1;
+}
+function extractToolCallId(params) {
+  if (!params || typeof params !== "object") {
+    return void 0;
+  }
+  const toolCall = params.toolCall;
+  if (!toolCall || typeof toolCall !== "object") {
+    return void 0;
+  }
+  const id = toolCall.toolCallId;
+  return typeof id === "string" ? id : void 0;
+}
+function buildPermissionResolvedUpdate(args) {
+  const outcome = extractOutcome(args.result);
+  const update = {
+    sessionUpdate: "permission_resolved"
+  };
+  if (args.toolCallId !== void 0) {
+    update.toolCallId = args.toolCallId;
+  }
+  if (outcome) {
+    update.outcome = outcome;
+    if (outcome.kind === "selected" && typeof outcome.optionId === "string") {
+      update.chosenOptionId = outcome.optionId;
+    }
+  }
+  update.resolvedBy = buildResolvedBy(args.resolver);
+  return update;
+}
+function extractOutcome(result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const raw = result.outcome;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const kind = raw.kind;
+  if (typeof kind !== "string") {
+    return void 0;
+  }
+  const out = { kind };
+  const optionId = raw.optionId;
+  if (typeof optionId === "string") {
+    out.optionId = optionId;
+  }
+  const reason = raw.reason;
+  if (typeof reason === "string") {
+    out.reason = reason;
+  }
+  return out;
+}
+function buildResolvedBy(client) {
+  const out = { clientId: client.clientId };
+  if (client.clientInfo?.name) {
+    out.name = client.clientInfo.name;
+  }
+  if (client.clientInfo?.version) {
+    out.version = client.clientInfo.version;
+  }
+  return out;
+}
 function extractPromptText(prompt) {
   if (typeof prompt === "string") {
     return prompt;
@@ -979,6 +1101,30 @@ var init_session = __esm({
       get attachedCount() {
         return this.clients.size;
       }
+      // Roster of currently-attached clients, optionally excluding one
+      // clientId. Used by the daemon to populate connectedClients on the
+      // session/attach response (per RFD #533) — the freshly-attaching
+      // client wants to see who else is on the session but not itself in
+      // the list.
+      connectedClients(excludeClientId) {
+        const out = [];
+        for (const client of this.clients.values()) {
+          if (excludeClientId && client.clientId === excludeClientId) {
+            continue;
+          }
+          const entry = {
+            clientId: client.clientId
+          };
+          if (client.clientInfo?.name) {
+            entry.name = client.clientInfo.name;
+          }
+          if (client.clientInfo?.version) {
+            entry.version = client.clientInfo.version;
+          }
+          out.push(entry);
+        }
+        return out;
+      }
       // Wall-clock when the in-flight agent turn began, or undefined when
       // idle. Tracked in-memory by broadcastPromptReceived/broadcastTurnComplete
       // so the daemon can hand a fresh attacher mid-turn the right elapsed
@@ -1010,10 +1156,12 @@ var init_session = __esm({
         };
       }
       // Register a client and (asynchronously) load the replay slice it
-      // should receive. Validation errors throw synchronously so callers
-      // can rely on either the registration being in effect or having
-      // thrown; the disk-load is the only async work.
-      attach(client, historyPolicy) {
+      // should receive. Returns both the slice to replay and the actual
+      // historyPolicy applied (which may differ from the requested one
+      // when after_message falls back to full). Validation errors throw
+      // synchronously so callers can rely on either the registration being
+      // in effect or having thrown; the disk-load is the only async work.
+      attach(client, historyPolicy, opts = {}) {
         if (this.closed) {
           throw withCode(
             new Error("session is closed"),
@@ -1029,9 +1177,20 @@ var init_session = __esm({
         this.clients.set(client.clientId, client);
         this.updatedAt = Date.now();
         if (historyPolicy === "none" || historyPolicy === "pending_only") {
-          return Promise.resolve([]);
+          return Promise.resolve({ entries: [], appliedPolicy: historyPolicy });
+        }
+        return this.loadReplay(historyPolicy, opts);
+      }
+      async loadReplay(historyPolicy, opts) {
+        const all = await this.getHistorySnapshot();
+        if (historyPolicy === "after_message") {
+          const cutoff = opts.afterMessageId ? findMessageIdIndex(all, opts.afterMessageId) : -1;
+          if (cutoff < 0) {
+            return { entries: all, appliedPolicy: "full" };
+          }
+          return { entries: all.slice(cutoff + 1), appliedPolicy: "after_message" };
         }
-        return this.getHistorySnapshot();
+        return { entries: all, appliedPolicy: "full" };
       }
       // Dispatch in-flight permission requests to a freshly-attached
       // client. Called by the daemon's WS handler *after* it finishes
@@ -1043,8 +1202,39 @@ var init_session = __esm({
         }
       }
       detach(clientId) {
-        if (this.clients.delete(clientId)) {
-          this.updatedAt = Date.now();
+        const leaving = this.clients.get(clientId);
+        if (!leaving) {
+          return;
+        }
+        this.clients.delete(clientId);
+        this.updatedAt = Date.now();
+        this.broadcastClientDisconnected(leaving);
+      }
+      // Notify remaining attached clients that a peer just left, per
+      // RFD #533. Fires for both explicit session/detach and ws-close
+      // teardown (acp-ws calls Session.detach() in both paths). The
+      // notification is broadcast (not recorded) — peer presence is
+      // transient, not part of conversation history.
+      broadcastClientDisconnected(client) {
+        const info = {
+          clientId: client.clientId
+        };
+        if (client.clientInfo?.name) {
+          info.name = client.clientInfo.name;
+        }
+        if (client.clientInfo?.version) {
+          info.version = client.clientInfo.version;
+        }
+        const update = {
+          sessionUpdate: "client_disconnected",
+          client: info,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        for (const peer of this.clients.values()) {
+          void peer.connection.notify("session/update", {
+            sessionId: this.sessionId,
+            update
+          }).catch(() => void 0);
         }
       }
       async prompt(clientId, params) {
@@ -1097,6 +1287,7 @@ var init_session = __esm({
             sessionId: this.sessionId,
             update: {
               sessionUpdate: "prompt_received",
+              messageId: generateMessageId(),
               prompt: promptParams.prompt,
               sentBy
             }
@@ -1122,7 +1313,8 @@ var init_session = __esm({
       broadcastTurnComplete(originatorClientId, response) {
         const stopReason = response && typeof response === "object" && "stopReason" in response && typeof response.stopReason === "string" ? response.stopReason : void 0;
         const update = {
-          sessionUpdate: "turn_complete"
+          sessionUpdate: "turn_complete",
+          messageId: generateMessageId()
         };
         if (stopReason !== void 0) {
           update.stopReason = stopReason;
@@ -1739,10 +1931,11 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
       recordAndBroadcast(method, params, excludeClientId) {
         const rewritten = this.rewriteForClient(params);
         const recordable = !isStateUpdate(method, rewritten);
+        const broadcast = recordable ? ensureMessageIdOnUpdate(method, rewritten) : rewritten;
         if (recordable) {
           const entry = {
             method,
-            params: rewritten,
+            params: broadcast,
             recordedAt: Date.now()
           };
           this.lastRecordedAt = entry.recordedAt;
@@ -1770,7 +1963,7 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           if (excludeClientId && client.clientId === excludeClientId) {
             continue;
           }
-          void client.connection.notify(method, rewritten).catch(() => void 0);
+          void client.connection.notify(method, broadcast).catch(() => void 0);
         }
       }
       async handlePermissionRequest(params) {
@@ -1782,11 +1975,13 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
           );
         }
         const clientParams = this.rewriteForClient(params);
+        const toolCallId = extractToolCallId(clientParams);
         return new Promise((resolve5, reject) => {
           let settled = false;
           const outbound = [];
           const entry = { addClient: sendTo };
           this.inFlightPermissions.add(entry);
+          const sessionId = this.sessionId;
           const settle = (fn) => {
             if (settled) {
               return;
@@ -1799,22 +1994,25 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
             if (settled) {
               return;
             }
-            const { id, response } = client.connection.requestWithId(
+            const response = client.connection.request(
               "session/request_permission",
               clientParams
             );
-            outbound.push({ client, id });
+            outbound.push({ client });
             void response.then((result) => {
               settle(() => {
+                const update = buildPermissionResolvedUpdate({
+                  toolCallId,
+                  result,
+                  resolver: client
+                });
                 for (const o of outbound) {
                   if (o.client.clientId === client.clientId) {
                     continue;
                   }
-                  void o.client.connection.notify("session/permission_resolved", {
-                    ...clientParams,
-                    requestId: o.id,
-                    resolvedBy: client.clientId,
-                    result
+                  void o.client.connection.notify("session/update", {
+                    sessionId,
+                    update
                   }).catch(() => void 0);
                 }
                 resolve5(result);
@@ -4355,7 +4553,7 @@ var init_screen = __esm({
         this.streamingActive = false;
         this.lines.push(...lines);
         this.trackLines(lines);
-        this.adjustScrollForLineChange(lines.length);
+        this.adjustScrollForRowChange(this.wrappedRowsOfMany(lines));
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -4363,19 +4561,40 @@ var init_screen = __esm({
         this.streamingActive = false;
         this.lines.push(line);
         this.trackLine(line);
-        this.adjustScrollForLineChange(1);
+        this.adjustScrollForRowChange(this.wrappedRowsOf(line));
         this.trimScrollback();
         this.scheduleRepaint();
       }
       // When scrolled away from the bottom, shift scrollOffset to keep the
       // user's visible window anchored on the same content as the lines
-      // array grows. Without this, every new line silently scrolls the view
-      // up by one row — the original bug the user reported.
-      adjustScrollForLineChange(delta) {
+      // array grows. `delta` is measured in WRAPPED ROWS — the same unit
+      // scrollOffset uses — so a single logical line that wraps to N rows
+      // contributes N, not 1. Counting logical lines here was the original
+      // bug: any wrapped append would slide the view up by N−1 rows.
+      adjustScrollForRowChange(delta) {
         if (this.scrollOffset > 0 && delta !== 0) {
           this.scrollOffset = Math.max(0, this.scrollOffset + delta);
         }
       }
+      // Wrapped-row count for a single line at the current terminal width.
+      // Reuses the wrap cache, and synchronises the cache's width with the
+      // current width so a resize that hasn't yet been picked up by
+      // drawScrollback can't return stale counts during an insert.
+      wrappedRowsOf(line) {
+        const w = this.term.width;
+        if (this.wrapCacheWidth !== w) {
+          this.wrapCache.clear();
+          this.wrapCacheWidth = w;
+        }
+        return this.wrapOne(line, w).length;
+      }
+      wrappedRowsOfMany(lines) {
+        let n = 0;
+        for (const line of lines) {
+          n += this.wrappedRowsOf(line);
+        }
+        return n;
+      }
       trackLine(line) {
         this.lineIds.set(line, this.nextLineId++);
       }
@@ -4425,12 +4644,14 @@ var init_screen = __esm({
         }
         const existing = this.keyedBlocks.get(key);
         let touchesEnd = false;
-        let scrollDelta = 0;
+        let rowDelta = 0;
         if (existing) {
           const oldEnd = existing.start + existing.count;
           touchesEnd = oldEnd >= this.lines.length;
+          const oldRows = this.wrappedRowsOfMany(
+            this.lines.slice(existing.start, oldEnd)
+          );
           const delta = newLines.length - existing.count;
-          scrollDelta = delta;
           const removed = this.lines.splice(
             existing.start,
             existing.count,
@@ -4448,20 +4669,21 @@ var init_screen = __esm({
               }
             }
           }
+          rowDelta = this.wrappedRowsOfMany(newLines) - oldRows;
         } else {
           touchesEnd = true;
-          scrollDelta = newLines.length;
           this.keyedBlocks.set(key, {
             start: this.lines.length,
             count: newLines.length
           });
           this.lines.push(...newLines);
           this.trackLines(newLines);
+          rowDelta = this.wrappedRowsOfMany(newLines);
         }
         if (touchesEnd) {
           this.streamingActive = false;
         }
-        this.adjustScrollForLineChange(scrollDelta);
+        this.adjustScrollForRowChange(rowDelta);
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -4475,12 +4697,14 @@ var init_screen = __esm({
         }
         const fragments = text.split("\n");
         const [first, ...rest] = fragments;
-        let added = 0;
+        let rowDelta = 0;
         if (this.streamingActive && this.lines.length > 0) {
           const last = this.lines[this.lines.length - 1];
           if (last) {
+            const before = this.wrappedRowsOf(last);
             this.forgetLine(last);
             last.body += first ?? "";
+            rowDelta += this.wrappedRowsOf(last) - before;
           }
         } else {
           if (this.lines.length > 0) {
@@ -4490,7 +4714,7 @@ var init_screen = __esm({
               const sep = { body: "" };
               this.lines.push(sep);
               this.trackLine(sep);
-              added += 1;
+              rowDelta += this.wrappedRowsOf(sep);
             }
           }
           const initial = {
@@ -4503,7 +4727,7 @@ var init_screen = __esm({
           }
           this.lines.push(initial);
           this.trackLine(initial);
-          added += 1;
+          rowDelta += this.wrappedRowsOf(initial);
         }
         const continuationPrefix = " ".repeat(prefix.length);
         for (const piece of rest) {
@@ -4514,10 +4738,10 @@ var init_screen = __esm({
           };
           this.lines.push(cont);
           this.trackLine(cont);
-          added += 1;
+          rowDelta += this.wrappedRowsOf(cont);
         }
         this.streamingActive = true;
-        this.adjustScrollForLineChange(added);
+        this.adjustScrollForRowChange(rowDelta);
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -4628,6 +4852,9 @@ var init_screen = __esm({
           return;
         }
         const touchesEnd = existing.start + existing.count >= this.lines.length;
+        const removedRows = this.wrappedRowsOfMany(
+          this.lines.slice(existing.start, existing.start + existing.count)
+        );
         const removed = this.lines.splice(existing.start, existing.count);
         for (const line of removed) {
           this.forgetLine(line);
@@ -4641,7 +4868,7 @@ var init_screen = __esm({
         if (touchesEnd) {
           this.streamingActive = false;
         }
-        this.adjustScrollForLineChange(-existing.count);
+        this.adjustScrollForRowChange(-removedRows);
         this.scheduleRepaint();
       }
       redraw() {
@@ -4726,7 +4953,7 @@ var init_screen = __esm({
         this.lines.push(sep);
         this.trackLine(sep);
         this.streamingActive = false;
-        this.adjustScrollForLineChange(1);
+        this.adjustScrollForRowChange(this.wrappedRowsOf(sep));
         this.trimScrollback();
         this.scheduleRepaint();
       }
@@ -7072,13 +7299,25 @@ async function runSession(term, config, opts, exitHint) {
     } else if (event?.kind === "turn-complete") {
       adjustPendingTurns(-1);
     }
+    if (rawTag === "permission_resolved") {
+      handlePermissionResolved(update);
+      return;
+    }
     appendRender(event);
     maybeDismissPermissionByToolUpdate(update);
   });
-  conn.onNotification("session/permission_resolved", (params) => {
-    const p = params ?? {};
-    dismissPermissionExternally(p.toolCall?.toolCallId, p.result);
-  });
+  const handlePermissionResolved = (update) => {
+    const u = update ?? {};
+    const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : void 0;
+    let outcome;
+    if (u.outcome && typeof u.outcome === "object") {
+      outcome = u.outcome;
+    } else if (typeof u.chosenOptionId === "string") {
+      outcome = { kind: "selected", optionId: u.chosenOptionId };
+    }
+    const result = outcome ? { outcome } : void 0;
+    dismissPermissionExternally(toolCallId, result);
+  };
   let pendingPermission = null;
   const dismissPermissionExternally = (toolCallId, result) => {
     if (!pendingPermission) {
@@ -10705,7 +10944,7 @@ function registerSessionRoutes(app, manager, defaults) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     reply.header(
       "Content-Disposition",
-      `attachment; filename="hydra-${id}-${stamp}.hydra"`
+      `attachment; filename="${id}-${stamp}.hydra"`
     );
     reply.code(200).send(bundle);
   });
@@ -11071,15 +11310,20 @@ function registerAcpWsEndpoint(app, deps) {
         connection,
         session,
         state,
-        params.clientInfo
+        params.clientInfo,
+        params.clientId
+      );
+      const { entries: replay, appliedPolicy } = await session.attach(
+        client,
+        params.historyPolicy,
+        { afterMessageId: params.afterMessageId }
       );
-      const replay = await session.attach(client, params.historyPolicy);
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} replayed=${replay.length}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length}`
       );
       for (const note of replay) {
         await connection.notify(note.method, note.params);
@@ -11087,6 +11331,13 @@ function registerAcpWsEndpoint(app, deps) {
       session.replayPendingPermissions(client);
       return {
         sessionId: session.sessionId,
+        clientId: client.clientId,
+        connectedClients: session.connectedClients(client.clientId),
+        // appliedPolicy surfaces whether after_message fell back to full
+        // (because afterMessageId wasn't found in history) — RFD #533
+        // says the response.historyPolicy should reflect what actually
+        // ran, not what was asked for.
+        historyPolicy: appliedPolicy,
         replayed: replay.length,
         _meta: buildResponseMeta(session)
       };
@@ -11102,7 +11353,7 @@ function registerAcpWsEndpoint(app, deps) {
       const session = deps.manager.get(params.sessionId);
       session?.detach(att.clientId);
       state.attached.delete(params.sessionId);
-      return { detached: true };
+      return { sessionId: params.sessionId, status: "detached" };
     });
     connection.onRequest("session/list", async (raw) => {
       const params = SessionListParams.parse(raw ?? {});
@@ -11175,7 +11426,7 @@ function registerAcpWsEndpoint(app, deps) {
         session = await deps.manager.resurrect(fromDisk);
       }
       const client = bindClientToSession(connection, session, state);
-      const replay = await session.attach(client, "pending_only");
+      const { entries: replay } = await session.attach(client, "pending_only");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
@@ -11269,11 +11520,11 @@ function buildInitializeResult() {
     ]
   };
 }
-function bindClientToSession(connection, session, state, clientInfo) {
+function bindClientToSession(connection, session, state, clientInfo, callerClientId) {
   void state;
   void session;
   return {
-    clientId: `cli_${nanoid2(8)}`,
+    clientId: callerClientId ?? `cli_${nanoid2(8)}`,
     connection,
     clientInfo
   };
@@ -12216,10 +12467,22 @@ var SessionTracker = class {
   contexts = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   pendingPermissions = /* @__PURE__ */ new Map();
+  // Secondary index — same entries as `pendingPermissions`, keyed by the
+  // tool call id from the request_permission params. Used to correlate
+  // the daemon's `session/update`/`permission_resolved` events back to the
+  // pending downstream request, since per-recipient JSON-RPC ids are no
+  // longer carried on the wire.
+  pendingPermissionsByToolCall = /* @__PURE__ */ new Map();
+  // Most recent messageId observed on a session/update from the daemon
+  // (prompt_received / turn_complete), keyed by sessionId. Used by the
+  // reconnect-replay path to send historyPolicy:"after_message" with
+  // afterMessageId so the daemon only replays the delta we missed.
+  lastMessageIds = /* @__PURE__ */ new Map();
   observeFromClient(msg) {
     if (isResponse2(msg)) {
-      if (this.pendingPermissions.has(msg.id)) {
-        this.pendingPermissions.delete(msg.id);
+      const existing = this.pendingPermissions.get(msg.id);
+      if (existing) {
+        this.deletePendingPermission(existing);
       }
       return;
     }
@@ -12246,16 +12509,34 @@ var SessionTracker = class {
     }
   }
   observeFromServer(msg) {
+    if (!isRequest(msg) && !isResponse2(msg) && "method" in msg) {
+      if (msg.method === "session/update") {
+        const params = msg.params ?? {};
+        const sessionId2 = typeof params.sessionId === "string" ? params.sessionId : void 0;
+        const messageId = typeof params.update?.messageId === "string" ? params.update.messageId : void 0;
+        if (sessionId2 && messageId) {
+          this.lastMessageIds.set(sessionId2, messageId);
+        }
+      }
+      return;
+    }
     if (isRequest(msg)) {
       if (msg.method === "session/request_permission") {
         const params = msg.params ?? {};
         const sessionId2 = typeof params.sessionId === "string" ? params.sessionId : void 0;
         if (sessionId2) {
-          this.pendingPermissions.set(msg.id, {
+          const toolCall = params.toolCall;
+          const toolCallId = toolCall && typeof toolCall.toolCallId === "string" ? toolCall.toolCallId : void 0;
+          const entry = {
             requestId: msg.id,
             sessionId: sessionId2,
+            toolCallId,
             params
-          });
+          };
+          this.pendingPermissions.set(msg.id, entry);
+          if (toolCallId) {
+            this.pendingPermissionsByToolCall.set(toolCallId, entry);
+          }
         }
       }
       return;
@@ -12303,6 +12584,14 @@ var SessionTracker = class {
   }
   forget(sessionId) {
     this.contexts.delete(sessionId);
+    this.lastMessageIds.delete(sessionId);
+  }
+  // Latest messageId observed for `sessionId`, or undefined if we
+  // haven't seen one (no prompt_received/turn_complete has flowed
+  // through yet). Used by reconnect-replay to issue
+  // historyPolicy:"after_message" with afterMessageId.
+  lastMessageId(sessionId) {
+    return this.lastMessageIds.get(sessionId);
   }
   clearPending() {
     this.pending.clear();
@@ -12310,15 +12599,29 @@ var SessionTracker = class {
   takePendingPermissions() {
     const out = [...this.pendingPermissions.values()];
     this.pendingPermissions.clear();
+    this.pendingPermissionsByToolCall.clear();
     return out;
   }
   takePendingPermission(requestId) {
     const found = this.pendingPermissions.get(requestId);
     if (found) {
-      this.pendingPermissions.delete(requestId);
+      this.deletePendingPermission(found);
+    }
+    return found;
+  }
+  takePendingPermissionByToolCall(toolCallId) {
+    const found = this.pendingPermissionsByToolCall.get(toolCallId);
+    if (found) {
+      this.deletePendingPermission(found);
     }
     return found;
   }
+  deletePendingPermission(entry) {
+    this.pendingPermissions.delete(entry.requestId);
+    if (entry.toolCallId) {
+      this.pendingPermissionsByToolCall.delete(entry.toolCallId);
+    }
+  }
 };
 function isRequest(msg) {
   return "method" in msg && "id" in msg && msg.id !== void 0;
@@ -12354,7 +12657,7 @@ async function runShim(opts) {
 `
       );
       for (const ctx of contexts) {
-        await replayAttach(upstream, ctx);
+        await replayAttach(upstream, ctx, tracker.lastMessageId(ctx.sessionId));
       }
     }
   });
@@ -12413,25 +12716,47 @@ function wireShim({
   });
 }
 function maybeReplyToResolvedPermission(msg, tracker, downstream) {
-  if (!isPermissionResolvedNotification(msg)) {
+  const update = extractPermissionResolvedUpdate(msg);
+  if (!update) {
     return;
   }
-  const params = msg.params ?? {};
-  if (params.requestId === void 0) {
+  const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+  if (!toolCallId) {
     return;
   }
-  const pending = tracker.takePendingPermission(params.requestId);
+  const pending = tracker.takePendingPermissionByToolCall(toolCallId);
   if (!pending) {
     return;
   }
+  const outcome = reconstructOutcome(update);
   void downstream.send({
     jsonrpc: "2.0",
     id: pending.requestId,
-    result: params.result ?? null
+    result: outcome ? { outcome } : null
   }).catch(() => void 0);
 }
-function isPermissionResolvedNotification(msg) {
-  return "method" in msg && msg.method === "session/permission_resolved" && !("id" in msg && msg.id !== void 0);
+function extractPermissionResolvedUpdate(msg) {
+  if (!isSessionUpdateNotification(msg)) {
+    return void 0;
+  }
+  const params = msg.params ?? {};
+  const update = params.update;
+  if (!update || typeof update !== "object" || update.sessionUpdate !== "permission_resolved") {
+    return void 0;
+  }
+  return update;
+}
+function isSessionUpdateNotification(msg) {
+  return "method" in msg && msg.method === "session/update" && !("id" in msg && msg.id !== void 0);
+}
+function reconstructOutcome(update) {
+  if (update.outcome && typeof update.outcome === "object") {
+    return update.outcome;
+  }
+  if (typeof update.chosenOptionId === "string") {
+    return { kind: "selected", optionId: update.chosenOptionId };
+  }
+  return void 0;
 }
 async function cancelPendingPermissions(tracker, downstream) {
   const pendings = tracker.takePendingPermissions();
@@ -12443,21 +12768,26 @@ async function cancelPendingPermissions(tracker, downstream) {
 `
   );
   for (const pending of pendings) {
-    const params = {
-      ...pending.params,
-      resolvedBy: "hydra-acp",
-      result: {
-        outcome: { kind: "cancelled", reason: "daemon-disconnected" }
-      }
+    const sessionId = typeof pending.params.sessionId === "string" ? pending.params.sessionId : void 0;
+    if (!sessionId) {
+      continue;
+    }
+    const update = {
+      sessionUpdate: "permission_resolved",
+      outcome: { kind: "cancelled", reason: "daemon-disconnected" },
+      resolvedBy: { clientId: "hydra-acp" }
     };
+    if (pending.toolCallId) {
+      update.toolCallId = pending.toolCallId;
+    }
     await downstream.send({
       jsonrpc: "2.0",
-      method: "session/permission_resolved",
-      params
+      method: "session/update",
+      params: { sessionId, update }
     }).catch(() => void 0);
   }
 }
-async function replayAttach(stream, ctx) {
+async function replayAttach(stream, ctx, afterMessageId) {
   const resumeHints = {
     upstreamSessionId: ctx.upstreamSessionId,
     agentId: ctx.agentId,
@@ -12469,19 +12799,21 @@ async function replayAttach(stream, ctx) {
   if (ctx.agentArgs && ctx.agentArgs.length > 0) {
     resumeHints.agentArgs = ctx.agentArgs;
   }
+  const params = {
+    sessionId: ctx.sessionId,
+    _meta: { "hydra-acp": { resume: resumeHints } }
+  };
+  if (afterMessageId) {
+    params.historyPolicy = "after_message";
+    params.afterMessageId = afterMessageId;
+  } else {
+    params.historyPolicy = "pending_only";
+  }
   const request = {
     jsonrpc: "2.0",
     id: `resume-${ctx.sessionId}-${Date.now()}`,
     method: "session/attach",
-    params: {
-      sessionId: ctx.sessionId,
-      historyPolicy: "pending_only",
-      _meta: {
-        "hydra-acp": {
-          resume: resumeHints
-        }
-      }
-    }
+    params
   };
   try {
     const resp = await stream.request(request);