@phnx-labs/agents-cli 1.22.115 → 1.22.116

package/dist/lib/feed/hub-server.js

@@ -10,7 +10,7 @@
  * This is that boundary, and it is deliberately the thinnest possible one: a
  * UNIX socket (named pipe on Windows) that writes the SAME NDJSON envelopes
  * `agents feed watch --json` has always written, one per line. A client is a
- * `readline` over the socket; there is no request/response protocol, no framing
+ * line splitter over the socket; there is no request/response protocol, no framing
  * of its own, and no second schema to keep in sync.
  *
  * The daemon owns the server (`FeedStreamService`), which is what makes it one
@@ -22,13 +22,13 @@
 import * as fs from 'node:fs';
 import * as net from 'node:net';
 import * as path from 'node:path';
-import { createInterface } from 'node:readline';
 import { getHelpersDir } from '../state.js';
 import { ipcEndpoint } from '../platform/ipc.js';
 const IS_WINDOWS = process.platform === 'win32';
 const SOCKET_NAME = 'feed-stream.sock';
 /**
- * Outbound bytes a single reader may leave unflushed before it is dropped.
+ * Live bytes a reader may leave queued, sustained past {@link HUB_BACKLOG_GRACE_MS},
+ * before it is dropped.
  *
  * `socket.write()` never blocks: when a reader stops draining — a stopped
  * process, a suspended laptop, a debugger paused on a breakpoint — node buffers
@@ -37,8 +37,42 @@ const SOCKET_NAME = 'feed-stream.sock';
  * can never reclaim, and the daemon is the process every other surface depends
  * on. A reader that cannot keep up is dropped loudly instead: it can reconnect
  * and be caught up from held state, which is cheaper than the backlog.
+ *
+ * The budget is a SUSTAINED condition on queued live events, never a verdict on
+ * one envelope or one burst. A cold collector delivers every peer's reset as a
+ * live event, thirteen of them inside one tick, and a healthy reader drains
+ * that in milliseconds; judging the budget the instant an envelope was written
+ * is how a 5 MB fleet reset was cut off after 8 KiB and delivered as one
+ * unterminated line (the Menu activation failure this module's writer fixes).
+ * The catch-up snapshot is never counted: it is bounded by the held state and is
+ * exactly what a fresh reader is waiting for.
  */
 export const HUB_CLIENT_BACKLOG_LIMIT = 4 * 1024 * 1024;
