@hyperdrive.bot/fleet-server 0.3.126 → 0.3.128

package/dist/server/server/session.js

@@ -1146,7 +1146,33 @@ export class Session {
             const record = await this.agentStorage.get(agentId);
             if (!record)
                 return;
-            const agent = this.buildStoredAgentPayload(record);
+            /*
+             * The LIVE payload when the agent is live.
+             *
+             * This always built the stored one, and `buildStoredAgentPayload`
+             * hardcodes `pendingPermissions: []`, `availableModes: []` and the
+             * default capabilities, because a stored record genuinely has none of
+             * those. Broadcasting that for a LIVE agent is a lie the app believes:
+             * `writeStoredMetadata` stamps a strictly newer `updatedAt`, so the
+             * client's staleness guard waves it through, and
+             * `applyAuthoritativeAgentSnapshot` then deletes the agent's permission
+             * keys because the incoming list is empty.
+             *
+             * The user-visible cost was specific and bad: a permission-blocked
+             * session ranks FIRST in the triage ring, and snoozing it - an ordinary
+             * move - erased the approval prompt app-wide, dropped the agent out of
+             * `needs_input`, and downgraded its mode list. The daemon stays blocked
+             * waiting on that approval and a blocked agent emits nothing further, so
+             * only a reconnect brought it back.
+             *
+             * Introduced by the round-35 broadcast fix, which is the shape this log
+             * keeps naming: a fix verified against the case that motivated it (an
+             * idle session) and not the space around it (a live one).
+             */
+            const liveAgent = this.agentManager.getAgent(agentId);
+            const agent = liveAgent
+                ? await this.buildAgentPayload(liveAgent)
+                : this.buildStoredAgentPayload(record);
             // `workspaceId` is optional on the record: an agent outside a workspace has
             // no project placement, and the payload's `project` is optional too.
             const project = record.workspaceId
@@ -2866,10 +2892,60 @@ export class Session {
             await this.agentManager.updateAgentMetadata(winnerId, {
                 digest: { ...winnerDigest, links: [...(winnerDigest.links ?? []), ...newLinks] },
             });
+            /*
+             * `archiveAgentCommand`, like every other archive caller in the repo.
+             *
+             * This called `agentManager.archiveAgent` directly, whose first statement
+             * is `requireAgent`, which THROWS `Unknown agent '<id>'` when the agent is
+             * not in memory. Most of a triage backlog is exactly that, and consolidate
+             * is the verb the refused-snooze copy points the user at: the hold
+             * completed, the sheet showed a raw uuid in an error, and nothing was
+             * archived.
+             *
+             * Worse on a mixed set: the links above were already written, on the
+             * winner AND on every source, so the live sources got archived, the
+             * stored-only ones did not, and the response said `accepted: false`. That
+             * is the half-consolidated fleet the single-call design exists to
+             * prevent, and a retry appends the links again because they are not
+             * deduped.
+             *
+             * The command branches on `getAgent()` and falls back to
+             * `archiveStoredAgent`, which is the same fallback `archiveAgentForClose`
+             * uses a few hundred lines up.
+             */
+            const archivedAtById = new Map();
             for (const sourceId of sources) {
-                await this.agentManager.archiveAgent(sourceId);
+                const { archivedAt } = await archiveAgentCommand({
+                    agentManager: this.agentManager,
+                    agentStorage: this.agentStorage,
+                    logger: this.sessionLogger,
+                }, sourceId);
+                archivedAtById.set(sourceId, archivedAt);
                 archivedIds.push(sourceId);
             }
+            /*
+             * Tell every client the sources are archived.
+             *
+             * This emitted only `agent.consolidate.response`, which is point to
+             * point: nothing set `archivedAt` in the app's store, so
+             * `selectFeedCandidates`' archived clause could not drop them and the N
+             * sources came back in the ring - the exact outcome
+             * `reels-feed-source.ts` says it closed. `handleArchiveAgentRequest`
+             * emits `agent_archived` for the single-session case; consolidate is the
+             * batch of the same operation and owes the same event.
+             */
+            for (const sourceId of archivedIds) {
+                const archivedAt = archivedAtById.get(sourceId);
+                if (!archivedAt)
+                    continue;
+                // `requestId` is the consolidate request's: the archive is part of it,
+                // and the schema requires the correlation id.
+                this.emit({
+                    type: "agent_archived",
+                    payload: { agentId: sourceId, archivedAt, requestId },
+                });
+            }
+            await this.emitAgentUpsertFromStorage(winnerId);
             this.emit({
                 type: "agent.consolidate.response",
                 payload: { requestId, winnerId, accepted: true, archivedIds, error: null },
@@ -3057,6 +3133,25 @@ export class Session {
                 });
                 return;
             }
+            /*
+             * Broadcast it, exactly like the snooze and decision handlers.
+             *
+             * `emitAgentUpsertFromStorage`'s own docblock names a kanban move on an
+             * idle session as one of the two symptoms it exists to fix, and then only
+             * the decision half was wired. This handler is the SOLE path for
+             * `setKanban` and `setTags`, and it emitted a point-to-point response and
+             * nothing else. For an agent the daemon has not loaded,
+             * `updateAgentMetadata` falls through to `writeStoredMetadata`, which
+             * emits nothing at all.
+             *
+             * What that cost, beyond the stale chip: reels reads the WIP occupancy
+             * from the same store labels, so a column at its limit kept counting the
+             * cards it had before the moves, and the gate that was added to refuse a
+             * fourth card went blind for the rest of the sitting. Nothing recovers
+             * within a session: the authoritative revalidation fires on connection
+             * events, not on a timer.
+             */
+            await this.emitAgentUpsertFromStorage(agentId);
             this.emit({
                 type: "update_agent_response",
                 payload: { requestId, agentId, accepted: true, error: null },