@dorokuma/herdsman-pi 0.9.0 → 0.11.5

package/README.md

@@ -12,7 +12,7 @@ pi install npm:@dorokuma/herdsman-pi
 herdsman daemon start
 ```
 
-When Pi runs inside Herdr, this extension connects to the Herdsman daemon and registers its exact Pi session path as presence identity. It does not send per-turn tool-result or final-message telemetry.
+When Pi runs inside Herdr, this extension connects to the Herdsman daemon and registers its exact Pi session path as presence identity. After register it sends `agent.ping` at least every 30 seconds so an idle owner is not dropped by the daemon heartbeat. It does not send per-turn tool-result or final-message telemetry.
 
 Enter these commands in Pi, not in a shell:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.9.0",
+  "version": "0.11.5",
   "description": "Pi extension bridge for Herdsman agent history. Forked from @ryonakae/herdsman.",
   "type": "module",
   "keywords": [
@@ -11,7 +11,7 @@
   "license": "MIT",
   "files": [
     "src",
-    "../LICENSE"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -21,6 +21,9 @@
     "url": "git+https://github.com/dorokuma/herdsman.git",
     "directory": "packages/herdsman-pi"
   },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
   "pi": {
     "extensions": [
       "./src/index.ts"
@@ -37,8 +40,5 @@
   "bugs": {
     "url": "https://github.com/dorokuma/herdsman/issues"
   },
-  "homepage": "https://github.com/dorokuma/herdsman#readme",
-  "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  }
-}
+  "homepage": "https://github.com/dorokuma/herdsman#readme"
+}

package/src/agent-update-ui.ts

@@ -39,11 +39,14 @@ function isAgentOutcome(value: unknown): value is AgentOutcome {
   return (
     typeof candidate.agent === "string" &&
     typeof candidate.eventId === "number" &&
-    (candidate.kind === "blocked" || candidate.kind === "completed") &&
+    (candidate.kind === "blocked" ||
+      candidate.kind === "completed" ||
+      candidate.kind === "failed") &&
     (candidate.name === undefined ||
       candidate.name === null ||
       typeof candidate.name === "string") &&
     (candidate.paneId === null || typeof candidate.paneId === "string") &&
+    (candidate.reason === undefined || typeof candidate.reason === "string") &&
     typeof candidate.terminalId === "string" &&
     typeof candidate.text === "string"
   );
@@ -106,7 +109,14 @@ export function renderAgentUpdateMessage(
     ].join(" ");
     if (!options.expanded) return [summary];
     const cleanedResponse = cleanDisplayText(outcome.text);
-    const response = cleanedResponse.length > 0 ? cleanedResponse : "No final response";
+    const cleanedReason =
+      outcome.kind === "failed" ? cleanDisplayText(outcome.reason ?? "") : "";
+    const response =
+      cleanedResponse.length > 0
+        ? cleanedResponse
+        : cleanedReason.length > 0
+          ? cleanedReason
+          : "No final response";
     return [summary, theme.fg("muted", `  Last response  ${response}`)];
   });
   const hiddenCount = details.outcomes.length - visibleOutcomes.length;

package/src/daemon-client.ts

@@ -87,6 +87,7 @@ type PendingRequest = {
   method: string;
   reject(error: Error): void;
   resolve(value: unknown): void;
+  timer: ReturnType<typeof setTimeout>;
 };
 
 type RpcMessage = {
@@ -98,6 +99,7 @@ type RpcMessage = {
 };
 
 const DEFAULT_RECONNECT_DELAYS_MS = [100, 250, 500, 1_000] as const;
+const REQUEST_TIMEOUT_MS = 15_000;
 
 export class ReconnectingDaemonClient {
   onConnected: (() => Promise<void> | void) | undefined;
@@ -152,7 +154,16 @@ export class ReconnectingDaemonClient {
     const id = `pi-${this.#nextId}`;
     this.#nextId += 1;
     return new Promise((resolve, reject) => {
-      this.#pending.set(id, { method, reject, resolve });
+      // A request that gets no reply within the timeout is rejected and its
+      // pending slot is removed; a response arriving later is ignored because
+      // the id is no longer tracked. This keeps acks from hanging forever when
+      // the socket stays open but the daemon is unresponsive.
+      const timer = setTimeout(() => {
+        if (this.#pending.delete(id)) {
+          reject(new Error("Herdsman daemon request timed out"));
+        }
+      }, REQUEST_TIMEOUT_MS);
+      this.#pending.set(id, { method, reject, resolve, timer });
       this.#socket?.write(`${JSON.stringify({ id, method, params })}\n`);
     });
   }
