@dorokuma/herdsman 0.9.0 → 0.11.5

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

@@ -1,21 +1,60 @@
-import { safeAllowedSessionPath } from "../agent-history/discovery.js";
+import { existsSync } from "node:fs";
+import { safeAllowedSessionPath, sessionPathAllowedByShape } from "../agent-history/discovery.js";
 import { createAgentHistoryService } from "../agent-history/service.js";
+import { hasNonEmptyAssistantMessage } from "../db/agent-events.js";
+import { runSqliteTransaction } from "../db/client.js";
 import { normalizeHerdrSessionSnapshot } from "../herdr/session-snapshot.js";
 import { HerdrSocketClient } from "../herdr/socket-client.js";
 import { AgentContextService } from "../observability/agent-context-service.js";
 import { parseAgentStatus, } from "../observability/contracts.js";
 import { TURN_SIGNAL_WAIT_MS } from "../observability/turn-completion.js";
+export function historyHasAdvanced(current, baseline, options) {
+    if (current.lastAssistantMessage?.ref &&
+        current.lastAssistantMessage.ref !== (baseline?.lastAssistantMessage?.ref ?? null)) {
+        return true;
+    }
+    if (current.lastAssistantMessage?.text &&
+        current.lastAssistantMessage.text !== (baseline?.lastAssistantMessage?.text ?? null)) {
+        return true;
+    }
+    if (options?.requireAssistantChange) {
+        return false;
+    }
+    return current.messageCount > (baseline?.messageCount ?? 0);
+}
+export const PLAN_WAITING_HISTORY = "PLAN_WAITING_HISTORY";
+export class PlanWaitingHistoryError extends Error {
+    constructor() {
+        super(PLAN_WAITING_HISTORY);
+        this.name = "PlanWaitingHistoryError";
+    }
+}
+/**
+ * Sentinel returned by #appendStatusEvents when the plan must be CANCELLED
+ * rather than skipped (skip still maps to completed in #runPlanRow). The agent
+ * row is gone, so appending would create an undeliverable dangling event.
+ */
+const PLAN_CANCELLED = Symbol("herdsman.status-event-plan-cancelled");
 export class AgentIndexService {
+    #activeWaiters = new Map();
+    #clearRetry;
     #clientFactory;
     #context;
     #stores;
     #mutationEpochBySession = new Map();
     #pendingPiSessionRefs = new Map();
+    #planTailByAgent = new Map();
     #refreshInFlightBySession = new Map();
+    #scheduleRetry;
     #sessionOperationTail = new Map();
+    #sleep;
     #turnCompletions;
+    #waitingHistoryTimers = new Map();
     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.#stores = options.stores;
         this.#turnCompletions = options.turnCompletions;
         if (options.context) {
@@ -38,12 +77,26 @@ export class AgentIndexService {
             });
         }
     }
