@dorokuma/herdsman-pi 0.14.6 → 0.14.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.14.6",
+  "version": "0.14.9",
   "description": "Pi extension bridge for Herdsman agent history.",
   "type": "module",
   "keywords": [
@@ -21,9 +21,6 @@
     "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,5 +34,8 @@
   "bugs": {
     "url": "https://github.com/dorokuma/herdsman/issues"
   },
-  "homepage": "https://github.com/dorokuma/herdsman#readme"
-}
+  "homepage": "https://github.com/dorokuma/herdsman#readme",
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}

package/src/daemon-client.ts

@@ -11,8 +11,10 @@ export type AgentEventWireRecord = {
   createdAt?: string;
   herdrSessionName?: string;
   id: number;
+  paneGeneration?: string | null;
   paneId?: string | null;
   payload: unknown;
+  status?: "pending" | "delivered" | "acked" | "invalidated" | "failed";
   terminalId?: string | null;
   type: string;
   workspaceId?: string | null;

package/src/index.ts

@@ -21,9 +21,11 @@ import {
   type HerdsmanFooterState,
 } from "./agent-update-ui.js";
 import {
-  projectAgentOutcomes,
   formatAgentOutcomeUpdates,
+  projectAgentOutcomes,
+  pruneCompletedPanes,
   type AgentOutcome,
+  type CompletedPaneKey,
   WAKE_SETTLE_MS,
 } from "./wake.js";
 import { loadWakeFilterConfig } from "./wake-filter-config.js";
@@ -241,6 +243,8 @@ type HerdsmanState = {
   wakeRequested: boolean;
   wakeRequestedThroughEventId: number;
   wakeTimer: ReturnType<typeof setTimeout> | undefined;
+  /** Completion evidence retained after its event leaves the pending window. */
+  completedPaneKeys: Set<string>;
 };
 
 type PiContext = {
@@ -476,6 +480,18 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       wakeRequestedThroughEventId: 0,
       wakeTimer: undefined,
       ackInFlight: false,
+      completedPaneKeys: new Set(),
+    };
+    // Completion evidence is the only part of the projection that must outlive a
+    // single batch; the dedup set stays per call exactly as before.
+    let completedPanes = new Map<CompletedPaneKey, number>();
+    const syncCompletedPaneKeys = () => {
+      state.completedPaneKeys = new Set(completedPanes.keys());
+    };
+    const projectPendingOutcomes = (events: AgentEventWireRecord[]) => {
+      const projection = projectAgentOutcomes(events, wakeFilter, completedPanes);
+      syncCompletedPaneKeys();
+      return projection;
     };
     options.onStateExposed?.(state);
     let activeContext: PiContext | undefined;
@@ -503,7 +519,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
     const setHerdsmanUi = (ctx: PiContext | undefined) => {
       if (!ctx) return;
-      const pendingOutcomeCount = projectAgentOutcomes(state.pendingEvents, wakeFilter).outcomes.length;
+      const pendingOutcomeCount = projectAgentOutcomes(
+        state.pendingEvents,
+        wakeFilter,
+        new Map(completedPanes),
+      ).outcomes.length;
       const footerState: HerdsmanFooterState = state.reconnectingFromOn
         ? { kind: "reconnecting" }
         : state.isOrchestrator
@@ -667,6 +687,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       // 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);
+      completedPanes = pruneCompletedPanes(completedPanes, ackedEventId);
+      syncCompletedPaneKeys();
       // The delivery queue follows the same watermark: an event covered by the
       // advanced acknowledgement cursor is confirmed even when its own ack was
       // superseded (the daemon acknowledges by watermark), so it leaves the
@@ -1370,7 +1392,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         // deferral there would let a second injection ride in behind it.
         return;
       }
-      const projection = projectAgentOutcomes(state.pendingEvents, wakeFilter);
+      const projection = projectPendingOutcomes(state.pendingEvents);
       const outcomes = projection.outcomes.filter(
         (outcome) =>
           outcome.eventId > state.failedWakeThroughEventId &&
@@ -1527,7 +1549,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           }
 
           const batchEvents = [...state.pendingEvents].sort((left, right) => left.id - right.id);
-          const batchProjection = projectAgentOutcomes(batchEvents, wakeFilter);
+          const batchProjection = projectPendingOutcomes(batchEvents);
           const batchSuppressedIds = new Set(batchProjection.suppressedEventIds);
           const projectableBatchOutcomes = batchProjection.outcomes.filter(
             (outcome) =>
@@ -1741,6 +1763,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.failedWakeThroughEventId = 0;
       state.pendingEvents = [];
       clearDeliveryBookkeeping();
+      completedPanes = new Map();
+      syncCompletedPaneKeys();
       setHerdsmanUi(ctx);
     };
 
@@ -1754,7 +1778,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
         // 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);
+        // Server fields win; the local snapshot only fills keys the page omitted.
+        byId.set(event.id, previous ? { ...previous, ...event } : event);
       }
       state.pendingEvents = [...byId.values()]
         .filter((event) => event.id > state.failedWakeThroughEventId)