@@ -228,16 +239,18 @@ export class ReconnectingDaemonClient {
     const pending = this.#pending.get(String(message.id));
     if (!pending) return;
     this.#pending.delete(String(message.id));
+    clearTimeout(pending.timer);
     if (message.error) {
       const error = Object.assign(new Error(message.error.message ?? "Herdsman RPC failed"), {
         code: message.error.code,
       });
       pending.reject(error);
-      // Optional methods (turn completion signaling) are rejected like any other
-      // failure but must not mark the daemon incompatible: an older daemon
-      // answers "Unknown method" and the connection has to stay alive.
+      // Optional methods (turn completion signaling, keepalive ping) are rejected
+      // like any other failure but must not mark the daemon incompatible: an older
+      // daemon answers "Unknown method" and the connection has to stay alive.
       if (
         pending.method !== "agent.turn.completed" &&
+        pending.method !== "agent.ping" &&
         /unknown|not found|unsupported|method/i.test(error.message)
       ) {
         const incompatible = new Error("Herdsman daemon version is incompatible; restart the session");
@@ -252,7 +265,10 @@ export class ReconnectingDaemonClient {
   }
 
   #rejectAll(error: Error): void {
-    for (const pending of this.#pending.values()) pending.reject(error);
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
     this.#pending.clear();
   }
 }

package/src/index.ts

@@ -1,7 +1,9 @@
 import { agentIdentityLabel } from "./agent-display.js";
+import { sanitizeText } from "./sanitize-text.js";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { stripVTControlCharacters } from "node:util";
 
 export type HerdsmanPiLogLevel = "info" | "warn" | "error";
 
@@ -110,12 +112,14 @@ type HerdsmanState = {
   connected: boolean;
   currentScope: CurrentScope | undefined;
   deliveredBatch: DeliveredBatch | undefined;
+  ackInFlight: boolean;
   failedWakeThroughEventId: number;
   isOrchestrator: boolean;
   launchIdentity: LaunchIdentity | undefined;
   latestContext: AgentWorkspaceContextSnapshot | undefined;
   pendingEvents: AgentEventWireRecord[];
   pinnedContext: AgentWorkspaceContextSnapshot | undefined;
+  presentedEventIds: Set<number>;
   reconnectingFromOn: boolean;
   registrationInFlight: Promise<void> | undefined;
   runActive: boolean;
@@ -168,6 +172,7 @@ type PiApi = {
 type ExtensionOptions = {
   clientFactory?: () => HerdsmanDaemonClient;
   onTurnCompletionSignal?: (completion: Promise<void>) => void;
+  onStateExposed?: (state: HerdsmanState) => void;
 };
 
 const DEFAULT_HOME_NAME = ".herdsman";
@@ -176,6 +181,7 @@ const HERDR_REQUIRED_MESSAGE = "Herdsman requires a Herdr workspace";
 const RECONNECTING_MESSAGE = "Herdsman is reconnecting · try again shortly";
 export const MAX_ACK_ATTEMPTS = 5;
 export const ACK_BACKOFF_CAP_MS = 30_000;
+const KEEPALIVE_INTERVAL_MS = 30_000;
 
 type AckFailureClass = "terminal" | "resync" | "transient";
 
@@ -248,6 +254,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       latestContext: undefined,
       pendingEvents: [],
       pinnedContext: undefined,
+      presentedEventIds: new Set(),
       reconnectingFromOn: false,
       registrationInFlight: undefined,
       roleMutationInFlight: false,
@@ -258,10 +265,27 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       wakeRequested: false,
       wakeRequestedThroughEventId: 0,
       wakeTimer: undefined,
+      ackInFlight: false,
     };
+    options.onStateExposed?.(state);
     let activeContext: PiContext | undefined;
+    let keepaliveTimer: ReturnType<typeof setInterval> | undefined;
     let wakeGeneration = 0;
 
+    const stopKeepalive = () => {
+      if (!keepaliveTimer) return;
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = undefined;
+    };
+
+    const startKeepalive = (client: HerdsmanDaemonClient) => {
+      stopKeepalive();
+      keepaliveTimer = setInterval(() => {
+        void client.request("agent.ping", {}).catch(() => undefined);
+      }, KEEPALIVE_INTERVAL_MS);
+      keepaliveTimer.unref?.();
+    };
+
     const setHerdsmanUi = (ctx: PiContext | undefined) => {
       if (!ctx) return;
       const footerState: HerdsmanFooterState = state.reconnectingFromOn
@@ -288,9 +312,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.wakeRequestedThroughEventId = 0;
     };
 
-    const wakeLabel = (count: number) =>
-      `Herdsman received ${count} agent update${count === 1 ? "" : "s"}.`;
-
     const clearAgentContext = () => {
       state.latestContext = undefined;
       state.pinnedContext = undefined;
@@ -299,9 +320,20 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
     const pruneAcknowledgedEvents = (ackedEventId: number | undefined) => {
       if (ackedEventId === undefined) return;
+      // Acknowledged events leave the pending projection but intentionally stay
+      // in presentedEventIds. The daemon never re-lists acked events (acked
+      // rows are excluded from pending discovery), so retaining the ids cannot
+      // suppress a legitimate future delivery; it only guarantees that an event
+      // already presented in this scope session is never presented again, even
+      // if a reconnect, an ack retry, or a daemon redelivery replays it. The
+      // set is bounded by the number of events presented per session and is
+      // cleared on role loss, scope change, and shutdown.
       state.pendingEvents = state.pendingEvents.filter((event) => event.id > ackedEventId);
     };
 
+    const isWakeableEvent = (event: AgentEventWireRecord | undefined) =>
+      !event?.nextAttemptAt || event.nextAttemptAt <= Date.now();
+
     const applyOwnerContext = (response: ConnectionStateResponse) => {
       state.latestContext = isLocalOwner(response) ? response.context ?? undefined : undefined;
     };
@@ -310,13 +342,14 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       if (!ctx || !state.isOrchestrator || !state.currentScope || !pi.sendMessage) return;
       if (state.wakeTimer || state.wakeRequested) return;
       const outcomes = projectAgentOutcomes(state.pendingEvents).outcomes.filter(
-        (outcome) => outcome.eventId > state.failedWakeThroughEventId,
+        (outcome) =>
+          outcome.eventId > state.failedWakeThroughEventId &&
+          !state.presentedEventIds.has(outcome.eventId),
       );
 
-      const wakeable = outcomes.filter((outcome) => {
-        const event = state.pendingEvents.find((pending) => pending.id === outcome.eventId);
-        return !event?.nextAttemptAt || event.nextAttemptAt <= Date.now();
-      });
+      const wakeable = outcomes.filter((outcome) =>
+        isWakeableEvent(state.pendingEvents.find((pending) => pending.id === outcome.eventId)),
+      );
       if (wakeable.length === 0) {
         const nextAttemptAt = outcomes
           .map((outcome) => state.pendingEvents.find((event) => event.id === outcome.eventId)?.nextAttemptAt)
@@ -331,7 +364,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         return;
       }
 
-      if (state.deliveredBatch || ctx.isIdle?.() === false) {
+      if (state.deliveredBatch || state.ackInFlight || ctx.isIdle?.() === false) {
         state.wakeDeferredUntilSettled = true;
         return;
       }
@@ -357,7 +390,6 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
             return;
           }
 
-          const requestedThroughEventId = wakeable.at(-1)?.eventId ?? 0;
           try {
             const response = (await state.client?.request(
               "agent.orchestrator.get",
@@ -370,10 +402,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
             applyConnectionStateResponse(response, ctx);
           } catch {
             state.wakeTimer = undefined;
-            state.failedWakeThroughEventId = Math.max(
-              state.failedWakeThroughEventId,
-              requestedThroughEventId,
-            );
+            // A failed load is only temporary: the batch stays pending and is
+            // retried on the next wake instead of being permanently suppressed.
             ctx.ui.notify?.(
               "Herdsman couldn’t load agent updates · updates remain pending",
               "warning",
@@ -399,7 +429,10 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
           const batchEvents = [...state.pendingEvents].sort((left, right) => left.id - right.id);
           const batchOutcomes = projectAgentOutcomes(batchEvents).outcomes.filter(
-            (outcome) => outcome.eventId > state.failedWakeThroughEventId,
+            (outcome) =>
+              outcome.eventId > state.failedWakeThroughEventId &&
+              !state.presentedEventIds.has(outcome.eventId) &&
+              isWakeableEvent(batchEvents.find((event) => event.id === outcome.eventId)),
           );
           if (batchOutcomes.length === 0) {
             state.wakeTimer = undefined;
@@ -428,26 +461,23 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
                 details: { eventIds: batchEvents.map((event) => event.id) },
                 display: false,
               },
-              { deliverAs: "followUp" },
-            );
-            pi.sendMessage?.(
-              {
-                content: wakeLabel(current.length),
-                customType: "herdsman-wake",
-                details: {
-                  eventIds: current.map((outcome) => outcome.eventId),
-                  outcomes: current,
-                } satisfies AgentUpdateMessageDetails,
-                display: true,
-              },
               { deliverAs: "followUp", triggerTurn: true },
             );
-            // Only expose the batch after both messages were accepted by pi. This
+            // Only expose the batch after the hidden context was accepted by pi. This
             // keeps an injection failure eligible for daemon redelivery.
             state.deliveredBatch = deliveredBatch;
             state.wakeRequested = false;
             state.wakeRequestedThroughEventId = 0;
+            // Record the presentation so a reclaim redelivery of the same id is
+            // never presented twice. The set is monotonic for the lifetime of
+            // the current orchestrator scope: ids are only removed on role
+            // loss, scope change, or shutdown (pruneAcknowledgedEvents keeps
+            // acknowledged ids on purpose).
+            for (const outcome of batchOutcomes) {
+              state.presentedEventIds.add(outcome.eventId);
+            }
           } catch {
+            state.deliveredBatch = undefined;
             state.wakeRequested = false;
           }
         };
@@ -455,8 +485,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       }, WAKE_SETTLE_MS);
     };
 
-    const loseRole = (ctx: PiContext | undefined, options: { abort?: boolean } = {}) => {
-      if (state.deliveredBatch) {
+    const loseRole = (
+      ctx: PiContext | undefined,
+      options: { abort?: boolean; preservePresented?: boolean } = {},
+    ) => {
+      if (state.deliveredBatch && !options.preservePresented) {
         state.deliveredBatch.invalidated = true;
         const abortedBatch = state.deliveredBatch;
         if (options.abort) {
@@ -486,13 +519,20 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       clearAgentContext();
       state.isOrchestrator = false;
       state.pendingEvents = [];
+      // A transient disconnect (reconnect) keeps the presentation guard so an
+      // event already presented in this scope session is not presented again;
+      // only a genuine role/scope loss or shutdown resets it.
+      if (!options.preservePresented) state.presentedEventIds.clear();
       state.reconnectingFromOn = false;
       setHerdsmanUi(ctx);
     };
 
     const markDisconnected = (ctx: PiContext | undefined) => {
       const reconnectingFromOn = state.reconnectingFromOn || state.isOrchestrator;
-      loseRole(ctx, { abort: false });
+      // Reconnects are not scope resets: keep the presentation guard and the
+      // in-flight batch so a settled turn can still be acknowledged and no
+      // already-presented event is injected twice.
+      loseRole(ctx, { abort: false, preservePresented: true });
       state.reconnectingFromOn = reconnectingFromOn;
       setHerdsmanUi(ctx);
     };
@@ -512,6 +552,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       cancelWake();
       state.failedWakeThroughEventId = 0;
       state.pendingEvents = [];
+      state.presentedEventIds.clear();
       setHerdsmanUi(ctx);
     };
 
@@ -520,7 +561,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       let addedNewEvent = false;
       for (const event of events) {
         const previous = byId.get(event.id);
-        if (!previous) addedNewEvent = true;
+        // Only an event that survives the dead-letter barrier counts as new.
+        // The server keeps re-listing dead-lettered events (id <= failedWakeThroughEventId)
+        // on every orchestrator.get; treating one as new would cancel the in-flight
+        // wake (wakeGeneration++) on every get and stall the whole stream forever.
+        if (!previous && event.id > state.failedWakeThroughEventId) addedNewEvent = true;
         byId.set(event.id, previous ? { ...event, ...previous } : event);
       }
       state.pendingEvents = [...byId.values()]
@@ -531,6 +576,58 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       scheduleWake(ctx);
     };
 
+    const syncPendingEventsFromServer = (
+      serverEvents: AgentEventWireRecord[],
+      ctx: PiContext | undefined,
+    ) => {
+      const serverEventById = new Map(serverEvents.map((event) => [event.id, event]));
+      const inFlightIds = new Set(state.deliveredBatch?.events.map((event) => event.id) ?? []);
+      const previousById = new Map(state.pendingEvents.map((event) => [event.id, event]));
+      const isTruncated = serverEvents.length >= 100;
+      const maxServerEventId = serverEvents.reduce((max, event) => Math.max(max, event.id), 0);
+
+      let addedNewEvent = false;
+      const nextPending: AgentEventWireRecord[] = [];
+
+      for (const serverEvent of serverEvents) {
+        const previous = previousById.get(serverEvent.id);
+        if (!previous && serverEvent.id > state.failedWakeThroughEventId) addedNewEvent = true;
+        nextPending.push(previous ? { ...serverEvent, ...previous } : serverEvent);
+      }
+
+      for (const [previousId, previousEvent] of previousById) {
+        if (serverEventById.has(previousId)) continue;
+        if (inFlightIds.has(previousId)) {
+          nextPending.push(previousEvent);
+        } else if (isTruncated && previousId > maxServerEventId) {
+          nextPending.push(previousEvent);
+        }
+      }
+
+      for (const inFlightId of inFlightIds) {
+        if (!serverEventById.has(inFlightId) && !previousById.has(inFlightId)) {
+          const inFlightEvent = state.deliveredBatch?.events.find(
+            (event) => event.id === inFlightId,
+          );
+          if (inFlightEvent) {
+            nextPending.push(inFlightEvent);
+          }
+        }
+      }
+
+      state.pendingEvents = nextPending
+        .filter((event) => event.id > state.failedWakeThroughEventId)
+        .sort((left, right) => left.id - right.id);
+
+      setHerdsmanUi(ctx);
+      if (state.pendingEvents.length === 0 && state.wakeTimer) {
+        cancelWakeTimer();
+      } else if (addedNewEvent && state.wakeTimer) {
+        cancelWakeTimer();
+      }
+      scheduleWake(ctx);
+    };
+
     const applyConnectionStateResponse = (
       response: ConnectionStateResponse,
       ctx: PiContext | undefined,
@@ -563,10 +660,25 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       }
       state.isOrchestrator = true;
       state.reconnectingFromOn = false;
+      if (state.deliveredBatch) {
+        if (state.deliveredBatch.invalidated || ctx?.isIdle?.() !== false) {
+          // A batch invalidated by a genuine role/scope reset, or a batch whose
+          // wake turn is no longer running (it never started, or it already
+          // settled during the disconnect), can no longer be acknowledged by a
+          // future settlement. Clear it so the still-pending events can be
+          // re-woken on this fresh connection instead of being gated forever;
+          // already acked events are covered by the server cursor
+          // (pruneAcknowledgedEvents below).
+          state.deliveredBatch = undefined;
+        }
+        // Otherwise the batch's wake turn is still in flight: keep it so the
+        // settlement acknowledges it and the events are not re-presented.
+      }
       applyOwnerContext(response);
       setHerdsmanUi(ctx);
-      addPendingEvents(response.events ?? [], ctx);
+      syncPendingEventsFromServer(response.events ?? [], ctx);
       pruneAcknowledgedEvents(response.state?.ackedEventId ?? response.ackedEventId);
+      if (state.pendingEvents.length === 0 && state.wakeTimer) cancelWakeTimer();
       setHerdsmanUi(ctx);
       scheduleWake(ctx);
     };
@@ -649,12 +761,14 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
             snapshot
               ? {
                   ...snapshot,
-                  agents: snapshot.agents.filter((agent) => {
-                    const nextAgents = next?.agents.filter((candidate) => candidate.paneId === agent.paneId) ?? [];
-                    if (nextAgents.length === 0) return false;
-                    return nextAgents.some(
-                      (nextAgent) => !agent.id || !nextAgent.id || agent.id === nextAgent.id,
+                  agents: snapshot.agents.flatMap((agent) => {
+                    const nextAgents =
+                      next?.agents.filter((candidate) => candidate.paneId === agent.paneId) ?? [];
+                    if (nextAgents.length === 0) return [];
+                    const nextAgent = nextAgents.find(
+                      (candidate) => !agent.id || !candidate.id || agent.id === candidate.id,
                     );
+                    return nextAgent ? [nextAgent] : [];
                   }),
                 }
               : undefined;
@@ -687,11 +801,13 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         })
         .then((response) => {
           state.connected = true;
+          startKeepalive(client);
           applyConnectionStateResponse(response as ConnectionStateResponse, ctx, {
             notifyReconnectLoss: true,
           });
         })
         .catch((error) => {
+          stopKeepalive();
           state.connected = false;
           const incompatibleMessage =
             error instanceof Error && /incompatible/i.test(error.message)
@@ -770,12 +886,19 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         loseRole(ctx);
         return;
       }
+      stopKeepalive();
       state.client?.close();
       const client = options.clientFactory?.() ?? new ReconnectingDaemonClient({ socketPath: defaultSocketPath() });
       client.resetForSession?.();
+      const closeClient = client.close.bind(client);
+      client.close = () => {
+        stopKeepalive();
+        closeClient();
+      };
       state.client = client;
       client.onConnected = () => registerPresence(ctx);
       client.onDisconnected = () => {
+        stopKeepalive();
         state.connected = false;
         markDisconnected(activeContext);
       };
@@ -783,9 +906,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
     });
 
     pi.on("session_shutdown", () => {
+      stopKeepalive();
       state.connected = false;
       loseRole(activeContext);
       state.deliveredBatch = undefined;
+      state.presentedEventIds.clear();
       state.client?.close();
       state.client = undefined;
       activeContext = undefined;
@@ -906,6 +1031,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         return;
       }
       state.deliveredBatch = undefined;
+      state.ackInFlight = true;
       const stillOwner =
         state.isOrchestrator && state.currentScope?.terminalId === batch.ownerTerminalId;
       const failBatch = () => {
@@ -915,6 +1041,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         );
       };
       const finishBatch = () => {
+        state.ackInFlight = false;
         state.wakeDeferredUntilSettled = false;
         setHerdsmanUi(ctx);
         scheduleWake(ctx);
@@ -939,6 +1066,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           })) as { ackedEventId?: number; state?: { ackedEventId?: number } };
           pruneAcknowledgedEvents(ackResponse?.ackedEventId ?? ackResponse?.state?.ackedEventId);
           state.pendingEvents = state.pendingEvents.filter((pending) => pending.id !== event.id);
+          // The id intentionally stays in presentedEventIds: the event was
+          // already presented this session and must not be injected again even
+          // if the daemon replays it (for example after a reconnect
+          // redelivery). The set is cleared only on role loss, scope change,
+          // or shutdown.
           state.failedWakeThroughEventId = Math.max(state.failedWakeThroughEventId, event.id);
           setHerdsmanUi(ctx);
         } catch (error) {
@@ -977,6 +1109,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
           if (attempts >= MAX_ACK_ATTEMPTS) {
             state.pendingEvents = state.pendingEvents.filter((pending) => pending.id !== event.id);
+            state.failedWakeThroughEventId = Math.max(state.failedWakeThroughEventId, event.id);
             logHerdsmanPi(
               "warn",
               `[herdsman-pi] acknowledgement moved to dead-letter eventId=${event.id} attempts=${attempts} code=${failureCode}`,
@@ -1012,7 +1145,12 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
                 `[herdsman-pi] acknowledgement resync failed eventId=${event.id} attempts=${attempts} code=${ackFailureCode(resyncError)}`,
               );
             }
-            break;
+            // The event stays pending with a backoff so the ack cursor can
+            // sweep it later, but it was already presented this session and is
+            // not re-presented: presentedEventIds keeps the guard until scope
+            // reset. Continue so one failed event does not block the rest of
+            // the batch.
+            continue;
           }
 
           state.pendingEvents = state.pendingEvents.map((pending) =>
@@ -1025,7 +1163,10 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
             "warning",
           );
           setHerdsmanUi(ctx);