+    refreshHerdrSessionFast(input) {
+        this.#incrementMutationEpoch(input.herdrSessionName);
+        return this.#enqueueSessionOperation(input.herdrSessionName, () => this.#refreshHerdrSessionNow(input));
+    }
     refreshHerdrSession(input) {
         const epoch = this.#mutationEpochBySession.get(input.herdrSessionName) ?? 0;
         const existing = this.#refreshInFlightBySession.get(input.herdrSessionName);
         if (existing?.epoch === epoch)
             return existing.promise;
-        const promise = this.#enqueueSessionOperation(input.herdrSessionName, () => this.#refreshHerdrSessionNow(input));
+        const promise = this.#enqueueSessionOperation(input.herdrSessionName, () => this.#refreshHerdrSessionNow(input)).then(async (intermediate) => {
+            const statusEvents = await Promise.all(intermediate.statusEventPlans.map((plan) => this.executeStatusEventPlan(plan)));
+            return {
+                agents: intermediate.agents,
+                contextChangedScopes: intermediate.contextChangedScopes,
+                events: [
+                    ...intermediate.events,
+                    ...statusEvents.filter((event) => event !== undefined),
+                ],
+            };
+        });
         this.#refreshInFlightBySession.set(input.herdrSessionName, { epoch, promise });
         const clear = () => {
             if (this.#refreshInFlightBySession.get(input.herdrSessionName)?.promise === promise) {
@@ -53,10 +106,530 @@ export class AgentIndexService {
         void promise.then(clear, clear);
         return promise;
     }
-    handleHerdrEvent(input) {
+    handleHerdrEventFast(input) {
         this.#incrementMutationEpoch(input.herdrSessionName);
         return this.#enqueueSessionOperation(input.herdrSessionName, () => this.#handleHerdrEventNow(input));
     }
+    async handleHerdrEvent(input) {
+        const intermediate = await this.handleHerdrEventFast(input);
+        const statusEvents = await Promise.all(intermediate.statusEventPlans.map((plan) => this.executeStatusEventPlan(plan)));
+        return {
+            contextChangedScopes: intermediate.contextChangedScopes,
+            events: [
+                ...intermediate.events,
+                ...statusEvents.filter((event) => event !== undefined),
+            ],
+        };
+    }
+    stopWaitingHistoryRetries() {
+        for (const timer of this.#waitingHistoryTimers.values()) {
+            this.#clearRetry(timer);
+        }
+        this.#waitingHistoryTimers.clear();
+    }
+    async drainInFlightPlans() {
+        const tails = Array.from(this.#planTailByAgent.values());
+        await Promise.allSettled(tails);
+    }
+    #clearWaitingTimer(planId) {
+        const existing = this.#waitingHistoryTimers.get(planId);
+        if (existing !== undefined) {
+            this.#clearRetry(existing);
+            this.#waitingHistoryTimers.delete(planId);
+        }
+    }
+    #scheduleWaitingHistoryRetry(planId, plan) {
+        this.#clearWaitingTimer(planId);
+        const timer = this.#scheduleRetry(async () => {
+            try {
+                const store = this.#stores.statusEventPlans;
+                if (!store)
+                    return;
+                const current = store.get(planId);
+                if (current.status !== "pending" || current.lastError !== PLAN_WAITING_HISTORY) {
+                    this.#waitingHistoryTimers.delete(planId);
+                    return;
+                }
+                await this.#enqueueAgentPlan(plan.agent.id, () => this.#retryWaitingPlanRow(planId, plan));
+            }
+            catch (error) {
+                console.debug("Herdsman waiting history retry callback error", error);
+            }
+        }, 10_000);
+        this.#waitingHistoryTimers.set(planId, timer);
+    }
+    async #retryWaitingPlanRow(planId, plan) {
+        const store = this.#stores.statusEventPlans;
+        if (!store)
+            return;
+        let current;
+        try {
+            current = store.get(planId);
+        }
+        catch {
+            this.#waitingHistoryTimers.delete(planId);
+            return;
+        }
+        if (current.status !== "pending" || current.lastError !== PLAN_WAITING_HISTORY) {
+            this.#waitingHistoryTimers.delete(planId);
+            return;
+        }
+        let retryPlan;
+        try {
+            const refreshed = await this.#context.refreshAgent({
+                agent: plan.agent,
+                forceRefresh: true,
+                identityChanged: false,
+            });
+            retryPlan = {
+                ...plan,
+                attempts: current.attempts,
+                compactHistory: refreshed.snapshot.compactHistory,
+            };
+        }
+        catch (err) {
+            console.warn("Herdsman failed to refresh agent before retry plan row, keeping waiting", {
+                planId,
+                agentId: plan.agent.id,
+                error: err,
+            });
+            store.markRetry(planId, new PlanWaitingHistoryError());
+            const updated = store.get(planId);
+            if (updated.status === "pending") {
+                this.#scheduleWaitingHistoryRetry(planId, plan);
+            }
+            else if (updated.status === "failed") {
+                console.warn("Herdsman status event plan failed after max attempts", {
+                    planId,
+                    agentId: plan.agent.id,
+                    attempts: updated.attempts,
+                    from: plan.from,
+                    to: plan.to,
+                    herdrSessionName: plan.agent.herdrSessionName,
+                });
+                this.#appendPlanFailedEvent({
+                    agent: plan.agent,
+                    attempts: updated.attempts,
+                    compactHistory: plan.compactHistory,
+                    from: plan.from,
+                    planId,
+                    reason: updated.lastError,
+                    to: plan.to,
+                });
+            }
+            return;
+        }
+        await this.#runPlanRow(current, retryPlan);
+    }
+    async executeStatusEventPlan(plan) {
+        if (plan.from === plan.to)
+            return undefined;
+        if (!this.#stores.statusEventPlans) {
+            return this.#enqueueAgentPlan(plan.agent.id, async () => {
+                try {
+                    const event = await this.#appendStatusEvents(plan);
+                    return event === PLAN_CANCELLED ? undefined : event;
+                }
+                catch (error) {
+                    if (error instanceof PlanWaitingHistoryError) {
+                        return undefined;
+                    }
+                    throw error;
+                }
+            });
+        }
+        const inserted = plan.planId !== undefined
+            ? this.#stores.statusEventPlans.get(plan.planId)
+            : this.#stores.statusEventPlans.insertPending({
+                agent: plan.agent,
+                from: plan.from,
+                herdrEventKey: plan.herdrEventKey ?? null,
+                to: plan.to,
+                ...(plan.compactHistory ? { compactHistory: plan.compactHistory } : {}),
+            });
+        return this.#enqueueAgentPlan(plan.agent.id, () => this.#runPlanRow(inserted, plan));
+    }
+    async drainPendingPlans() {
+        if (!this.#stores.statusEventPlans)
+            return;
+        this.#stores.statusEventPlans.resetRunningToPending();
+        const rows = this.#stores.statusEventPlans.listUnfinished();
+        const tasks = rows.map((row) => {
+            try {
+                return this.#enqueueAgentPlan(row.agentId, () => this.#drainPlanRow(row));
+            }
+            catch (_error) {
+                // A row whose agent cannot even be resolved must never take down the
+                // daemon boot drain (that failure mode used to boot-loop systemd).
+                try {
+                    this.#stores.statusEventPlans.markCancelled(row.id);
+                }
+                catch {
+                    // The row may already be gone; the drain must continue regardless.
+                }
+                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,
+                });
+                return Promise.resolve();
+            }
+        });
+        // Individual rows may reject (after markRetry) but the drain itself never
+        // rejects: every row is either drained, cancelled, or retried.
+        await Promise.allSettled(tasks);
+        await this.#backfillFailedPlanEvents();
+    }
+    async #backfillFailedPlanEvents() {
+        const store = this.#stores.statusEventPlans;
+        if (!store)
+            return;
+        for (const row of store.listFailed()) {
+            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}`);
+            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.failed backfill; no agent row or events", {
+                        agentId: row.agentId,
+                        herdrSessionName: row.herdrSessionName,
+                        planId: row.id,
+                    });
+                    continue;
+                }
+            }
+            this.#appendPlanFailedEvent({
+                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
+         from agent_events where agent_id = ? order by id desc limit 1`)
+            .get(agentId);
+        if (!latest?.pane_id || !latest.workspace_id)
+            return undefined;
+        return {
+            agent: null,
+            agentSession: null,
+            agentStatus: "unknown",
+            cwd: null,
+            firstSeenAt: new Date(0),
+            focused: false,
+            foregroundCwd: null,
+            herdrSessionName: latest.herdr_session_name || herdrSessionName,
+            id: agentId,
+            lastSeenAt: new Date(0),
+            name: null,
+            paneId: latest.pane_id,
+            paneRevision: null,
+            ...(latest.pane_generation === null ? {} : { paneGeneration: latest.pane_generation }),
+            tabId: null,
+            terminalId: latest.terminal_id,
+            workspaceId: latest.workspace_id,
+        };
+    }
+    async #drainPlanRow(row) {
+        let agent;
+        try {
+            agent =
+                this.#stores.agents.findByPane({
+                    herdrSessionName: row.herdrSessionName,
+                    paneId: row.paneId,
+                    paneGeneration: row.paneGeneration,
+                }) ?? this.#stores.agents.get(row.agentId);
+        }
+        catch {
+            agent = undefined;
+        }
+        if (!agent) {
+            this.#stores.statusEventPlans.markCancelled(row.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,
+            });
+            return;
+        }
+        let activeCompact = row.compactHistory;
+        try {
+            const refreshed = await this.#context.refreshAgent({
+                agent,
+                forceRefresh: true,
+                identityChanged: false,
+            });
+            activeCompact = refreshed.snapshot.compactHistory;
+        }
+        catch (err) {
+            this.#stores.statusEventPlans.markRetry(row.id, new PlanWaitingHistoryError());
+            const updated = this.#stores.statusEventPlans.get(row.id);
+            if (updated.status === "pending") {
+                console.warn("Herdsman failed to refresh agent during drain plan row, keeping waiting", {
+                    planId: row.id,
+                    agentId: agent.id,
+                    error: err,
+                });
+                this.#scheduleWaitingHistoryRetry(row.id, {
+                    agent,
+                    compactHistory: row.compactHistory,
+                    from: row.fromStatus,
+                    to: row.toStatus,
+                    ...(row.herdrEventKey ? { herdrEventKey: row.herdrEventKey } : {}),
+                });
+            }
+            else if (updated.status === "failed") {
+                this.#clearWaitingTimer(row.id);
+                console.warn("Herdsman plan marked failed", {
+                    planId: row.id,
+                    agentId: agent.id,
+                    from: row.fromStatus,
+                    to: row.toStatus,
+                    reason: updated.lastError,
+                });
+                this.#appendPlanFailedEvent({
+                    agent,
+                    attempts: updated.attempts,
+                    compactHistory: row.compactHistory,
+                    from: row.fromStatus,
+                    planId: row.id,
+                    reason: updated.lastError,
+                    to: row.toStatus,
+                });
+            }
+            return;
+        }
+        const plan = {
+            agent,
+            attempts: row.attempts,
+            compactHistory: activeCompact,
+            from: row.fromStatus,
+            to: row.toStatus,
+            ...(row.herdrEventKey ? { herdrEventKey: row.herdrEventKey } : {}),
+        };
+        await this.#runPlanRow(row, plan);
+    }
+    #enqueueAgentPlan(agentId, operation) {
+        const previous = this.#planTailByAgent.get(agentId) ?? Promise.resolve();
+        const result = previous.then(operation, operation);
+        const tail = result.then(() => undefined, () => undefined);
+        this.#planTailByAgent.set(agentId, tail);
+        void tail.finally(() => {
+            if (this.#planTailByAgent.get(agentId) === tail) {
+                this.#planTailByAgent.delete(agentId);
+            }
+        });
+        return result;
+    }
+    async #runPlanRow(row, plan) {
+        const store = this.#stores.statusEventPlans;
+        if (!store)
+            return undefined;
+        const current = store.get(row.id);
+        if (current.status === "completed" ||
+            current.status === "cancelled" ||
+            current.status === "failed") {
+            this.#clearWaitingTimer(row.id);
+            return undefined;
+        }
+        store.markRunning(row.id);
+        let activePlan = {
+            ...plan,
+            attempts: row.attempts,
+        };
+        if (row.attempts > 0) {
+            try {
+                const refreshed = await this.#context.refreshAgent({
+                    agent: plan.agent,
+                    forceRefresh: true,
+                    identityChanged: false,
+                });
+                activePlan = {
+                    ...plan,
+                    attempts: row.attempts,
+                    compactHistory: refreshed.snapshot.compactHistory,
+                };
+            }
+            catch (err) {
+                console.warn("Herdsman failed to refresh agent before running retry row, keeping waiting", {
+                    planId: row.id,
+                    agentId: plan.agent.id,
+                    error: err,
+                });
+                store.markRetry(row.id, new PlanWaitingHistoryError());
+                const updated = store.get(row.id);
+                if (updated.status === "pending") {
+                    this.#scheduleWaitingHistoryRetry(row.id, plan);
+                }
+                else {
+                    this.#clearWaitingTimer(row.id);
+                    if (updated.status === "failed") {
+                        console.warn("Herdsman status event plan failed after max attempts", {
+                            planId: row.id,
+                            agentId: row.agentId,
+                            attempts: updated.attempts,
+                            from: row.fromStatus,
+                            to: row.toStatus,
+                            herdrSessionName: row.herdrSessionName,
+                        });
+                        return this.#appendPlanFailedEvent({
+                            agent: plan.agent,
+                            attempts: updated.attempts,
+                            compactHistory: plan.compactHistory,
+                            from: row.fromStatus,
+                            planId: row.id,
+                            reason: updated.lastError,
+                            to: row.toStatus,
+                        });
+                    }
+                }
+                return undefined;
+            }
+        }
+        try {
+            const event = await this.#appendStatusEvents(activePlan);
+            if (event === PLAN_CANCELLED) {
+                this.#clearWaitingTimer(row.id);
+                store.markCancelled(row.id);
+                return undefined;
+            }
+            if (event === undefined &&
+                this.#stores.agents.isPaneClosed({
+                    herdrSessionName: plan.agent.herdrSessionName,
+                    paneId: plan.agent.paneId,
+                    paneGeneration: plan.agent.paneGeneration ?? null,
+                })) {
+                this.#clearWaitingTimer(row.id);
+                store.markCancelled(row.id);
+                return undefined;
+            }
+            this.#clearWaitingTimer(row.id);
+            store.markCompleted(row.id);
+            return event;
+        }
+        catch (error) {
+            if (error instanceof PlanWaitingHistoryError) {
+                store.markRetry(row.id, error);
+                const updated = store.get(row.id);
+                if (updated.status === "pending") {
+                    this.#scheduleWaitingHistoryRetry(row.id, plan);
+                }
+                else {
+                    this.#clearWaitingTimer(row.id);
+                    if (updated.status === "failed") {
+                        console.warn("Herdsman status event plan failed after max attempts", {
+                            planId: row.id,
+                            agentId: row.agentId,
+                            attempts: updated.attempts,
+                            from: row.fromStatus,
+                            to: row.toStatus,
+                            herdrSessionName: row.herdrSessionName,
+                        });
+                        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 undefined;
+            }
+            const err = error instanceof Error ? error : undefined;
+            const isPaneClosed = this.#stores.agents.isPaneClosed({
+                herdrSessionName: plan.agent.herdrSessionName,
+                paneId: plan.agent.paneId,
+                paneGeneration: plan.agent.paneGeneration ?? null,
+            }) ||
+                err?.name === "AbortError" ||
+                err?.message?.includes("aborted");
+            if (isPaneClosed) {
+                this.#clearWaitingTimer(row.id);
+                store.markCancelled(row.id);
+                return undefined;
+            }
+            this.#clearWaitingTimer(row.id);
+            store.markRetry(row.id, error);
+            const updated = store.get(row.id);
+            if (updated.status === "failed") {
+                console.warn("Herdsman status event plan failed after max attempts", {
+                    planId: row.id,
+                    agentId: row.agentId,
+                    attempts: updated.attempts,
+                    from: row.fromStatus,
+                    to: row.toStatus,
+                    herdrSessionName: row.herdrSessionName,
+                });
+                return this.#appendPlanFailedEvent({
+                    agent: plan.agent,
+                    attempts: updated.attempts,
+                    compactHistory: activePlan.compactHistory,
+                    from: row.fromStatus,
+                    planId: row.id,
+                    reason: updated.lastError,
+                    to: row.toStatus,
+                });
+            }
+            throw error;
+        }
+    }
+    async #waitForHistoryAdvance(input) {
+        const maxAttempts = input.maxAttempts ?? 8;
+        let refreshed = input.initial
+            ? { snapshot: { compactHistory: input.initial } }
+            : await this.#context.refreshAgent({
+                agent: input.agent,
+                forceRefresh: true,
+                identityChanged: false,
+            });
+        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({
+                    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,
+                    agentId: input.agent.id,
+                    herdrSessionName: input.agent.herdrSessionName,
+                    paneId: input.agent.paneId,
+                });
+                return undefined;
+            }
+            refreshed = await this.#context.refreshAgent({
+                agent: input.agent,
+                forceRefresh: true,
+                identityChanged: false,
+            });
+        }
+        return refreshed.snapshot.compactHistory;
+    }
     registerPiSessionRef(input) {
         this.#incrementMutationEpoch(input.herdrSessionName);
         return this.#enqueueSessionOperation(input.herdrSessionName, () => this.#registerPiSessionRefNow(input));
@@ -76,23 +649,38 @@ export class AgentIndexService {
                     refreshEpoch,
                     mutationEpoch,
                 });