+/**
+ * How long a reader may stay past {@link HUB_CLIENT_BACKLOG_LIMIT} before it is
+ * dropped. A healthy reader on a unix socket clears the whole budget in well
+ * under this; one still over it after this long is not keeping up. The live
+ * bytes queued for a reader are therefore bounded by the budget plus what the
+ * stream produces in this window; the snapshot and the frame in flight sit
+ * outside that figure.
+ */
+export const HUB_BACKLOG_GRACE_MS = 2_000;
+/**
+ * How long a reader may leave one chunk unaccepted before it is dropped.
+ *
+ * A write that returned `false` is a kernel buffer full of bytes the reader has
+ * not read. A healthy reader — even one on a busy laptop — clears it in
+ * milliseconds; one that has not in this long is not reading at all, and the
+ * live-bytes budget alone would let a paused reader hold a large snapshot's
+ * remainder in the daemon's heap forever.
+ */
+export const HUB_DRAIN_STALL_MS = 30_000;
+/**
+ * Bytes handed to the socket per write. Small enough that a reader's own
+ * backpressure (`write()` returning `false`, then `'drain'`) paces a multi-MB
+ * snapshot instead of dumping it into the daemon's heap in one copy.
+ */
+export const HUB_WRITE_CHUNK_BYTES = 64 * 1024;
 /**
  * How long a reader gets to send its scope line before it is REJECTED.
  *
@@ -63,6 +97,146 @@ export function feedHubSocketPath() {
 export function feedHubEndpoint(socketPath = feedHubSocketPath()) {
     return ipcEndpoint(socketPath);
 }
+/**
+ * One reader's ordered outbound queue.
+ *
+ * Every line to one socket goes through this — snapshot, live events, and the
+ * error envelope that precedes a refusal — so nothing can land inside another
+ * line. Lines are written in {@link HUB_WRITE_CHUNK_BYTES} chunks and the pump
+ * waits for `'drain'` after every write the socket did not accept, so the socket
+ * never holds more than one chunk past its high-water mark. The frame's own
+ * Buffer stays allocated until its last chunk is written (`subarray` is a view),
+ * so `pendingBytes` is a gauge of UNFLUSHED bytes, not of retained heap. Two
+ * bounds drop the reader: a chunk left unaccepted for `drainStallMs`, and live
+ * bytes queued past `backlogBytes` for longer than `backlogGraceMs`. The bound
+ * on what a reader can make the daemon hold is therefore time- and
+ * rate-dependent — the budget, plus the stream's ingress during the grace,
+ * plus the snapshot and the frame in flight — not a hard allocation cap.
+ */
+class ReaderWriter {
+    socket;
+    limits;
+    drop;
+    /** Lines not yet handed to the socket; `live` marks the ones the budget counts. */
+    queue = [];
+    /** Bytes queued since the snapshot finished enqueuing; the budgeted part. */
+    liveBytes = 0;
+    live = false;
+    running = false;
+    closeAfterFlush = false;
+    /** Armed while the live queue is over budget; fires the drop if it still is. */
+    overBudget = null;
+    /** Bytes of the line being pumped that have not yet been handed to the socket. */
+    activeRemaining = 0;
+    constructor(socket, limits, drop) {
+        this.socket = socket;
+        this.limits = limits;
+        this.drop = drop;
+    }
+    /**
+     * Unflushed bytes for this reader: queued lines, the unwritten rest of the
+     * line being pumped, and the socket's own buffer. A gauge of what is still
+     * owed to the socket, not of retained heap. A 5 MiB frame to a paused reader
+     * leaves the queue on its first chunk, so a queue-only gauge read 0 while
+     * almost all of it was still unflushed.
+     */
+    get pendingBytes() {
+        return this.queue.reduce((sum, line) => sum + line.bytes.length, 0) + this.activeRemaining + this.socket.writableLength;
+    }
+    /** Everything enqueued from now on is a live event and counts against the budget. */
+    startLive() { this.live = true; }
+    write(line) {
+        if (this.socket.destroyed)
+            return;
+        const bytes = Buffer.from(`${line}\n`, 'utf-8');
+        this.queue.push({ bytes, live: this.live });
+        if (this.live) {
+            this.liveBytes += bytes.length;
+            this.judgeBacklog();
+        }
+        void this.pump();
+    }
+    /** FIN once everything queued has been handed to the socket. */
+    end() {
+        this.closeAfterFlush = true;
+        void this.pump();
+    }
+    /** Release the timers; the socket is gone. */
+    dispose() {
+        if (this.overBudget) {
+            clearTimeout(this.overBudget);
+            this.overBudget = null;
+        }
+        this.queue.length = 0;
+        this.liveBytes = 0;
+        this.activeRemaining = 0;
+    }
+    judgeBacklog() {
+        if (this.liveBytes <= this.limits.backlogBytes) {
+            if (this.overBudget) {
+                clearTimeout(this.overBudget);
+                this.overBudget = null;
+            }
+            return;
+        }
+        if (this.overBudget)
+            return;
+        this.overBudget = setTimeout(() => {
+            this.overBudget = null;
+            if (this.liveBytes > this.limits.backlogBytes) {
+                this.drop('backlog', `feed reader dropped: ${this.liveBytes} live bytes queued exceeded the ${this.limits.backlogBytes}-byte budget for ${this.limits.backlogGraceMs}ms`);
+            }
+        }, this.limits.backlogGraceMs);
+        this.overBudget.unref();
+    }
+    async pump() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            while (this.queue.length > 0 && !this.socket.destroyed) {
+                const { bytes, live } = this.queue.shift();
+                if (live) {
+                    this.liveBytes -= bytes.length;
+                    this.judgeBacklog();
+                }
+                for (let offset = 0; offset < bytes.length && !this.socket.destroyed; offset += this.limits.chunkBytes) {
+                    const end = Math.min(offset + this.limits.chunkBytes, bytes.length);
+                    this.activeRemaining = bytes.length - end;
+                    const accepted = this.socket.write(bytes.subarray(offset, end));
+                    if (!accepted && !await this.drained())
+                        return;
+                }
+                this.activeRemaining = 0;
+            }
+            if (this.closeAfterFlush && !this.socket.destroyed)
+                this.socket.end();
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /** Resolve true on `'drain'`; false when the socket closed or the stall deadline passed. */
+    drained() {
+        return new Promise((resolve) => {
+            const settle = (ok) => {
+                clearTimeout(stall);
+                this.socket.off('drain', onDrain);
+                this.socket.off('close', onClose);
+                resolve(ok);
+            };
+            const onDrain = () => settle(true);
+            const onClose = () => settle(false);
+            const stall = setTimeout(() => {
+                this.drop('stall', `feed reader dropped: no drain within ${this.limits.drainStallMs}ms with ${this.socket.writableLength} bytes unaccepted`);
+                settle(false);
+            }, this.limits.drainStallMs);
+            stall.unref();
+            this.socket.once('drain', onDrain);
+            this.socket.once('close', onClose);
+        });
+    }
+}
 /**
  * Serve one {@link FeedHub} to other processes. Each accepted connection is one
  * subscriber; closing it detaches, and the last detach stops the fan-out.
@@ -75,8 +249,12 @@ export class FeedHubServer {
     detachers = new Map();
     /** Which collector each reader is attached to, so a failure reaches only its own. */
     attachedTo = new Map();