-          break;
+          // The event stays pending with a backoff so the ack cursor can sweep
+          // it later, but it was already presented this session and is not
+          // re-presented: presentedEventIds keeps the guard until scope reset.
+          continue;
         }
       }
       finishBatch();
@@ -1049,11 +1190,44 @@ export function formatHiddenAgentContext(input: {
         agent: agent.agent ?? "unknown",
         name: agent.name,
       });
-      return [
-        `- ${identity} ${agent.paneId ?? "unknown"} ${agent.agentStatus ?? "unknown"}`,
-        `  last user: ${oneLine(history.lastUserMessage?.text ?? "")}`,
-        `  last assistant: ${oneLine(history.lastAssistantMessage?.text ?? "")}`,
-      ].join("\n");
+      const paneId = agent.paneId ?? "unknown";
+      const status = agent.agentStatus ?? "unknown";
+      const prefix = `- ${identity} ${paneId} ${status}`;
+
+      const rawAgent = record(agent);
+      const tabTitleCandidate =
+        stringValue(rawAgent.terminalTitle) ?? stringValue(rawAgent.label);
+      const tabTitleCleaned =
+        tabTitleCandidate !== null ? sanitizeAndCleanContextText(tabTitleCandidate) : "";
+      const tabTitle =
+        tabTitleCleaned.length > 0 ? truncateSummary(tabTitleCleaned, 60) : null;
+
+      const rawHistory = record(history);
+      const lastAssistantRecord = record(history.lastAssistantMessage);
+      const timeCandidate =
+        lastAssistantRecord.timestamp ??
+        history.updatedAt ??
+        rawHistory.updatedAt ??
+        rawAgent.updatedAt ??
+        rawAgent.time;
+      const formattedTime = formatTimestamp(timeCandidate);
+
+      const assistantRaw = history.lastAssistantMessage?.text;
+      const assistantCleaned =
+        assistantRaw !== undefined && assistantRaw !== null
+          ? sanitizeAndCleanContextText(assistantRaw)
+          : "";
+      const assistantSummary =
+        assistantCleaned.length > 0 ? truncateSummary(assistantCleaned, 100) : null;
+
+      const segments = [
+        prefix,
+        tabTitle,
+        formattedTime,
+        assistantSummary,
+      ].filter((segment): segment is string => segment !== null && segment.length > 0);
+
+      return segments.join(" · ");
     }),
     "Use herdsman agent get/read if details are needed.",
   ].join("\n");