@@ -1767,10 +1792,14 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
     const syncPendingEventsFromServer = (
       serverEvents: AgentEventWireRecord[],
       ctx: PiContext | undefined,
+      serverAckedEventId = 0,
     ) => {
       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]));
+      // The daemon's pending page is hard-capped at 100, so a page of exactly
+      // 100 cannot tell "exhausted" from "more remain". Keep any higher local id
+      // rather than drop it: a later shorter page is what proves the stream ended.
       const isTruncated = serverEvents.length >= 100;
       const maxServerEventId = serverEvents.reduce((max, event) => Math.max(max, event.id), 0);
 
@@ -1780,14 +1809,29 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       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);
+        // Server fields win; the local snapshot only fills keys the page omitted.
+        nextPending.push(previous ? { ...previous, ...serverEvent } : serverEvent);
       }
 
       for (const [previousId, previousEvent] of previousById) {
         if (serverEventById.has(previousId)) continue;
-        if (inFlightIds.has(previousId)) {
+        const barrier =
+          state.unackedDelivered.has(previousId) &&
+          (state.wakeAwaitingConsumption.has(previousId) ||
+            state.wakeRetryableEventIds.has(previousId));
+        // Only the server cursor settles an absent barrier. A local status of
+        // acked/failed is a stale snapshot (and, when merged, the server's own
+        // status wins), so it must not reap a watermark barrier by itself.
+        const settledByServer = previousId <= serverAckedEventId;
+        // Absence from pending() is not settlement: generation, reclaim, and
+        // backoff filters hide events that are still deliverable. A local
+        // watermark barrier stays until the server cursor covers it.
+        if (barrier && !settledByServer) {
           nextPending.push(previousEvent);
-        } else if (isTruncated && previousId > maxServerEventId) {
+          continue;
+        }
+        if (settledByServer) continue;
+        if (inFlightIds.has(previousId) || (isTruncated && previousId > maxServerEventId)) {
           nextPending.push(previousEvent);
         }
       }
@@ -1864,8 +1908,14 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       }
       applyOwnerContext(response);
       setHerdsmanUi(ctx);
-      syncPendingEventsFromServer(response.events ?? [], ctx);
+      // The watermark first: a barrier the server has already settled is reaped
+      // inside the sync instead of being kept as a barrier by it.
       pruneAcknowledgedEvents(response.state?.ackedEventId ?? response.ackedEventId);
+      syncPendingEventsFromServer(
+        response.events ?? [],
+        ctx,
+        response.state?.ackedEventId ?? response.ackedEventId ?? 0,
+      );
       if (state.pendingEvents.length === 0 && state.wakeTimer) cancelWakeTimer();
       setHerdsmanUi(ctx);
       scheduleWake(ctx);

package/src/wake.ts