-                return { agents: previous, contextChangedScopes: [], events: [] };
-            }
-            if (mutationEpoch !== refreshEpoch) {
-                console.warn("Herdsman discarding stale Herdr session refresh", {
-                    sessionName: input.herdrSessionName,
-                    refreshEpoch,
-                    mutationEpoch,
-                });
-                return { agents: previous, contextChangedScopes: [], events: [] };
+                return { agents: previous, contextChangedScopes: [], events: [], statusEventPlans: [] };
             }
-            const revisionByPane = new Map(snapshot.panes.flatMap((pane) => {
+            const overlayByPane = new Map();
+            for (const pane of snapshot.panes) {
                 const value = record(pane);
                 const paneId = stringValue(value.pane_id) ?? stringValue(value.paneId);
+                if (!paneId)
+                    continue;
                 const revision = integerValue(value.revision);
-                return paneId && revision !== undefined ? [[paneId, revision]] : [];
-            }));
-            const snapshotAgents = snapshot.agents.map((agent) => withPaneRevision(agent, revisionByPane));
+                const terminalTitle = stringValue(value.terminal_title) ?? stringValue(value.terminalTitle);
+                if (revision === undefined && !terminalTitle)
+                    continue;
+                overlayByPane.set(paneId, {
+                    ...(revision === undefined ? {} : { revision }),
+                    ...(terminalTitle ? { terminalTitle } : {}),
+                });
+            }
+            const snapshotAgents = snapshot.agents.map((agent) => withPaneRevision(agent, overlayByPane));
+            // A live pane that reports a pane_generation overrides any generation-less
+            // (legacy) close: drop the legacy tombstone before consulting
+            // isPaneClosed so the generation-carrying agent is indexed instead of
+            // being swallowed by the phantom close. Generation-scoped tombstones stay.
+            for (const agent of snapshotAgents) {
+                const paneId = stringValue(agent.pane_id) ?? stringValue(agent.paneId);
+                if (paneId && paneGenerationOf(agent)) {
+                    this.#stores.agents.clearLegacyPaneTombstone({
+                        herdrSessionName: input.herdrSessionName,
+                        paneId,
+                    });
+                }
+            }
+            const liveSnapshotAgents = snapshotAgents.filter((agent) => !this.#isClosedPaneAgent(input.herdrSessionName, agent));
             this.#stores.herdrSessions.upsertRunning({
                 name: input.herdrSessionName,
                 sessionDir: input.sessionDir,
@@ -103,7 +691,7 @@ export class AgentIndexService {
                 workspaces: snapshot.workspaces.map(record),
             });
             const indexedAgents = this.#stores.agents.replaceForSession({