-    /** Readers dropped for exceeding {@link HUB_CLIENT_BACKLOG_LIMIT}. Observability. */
+    writers = new Map();
+    limits;
+    /** Readers dropped for queueing live bytes past the budget. Observability. */
     droppedForBacklog = 0;
+    /** Readers dropped for not draining a chunk within the stall deadline. Observability. */
+    droppedForStall = 0;
     /** Readers refused for a missing, invalid, or late scope line. Observability. */
     rejectedHandshakes = 0;
     /**
@@ -86,10 +264,16 @@ export class FeedHubServer {
      *                 every reader from the fleet hub, which is what the fleet
      *                 stream already contained.
      */
-    constructor(hub, socketPathOverride, localHub) {
+    constructor(hub, socketPathOverride, localHub, limits = {}) {
         this.hub = hub;
         this.socketPathOverride = socketPathOverride;
         this.localHub = localHub;
+        this.limits = {
+            backlogBytes: limits.backlogBytes ?? HUB_CLIENT_BACKLOG_LIMIT,
+            backlogGraceMs: limits.backlogGraceMs ?? HUB_BACKLOG_GRACE_MS,
+            drainStallMs: limits.drainStallMs ?? HUB_DRAIN_STALL_MS,
+            chunkBytes: limits.chunkBytes ?? HUB_WRITE_CHUNK_BYTES,
+        };
         // A collector that cannot start is reported to every reader attached to it
         // and the connection is ended, so a consumer sees a failure instead of an
         // indefinitely silent stream it cannot distinguish from an idle fleet.
@@ -103,12 +287,20 @@ export class FeedHubServer {
         for (const [socket, attached] of this.attachedTo) {
             if (attached !== collector || socket.destroyed)
                 continue;
-            socket.write(`${JSON.stringify({ v: 1, type: 'error', scope: '', error: error.message })}\n`);
-            socket.end();
+            const writer = this.writers.get(socket);
+            writer.write(JSON.stringify({ v: 1, type: 'error', scope: '', error: error.message }));
+            writer.end();
         }
     }
     /** Subscribers currently connected. Observability + tests. */
     get clientCount() { return this.detachers.size; }
+    /** Bytes queued for every reader and not yet handed to a socket. Observability + tests. */
+    get pendingBytes() {
+        let total = 0;
+        for (const writer of this.writers.values())
+            total += writer.pendingBytes;
+        return total;
+    }
     async start() {
         const socketPath = this.socketPathOverride ?? feedHubSocketPath();
         const endpoint = this.socketPathOverride ?? feedHubEndpoint();
@@ -124,41 +316,51 @@ export class FeedHubServer {
             catch { /* nothing stale to remove */ }
         }
         this.server = net.createServer((socket) => {
+            // The scope line is REQUIRED and must arrive within the grace window.
+            const grace = setTimeout(() => reject(`no scope line within ${HUB_HANDSHAKE_GRACE_MS}ms`), HUB_HANDSHAKE_GRACE_MS);
+            grace.unref();
             const end = () => {
+                clearTimeout(grace);
                 this.detachers.get(socket)?.();
                 this.detachers.delete(socket);
                 this.attachedTo.delete(socket);
+                this.writers.get(socket)?.dispose();
+                this.writers.delete(socket);
             };
             socket.on('close', end);
             // A reader that dies mid-write surfaces as an error, not a close, and
             // leaving it subscribed would hold every peer connection open forever.
             socket.on('error', end);
+            const writer = new ReaderWriter(socket, this.limits, (reason, message) => {
+                if (socket.destroyed)
+                    return;
+                if (reason === 'backlog')
+                    this.droppedForBacklog += 1;
+                else
+                    this.droppedForStall += 1;
+                // `destroy` rather than `end`: a reader this far behind is not going
+                // to drain a graceful FIN either, and the point is to release the
+                // queued bytes now. 'close' fires and detaches it.
+                socket.destroy(new Error(message));
+            });
+            this.writers.set(socket, writer);
             /** Refuse this reader, telling it why rather than hanging up silently. */
             const reject = (reason) => {
                 clearTimeout(grace);
                 if (socket.destroyed)
                     return;
                 this.rejectedHandshakes += 1;
-                socket.write(`${JSON.stringify({ v: 1, type: 'error', scope: '', error: `feed handshake rejected: ${reason}` })}\n`);
-                socket.end();
+                writer.write(JSON.stringify({ v: 1, type: 'error', scope: '', error: `feed handshake rejected: ${reason}` }));
+                writer.end();
             };
             const attach = (hub) => {
                 if (socket.destroyed || this.detachers.has(socket))
                     return;
-                const detach = hub.subscribe((event) => {
-                    if (socket.destroyed)
-                        return;
-                    socket.write(`${JSON.stringify(event)}\n`);
-                    // Checked AFTER the write, so the reader is judged on a real backlog
-                    // rather than on one envelope's size.
-                    if (socket.writableLength > HUB_CLIENT_BACKLOG_LIMIT) {
-                        this.droppedForBacklog += 1;
-                        // `destroy` rather than `end`: a reader this far behind is not going
-                        // to drain a graceful FIN either, and the point is to release the
-                        // buffered bytes now. 'close' fires and detaches it.
-                        socket.destroy(new Error(`feed reader dropped: ${socket.writableLength} bytes unflushed exceeds the ${HUB_CLIENT_BACKLOG_LIMIT}-byte budget`));
-                    }
-                });
+                // `subscribe` emits the catch-up snapshot synchronously before it
+                // returns, so every line enqueued until then is snapshot and the first
+                // live event can only ever queue behind it.
+                const detach = hub.subscribe((event) => writer.write(JSON.stringify(event)));
+                writer.startLive();
                 this.detachers.set(socket, detach);
                 this.attachedTo.set(socket, hub);
                 // A collector that ALREADY failed must not leave this reader waiting for
@@ -166,10 +368,7 @@ export class FeedHubServer {
                 if (hub.lastFailure)
                     this.failReaders(hub, hub.lastFailure);
             };
-            // The scope line is REQUIRED and must arrive within the grace window.
             let handshake = '';
-            const grace = setTimeout(() => reject(`no scope line within ${HUB_HANDSHAKE_GRACE_MS}ms`), HUB_HANDSHAKE_GRACE_MS);
-            grace.unref();
             socket.on('data', (chunk) => {
                 if (socket.destroyed)
                     return;
@@ -207,7 +406,6 @@ export class FeedHubServer {
                 }
                 attach(scope === 'local' ? this.localHub : this.hub);
             });
-            socket.once('end', () => clearTimeout(grace));
         });
         await new Promise((resolve, reject) => {
             const listener = this.server;
@@ -243,12 +441,18 @@ export class FeedHubServer {
         });
     }
     async stop() {
-        for (const [socket, detach] of this.detachers) {
+        for (const detach of this.detachers.values())
             detach();
+        // Every connection, including one still in its handshake: `server.close`
+        // waits for open sockets, and a reader that never sent its scope line
+        // would otherwise hold the daemon's shutdown for the whole grace window.
+        for (const [socket, writer] of this.writers) {
+            writer.dispose();
             socket.destroy();
         }
         this.detachers.clear();
         this.attachedTo.clear();
+        this.writers.clear();
         const server = this.server;
         this.server = null;
         if (server)
@@ -289,46 +493,94 @@ export async function waitForHub(endpoint = feedHubEndpoint(), deadlineMs = 10_0
  * quietly ran its own `watchFleetFeed` instead would restore the per-caller
  * ssh fan-out, so the caller starts the daemon and retries rather than
  * degrading into the thing this replaced.
+ *
+ * Also rejects on any close the caller did not ask for. The stream has no end
+ * of its own — the hub serves it until the reader leaves — so a FIN that
+ * arrives before `signal` aborts is the hub refusing, failing, or dropping this
+ * reader, and a FIN inside a line is a frame the hub never finished. Resolving
+ * there let `agents feed watch --json` exit 0 after 8 KiB of a 5 MB reset,
+ * which is indistinguishable from an empty fleet.
  */
 export function streamFeedFromHub(options) {
     return new Promise((resolve, reject) => {
         const socket = net.createConnection(options.endpoint ?? feedHubEndpoint());
-        let connected = false;
+        let aborted = false;
+        let failure;
+        const fail = (error) => { failure ??= error; socket.destroy(); };
         // Registered before anything else touches the socket: a connect failure on
         // a missing socket path is emitted as an 'error' with no listener attached
         // yet, which node raises as an uncaught exception rather than rejecting.
-        socket.on('error', (error) => finish(error));
-        const stop = () => { socket.destroy(); };
+        socket.on('error', (error) => { failure ??= error; });
+        const stop = () => { aborted = true; socket.destroy(); };
         options.signal.addEventListener('abort', stop, { once: true });
-        const finish = (error) => {
-            options.signal.removeEventListener('abort', stop);
-            reader.close();
-            if (error && !connected)
-                reject(error);
-            else
-                resolve();
-        };
-        const reader = createInterface({ input: socket });
-        // `readline.Interface` re-emits its input stream's error on ITSELF, and an
-        // Interface with no 'error' listener raises it as an uncaught exception —
-        // so handling it on the socket alone is not enough. Routed to the same
-        // `finish` so a mid-stream input failure ends the read once.
-        reader.on('error', (error) => finish(error));
-        reader.on('line', (line) => {
-            if (!line)
-                return;
-            try {
-                const event = JSON.parse(line);
+        if (options.signal.aborted)
+            stop();
+        // Pieces of the line in progress; only the newest chunk is searched for a
+        // newline, so an 8 MB reset arriving in 64 KiB chunks is not rescanned from
+        // its start on every chunk.
+        const partial = [];
+        let partialBytes = 0;
+        socket.setEncoding('utf-8');
+        socket.on('data', (chunk) => {
+            let rest = chunk;
+            for (;;) {
+                const newline = rest.indexOf('\n');
+                if (newline < 0) {
+                    partial.push(rest);
+                    partialBytes += rest.length;
+                    return;
+                }
+                partial.push(rest.slice(0, newline));
+                const line = partial.join('');
+                partial.length = 0;
+                partialBytes = 0;
+                rest = rest.slice(newline + 1);
+                if (!line)
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    fail(new Error(`feed hub sent a line that is not JSON (${line.length} chars)`));
+                    return;
+                }
+                if (typeof event !== 'object' || event === null) {
+                    fail(new Error(`feed hub sent a line that is not an envelope: ${line.slice(0, 80)}`));
+                    return;
+                }
                 // Protocol only: an unversioned line is not a feed envelope.
-                if (event.v === 1)
+                if (event.v !== 1)
+                    continue;
+                // A consumer that throws ends the read as a failure of THIS promise; left
+                // to escape the socket's 'data' handler it is an uncaught exception.
+                try {
                     options.emit(event);
+                }
+                catch (error) {
+                    fail(error instanceof Error ? error : new Error(String(error)));
+                    return;
+                }
             }
-            catch { /* a partial/foreign line is not state */ }
         });
         socket.on('connect', () => {
-            connected = true;
             socket.write(`${JSON.stringify({ v: 1, scope: options.scope ?? 'fleet' })}\n`);
         });
-        socket.on('close', () => finish());
+        socket.on('close', () => {
+            options.signal.removeEventListener('abort', stop);
+            if (aborted) {
+                resolve();
+                return;
+            }
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            if (partialBytes > 0) {
+                reject(new Error(`feed hub closed mid-frame: ${partialBytes} chars of an unterminated line`));
+                return;
+            }
+            reject(new Error('feed hub closed the stream'));
+        });
     });
 }

package/dist/lib/feed/pr-status.d.ts

@@ -7,9 +7,17 @@ export interface PullRequestStatus extends PullRequestAttentionSignal {
     statusCheckRollup?: unknown[];
 }
 /** CLI-owned bounded-TTL source shared by feed attention and PR-board consumers. */
+export declare const PR_STATUS_DEFAULT_TIMEOUT_MS = 15000;
+/**
+ * @param options.timeoutMs bound for the underlying `gh` call. An operator-facing
+ *   caller working against a deadline (the feed answer path) passes its remaining
+ *   budget so one unreachable PR cannot consume the whole operation; a timed-out
+ *   read is negative-cached for the TTL like any other failure.
+ */
 export declare function readPullRequestStatus(session: ActiveSession, options?: {
     nowMs?: number;
     ttlMs?: number;
+    timeoutMs?: number;
     gh?: GhExec;
 }): Promise<PullRequestStatus | undefined>;
 export declare function resetPullRequestStatusCache(): void;

package/dist/lib/feed/pr-status.js

@@ -15,6 +15,13 @@ function needsHuman(value) {
     return value.reviewDecision !== 'APPROVED' || (value.mergeable === 'MERGEABLE' && checksSettled);
 }
 /** CLI-owned bounded-TTL source shared by feed attention and PR-board consumers. */
+export const PR_STATUS_DEFAULT_TIMEOUT_MS = 15_000;
+/**
+ * @param options.timeoutMs bound for the underlying `gh` call. An operator-facing
+ *   caller working against a deadline (the feed answer path) passes its remaining
+ *   budget so one unreachable PR cannot consume the whole operation; a timed-out
+ *   read is negative-cached for the TTL like any other failure.
+ */
 export async function readPullRequestStatus(session, options = {}) {
     const ref = session.pr?.url ?? session.pr?.number;
     if (!ref || !session.cwd)
@@ -25,7 +32,8 @@ export async function readPullRequestStatus(session, options = {}) {
     if (hit && hit.expiresAt > now)
         return hit.value;
     const cwd = session.cwd;
-    const gh = options.gh ?? (async (args) => (await execFileAsync('gh', args, { cwd, timeout: 15_000, maxBuffer: 1024 * 1024 })).stdout);
+    const timeout = options.timeoutMs ?? PR_STATUS_DEFAULT_TIMEOUT_MS;
+    const gh = options.gh ?? (async (args) => (await execFileAsync('gh', args, { cwd, timeout, maxBuffer: 1024 * 1024 })).stdout);
     try {
         const stdout = await gh(['pr', 'view', String(ref), '--json', PR_STATUS_FIELDS]);
         const raw = JSON.parse(stdout);

package/dist/lib/feed-outcome.d.ts

@@ -1,4 +1,4 @@
-import type { OpenBlock } from './feed/feed.js';
+import { type OpenBlock } from './feed/feed.js';
 type OutcomeKind = 'ticket' | 'pr' | 'worktree' | 'unassigned';
 /** Stable attribution of a block (or agent) to one deliverable. */
 export interface OutcomeRef {

package/dist/lib/feed-outcome.js

@@ -17,6 +17,7 @@
  * and any UI that collapses blocks under deliverables.
  */
 import { detectTicket, extractPrUrl } from './session/state.js';
+import { deriveBlockState } from './feed/feed.js';
 const UNASSIGNED = {
     key: 'unassigned',
     kind: 'unassigned',
@@ -132,8 +133,14 @@ export function outcomeForBlock(block) {
         text: blockScanText(block),
     });
 }
+/**
+ * Openness is the canonical {@link deriveBlockState}, never a raw `block.answer`
+ * test: a PENDING claim carries an answer record while the block is still
+ * `open`, so reading the field directly showed a claimed-but-undelivered
+ * question as answered in the operator's own feed (PHNX-3999).
+ */
 function isOpen(block) {
-    return !block.answer && !block.parkedAt && !block.continuedAt && !block.defaultedAt;
+    return deriveBlockState(block) === 'open' && !block.parkedAt && !block.continuedAt && !block.defaultedAt;
 }
 /**
  * Collapse blocks under their outcome. Order: needs-you outcomes first
@@ -156,7 +163,7 @@ export function groupBlocksByOutcome(blocks) {
         for (const b of members) {
             const next = b.parkedAt
                 ? 'parked'
-                : b.answer || b.defaultedAt || b.continuedAt ? 'answered' : 'open';
+                : isOpen(b) ? 'open' : 'answered';
             const current = states.get(b.mailboxId);
             // One agent occupies one state. Its most actionable block wins.
             if (!current || next === 'open' || (next === 'parked' && current === 'answered')) {

package/dist/lib/feed-policy.js

@@ -16,7 +16,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getUserAgentsDir } from './state.js';
-import { recordAnswer, recordDefaulted, recordMessageReceipt, recordParked, } from './feed/feed.js';
+import { deriveBlockState, recordAnswer, recordDefaulted, recordMessageReceipt, recordParked, } from './feed/feed.js';
 import { enqueue, mailboxDir } from './mailbox.js';
 const POLICY_FILE = 'feed-policy.yaml';
 const COST_RANK = { low: 0, medium: 1, high: 2 };
@@ -60,7 +60,10 @@ export function blockClass(block) {
     return block.blockClass === 'decision' ? 'decision' : 'approval';
 }
 export function isPhoneUrgent(block, policy) {
-    if (block.answer)
+    // Openness is the canonical deriveBlockState, not a raw `block.answer`: a
+    // pending, unconfirmed claim sets `answer` while state stays `open`, and such
+    // a block is still waiting on the operator, so it must not silence the alert.
+    if (deriveBlockState(block) !== 'open')
         return false; // already answered
     const cost = block.costOfDelay ?? 'low';
     return COST_RANK[cost] >= COST_RANK[policy.phoneNotifyThreshold];
@@ -86,7 +89,10 @@ export function isTimedOut(block, policy, now) {
  * Caller is responsible for persistence/logging side effects not owned by feed.ts.
  */
 export function applyPolicyToBlock(block, policy, now, root, mailboxRoot) {
-    if (block.answer || block.parkedAt || block.defaultedAt) {
+    // A pending, unconfirmed claim sets `block.answer` but keeps state `open`
+    // (deriveBlockState), so it must still be able to time out and escalate;
+    // parked/defaulted are separate terminal markers deriveBlockState omits.
+    if (deriveBlockState(block) !== 'open' || block.parkedAt || block.defaultedAt) {
         return { blockId: block.blockId, action: 'none' };
     }
     if (!isTimedOut(block, policy, now)) {