@dorokuma/herdsman 0.11.5 → 0.12.1

package/dist/src/observability/agent-index-service.js

@@ -22,6 +22,10 @@ export function historyHasAdvanced(current, baseline, options) {
     }
     return current.messageCount > (baseline?.messageCount ?? 0);
 }
+function isTerminalAssistant(compact) {
+    const stopReason = compact?.lastAssistantMessage?.stopReason;
+    return stopReason === "stop" || stopReason === "length";
+}
 export const PLAN_WAITING_HISTORY = "PLAN_WAITING_HISTORY";
 export class PlanWaitingHistoryError extends Error {
     constructor() {
@@ -50,11 +54,13 @@ export class AgentIndexService {
     #sleep;
     #turnCompletions;
     #waitingHistoryTimers = new Map();
+    #now;
     constructor(options) {
         this.#clearRetry = options.clearRetry ?? ((timer) => clearTimeout(timer));
         this.#clientFactory = options.clientFactory ?? ((input) => new HerdrSocketClient(input));
         this.#scheduleRetry = options.scheduleRetry ?? ((cb, delay) => setTimeout(cb, delay));
         this.#sleep = options.sleep ?? sleep;
+        this.#now = options.now ?? (() => Date.now());
         this.#stores = options.stores;
         this.#turnCompletions = options.turnCompletions;
         if (options.context) {
@@ -146,8 +152,8 @@ export class AgentIndexService {
                 if (!store)
                     return;
                 const current = store.get(planId);
-                if (current.status !== "pending" || current.lastError !== PLAN_WAITING_HISTORY) {
-                    this.#waitingHistoryTimers.delete(planId);
+                if (current.status !== "pending") {
+                    this.#clearWaitingTimer(planId);
                     return;
                 }
                 await this.#enqueueAgentPlan(plan.agent.id, () => this.#retryWaitingPlanRow(planId, plan));
@@ -167,11 +173,7 @@ export class AgentIndexService {
             current = store.get(planId);
         }
         catch {
-            this.#waitingHistoryTimers.delete(planId);
-            return;
-        }
-        if (current.status !== "pending" || current.lastError !== PLAN_WAITING_HISTORY) {
-            this.#waitingHistoryTimers.delete(planId);
+            this.#clearWaitingTimer(planId);
             return;
         }
         let retryPlan;
@@ -193,12 +195,36 @@ export class AgentIndexService {
                 agentId: plan.agent.id,
                 error: err,
             });
-            store.markRetry(planId, new PlanWaitingHistoryError());
-            const updated = store.get(planId);
+            const updated = store.markRetry(planId, new PlanWaitingHistoryError());
+            if (!updated) {
+                this.#clearWaitingTimer(planId);
+                return;
+            }
             if (updated.status === "pending") {
                 this.#scheduleWaitingHistoryRetry(planId, plan);
             }
+            else if (updated.status === "discarded") {
+                this.#clearWaitingTimer(planId);
+                console.info("Herdsman status event plan discarded after max attempts", {
+                    planId,
+                    agentId: plan.agent.id,
+                    attempts: updated.attempts,
+                    from: plan.from,
+                    to: plan.to,
+                    herdrSessionName: plan.agent.herdrSessionName,
+                });
+                this.#appendPlanDiscardedEvent({
+                    agent: plan.agent,
+                    attempts: updated.attempts,
+                    compactHistory: plan.compactHistory,
+                    from: plan.from,
+                    planId,
+                    reason: updated.lastError,
+                    to: plan.to,
+                });
+            }
             else if (updated.status === "failed") {
+                this.#clearWaitingTimer(planId);
                 console.warn("Herdsman status event plan failed after max attempts", {
                     planId,
                     agentId: plan.agent.id,
@@ -281,12 +307,15 @@ export class AgentIndexService {
         // rejects: every row is either drained, cancelled, or retried.
         await Promise.allSettled(tasks);
         await this.#backfillFailedPlanEvents();
+        await this.#backfillDiscardedPlanEvents();
     }
     async #backfillFailedPlanEvents() {
         const store = this.#stores.statusEventPlans;
         if (!store)
             return;
         for (const row of store.listFailed()) {
+            if (row.lastError === PLAN_WAITING_HISTORY)
+                continue;
             const existing = this.#stores.sqlite
                 .prepare("select 1 from agent_events where herdr_session_name = ? and idempotency_key = ?")
                 .get(row.herdrSessionName, `agent.failed:plan:${row.id}`);
@@ -318,6 +347,42 @@ export class AgentIndexService {
             });
         }
     }
+    async #backfillDiscardedPlanEvents() {
+        const store = this.#stores.statusEventPlans;
+        if (!store)
+            return;
+        for (const row of store.listDiscarded()) {
+            const existing = this.#stores.sqlite
+                .prepare("select 1 from agent_events where herdr_session_name = ? and idempotency_key = ?")
+                .get(row.herdrSessionName, `agent.discarded:plan:${row.id}`);
+            if (existing)
+                continue;
+            let agent;
+            try {
+                agent = this.#stores.agents.get(row.agentId);
+            }
+            catch {
+                agent = this.#minimalAgentFromLatestEvent(row.agentId, row.herdrSessionName);
+                if (!agent) {
+                    console.warn("Herdsman skipping agent.discarded backfill; no agent row or events", {
+                        agentId: row.agentId,
+                        herdrSessionName: row.herdrSessionName,
+                        planId: row.id,
+                    });
+                    continue;
+                }
+            }
+            this.#appendPlanDiscardedEvent({
+                agent,
+                attempts: row.attempts,
+                compactHistory: row.compactHistory,
+                from: row.fromStatus,
+                planId: row.id,
+                reason: row.lastError,
+                to: row.toStatus,
+            });
+        }
+    }
     #minimalAgentFromLatestEvent(agentId, herdrSessionName) {
         const latest = this.#stores.sqlite
             .prepare(`select pane_id, pane_generation, terminal_id, workspace_id, herdr_session_name
@@ -346,30 +411,48 @@ export class AgentIndexService {
         };
     }
     async #drainPlanRow(row) {
+        const store = this.#stores.statusEventPlans;
+        if (!store)
+            return;
+        let current;
+        try {
+            current = store.get(row.id);
+        }
+        catch {
+            this.#clearWaitingTimer(row.id);
+            return;
+        }
+        if (current.status === "completed" ||
+            current.status === "cancelled" ||
+            current.status === "failed" ||
+            current.status === "discarded") {
+            this.#clearWaitingTimer(row.id);
+            return;
+        }
         let agent;
         try {
             agent =
                 this.#stores.agents.findByPane({
-                    herdrSessionName: row.herdrSessionName,
-                    paneId: row.paneId,
-                    paneGeneration: row.paneGeneration,
-                }) ?? this.#stores.agents.get(row.agentId);
+                    herdrSessionName: current.herdrSessionName,
+                    paneId: current.paneId,
+                    paneGeneration: current.paneGeneration,
+                }) ?? this.#stores.agents.get(current.agentId);
         }
         catch {
             agent = undefined;
         }
         if (!agent) {
-            this.#stores.statusEventPlans.markCancelled(row.id);
+            store.markCancelled(current.id);
             console.warn("Herdsman cancelling status event plan for missing agent", {
-                agentId: row.agentId,
-                herdrSessionName: row.herdrSessionName,
-                paneId: row.paneId,
-                from: row.fromStatus,
-                to: row.toStatus,
+                agentId: current.agentId,
+                herdrSessionName: current.herdrSessionName,
+                paneId: current.paneId,
+                from: current.fromStatus,
+                to: current.toStatus,
             });
             return;
         }
-        let activeCompact = row.compactHistory;
+        let activeCompact = current.compactHistory;
         try {
             const refreshed = await this.#context.refreshAgent({
                 agent,
@@ -379,52 +462,74 @@ export class AgentIndexService {
             activeCompact = refreshed.snapshot.compactHistory;
         }
         catch (err) {
-            this.#stores.statusEventPlans.markRetry(row.id, new PlanWaitingHistoryError());
-            const updated = this.#stores.statusEventPlans.get(row.id);
+            const updated = store.markRetry(current.id, new PlanWaitingHistoryError());
+            if (!updated) {
+                this.#clearWaitingTimer(current.id);
+                return;
+            }
             if (updated.status === "pending") {
                 console.warn("Herdsman failed to refresh agent during drain plan row, keeping waiting", {
-                    planId: row.id,
+                    planId: current.id,
                     agentId: agent.id,
                     error: err,
                 });
-                this.#scheduleWaitingHistoryRetry(row.id, {
+                this.#scheduleWaitingHistoryRetry(current.id, {
                     agent,
-                    compactHistory: row.compactHistory,
-                    from: row.fromStatus,
-                    to: row.toStatus,
-                    ...(row.herdrEventKey ? { herdrEventKey: row.herdrEventKey } : {}),
+                    compactHistory: current.compactHistory,
+                    from: current.fromStatus,
+                    to: current.toStatus,
+                    ...(current.herdrEventKey ? { herdrEventKey: current.herdrEventKey } : {}),
+                });
+            }
+            else if (updated.status === "discarded") {
+                this.#clearWaitingTimer(current.id);
+                console.info("Herdsman plan marked discarded during drain", {
+                    planId: current.id,
+                    agentId: agent.id,
+                    from: current.fromStatus,
+                    to: current.toStatus,
+                    reason: updated.lastError,
+                });
+                this.#appendPlanDiscardedEvent({
+                    agent,
+                    attempts: updated.attempts,
+                    compactHistory: current.compactHistory,
+                    from: current.fromStatus,
+                    planId: current.id,
+                    reason: updated.lastError,
+                    to: current.toStatus,
                 });
             }
             else if (updated.status === "failed") {
-                this.#clearWaitingTimer(row.id);
+                this.#clearWaitingTimer(current.id);
                 console.warn("Herdsman plan marked failed", {
-                    planId: row.id,
+                    planId: current.id,
                     agentId: agent.id,
-                    from: row.fromStatus,
-                    to: row.toStatus,
+                    from: current.fromStatus,
+                    to: current.toStatus,
                     reason: updated.lastError,
                 });
                 this.#appendPlanFailedEvent({
                     agent,
                     attempts: updated.attempts,
-                    compactHistory: row.compactHistory,
-                    from: row.fromStatus,
-                    planId: row.id,
+                    compactHistory: current.compactHistory,
+                    from: current.fromStatus,
+                    planId: current.id,
                     reason: updated.lastError,
-                    to: row.toStatus,
+                    to: current.toStatus,
                 });
             }
             return;
         }
         const plan = {
             agent,
-            attempts: row.attempts,
+            attempts: current.attempts,
             compactHistory: activeCompact,
-            from: row.fromStatus,
-            to: row.toStatus,
-            ...(row.herdrEventKey ? { herdrEventKey: row.herdrEventKey } : {}),
+            from: current.fromStatus,
+            to: current.toStatus,
+            ...(current.herdrEventKey ? { herdrEventKey: current.herdrEventKey } : {}),
         };
-        await this.#runPlanRow(row, plan);
+        await this.#runPlanRow(current, plan);
     }
     #enqueueAgentPlan(agentId, operation) {
         const previous = this.#planTailByAgent.get(agentId) ?? Promise.resolve();
@@ -445,7 +550,8 @@ export class AgentIndexService {
         const current = store.get(row.id);
         if (current.status === "completed" ||
             current.status === "cancelled" ||
-            current.status === "failed") {
+            current.status === "failed" ||
+            current.status === "discarded") {
             this.#clearWaitingTimer(row.id);
             return undefined;
         }
@@ -473,13 +579,35 @@ export class AgentIndexService {
                     agentId: plan.agent.id,
                     error: err,
                 });
-                store.markRetry(row.id, new PlanWaitingHistoryError());
-                const updated = store.get(row.id);
+                const updated = store.markRetry(row.id, new PlanWaitingHistoryError());
+                if (!updated) {
+                    this.#clearWaitingTimer(row.id);
+                    return undefined;
+                }
                 if (updated.status === "pending") {
                     this.#scheduleWaitingHistoryRetry(row.id, plan);
                 }
                 else {
                     this.#clearWaitingTimer(row.id);
+                    if (updated.status === "discarded") {
+                        console.info("Herdsman status event plan discarded after max attempts", {
+                            planId: row.id,
+                            agentId: row.agentId,
+                            attempts: updated.attempts,
+                            from: row.fromStatus,
+                            to: row.toStatus,
+                            herdrSessionName: row.herdrSessionName,
+                        });
+                        return this.#appendPlanDiscardedEvent({
+                            agent: plan.agent,
+                            attempts: updated.attempts,
+                            compactHistory: plan.compactHistory,
+                            from: row.fromStatus,
+                            planId: row.id,
+                            reason: updated.lastError,
+                            to: row.toStatus,
+                        });
+                    }
                     if (updated.status === "failed") {
                         console.warn("Herdsman status event plan failed after max attempts", {
                             planId: row.id,
@@ -521,18 +649,80 @@ export class AgentIndexService {
                 return undefined;
             }
             this.#clearWaitingTimer(row.id);
+            const eventPayload = event?.payload;
+            const isDegraded = !!event &&
+                typeof eventPayload === "object" &&
+                eventPayload !== null &&
+                eventPayload.degraded === true;
+            if (isDegraded) {
+                const updated = store.markRetry(row.id, new Error("degraded"));
+                if (!updated) {
+                    return event;
+                }
+                if (updated.status === "pending") {
+                    this.#scheduleWaitingHistoryRetry(row.id, plan);
+                }
+                else {
+                    this.#clearWaitingTimer(row.id);
+                    if (updated.status === "discarded") {
+                        return this.#appendPlanDiscardedEvent({
+                            agent: plan.agent,
+                            attempts: updated.attempts,
+                            compactHistory: activePlan.compactHistory,
+                            from: row.fromStatus,
+                            planId: row.id,
+                            reason: updated.lastError,
+                            to: row.toStatus,
+                        });
+                    }
+                    if (updated.status === "failed") {
+                        return this.#appendPlanFailedEvent({
+                            agent: plan.agent,
+                            attempts: updated.attempts,
+                            compactHistory: activePlan.compactHistory,
+                            from: row.fromStatus,
+                            planId: row.id,
+                            reason: updated.lastError,
+                            to: row.toStatus,
+                        });
+                    }
+                }
+                return event;
+            }
             store.markCompleted(row.id);
             return event;
         }
         catch (error) {
             if (error instanceof PlanWaitingHistoryError) {
-                store.markRetry(row.id, error);
-                const updated = store.get(row.id);
+                const updated = store.markRetry(row.id, error);
+                if (!updated) {
+                    this.#clearWaitingTimer(row.id);
+                    return undefined;
+                }
                 if (updated.status === "pending") {
                     this.#scheduleWaitingHistoryRetry(row.id, plan);
                 }
                 else {
                     this.#clearWaitingTimer(row.id);
+                    if (updated.status === "discarded") {
+                        console.info("Herdsman status event plan discarded after max attempts", {
+                            planId: row.id,
+                            agentId: row.agentId,
+                            attempts: updated.attempts,
+                            from: row.fromStatus,
+                            to: row.toStatus,
+                            herdrSessionName: row.herdrSessionName,
+                        });
+                        return this.#appendPlanDiscardedEvent({
+                            agent: plan.agent,
+                            attempts: updated.attempts,
+                            compactHistory: activePlan.compactHistory,
+                            from: row.fromStatus,
+                            planId: row.id,
+                            reason: updated.lastError,
+                            to: row.toStatus,
+                        });
+                    }
                     if (updated.status === "failed") {
                         console.warn("Herdsman status event plan failed after max attempts", {
                             planId: row.id,
@@ -569,8 +759,29 @@ export class AgentIndexService {
                 return undefined;
             }
             this.#clearWaitingTimer(row.id);
-            store.markRetry(row.id, error);
-            const updated = store.get(row.id);
+            const updated = store.markRetry(row.id, error);
+            if (!updated) {
+                return undefined;
+            }
+            if (updated.status === "discarded") {
+                console.info("Herdsman status event plan discarded after max attempts", {
+                    planId: row.id,
+                    agentId: row.agentId,
+                    attempts: updated.attempts,
+                    from: row.fromStatus,
+                    to: row.toStatus,
+                    herdrSessionName: row.herdrSessionName,
+                });
+                return this.#appendPlanDiscardedEvent({
+                    agent: plan.agent,
+                    attempts: updated.attempts,
+                    compactHistory: activePlan.compactHistory,
+                    from: row.fromStatus,
+                    planId: row.id,
+                    reason: updated.lastError,
+                    to: row.toStatus,
+                });
+            }
             if (updated.status === "failed") {
                 console.warn("Herdsman status event plan failed after max attempts", {
                     planId: row.id,
@@ -595,6 +806,10 @@ export class AgentIndexService {
     }
     async #waitForHistoryAdvance(input) {
         const maxAttempts = input.maxAttempts ?? 8;
+        const baseDelay = 500;
+        const maxDelay = 16000;
+        const maxTotalMs = 30000;
+        let delay = baseDelay;
         let refreshed = input.initial
             ? { snapshot: { compactHistory: input.initial } }
             : await this.#context.refreshAgent({
@@ -602,20 +817,28 @@ export class AgentIndexService {
                 forceRefresh: true,
                 identityChanged: false,
             });
+        const start = this.#now();
         for (let attempt = 0; attempt < maxAttempts &&
             !historyHasAdvanced(refreshed.snapshot.compactHistory, input.baseline, {
                 requireAssistantChange: input.requireAssistantChange,
             }) &&
-            !input.controller.signal.aborted; attempt += 1) {
-            await this.#sleep(500, input.controller.signal);
-            if (input.controller.signal.aborted ||
-                this.#stores.agents.isPaneClosed({
+            !input.controller.signal.aborted &&
+            this.#now() - start < maxTotalMs; attempt += 1) {
+            await this.#sleep(delay, input.controller.signal);
+            if (input.controller.signal.aborted) {
+                console.debug("Herdsman retrying status event plan because wait was aborted during history refresh", {
+                    agentId: input.agent.id,
                     herdrSessionName: input.agent.herdrSessionName,
                     paneId: input.agent.paneId,
-                    paneGeneration: input.agent.paneGeneration ?? null,
-                })) {
-                console.debug("Herdsman skipping status event generation because wait was aborted during history refresh", {
-                    aborted: input.controller.signal.aborted,
+                });
+                throw new PlanWaitingHistoryError();
+            }
+            if (this.#stores.agents.isPaneClosed({
+                herdrSessionName: input.agent.herdrSessionName,
+                paneId: input.agent.paneId,
+                paneGeneration: input.agent.paneGeneration ?? null,
+            })) {
+                console.debug("Herdsman skipping status event generation because pane closed during history refresh", {
                     agentId: input.agent.id,
                     herdrSessionName: input.agent.herdrSessionName,
                     paneId: input.agent.paneId,
@@ -627,6 +850,7 @@ export class AgentIndexService {
                 forceRefresh: true,
                 identityChanged: false,
             });
+            delay = Math.min(delay * 2, maxDelay);
         }
         return refreshed.snapshot.compactHistory;
     }
@@ -1042,9 +1266,18 @@ export class AgentIndexService {
                 skipStatusChanged = true;
             }
             if (hasTerminalAfter && !input.herdrEventKey) {
-                const lastTerminal = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
+                const isAgyHistory = input.agent.agent === "agy" || input.compactHistory.source === "antigravity-sqlite";
+                // For an agy/antigravity pane only a terminal event that already
+                // represented a completed turn may count as the delivered baseline: an
+                // `unknown -> idle` startup row would otherwise make the `working -> done`
+                // row of the same round look like a duplicate.
+                const lastTerminal = isAgyHistory
+                    ? this.#stores.agentEvents.latestCompletedTurnEvent(input.agent.id, input.agent.herdrSessionName)
+                    : this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
                 if (sameTerminalAssistantContent(input.compactHistory, lastTerminal?.compactHistory, input.agent.agent)) {
-                    if ((input.attempts ?? 0) > 0) {
+                    // An agy round whose ref already reached a completed turn is settled: a
+                    // retry must skip it instead of exhausting the budget into `discarded`.
+                    if ((input.attempts ?? 0) > 0 && !isAgyHistory) {
                         throw new PlanWaitingHistoryError();
                     }
                     console.debug("Herdsman skipping legacy duplicate status transition event with identical history ref", {
@@ -1100,7 +1333,28 @@ export class AgentIndexService {
                         forceRefresh: true,
                         identityChanged: false,
                     })).snapshot.compactHistory;
-                    if (!isAlreadyEmittedInRetry && hasNonEmptyAssistantMessage(fresh)) {
+                    if (this.#stores.agents.isPaneClosed({
+                        herdrSessionName: input.agent.herdrSessionName,
+                        paneId: input.agent.paneId,
+                        paneGeneration: input.agent.paneGeneration ?? null,
+                    })) {
+                        console.debug("Herdsman skipping status event generation because pane closed after turn signal", {
+                            agentId: input.agent.id,
+                            herdrSessionName: input.agent.herdrSessionName,
+                            paneId: input.agent.paneId,
+                        });
+                        return undefined;
+                    }
+                    const freshIsTerminal = isTerminalAssistant(fresh);
+                    const expectedText = turn.expectedText?.trim();
+                    const lastAssistantText = fresh.lastAssistantMessage?.text?.trim() ?? "";
+                    const textMatches = !expectedText || lastAssistantText.endsWith(expectedText);
+                    if (!isAlreadyEmittedInRetry &&
+                        freshIsTerminal &&
+                        textMatches &&
+                        hasNonEmptyAssistantMessage(fresh) &&
+                        (isTerminalAssistant(input.compactHistory) ||
+                            historyHasAdvanced(fresh, input.compactHistory))) {
                         compactHistory = fresh;
                     }
                     else {
@@ -1118,7 +1372,38 @@ export class AgentIndexService {
                             !historyHasAdvanced(advanced, baseline, { requireAssistantChange: true })) {
                             throw new PlanWaitingHistoryError();
                         }
-                        compactHistory = advanced;
+                        if (!isRetry &&
+                            !historyHasAdvanced(advanced, input.compactHistory, { requireAssistantChange: true })) {
+                            compactHistory = { ...advanced, lastAssistantMessage: null };
+                            payloadExtra = {
+                                degraded: true,
+                                degradedReason: "no_advance_from_input",
+                                staleSnapshot: false,
+                            };
+                        }
+                        else {
+                            const advancedText = advanced.lastAssistantMessage?.text?.trim() ?? "";
+                            const advancedMatchesExpected = !expectedText || advancedText.endsWith(expectedText);
+                            if (!advancedMatchesExpected) {
+                                compactHistory = { ...advanced, lastAssistantMessage: null };
+                                payloadExtra = {
+                                    degraded: true,
+                                    degradedReason: "expected_text_mismatch",
+                                    staleSnapshot: false,
+                                };
+                            }
+                            else if (!isTerminalAssistant(advanced)) {
+                                compactHistory = { ...advanced, lastAssistantMessage: null };
+                                payloadExtra = {
+                                    degraded: true,
+                                    degradedReason: "non_terminal_assistant",
+                                    staleSnapshot: false,
+                                };
+                            }
+                            else {
+                                compactHistory = advanced;
+                            }
+                        }
                     }
                     console.log(`Herdsman emitted pi agent.${input.to} after turn completion signal (confirmed=${turn.confirmed})`, {
                         agentId: input.agent.id,
@@ -1143,7 +1428,19 @@ export class AgentIndexService {
                     if (!isRetry &&
                         !historyHasAdvanced(advanced, input.compactHistory, { requireAssistantChange: true })) {
                         compactHistory = { ...advanced, lastAssistantMessage: null };
-                        payloadExtra = { noAdvance: true, staleSnapshot: false };
+                        payloadExtra = {
+                            degraded: true,
+                            degradedReason: "no_advance_from_input",
+                            staleSnapshot: false,
+                        };
+                    }
+                    else if (!isTerminalAssistant(advanced)) {
+                        compactHistory = { ...advanced, lastAssistantMessage: null };
+                        payloadExtra = {
+                            degraded: true,
+                            degradedReason: "non_terminal_assistant",
+                            staleSnapshot: false,
+                        };
                     }
                     else {
                         compactHistory = advanced;
@@ -1157,15 +1454,21 @@ export class AgentIndexService {
             }
             else if (input.agent.agent !== "pi" && (input.to === "idle" || input.to === "done")) {
                 // Note: blocked is an interactive intermediate state, exempt from ready gate and empty delivery gate.
+                const isAgyHistory = (compact) => compact?.source === "antigravity-sqlite" || input.agent.agent === "agy";
+                // Only a terminal event that already represented a completed turn may
+                // consume the assistant ref: a late startup idle (`unknown -> idle`),
+                // an `agent.status.changed` row or a discarded plan must not make the
+                // following `working -> done` plan look like a duplicate round.
+                const latestCompletedTurnRef = () => this.#stores.agentEvents.latestCompletedTurnEvent(input.agent.id, input.agent.herdrSessionName)?.compactHistory?.lastAssistantMessage?.ref ?? null;
                 const isReadyNonPi = (compact) => {
                     if (!compact || !hasNonEmptyAssistantMessage(compact))
                         return false;
-                    const latestTerminal = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
-                    if (compact.source === "antigravity-sqlite" || input.agent.agent === "agy") {
-                        const prevRef = latestTerminal?.compactHistory?.lastAssistantMessage?.ref ?? null;
+                    if (isAgyHistory(compact)) {
+                        const prevRef = latestCompletedTurnRef();
                         const currentRef = compact.lastAssistantMessage?.ref ?? null;
                         return currentRef !== null && currentRef !== prevRef;
                     }
+                    const latestTerminal = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
                     if (!latestTerminal)
                         return true;
                     const currentMsg = compact.lastAssistantMessage;
@@ -1175,6 +1478,16 @@ export class AgentIndexService {
                     const same = sameTerminalAssistantContent(compact, latestTerminal.compactHistory, input.agent.agent);
                     return !same || refChanged || textChanged;
                 };
+                // A non-empty assistant ref that was already delivered by a completed
+                // turn is a genuine skip (the round was announced), never a reason to
+                // exhaust the retry budget into `discarded`.
+                const isAlreadyDeliveredCompletedTurn = (compact) => {
+                    if (!compact || !isAgyHistory(compact) || !hasNonEmptyAssistantMessage(compact)) {
+                        return false;
+                    }
+                    const currentRef = compact.lastAssistantMessage?.ref ?? null;
+                    return currentRef !== null && currentRef === latestCompletedTurnRef();
+                };
                 const latestTerminalForSkip = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
                 if (input.agent.agent !== "agy" &&
                     compactHistory?.source !== "antigravity-sqlite" &&
@@ -1224,6 +1537,16 @@ export class AgentIndexService {
                     }
                 }
                 if (!isReadyNonPi(compactHistory)) {
+                    if (isAlreadyDeliveredCompletedTurn(compactHistory)) {
+                        console.debug("Herdsman skipping non-pi terminal status event because the assistant ref was already delivered by a completed turn", {
+                            agent: input.agent.agent,
+                            agentId: input.agent.id,
+                            from: input.from,
+                            ref: compactHistory?.lastAssistantMessage?.ref ?? null,
+                            to: input.to,
+                        });
+                        return undefined;
+                    }
                     throw new PlanWaitingHistoryError();
                 }
             }
@@ -1358,6 +1681,42 @@ export class AgentIndexService {
             workspaceId: agent.workspaceId,
         });
     }
+    #appendPlanDiscardedEvent(input) {
+        let agent = input.agent;
+        try {
+            agent = this.#stores.agents.get(input.agent.id);
+        }
+        catch {
+            const stitched = this.#minimalAgentFromLatestEvent(input.agent.id, input.agent.herdrSessionName);
+            if (stitched)
+                agent = stitched;
+        }
+        return this.#appendAndAckSelfEvent({
+            agentId: agent.id,
+            compactHistory: input.compactHistory ?? null,
+            herdrSessionName: agent.herdrSessionName,
+            idempotencyKey: `agent.discarded:plan:${input.planId}`,
+            paneId: agent.paneId,
+            paneGeneration: agent.paneGeneration ?? null,
+            payload: {
+                agent: agent.agent,
+                agentId: agent.id,
+                attempts: input.attempts,
+                from: input.from,
+                herdrSessionName: agent.herdrSessionName,
+                name: agent.name,
+                paneId: agent.paneId,
+                planId: input.planId,
+                reason: input.reason ?? "unknown",
+                terminalId: agent.terminalId,
+                to: input.to,
+                workspaceId: agent.workspaceId,
+            },
+            terminalId: agent.terminalId,
+            type: "agent.discarded",
+            workspaceId: agent.workspaceId,
+        });
+    }
     #appendAndAckSelfEvent(input) {
         const event = this.#stores.agentEvents.append(input);
         const owner = this.#stores.agentOrchestratorScopes?.get({