-                agents: snapshotAgents,
+                agents: liveSnapshotAgents,
                 herdrSessionName: input.herdrSessionName,
             });
             const agents = indexedAgents.map((agent) => {
@@ -122,6 +710,7 @@ export class AgentIndexService {
             });
             const scopes = new Map();
             const events = [];
+            const statusEventPlans = [];
             const currentIds = new Set(agents.map((agent) => agent.id));
             for (const prior of previous) {
                 if (!currentIds.has(prior.id))
@@ -133,10 +722,21 @@ export class AgentIndexService {
                 const identityChanged = !prior || !sameIdentity(prior, agent);
                 const metadataChanged = !prior || !sameContextMetadata(prior, agent);
                 const cached = this.#context.getAgentSnapshot(agent.id);
+                const occupiedByOthers = this.#context.occupiedSessionPathsFor(agent);
+                const occupancyConflict = Boolean(cached?.historyRef?.path && occupiedByOthers.has(cached.historyRef.path));
+                const sessionReady = agent.agentSession?.kind === "path" &&
+                    safeAllowedSessionPath(agent.agentSession.value) !== null;
+                const sessionUnbound = sessionReady &&
+                    (cached?.historyRef?.kind !== "agent_session" ||
+                        cached.historyRef.path !== agent.agentSession?.value);
                 const dirty = !cached ||
                     agent.paneRevision === null ||
                     cached.paneRevision !== agent.paneRevision ||
-                    identityChanged;
+                    identityChanged ||
+                    cached.historyRef == null ||
+                    cached.historyRef.kind === "discovered_file" ||
+                    occupancyConflict ||
+                    sessionUnbound;
                 let refreshed = cached;
                 if (dirty) {
                     const occupiedForCurrent = new Set(occupiedSessionPaths);
@@ -157,14 +757,12 @@ export class AgentIndexService {
                     addScope(scopes, scopeOf(agent));
                 }
                 if (prior && prior.agentStatus !== agent.agentStatus) {
-                    const event = await this.#appendStatusEvents({
+                    statusEventPlans.push({
                         agent,
                         compactHistory: refreshed?.compactHistory ?? this.#context.getAgentSnapshot(agent.id)?.compactHistory,
                         from: prior.agentStatus,
                         to: agent.agentStatus,
                     });
-                    if (event)
-                        events.push(event);
                     addScope(scopes, scopeOf(agent));
                 }
             }
@@ -172,6 +770,7 @@ export class AgentIndexService {
                 agents,
                 contextChangedScopes: sortedScopes(scopes),
                 events,
+                statusEventPlans,
             };
         }
         finally {
@@ -182,9 +781,14 @@ export class AgentIndexService {
         const event = record(input.event);
         const paneId = stringValue(event.pane_id) ?? stringValue(event.paneId);
         if (!paneId)
-            return { contextChangedScopes: [], events: [] };
+            return { contextChangedScopes: [], events: [], statusEventPlans: [] };
         if (event.type === "pane.closed") {
             const closedGeneration = paneGenerationFromEvent(event);
+            this.#abortPendingWaiters({
+                herdrSessionName: input.herdrSessionName,
+                paneId,
+                paneGeneration: closedGeneration,
+            });
             this.#stores.agentEvents.invalidatePane({
                 herdrSessionName: input.herdrSessionName,
                 paneId,
@@ -204,7 +808,7 @@ export class AgentIndexService {
             });
             const scopes = new Map();
             const closedTerminalId = stringValue(event.terminal_id) ?? stringValue(event.terminalId);
-            if (closedGeneration && closedTerminalId) {
+            if (closedTerminalId) {
                 for (const agent of retired) {
                     const scope = scopeOf(agent);
                     const change = this.#stores.agentOrchestratorScopes?.releaseIfOwnerIdentity({
@@ -223,10 +827,12 @@ export class AgentIndexService {
             return {
                 contextChangedScopes: sortedScopes(scopes),
                 events: [],
+                statusEventPlans: [],
             };
         }
-        if (event.type !== "pane.agent_status_changed")
-            return { contextChangedScopes: [], events: [] };
+        if (event.type !== "pane.agent_status_changed") {
+            return { contextChangedScopes: [], events: [], statusEventPlans: [] };
+        }
         const eventGeneration = paneGenerationFromEvent(event);
         let agent = this.#stores.agents.findByPane({
             herdrSessionName: input.herdrSessionName,
@@ -235,6 +841,27 @@ export class AgentIndexService {
         });
         let recovered;
         if (!agent) {
+            if (eventGeneration) {
+                // A generation-scoped tombstone still closes its own generation.
+                if (this.#stores.agents.hasGenerationScopedTombstone({
+                    herdrSessionName: input.herdrSessionName,
+                    paneId,
+                    paneGeneration: eventGeneration,
+                })) {
+                    return { contextChangedScopes: [], events: [], statusEventPlans: [] };
+                }
+                // No generation-scoped close: a live generation-carrying status
+                // overrides a generation-less close, so recover the pane (the refresh
+                // below clears the legacy tombstone only when the agent is actually
+                // present in the snapshot).
+            }
+            else if (this.#stores.agents.isPaneClosed({
+                herdrSessionName: input.herdrSessionName,
+                paneId,
+                paneGeneration: null,
+            })) {
+                return { contextChangedScopes: [], events: [], statusEventPlans: [] };
+            }
             recovered = await this.#refreshHerdrSessionNow(input);
             agent = this.#stores.agents.findByPane({
                 herdrSessionName: input.herdrSessionName,
@@ -244,19 +871,17 @@ export class AgentIndexService {
         }
         if (!agent) {
             return recovered
-                ? { contextChangedScopes: recovered.contextChangedScopes, events: recovered.events }
-                : { contextChangedScopes: [], events: [] };
+                ? {
+                    contextChangedScopes: recovered.contextChangedScopes,
+                    events: recovered.events,
+                    statusEventPlans: recovered.statusEventPlans,
+                }
+                : { contextChangedScopes: [], events: [], statusEventPlans: [] };
         }
         const from = recovered ? "unknown" : agent.agentStatus;
         const to = parseAgentStatus(event.agent_status);
         const herdrEventKey = herdrInputIdempotencyKey(input.herdrSessionName, paneId, event, to);
-        const updated = this.#stores.agents.updateStatus({
-            agentStatus: to,
-            herdrSessionName: input.herdrSessionName,
-            paneId,
-            paneGeneration: eventGeneration,
-        });
-        const current = updated ?? { ...agent, agentStatus: to };
+        const current = { ...agent, agentStatus: to };
         const refreshed = await this.#context.refreshAgent({ agent: current, identityChanged: false });
         const scopes = new Map();
         for (const scope of recovered?.contextChangedScopes ?? [])