@@ -1071,7 +1245,7 @@ export function formatHiddenAgentUpdates(events: AgentEventWireRecord[]): string
       });
       return [
         `- ${event.type} ${identity} ${event.paneId ?? "unknown"}`,
-        `  last assistant: ${oneLine(history.lastAssistantMessage?.text ?? "")}`,
+        `  last assistant: ${oneLine(sanitizeText(history.lastAssistantMessage?.text ?? "").text)}`,
         `  event: ${event.id}`,
       ].join("\n");
     }),
@@ -1135,3 +1309,50 @@ function record(value: unknown): Record<string, unknown> {
 function oneLine(value: string): string {
   return value.replace(/\s+/g, " ");
 }
+
+function cleanContextText(value: string): string {
+  return stripVTControlCharacters(value)
+    .replace(
+      /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u00ad\u180e\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g,
+      "",
+    )
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function sanitizeAndCleanContextText(value: string): string {
+  const preCleaned = cleanContextText(value);
+  if (!preCleaned) return "";
+  const sanitized = sanitizeText(preCleaned).text;
+  return cleanContextText(sanitized);
+}
+
+function truncateSummary(value: string, limit = 100): string {
+  if (value.length <= limit) return value;
+  const maxSearch = Math.min(value.length, limit + 8);
+  const searchSlice = value.slice(0, maxSearch);
+  const lastSpaceIndex = searchSlice.search(/\s[^\s]*$/);
+  if (lastSpaceIndex >= limit - 20) {
+    return `${value.slice(0, lastSpaceIndex)}…`;
+  }
+  return `${value.slice(0, limit)}…`;
+}
+
+function formatTimestamp(value: unknown): string | null {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (/^\d{2}:\d{2}:\d{2}$/.test(trimmed)) return trimmed;
+    if (/^\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(trimmed)) return trimmed;
+  }
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value as string | number);
+  if (Number.isNaN(date.getTime())) return null;
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+

package/src/sanitize-text.ts

@@ -0,0 +1,23 @@
+export function sanitizeText(value: unknown): { redacted: boolean; text: string } {
+  let text = typeof value === "string" ? value : JSON.stringify(value);
+  if (text === undefined) text = String(value);
+  let redacted = false;
+  for (const pattern of [
+    /(Authorization:\s*Bearer\s+)[^\s]+/gi,
+    /\b(Bearer\s+)[A-Za-z0-9._\-+=/]+/gi,
+    /\b(token=)[^\s&]+/gi,
+    /\b(password=)[^\s&]+/gi,
+    /\b(secret=)[^\s&]+/gi,
+    /\b(api_key=)[^\s&]+/gi,
+  ]) {
+    text = text.replace(pattern, (_match, prefix: string) => {
+      redacted = true;
+      return `${prefix}[REDACTED]`;
+    });
+  }
+  text = text.replace(/\bsk-[A-Za-z0-9_-]{8,}/g, () => {
+    redacted = true;
+    return "sk-[REDACTED]";
+  });
+  return { redacted, text };
+}

package/src/wake.ts

@@ -7,9 +7,10 @@ export const WAKE_SETTLE_MS = 500;
 export type AgentOutcome = {
   agent: string;
   eventId: number;
-  kind: "blocked" | "completed";
+  kind: "blocked" | "completed" | "failed";
   name?: string | null;
   paneId: string | null;
+  reason?: string;
   terminalId: string;
   text: string;
 };
@@ -31,6 +32,7 @@ function outcomeKind(event: AgentEventWireRecord): AgentOutcome["kind"] | undefi
   if (!event.terminalId) return undefined;
   if (event.type === "agent.done") return "completed";
   if (event.type === "agent.blocked") return "blocked";
+  if (event.type === "agent.failed") return "failed";
   const payload = asRecord(event.payload);
   if (event.type === "agent.idle" && payload.from === "working") return "completed";
   return undefined;
@@ -45,7 +47,8 @@ function project(events: AgentEventWireRecord[], seen: Set<number>): AgentOutcom
     const payload = asRecord(event.payload);
     const paneId = event.paneId ?? null;
     const text = normalizeExcerpt(event.compactHistory?.lastAssistantMessage?.text);
-    return [{ agent: stringValue(payload.agent) ?? stringValue(event.agentId) ?? paneId ?? event.terminalId, eventId: event.id, kind, name: stringValue(payload.name) ?? null, paneId, terminalId: event.terminalId, text }];
+    const reason = kind === "failed" ? normalizeExcerpt(payload.reason) : undefined;
+    return [{ agent: stringValue(payload.agent) ?? stringValue(event.agentId) ?? paneId ?? event.terminalId, eventId: event.id, kind, name: stringValue(payload.name) ?? null, paneId, ...(reason ? { reason } : {}), terminalId: event.terminalId, text }];
   });
   for (const outcome of outcomes) seen.add(outcome.eventId);
   return { outcomes, rawEvents };