@@ -7,6 +7,10 @@ import { DEFAULT_WAKE_FILTER_CONFIG, isUpstreamModelError, type WakeFilterConfig
 // next microtask (0ms timer) instead of waiting out a settle window. Delivery
 // latency is owned by the bounded deferral in the extension, not by this delay.
 export const WAKE_SETTLE_MS = 0;
+// Mirrors `PLAN_WAITING_HISTORY` in `src/observability/contracts.ts` (the string
+// value is the contract; duplicated here because `@dorokuma/herdsman-pi` ships
+// standalone `src/` without root `src/`).
+export const PLAN_WAITING_HISTORY = "PLAN_WAITING_HISTORY";
 
 export type AgentOutcome = {
   agent: string;
@@ -80,7 +84,7 @@ function outcomeKind(event: AgentEventWireRecord): AgentOutcome["kind"] | undefi
     const reason = stringValue(payload.reason);
     // Backward compatibility filter for legacy pre-upgrade failed rows with PLAN_WAITING_HISTORY
     // and degraded retries that exceeded the bounded retry budget.
-    if (reason === "PLAN_WAITING_HISTORY" || reason === "degraded") {
+    if (reason === PLAN_WAITING_HISTORY || reason === "degraded") {
       if (payload.fallbackOutcome === true) {
         return "failed";
       }
@@ -97,10 +101,47 @@ function outcomeKind(event: AgentEventWireRecord): AgentOutcome["kind"] | undefi
   if (event.type === "agent.idle" && payload.from === "working") return "completed";
   return undefined;
 }
+export type CompletedPaneKey = `${string}\u0000${string}`;
+
+/** A completion without a pane generation is not evidence for any generation. */
+export function completedPaneKey(
+  paneId: string,
+  paneGeneration: string | null | undefined,
+): CompletedPaneKey | undefined {
+  if (paneGeneration === null || paneGeneration === undefined || paneGeneration.length === 0) {
+    return undefined;
+  }
+  return `${paneId}\u0000${paneGeneration}`;
+}
+
+export type AgentOutcomeProjector = ((events: AgentEventWireRecord[]) => AgentOutcomeProjection) & {
+  completedPaneKeys(): readonly CompletedPaneKey[];
+  /** Drops completion evidence covered by the daemon's acknowledgement watermark. */
+  pruneCompletedPanes(ackedEventId: number | undefined): void;
+};
+
+function rememberCompletedPane(
+  completedPanes: Map<CompletedPaneKey, number>,
+  event: AgentEventWireRecord,
+): void {
+  if (!event.paneId) return;
+  if (
+    event.type !== "agent.done" &&
+    !(event.type === "agent.idle" && asRecord(event.payload).from === "working")
+  ) {
+    return;
+  }
+  const key = completedPaneKey(event.paneId, event.paneGeneration);
+  if (!key) return;
+  const current = completedPanes.get(key);
+  if (current === undefined || event.id > current) completedPanes.set(key, event.id);
+}
+
 function project(
   events: AgentEventWireRecord[],
   seen: Set<number>,
   config: WakeFilterConfig,
+  completedPanes: Map<CompletedPaneKey, number> = new Map(),
 ): AgentOutcomeProjection {
   const uniqueEvents = new Map<number, AgentEventWireRecord>();
   for (const event of events) if (!seen.has(event.id) && !uniqueEvents.has(event.id)) uniqueEvents.set(event.id, event);
@@ -108,26 +149,23 @@ function project(
   const outcomes: AgentOutcome[] = [];
   const suppressedEventIds: number[] = [];
 
-  // 维护单次扫描中已具备成功完成态的 pane 集合
-  const completedPaneIds = new Set<string>();
-  for (const event of rawEvents) {
-    if (
-      event.paneId &&
-      (event.type === "agent.done" || (event.type === "agent.idle" && asRecord(event.payload).from === "working"))
-    ) {
-      completedPaneIds.add(event.paneId);
-    }
-  }
+  // Completion evidence survives the current batch: a later fallback for the
+  // same pane and the same generation stays suppressed after the completion
+  // itself has left the pending window. A missing generation proves nothing.
+  for (const event of rawEvents) rememberCompletedPane(completedPanes, event);
 
   for (const event of rawEvents) {
     const kind = outcomeKind(event);
     if (!kind || !event.terminalId) continue;
     const payload = asRecord(event.payload);
     const paneId = event.paneId ?? null;
+    const completedKey = event.paneId
+      ? completedPaneKey(event.paneId, event.paneGeneration)
+      : undefined;
 
-    // 核心噪音门禁：若当前事件为 fallbackOutcome，但该 pane 存在任意成功的完成事件，直接压制
-    if (payload.fallbackOutcome === true && event.paneId && completedPaneIds.has(event.paneId)) {
-      continue; // 压制噪音，不产生 outcome
+    // A fallback is noise only when this exact pane generation already completed.
+    if (payload.fallbackOutcome === true && completedKey !== undefined && completedPanes.has(completedKey)) {
+      continue;
     }
 
     const text = normalizeExcerpt(event.compactHistory?.lastAssistantMessage?.text);
@@ -153,8 +191,37 @@ function project(
   for (const outcome of outcomes) seen.add(outcome.eventId);
   return { outcomes, rawEvents, suppressedEventIds };
 }
-export function projectAgentOutcomes(events: AgentEventWireRecord[], config: WakeFilterConfig = DEFAULT_WAKE_FILTER_CONFIG): AgentOutcomeProjection { return project(events, new Set(), config); }
-export function createAgentOutcomeProjector(config: WakeFilterConfig = DEFAULT_WAKE_FILTER_CONFIG): (events: AgentEventWireRecord[]) => AgentOutcomeProjection { const seen = new Set<number>(); return (events) => project(events, seen, config); }
+export function projectAgentOutcomes(
+  events: AgentEventWireRecord[],
+  config: WakeFilterConfig = DEFAULT_WAKE_FILTER_CONFIG,
+  completedPanes?: Map<CompletedPaneKey, number>,
+): AgentOutcomeProjection {
+  return project(events, new Set(), config, completedPanes);
+}
+
+/** Drops completion evidence the daemon's acknowledgement watermark has covered. */
+export function pruneCompletedPanes(
+  completedPanes: Map<CompletedPaneKey, number>,
+  ackedEventId: number | undefined,
+): Map<CompletedPaneKey, number> {
+  if (ackedEventId === undefined) return completedPanes;
+  for (const [key, eventId] of completedPanes) {
+    if (eventId <= ackedEventId) completedPanes.delete(key);
+  }
+  return completedPanes;
+}
+
+export function createAgentOutcomeProjector(config: WakeFilterConfig = DEFAULT_WAKE_FILTER_CONFIG): AgentOutcomeProjector {
+  const seen = new Set<number>();
+  const completedPanes = new Map<CompletedPaneKey, number>();
+  const projector = ((events: AgentEventWireRecord[]) =>
+    project(events, seen, config, completedPanes)) as AgentOutcomeProjector;
+  projector.completedPaneKeys = () => [...completedPanes.keys()];
+  projector.pruneCompletedPanes = (ackedEventId) => {
+    pruneCompletedPanes(completedPanes, ackedEventId);
+  };
+  return projector;
+}
 export function formatAgentOutcomeUpdates(outcomes: AgentOutcome[]): string {
   const updates = outcomes.map((outcome) => {
     const identity = agentIdentityLabel({ agent: outcome.agent, name: outcome.name });