@@ -264,26 +889,52 @@ export class AgentIndexService {
         if (refreshed.changed || from !== to)
             addScope(scopes, scopeOf(current));
         const events = [...(recovered?.events ?? [])];
-        const equivalent = events.some((candidate) => candidate.agentId === current.id &&
-            candidate.type === statusEventType(to) &&
-            candidate.payload.to === to);
-        if (!equivalent) {
-            const statusEvent = await this.#appendStatusEvents({
-                agent: current,
+        const statusEventPlans = [...(recovered?.statusEventPlans ?? [])];
+        const equivalent = statusEventPlans.some((candidate) => candidate.agent.id === current.id && candidate.to === to);
+        const statusInput = {
+            agentStatus: to,
+            herdrSessionName: input.herdrSessionName,
+            paneId,
+            paneGeneration: eventGeneration,
+        };
+        if (from === to) {
+            this.#stores.agents.updateStatus(statusInput);
+        }
+        else if (!equivalent) {
+            const inserted = runSqliteTransaction(this.#stores.sqlite, () => {
+                const updated = this.#stores.agents.updateStatus(statusInput) ?? current;
+                const plan = this.#stores.statusEventPlans.insertPending({
+                    agent: updated,
+                    from,
+                    herdrEventKey: herdrEventKey ?? null,
+                    to,
+                    ...(refreshed.snapshot.compactHistory
+                        ? { compactHistory: refreshed.snapshot.compactHistory }
+                        : {}),
+                });
+                return { plan, updated };
+            });
+            statusEventPlans.push({
+                agent: inserted.updated,
                 compactHistory: refreshed.snapshot.compactHistory,
                 from,
-                herdrEventKey,
+                ...(herdrEventKey ? { herdrEventKey } : {}),
+                planId: inserted.plan.id,
                 to,
             });
-            if (statusEvent)
-                events.push(statusEvent);
         }
-        return { contextChangedScopes: sortedScopes(scopes), events };
+        else {
+            this.#stores.agents.updateStatus(statusInput);
+        }
+        return { contextChangedScopes: sortedScopes(scopes), events, statusEventPlans };
     }
     async #registerPiSessionRefNow(input) {
         const key = terminalSessionKey(input.herdrSessionName, input.terminalId);
         if (input.sessionRef.kind === "path" && !safeAllowedSessionPath(input.sessionRef.value)) {
-            return { agent: undefined, contextChangedScopes: [] };
+            if (existsSync(input.sessionRef.value) ||
+                !sessionPathAllowedByShape(input.sessionRef.value)) {
+                return { agent: undefined, contextChangedScopes: [] };
+            }
         }
         const previous = this.#stores.agents.findByTerminal(input);
         if (!previous) {
@@ -320,89 +971,392 @@ export class AgentIndexService {
         });
         return result;
     }
+    #isClosedPaneAgent(herdrSessionName, agent) {
+        const paneId = stringValue(agent.pane_id) ?? stringValue(agent.paneId);
+        if (!paneId)
+            return false;
+        return this.#stores.agents.isPaneClosed({
+            herdrSessionName,
+            paneId,
+            paneGeneration: paneGenerationOf(agent),
+        });
+    }
+    #registerActiveWaiter(agent, controller) {
+        const key = `${agent.herdrSessionName}\0${agent.paneId}\0${agent.paneGeneration ?? ""}`;
+        let set = this.#activeWaiters.get(key);
+        if (!set) {
+            set = new Set();
+            this.#activeWaiters.set(key, set);
+        }
+        set.add(controller);
+        return () => {
+            set.delete(controller);
+            if (set.size === 0 && this.#activeWaiters.get(key) === set) {
+                this.#activeWaiters.delete(key);
+            }
+        };
+    }
+    #abortPendingWaiters(input) {
+        for (const [key, controllers] of this.#activeWaiters) {
+            const [sessionName, paneId, paneGen] = key.split("\0");
+            if (sessionName === input.herdrSessionName && paneId === input.paneId) {
+                if (!input.paneGeneration || !paneGen || input.paneGeneration === paneGen) {
+                    for (const controller of controllers) {
+                        controller.abort();
+                    }
+                    controllers.clear();
+                    this.#activeWaiters.delete(key);
+                }
+            }
+        }
+    }
     async #appendStatusEvents(input) {