@@ -54,9 +57,14 @@ export function projectAgentOutcomes(events: AgentEventWireRecord[]): AgentOutco
 export function createAgentOutcomeProjector(): (events: AgentEventWireRecord[]) => AgentOutcomeProjection { const seen = new Set<number>(); return (events) => project(events, seen); }
 export function formatAgentOutcomeUpdates(outcomes: AgentOutcome[]): string {
   const updates = outcomes.map((outcome) => {
-    const excerpt = outcome.text.length > 0 ? outcome.text : "(no assistant message)";
     const identity = agentIdentityLabel({ agent: outcome.agent, name: outcome.name });
-    return `- ${outcome.kind} ${identity} ${outcome.paneId ?? "unknown"}\n  last assistant: ${excerpt}\n  event: ${outcome.eventId}`;
+    const pane = outcome.paneId ?? "unknown";
+    if (outcome.kind === "failed") {
+      const reason = outcome.reason && outcome.reason.length > 0 ? outcome.reason : "(unknown)";
+      return `- failed ${identity} ${pane}\n  reason: ${reason}`;
+    }
+    const excerpt = outcome.text.length > 0 ? outcome.text : "(no assistant message)";
+    return `- ${outcome.kind} ${identity} ${pane}\n  last assistant: ${excerpt}\n  event: ${outcome.eventId}`;
   }).join("\n");
   return `${WAKE_POLICY}\n\n[HERDSMAN AGENT UPDATES]\n${updates}`;
 }