@dorokuma/herdsman-pi 0.14.7 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.14.7",
+  "version": "0.15.0",
   "description": "Pi extension bridge for Herdsman agent history.",
   "type": "module",
   "keywords": [

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";
@@ -95,6 +97,7 @@ type DeliveredBatch = {
 };
 
 type HerdsmanState = {
+  autoClaimAttempted: boolean;
   client: HerdsmanDaemonClient | undefined;
   connected: boolean;
   currentScope: CurrentScope | undefined;
@@ -241,6 +244,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 = {
@@ -446,6 +451,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
     const wakeFilter = options.wakeFilter ?? loadWakeFilterConfig();
 
     const state: HerdsmanState = {
+      autoClaimAttempted: false,
       client: undefined,
       connected: false,
       currentScope: undefined,
@@ -476,6 +482,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 +521,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 +689,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 +1394,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 +1551,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 +1765,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.failedWakeThroughEventId = 0;
       state.pendingEvents = [];
       clearDeliveryBookkeeping();
+      completedPanes = new Map();
+      syncCompletedPaneKeys();
       setHerdsmanUi(ctx);
     };
 
@@ -1754,7 +1780,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 +1794,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 +1811,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 +1910,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);
@@ -1971,10 +2023,32 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
           subscriberKind: "pi",
           workspaceId: state.currentScope?.workspaceId ?? launchIdentity.workspaceId,
         })
-        .then((response) => {
+        .then(async (rawResponse) => {
           state.connected = true;
           startKeepalive(client);
-          applyConnectionStateResponse(response as ConnectionStateResponse, ctx, {
+          let response = rawResponse as ConnectionStateResponse;
+          const currentPaneId = state.currentScope?.paneId ?? launchIdentity.paneId;
+          if (
+            process.env.HERDSMAN_AUTO_ON === "1" &&
+            !state.autoClaimAttempted &&
+            isMainOrchestratorPane(currentPaneId) &&
+            !isDispatchedRoleSession(sessionRef.value, process.env)
+          ) {
+            state.autoClaimAttempted = true;
+            if (!isLocalOwner(response) && !response.state?.owner) {
+              try {
+                state.roleMutationInFlight = true;
+                response = (await client.request("agent.orchestrator.set", {
+                  enabled: true,
+                })) as ConnectionStateResponse;
+              } catch {
+                // Ignore race if another terminal claimed the workspace concurrently.
+              } finally {
+                state.roleMutationInFlight = false;
+              }
+            }
+          }
+          applyConnectionStateResponse(response, ctx, {
             notifyReconnectLoss: true,
           });
         })
@@ -2045,6 +2119,7 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
     pi.on("session_start", (_event: unknown, ctx: PiContext) => {
       activeContext = ctx;
+      state.autoClaimAttempted = false;
       state.subscriberId = ctx.sessionManager.getSessionId();
       state.sessionRef = {
         agent: "pi",
@@ -2388,6 +2463,17 @@ function herdrLaunchIdentity(environment: NodeJS.ProcessEnv): LaunchIdentity | u
   return { herdrSocketPath, paneId, workspaceId };
 }
 
+function isMainOrchestratorPane(paneId: string): boolean {
+  return paneId.trim().endsWith(":p1");
+}
+
+function isDispatchedRoleSession(sessionPath: string, environment: NodeJS.ProcessEnv): boolean {
+  if (typeof environment.CTXMODE_ROLE === "string" && environment.CTXMODE_ROLE.trim().length > 0) {
+    return true;
+  }
+  return sessionPath.startsWith("/tmp/herdr-role-sessions/");
+}
+
 
 function stringValue(value: unknown): string | null {
   return typeof value === "string" && value.length > 0 ? value : null;

package/src/wake.ts

@@ -11,6 +11,7 @@ export const WAKE_SETTLE_MS = 0;
 // 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 const PLAN_STALLED = "PLAN_STALLED";
 
 export type AgentOutcome = {
   agent: string;
@@ -93,18 +94,65 @@ function outcomeKind(event: AgentEventWireRecord): AgentOutcome["kind"] | undefi
     return "failed";
   }
   if (event.type === "agent.discarded") {
-    // 观察者放弃等待也是终态失败：结果永远不会到达，必须能在编排者对话里被唤醒。
-    // 压制/死信语义保持既有实现（上游错误抑制、pane 级 fallback 压制、seen 去重）。
+    const payload = asRecord(event.payload);
+    const agent = stringValue(payload.agent);
+    const isAgyOrEmpty = agent === undefined || agent === "agy";
+    if (isAgyOrEmpty) {
+      const reason = stringValue(payload.reason);
+      if (reason === PLAN_WAITING_HISTORY || reason === "degraded") {
+        if (payload.fallbackOutcome === true) {
+          return "failed";
+        }
+        return undefined;
+      }
+    }
     return "failed";
   }
   const payload = asRecord(event.payload);
   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);
@@ -112,26 +160,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);
@@ -157,8 +202,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 });