+        // Invariant: compactHistory is always populated as an object before calling #appendStatusEvents; !input.compactHistory check below is defensive and unreachable in normal operation.
         if (input.from === input.to || !input.compactHistory)
             return undefined;
-        const latest = this.#stores.agentEvents.latestStatusTransition(input.agent.id, input.agent.herdrSessionName);
-        if (latest && statusTransitionMatches(latest, input.from, input.to))
-            return undefined;
-        const observationId = `transition:${latest?.id ?? 0}`;
-        let compactHistory = input.compactHistory;
-        if (this.#turnCompletions !== undefined &&
-            (input.to === "done" || input.to === "blocked") &&
-            input.agent.agent === "pi" &&
-            input.agent.terminalId !== null) {
-            const turn = await this.#turnCompletions.waitForSignal({
+        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 is closed", {
+                agentId: input.agent.id,
                 herdrSessionName: input.agent.herdrSessionName,
-                recordedAfterMs: Date.now() - TURN_SIGNAL_WAIT_MS,
-                terminalId: input.agent.terminalId,
+                paneId: input.agent.paneId,
             });
-            if (turn.received) {
-                let refreshed = await this.#context.refreshAgent({
-                    agent: input.agent,
-                    identityChanged: false,
-                    forceRefresh: true,
-                });
-                for (let attempt = 0; attempt < 3 && refreshed.snapshot.compactHistory.lastAssistantMessage === null; attempt += 1) {
-                    await new Promise((resolve) => setTimeout(resolve, 300));
-                    refreshed = await this.#context.refreshAgent({
-                        agent: input.agent,
-                        identityChanged: false,
-                        forceRefresh: true,
+            return undefined;
+        }
+        const latest = this.#stores.agentEvents.latestStatusTransition(input.agent.id, input.agent.herdrSessionName);
+        let skipStatusChanged = false;
+        if (latest && statusTransitionMatches(latest, input.from, input.to)) {
+            const hasTerminalAfter = this.#stores.agentEvents.hasTerminalEventAfter(input.agent.id, input.agent.herdrSessionName, latest.id);
+            if (!hasTerminalAfter) {
+                if (statusEventType(input.to) === undefined) {
+                    console.debug("Herdsman skipping duplicate status transition event", {
+                        agentId: input.agent.id,
+                        from: input.from,
+                        to: input.to,
                     });
+                    return undefined;
                 }
-                compactHistory = refreshed.snapshot.compactHistory;
-                console.log(`Herdsman emitted pi agent.${input.to} after turn completion signal (confirmed=${turn.confirmed})`, {
-                    agentId: input.agent.id,
+                skipStatusChanged = true;
+            }
+            if (hasTerminalAfter && !input.herdrEventKey) {
+                const lastTerminal = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
+                if (sameTerminalAssistantContent(input.compactHistory, lastTerminal?.compactHistory, input.agent.agent)) {
+                    if ((input.attempts ?? 0) > 0) {
+                        throw new PlanWaitingHistoryError();
+                    }
+                    console.debug("Herdsman skipping legacy duplicate status transition event with identical history ref", {
+                        agentId: input.agent.id,
+                        from: input.from,
+                        to: input.to,
+                    });
+                    return undefined;
+                }
+            }
+        }
+        const observationId = `transition:${latest?.id ?? 0}`;
+        const controller = new AbortController();
+        const unregister = this.#registerActiveWaiter(input.agent, controller);
+        try {
+            let compactHistory = input.compactHistory;
+            let payloadExtra = {};
+            if (this.#turnCompletions !== undefined &&
+                (input.to === "done" || input.to === "blocked") &&
+                input.agent.terminalId !== null &&
+                input.agent.agent === "pi") {
+                const isRetry = (input.attempts ?? 0) > 0;
+                const latestTerminal = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
+                const baseline = isRetry && latestTerminal?.compactHistory
+                    ? latestTerminal.compactHistory
+                    : input.compactHistory;
+                const isAlreadyEmittedInRetry = isRetry &&
+                    latestTerminal?.compactHistory &&
+                    sameTerminalAssistantContent(input.compactHistory, latestTerminal.compactHistory, "pi");
+                const turn = await this.#turnCompletions.waitForSignal({
                     herdrSessionName: input.agent.herdrSessionName,
+                    recordedAfterMs: Date.now() - TURN_SIGNAL_WAIT_MS,
+                    signal: controller.signal,
                     terminalId: input.agent.terminalId,
                 });
-            }
-            else {
-                for (let attempt = 0; attempt < 3 && compactHistory.lastAssistantMessage === null; attempt += 1) {
-                    await new Promise((resolve) => setTimeout(resolve, 300));
-                    const refreshed = await this.#context.refreshAgent({
+                if (controller.signal.aborted ||
+                    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 turn wait was aborted or pane closed", {
+                        aborted: controller.signal.aborted,
+                        agentId: input.agent.id,
+                        herdrSessionName: input.agent.herdrSessionName,
+                        paneId: input.agent.paneId,
+                    });
+                    return undefined;
+                }
+                if (turn?.received) {
+                    const fresh = (await this.#context.refreshAgent({
                         agent: input.agent,
-                        identityChanged: false,
                         forceRefresh: true,
+                        identityChanged: false,
+                    })).snapshot.compactHistory;
+                    if (!isAlreadyEmittedInRetry && hasNonEmptyAssistantMessage(fresh)) {
+                        compactHistory = fresh;
+                    }
+                    else {
+                        const advanced = await this.#waitForHistoryAdvance({
+                            agent: input.agent,
+                            baseline,
+                            controller,
+                            initial: fresh,
+                            maxAttempts: 8,
+                            requireAssistantChange: isRetry,
+                        });
+                        if (advanced === undefined)
+                            return undefined;
+                        if (isRetry &&
+                            !historyHasAdvanced(advanced, baseline, { requireAssistantChange: true })) {
+                            throw new PlanWaitingHistoryError();
+                        }
+                        compactHistory = advanced;
+                    }
+                    console.log(`Herdsman emitted pi agent.${input.to} after turn completion signal (confirmed=${turn.confirmed})`, {
+                        agentId: input.agent.id,
+                        herdrSessionName: input.agent.herdrSessionName,
+                        terminalId: input.agent.terminalId,
                     });
-                    compactHistory = refreshed.snapshot.compactHistory;
                 }
