@dorokuma/herdsman-pi 0.9.0 → 0.11.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.9.0",
+  "version": "0.11.4",
   "description": "Pi extension bridge for Herdsman agent history. Forked from @ryonakae/herdsman.",
   "type": "module",
   "keywords": [
@@ -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,6 +239,7 @@ 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,
@@ -252,7 +264,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,4 +1,5 @@
 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";
@@ -110,12 +111,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 +171,7 @@ type PiApi = {
 type ExtensionOptions = {
   clientFactory?: () => HerdsmanDaemonClient;
   onTurnCompletionSignal?: (completion: Promise<void>) => void;
+  onStateExposed?: (state: HerdsmanState) => void;
 };
 
 const DEFAULT_HOME_NAME = ".herdsman";
@@ -248,6 +252,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       latestContext: undefined,
       pendingEvents: [],
       pinnedContext: undefined,
+      presentedEventIds: new Set(),
       reconnectingFromOn: false,
       registrationInFlight: undefined,
       roleMutationInFlight: false,
@@ -258,7 +263,9 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       wakeRequested: false,
       wakeRequestedThroughEventId: 0,
       wakeTimer: undefined,
+      ackInFlight: false,
     };
+    options.onStateExposed?.(state);
     let activeContext: PiContext | undefined;
     let wakeGeneration = 0;
 
@@ -288,9 +295,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 +303,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 +325,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 +347,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 +373,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 +385,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 +412,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 +444,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 +468,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 +502,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 +535,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       cancelWake();
       state.failedWakeThroughEventId = 0;
       state.pendingEvents = [];
+      state.presentedEventIds.clear();
       setHerdsmanUi(ctx);
     };
 
@@ -520,7 +544,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 +559,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 +643,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);
     };
@@ -786,6 +881,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.connected = false;
       loseRole(activeContext);
       state.deliveredBatch = undefined;
+      state.presentedEventIds.clear();
       state.client?.close();
       state.client = undefined;
       activeContext = undefined;
@@ -906,6 +1002,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 +1012,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         );
       };
       const finishBatch = () => {
+        state.ackInFlight = false;
         state.wakeDeferredUntilSettled = false;
         setHerdsmanUi(ctx);
         scheduleWake(ctx);
@@ -939,6 +1037,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 +1080,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 +1116,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 +1134,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();
@@ -1051,8 +1163,8 @@ export function formatHiddenAgentContext(input: {
       });
       return [
         `- ${identity} ${agent.paneId ?? "unknown"} ${agent.agentStatus ?? "unknown"}`,
-        `  last user: ${oneLine(history.lastUserMessage?.text ?? "")}`,
-        `  last assistant: ${oneLine(history.lastAssistantMessage?.text ?? "")}`,
+        `  last user: ${oneLine(sanitizeText(history.lastUserMessage?.text ?? "").text)}`,
+        `  last assistant: ${oneLine(sanitizeText(history.lastAssistantMessage?.text ?? "").text)}`,
       ].join("\n");
     }),
     "Use herdsman agent get/read if details are needed.",
@@ -1071,7 +1183,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");
     }),

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}`;
 }

package/LICENSE

@@ -1,23 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ryo Nakae
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-Copyright (c) 2026 dorokuma (herdsman)