-                console.warn(`Herdsman emitted pi agent.${input.to} without a turn completion signal after ${TURN_SIGNAL_WAIT_MS}ms`, {
+                else if (!controller.signal.aborted) {
+                    const advanced = await this.#waitForHistoryAdvance({
+                        agent: input.agent,
+                        baseline,
+                        controller,
+                        maxAttempts: 8,
+                        requireAssistantChange: isRetry,
+                    });
+                    if (advanced === undefined)
+                        return undefined;
+                    if (isRetry &&
+                        !historyHasAdvanced(advanced, baseline, { requireAssistantChange: true })) {
+                        throw new PlanWaitingHistoryError();
+                    }
+                    if (!isRetry &&
+                        !historyHasAdvanced(advanced, input.compactHistory, { requireAssistantChange: true })) {
+                        compactHistory = { ...advanced, lastAssistantMessage: null };
+                        payloadExtra = { noAdvance: true, staleSnapshot: false };
+                    }
+                    else {
+                        compactHistory = advanced;
+                    }
+                    console.warn(`Herdsman emitted pi agent.${input.to} without a turn completion signal after ${TURN_SIGNAL_WAIT_MS}ms`, {
+                        agentId: input.agent.id,
+                        herdrSessionName: input.agent.herdrSessionName,
+                        terminalId: input.agent.terminalId,
+                    });
+                }
+            }
+            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 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;
+                        const currentRef = compact.lastAssistantMessage?.ref ?? null;
+                        return currentRef !== null && currentRef !== prevRef;
+                    }
+                    if (!latestTerminal)
+                        return true;
+                    const currentMsg = compact.lastAssistantMessage;
+                    const prevMsg = latestTerminal.compactHistory?.lastAssistantMessage;
+                    const refChanged = (currentMsg?.ref ?? null) !== (prevMsg?.ref ?? null);
+                    const textChanged = (currentMsg?.text ?? "") !== (prevMsg?.text ?? "");
+                    const same = sameTerminalAssistantContent(compact, latestTerminal.compactHistory, input.agent.agent);
+                    return !same || refChanged || textChanged;
+                };
+                const latestTerminalForSkip = this.#stores.agentEvents.latestTerminalEvent(input.agent.id, input.agent.herdrSessionName);
+                if (input.agent.agent !== "agy" &&
+                    compactHistory?.source !== "antigravity-sqlite" &&
+                    input.herdrEventKey &&
+                    latestTerminalForSkip &&
+                    hasNonEmptyAssistantMessage(compactHistory)) {
+                    const currentMsg = compactHistory.lastAssistantMessage;
+                    const prevMsg = latestTerminalForSkip.compactHistory?.lastAssistantMessage;
+                    const refChanged = (currentMsg?.ref ?? null) !== (prevMsg?.ref ?? null);
+                    const textChanged = (currentMsg?.text ?? "") !== (prevMsg?.text ?? "");
+                    const same = sameTerminalAssistantContent(compactHistory, latestTerminalForSkip.compactHistory, input.agent.agent);
+                    if (same && !refChanged && !textChanged) {
+                        return undefined;
+                    }
+                }
+                if (!isReadyNonPi(compactHistory)) {
+                    for (let attempt = 0; attempt < 8; attempt += 1) {
+                        await this.#sleep(500, controller.signal);
+                        if (controller.signal.aborted ||
+                            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 wait was aborted or pane closed", {
+                                aborted: controller.signal.aborted,
+                                agentId: input.agent.id,
+                                herdrSessionName: input.agent.herdrSessionName,
+                                paneId: input.agent.paneId,
+                            });
+                            return undefined;
+                        }
+                        try {
+                            const refreshed = await this.#context.refreshAgent({
+                                agent: input.agent,
+                                forceRefresh: true,
+                                identityChanged: false,
+                            });
+                            compactHistory = refreshed.snapshot.compactHistory;
+                        }
+                        catch (err) {
+                            console.debug("Herdsman failed to refresh agent during ready wait", err);
+                        }
+                        if (isReadyNonPi(compactHistory)) {
+                            break;
+                        }
+                    }
+                }
+                if (!isReadyNonPi(compactHistory)) {
+                    throw new PlanWaitingHistoryError();
+                }
+            }
+            if (controller.signal.aborted ||
+                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 turn wait was aborted or pane closed before append", {
+                    aborted: controller.signal.aborted,
                     agentId: input.agent.id,
                     herdrSessionName: input.agent.herdrSessionName,
-                    terminalId: input.agent.terminalId,
+                    paneId: input.agent.paneId,
                 });
+                return undefined;
             }
-        }
-        const lastEvent = this.#appendAndAckSelfEvent({
-            agentId: input.agent.id,
-            compactHistory,
-            herdrSessionName: input.agent.herdrSessionName,
-            idempotencyKey: idempotencyKey("agent.status.changed", input.agent, input.from, input.to, `${observationId}:${input.herdrEventKey ?? "legacy"}:agent.status.changed`),
-            paneId: input.agent.paneId,
-            paneGeneration: input.agent.paneGeneration ?? null,
-            payload: payload(input.agent, input.from, input.to),
-            terminalId: input.agent.terminalId,
-            type: "agent.status.changed",
-            workspaceId: input.agent.workspaceId,
-        });
-        const statusType = statusEventType(input.to);
-        if (statusType) {
-            return this.#appendAndAckSelfEvent({
-                agentId: input.agent.id,
-                compactHistory,
+            const currentAgent = this.#stores.agents.findByPane({
                 herdrSessionName: input.agent.herdrSessionName,
-                idempotencyKey: idempotencyKey(statusType, input.agent, input.from, input.to, `${observationId}:${input.herdrEventKey ?? "legacy"}:${statusType}`),
                 paneId: input.agent.paneId,
                 paneGeneration: input.agent.paneGeneration ?? null,
-                payload: payload(input.agent, input.from, input.to),
-                terminalId: input.agent.terminalId,
-                type: statusType,
-                workspaceId: input.agent.workspaceId,
             });
+            if (!currentAgent) {
+                // The agent row is gone: appending would create a dangling event with
+                // a dead agent_id that only the reconciler could sweep. Cancel the
+                // plan instead of marking it completed (the skip->completed branch
+                // must stay reserved for genuine skips).
+                console.debug("Herdsman cancelling terminal status plan because agent row is gone", {
+                    agentId: input.agent.id,
+                    herdrSessionName: input.agent.herdrSessionName,
+                    paneId: input.agent.paneId,
+                    from: input.from,
+                    to: input.to,
+                });
+                return PLAN_CANCELLED;
+            }
+            let targetAgent;
+            if (currentAgent.agentStatus !== input.to) {
+                if (input.to === "done" ||
+                    input.to === "blocked" ||
+                    (input.to === "idle" && currentAgent.agent === "agy")) {
+                    console.info("Herdsman emitting terminal status event after subsequent status change", {
+                        agentId: input.agent.id,
+                        current: currentAgent.agentStatus,
+                        expected: input.to,
+                        herdrSessionName: input.agent.herdrSessionName,
+                        paneId: input.agent.paneId,
+                    });
+                    targetAgent = currentAgent;
+                }
+                else {
+                    console.debug("Herdsman skipping status event generation due to status mismatch", {
+                        agentId: input.agent.id,
+                        current: currentAgent.agentStatus,
+                        expected: input.to,
+                        herdrSessionName: input.agent.herdrSessionName,
+                        paneId: input.agent.paneId,
+                    });
+                    return undefined;
+                }
+            }
+            else {
+                targetAgent = currentAgent;
+            }
+            const eventPayload = { ...payload(targetAgent, input.from, input.to), ...payloadExtra };
+            const lastEvent = skipStatusChanged
+                ? undefined
+                : this.#appendAndAckSelfEvent({
+                    agentId: targetAgent.id,
+                    compactHistory,
+                    herdrSessionName: targetAgent.herdrSessionName,
+                    idempotencyKey: idempotencyKey("agent.status.changed", targetAgent, input.from, input.to, `${observationId}:${input.herdrEventKey ?? "legacy"}:agent.status.changed`),
+                    paneId: targetAgent.paneId,
+                    paneGeneration: targetAgent.paneGeneration ?? null,
+                    payload: eventPayload,
+                    terminalId: targetAgent.terminalId,
+                    type: "agent.status.changed",
+                    workspaceId: targetAgent.workspaceId,
+                });
+            const statusType = statusEventType(input.to);
+            if (statusType) {
+                return this.#appendAndAckSelfEvent({
+                    agentId: targetAgent.id,
+                    compactHistory,
+                    herdrSessionName: targetAgent.herdrSessionName,
+                    idempotencyKey: idempotencyKey(statusType, targetAgent, input.from, input.to, `${observationId}:${input.herdrEventKey ?? "legacy"}:${statusType}`),
+                    paneId: targetAgent.paneId,
+                    paneGeneration: targetAgent.paneGeneration ?? null,
+                    payload: eventPayload,
+                    terminalId: targetAgent.terminalId,
+                    type: statusType,
+                    workspaceId: targetAgent.workspaceId,
+                });
+            }
+            return lastEvent;
+        }
+        finally {
+            unregister();
+        }
+    }
+    #appendPlanFailedEvent(input) {
+        let agent = input.agent;
+        try {
+            agent = this.#stores.agents.get(input.agent.id);
         }
-        return lastEvent;
+        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.failed:plan:${input.planId}`,
+            paneId: agent.paneId,
+            paneGeneration: agent.paneGeneration ?? null,
+            payload: {
+                agent: agent.agent,
+                attempts: input.attempts,
+                from: input.from,
+                herdrSessionName: agent.herdrSessionName,
+                name: agent.name,
+                paneId: agent.paneId,
+                reason: input.reason ?? "unknown",
+                terminalId: agent.terminalId,
+                to: input.to,
+                workspaceId: agent.workspaceId,
+            },
+            terminalId: agent.terminalId,
+            type: "agent.failed",
+            workspaceId: agent.workspaceId,
+        });
     }
     #appendAndAckSelfEvent(input) {
         const event = this.#stores.agentEvents.append(input);
@@ -417,13 +1371,33 @@ export class AgentIndexService {
         return event;
     }
 }
-function withPaneRevision(agent, revisionByPane) {
+function withPaneRevision(agent, overlayByPane) {
     const raw = record(agent);
-    if (integerValue(raw.revision) !== undefined)
-        return raw;
     const paneId = stringValue(raw.pane_id) ?? stringValue(raw.paneId);
-    const revision = paneId ? revisionByPane.get(paneId) : undefined;
-    return revision === undefined ? raw : { ...raw, revision };
+    const overlay = paneId ? overlayByPane.get(paneId) : undefined;
+    const revision = integerValue(raw.revision) ?? overlay?.revision;
+    const terminalTitle = stringValue(raw.terminal_title) ?? stringValue(raw.terminalTitle) ?? overlay?.terminalTitle;
+    if (revision === undefined && !terminalTitle)
+        return raw;
+    // Collapse dual keys onto herdr-canonical snake_case `terminal_title`.
+    // Incoming snapshots may carry camelCase `terminalTitle`; spreading `raw`
+    // would otherwise leave both keys on the overlay object. Downstream
+    // HerdrAgentLike readers (AgentStore.replaceForSession) still accept
+    // camelCase as fallback, and AgentIndexRecord.terminalTitle is populated
+    // later from whichever key is present.
+    const rest = { ...raw };
+    delete rest.terminalTitle;
+    return {
+        ...rest,
+        ...(revision === undefined ? {} : { revision }),
+        ...(terminalTitle ? { terminal_title: terminalTitle } : {}),
+    };
+}
+function paneGenerationOf(agent) {
+    return (stringValue(agent.pane_generation) ??
+        stringValue(agent.paneGeneration) ??
+        stringValue(agent.creation_id) ??
+        stringValue(agent.creationId));
 }
 function matchingPrior(agent, previousByTerminal, previousByPane) {
     const terminalMatch = agent.terminalId ? previousByTerminal.get(agent.terminalId) : undefined;
@@ -495,12 +1469,11 @@ function payload(agent, from, to) {
 function idempotencyKey(type, agent, from, to, observationId) {
     return `${type}:${agent.herdrSessionName}:${agent.paneId}:${from}:${to}:${observationId}`;
 }
-function herdrInputIdempotencyKey(sessionName, paneId, event, targetStatus) {
+function herdrInputIdempotencyKey(sessionName, paneId, event, _targetStatus) {
     const eventId = stringValue(event.id) ?? stringValue(event.event_id) ?? stringValue(event.eventId);
-    if (eventId)
-        return `${sessionName}:${paneId}:${String(event.type)}:${eventId}`;
-    const revision = integerValue(event.revision) ?? integerValue(event.pane_revision) ?? "unknown";
-    return `${sessionName}:${paneId}:${revision}:${targetStatus}`;
+    if (!eventId)
+        return undefined;
+    return `${sessionName}:${paneId}:${String(event.type)}:${eventId}`;
 }
 function statusTransitionMatches(event, from, to) {
     const eventPayload = event.payload;
@@ -521,4 +1494,41 @@ function stringValue(value) {
 function integerValue(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
 }
+function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let timer;
+        const onAbort = () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            resolve();
+        };
+        timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function sameTerminalAssistantContent(current, previous, agentKind) {
+    const currentMsg = current?.lastAssistantMessage;
+    const prevMsg = previous?.lastAssistantMessage;
+    if (!currentMsg || !prevMsg)
+        return false;
+    if (agentKind === "agy" || current?.source === "antigravity-sqlite") {
+        if (currentMsg.ref !== null && prevMsg.ref !== null) {
+            return currentMsg.ref === prevMsg.ref;
+        }
+        return Boolean(currentMsg.text && currentMsg.text === prevMsg.text);
+    }
+    // Non-agy (pi, claude, codex, grok, opencode):
+    if (currentMsg.ref !== null && prevMsg.ref !== null) {
+        return currentMsg.ref === prevMsg.ref;
+    }
+    if (currentMsg.text.length > 0 && prevMsg.text.length > 0) {
+        return currentMsg.text === prevMsg.text;
+    }
+    return false;
+}
 //# sourceMappingURL=agent-index-service.js.map