@indigoai-us/hq-cli 5.108.14 → 5.108.16

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [5.108.16] — 2026-09-07
+
+### Fixed
+
+- Work Mesh Live daemon no longer retries every queued work-context outbox
+  operation on every flush cycle. Outbox replay now applies per-operation
+  exponential backoff (`nextAttemptAt`, 30s base → 6h cap with jitter), a
+  per-cycle cap (200 due ops), an attempt ceiling (50 → quarantine as
+  `<code>_MAX_ATTEMPTS`), cheaper listing that skips re-reading unchanged
+  outbox files, and classifies HTTP 404/409/410/412 (and other 4xx) from
+  transport errors as non-retryable instead of retrying them forever as
+  `TRANSPORT_ERROR`.
+
+## [5.108.15] — 2026-09-07
+
+### Fixed
+
+- Work Mesh Live presence daemon (`hq mesh daemon run`) no longer pins a CPU
+  core when the MQTT broker accepts a connection then closes it just past the
+  stable-connect grace window. The full-jitter reconnect backoff could collapse
+  to ~0 ms after the connect handler reset its counters, producing a tight
+  accept-then-close reconnect spin (each pass re-ran the SigV4 presign and
+  re-materialised the daemon state dir) with no network progress and no log
+  output. A hard `RECONNECT_MIN_DELAY_MS` (1s) floor now applies to every
+  reconnect path — normal backoff, the post-grace reset, and the refused-retry
+  path (which a server `Retry-After: 0` could otherwise drive to 0) — so the
+  delay can never shrink below 1s. Regression tests cover the reset and the
+  refused-retry floor. (#524)
+- The Work Mesh Live daemon no longer burns CPU in a self-triggered flush loop.
+  Its spool directory watcher woke on files the daemon writes itself during a
+  flush (`held.jsonl` and the `*.claimed` files), so any box with held events
+  flushed every two seconds forever; the watcher now reacts only to producer
+  appends to `spool.jsonl`. Recovering a very large orphan claim file no longer
+  overflows the stack, mid-flush disposal is O(1), held events are re-attempted
+  at most every five minutes, and `held.jsonl` is capped at 20,000 lines with
+  the oldest overflow dead-lettered as `HELD_OVERFLOW` (loss-free under failure
+  and concurrent flushers). (#525)
+
 ## [5.108.14] — 2026-09-07
 
 ### Fixed

package/dist/lib/mesh/api.js

@@ -43,7 +43,12 @@ export async function meshJson(token, path, init = {}) {
     }
     if (!res.ok) {
         const err = data;
-        throw new Error(err.error || err.message || `${res.status} ${res.statusText}`);
+        // Always lead with the HTTP status: callers classify retryable vs permanent
+        // failures from the message (see createWorkSessionDeliverer). Without it a
+        // 400 whose body text matched no pattern was retried forever.
+        const detail = err.error || err.message || res.statusText || "request failed";
+        const code = typeof err.code === "string" && err.code ? `${err.code}: ` : "";
+        throw new Error(`${res.status} ${code}${detail}`);
     }
     return data;
 }

package/dist/lib/mesh/client.js

@@ -46,17 +46,37 @@ export function createWorkSessionDeliverer(opts) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            // meshJson throws on !ok with error text; classify roughly.
-            if (/^401\b|^403\b|unauthorized|forbidden|auth/i.test(message)) {
+            // meshJson throws on !ok with error text; classify by leading status when present.
+            const statusMatch = /^(\d{3})\b/.exec(message);
+            if (statusMatch) {
+                const status = Number(statusMatch[1]);
+                if (status === 401 || status === 403) {
+                    return { ok: false, retryable: false, code: "AUTH_DENIED" };
+                }
+                if (status === 400 || status === 422) {
+                    return { ok: false, retryable: false, code: "VALIDATION_FAILED" };
+                }
+                if (status === 429 || (status >= 500 && status <= 599)) {
+                    return { ok: false, retryable: true, code: `HTTP_${status}` };
+                }
+                if (status === 404 ||
+                    status === 409 ||
+                    status === 410 ||
+                    status === 412 ||
+                    (status >= 400 && status < 500)) {
+                    return { ok: false, retryable: false, code: `HTTP_${status}` };
+                }
+            }
+            if (/unauthorized|forbidden|auth/i.test(message)) {
                 return { ok: false, retryable: false, code: "AUTH_DENIED" };
             }
-            if (/^400\b|^422\b|invalid|validation/i.test(message)) {
+            if (/invalid|validation/i.test(message)) {
                 return { ok: false, retryable: false, code: "VALIDATION_FAILED" };
             }
-            if (/^5\d\d\b|ECONN|ENOTFOUND|ETIMEDOUT|network|fetch failed/i.test(message)) {
+            if (/ECONN|ENOTFOUND|ETIMEDOUT|network|fetch failed/i.test(message)) {
                 return { ok: false, retryable: true, code: "NETWORK_OR_5XX" };
             }
-            // Unknown: keep queued (fail open to retry, not quarantine).
+            // No status in the message: keep queued (fail open to retry, not quarantine).
             return { ok: false, retryable: true, code: "TRANSPORT_ERROR" };
         }
     };
@@ -73,7 +93,7 @@ function mapRegisterResponse(status, body, operationId) {
     if (status >= 500 || status === 429) {
         return { ok: false, retryable: true, code: `HTTP_${status}` };
     }
-    if (status === 401 || status === 403 || status === 400 || status === 422) {
+    if (status >= 400 && status < 500) {
         return { ok: false, retryable: false, code: `HTTP_${status}` };
     }
     if (status === 0) {

package/dist/lib/mesh/live/daemon/presence.d.ts

@@ -20,6 +20,20 @@ export type MqttConnectionState = "idle" | "connecting" | "connected" | "reconne
  * then closes immediately after a denied publish).
  */
 export declare const CONNECT_STABLE_GRACE_MS = 5000;
+/**
+ * Hard floor for the delay between MQTT presence reconnect attempts.
+ *
+ * The full-jitter backoff can otherwise compute ~0 ms: after a connection
+ * survives {@link CONNECT_STABLE_GRACE_MS} the connect handler resets both
+ * `attempt` and `lastBackoffMs` to 0, so a broker that accepts-then-closes just
+ * past the grace window makes the next `backoffDelayMs(0, base, cap, random, 0)`
+ * return `random() * base` — frequently a handful of ms, or 0 when `random()`
+ * is near 0. That produces a tight reconnect loop (each pass re-runs the SigV4
+ * presign and re-materialises the daemon state dir) that pins a CPU core with
+ * no network progress and no log output. This floor guarantees every reconnect
+ * waits at least this long regardless of the backoff/grace-reset state.
+ */
+export declare const RECONNECT_MIN_DELAY_MS = 1000;
 /** Always emit the first N close info lines, then at most one per interval. */
 export declare const CLOSE_LOG_ALWAYS_COUNT = 3;
 export declare const CLOSE_LOG_INTERVAL_MS = 60000;
@@ -69,9 +83,13 @@ export interface PresenceClientOptions {
 }
 /**
  * Full-jitter capped exponential backoff (1s base → 60s cap by default),
- * floored at `previousMs` so consecutive failures never shrink the delay.
+ * floored at `previousMs` so consecutive failures never shrink the delay and at
+ * `minMs` so the result can never collapse to ~0 (see
+ * {@link RECONNECT_MIN_DELAY_MS}). The `minMs` floor is what prevents the
+ * accept-then-close reconnect spin after the connect handler resets the
+ * backoff counters.
  */
-export declare function backoffDelayMs(attempt: number, baseMs: number, maxMs: number, random: () => number, previousMs?: number): number;
+export declare function backoffDelayMs(attempt: number, baseMs: number, maxMs: number, random: () => number, previousMs?: number, minMs?: number): number;
 export declare function buildPresencePayload(input: {
     status: "online" | "offline";
     actorUid: string;

package/dist/lib/mesh/live/daemon/presence.js

@@ -20,17 +20,35 @@ import { presignIotWssUrl } from "./presign.js";
  * then closes immediately after a denied publish).
  */
 export const CONNECT_STABLE_GRACE_MS = 5_000;
+/**
+ * Hard floor for the delay between MQTT presence reconnect attempts.
+ *
+ * The full-jitter backoff can otherwise compute ~0 ms: after a connection
+ * survives {@link CONNECT_STABLE_GRACE_MS} the connect handler resets both
+ * `attempt` and `lastBackoffMs` to 0, so a broker that accepts-then-closes just
+ * past the grace window makes the next `backoffDelayMs(0, base, cap, random, 0)`
+ * return `random() * base` — frequently a handful of ms, or 0 when `random()`
+ * is near 0. That produces a tight reconnect loop (each pass re-runs the SigV4
+ * presign and re-materialises the daemon state dir) that pins a CPU core with
+ * no network progress and no log output. This floor guarantees every reconnect
+ * waits at least this long regardless of the backoff/grace-reset state.
+ */
+export const RECONNECT_MIN_DELAY_MS = 1_000;
 /** Always emit the first N close info lines, then at most one per interval. */
 export const CLOSE_LOG_ALWAYS_COUNT = 3;
 export const CLOSE_LOG_INTERVAL_MS = 60_000;
 /**
  * Full-jitter capped exponential backoff (1s base → 60s cap by default),
- * floored at `previousMs` so consecutive failures never shrink the delay.
+ * floored at `previousMs` so consecutive failures never shrink the delay and at
+ * `minMs` so the result can never collapse to ~0 (see
+ * {@link RECONNECT_MIN_DELAY_MS}). The `minMs` floor is what prevents the
+ * accept-then-close reconnect spin after the connect handler resets the
+ * backoff counters.
  */
-export function backoffDelayMs(attempt, baseMs, maxMs, random, previousMs = 0) {
+export function backoffDelayMs(attempt, baseMs, maxMs, random, previousMs = 0, minMs = 0) {
     const cap = Math.min(maxMs, baseMs * 2 ** attempt);
     const raw = Math.max(0, random() * cap);
-    return Math.min(maxMs, Math.max(previousMs, raw));
+    return Math.min(maxMs, Math.max(previousMs, raw, minMs));
 }
 export function buildPresencePayload(input) {
     return {
@@ -341,12 +359,14 @@ export class PresenceClient {
             else {
                 delay = refusedRetryDelayMs(this.refusedRetryMs, this.random);
             }
-            delay = clampRetryDelayMs(delay);
+            // Floor the refused retry too: a server `Retry-After: 0` (or a 0 env
+            // override) would otherwise clamp to 0 and hot-loop the refused path.
+            delay = Math.max(RECONNECT_MIN_DELAY_MS, clampRetryDelayMs(delay));
             const nextRetryAt = new Date(this.timers.now() + delay).toISOString();
             this.noteRefusal(refused, nextRetryAt);
         }
         else {
-            delay = backoffDelayMs(this.attempt, this.baseBackoffMs, this.maxBackoffMs, this.random, this.lastBackoffMs);
+            delay = backoffDelayMs(this.attempt, this.baseBackoffMs, this.maxBackoffMs, this.random, this.lastBackoffMs, RECONNECT_MIN_DELAY_MS);
             this.lastBackoffMs = delay;
             this.attempt += 1;
             // Do not clear refusal here — MQTT close must retain doctor/status refusal

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -15,6 +15,16 @@ import { PresenceClient, type MqttConnectFn } from "./presence.js";
 import { TranscriptWatcher, type TranscriptFs } from "./transcript-watch.js";
 export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
+/**
+ * Only producer appends to spool.jsonl should wake the watcher. Every other
+ * file in the work-mesh root (held.jsonl, spool.<ts>.claimed, held.<ts>.claimed,
+ * live-cache.json, dead-letter.jsonl, ...) is written by the daemon itself
+ * during a flush; reacting to those turned each flush into a self-triggered
+ * flush 2s later, forever (observed ~1,750 watch flushes/hour and >50% of a
+ * core on fleet boxes with a non-empty held file). A null filename (platforms
+ * that do not report one) keeps the conservative behaviour and flushes.
+ */
+export declare function shouldFlushOnSpoolDirEvent(filename: string | Buffer | null | undefined): boolean;
 export interface DaemonRunDeps {
     home?: string;
     env?: NodeJS.ProcessEnv;
@@ -31,6 +41,7 @@ export interface DaemonRunDeps {
         delivered: number;
         queued: number;
         quarantined: number;
+        skipped?: number;
     }>;
     /** Injected board refresh (tests). */
     refreshBoards?: () => Promise<{

package/dist/lib/mesh/live/daemon/run.js

@@ -17,7 +17,7 @@ import { ensureCognitoToken } from "../../../../utils/cognito-session.js";
 import { replayOutbox } from "../../../work-context/outbox.js";
 import { workContextRoot } from "../../../work-context/paths.js";
 import { createSessionEventsPoster, resolveVaultApiBase, } from "../session-events-client.js";
-import { flushSessionEvents } from "../flush.js";
+import { flushSessionEvents, HELD_RETRY_INTERVAL_MS, } from "../flush.js";
 import { workMeshRoot, workMeshSpoolPath } from "../paths.js";
 import { createVaultBoardReader, refreshBoundSessionBoards, BOARD_REFRESH_INTERVAL_MS, } from "./board-refresh.js";
 import { createContract3Fetcher, realTimerHost, } from "./credentials.js";
@@ -30,6 +30,20 @@ import { workMeshHeldPath } from "../paths.js";
 import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, } from "./transcript-watch.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
+/**
+ * Only producer appends to spool.jsonl should wake the watcher. Every other
+ * file in the work-mesh root (held.jsonl, spool.<ts>.claimed, held.<ts>.claimed,
+ * live-cache.json, dead-letter.jsonl, ...) is written by the daemon itself
+ * during a flush; reacting to those turned each flush into a self-triggered
+ * flush 2s later, forever (observed ~1,750 watch flushes/hour and >50% of a
+ * core on fleet boxes with a non-empty held file). A null filename (platforms
+ * that do not report one) keeps the conservative behaviour and flushes.
+ */
+export function shouldFlushOnSpoolDirEvent(filename) {
+    if (filename === null || filename === undefined)
+        return true;
+    return String(filename) === "spool.jsonl";
+}
 function alive(pid) {
     try {
         process.kill(pid, 0);
@@ -76,6 +90,8 @@ export async function runMeshDaemon(deps = {}) {
     // daemon went dark once its IoT credentials expired.
     const defaultGetToken = async () => ensureCognitoToken({ interactive: false, tokenSource: "machine" });
     const getToken = deps.getToken ?? defaultGetToken;
+    /** In-memory held re-attempt throttle (survives watch-triggered flushes). */
+    let lastHeldRetryAtMs = 0;
     const flushFn = deps.flush ??
         (async () => {
             const t = await getToken();
@@ -87,6 +103,12 @@ export async function runMeshDaemon(deps = {}) {
                 workMeshRoot: meshRoot,
                 workContextRoot: ctxRoot,
                 poster,
+                heldRetryIntervalMs: HELD_RETRY_INTERVAL_MS,
+                lastHeldRetryAtMs,
+                onHeldClaimed: (atMs) => {
+                    lastHeldRetryAtMs = atMs;
+                },
+                log: (message) => log(dir, message),
             });
         });
     const replayFn = deps.replayOutbox ??
@@ -233,7 +255,14 @@ export async function runMeshDaemon(deps = {}) {
                 noteHookSessionsFromSpoolFile(workMeshHeldPath(meshRoot), lastHookEventAt, at);
                 const summary = await flushFn();
                 try {
-                    await replayFn();
+                    const replay = await replayFn();
+                    const delivered = replay.delivered ?? 0;
+                    const queued = replay.queued ?? 0;
+                    const quarantined = replay.quarantined ?? 0;
+                    const skipped = replay.skipped ?? 0;
+                    if (delivered > 0 || queued > 0 || quarantined > 0 || skipped > 0) {
+                        log(dir, `outbox replay: delivered=${delivered} queued=${queued} quarantined=${quarantined} skipped=${skipped}`);
+                    }
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -243,7 +272,10 @@ export async function runMeshDaemon(deps = {}) {
                     lastFlushAt: now().toISOString(),
                     lastFlushResult: { ...summary, ok: true },
                 }, now);
-                if (summary.claimed > 0 || summary.posted > 0 || summary.held > 0) {
+                if (summary.claimed > 0 ||
+                    summary.posted > 0 ||
+                    summary.held > 0 ||
+                    (summary.heldOverflow ?? 0) > 0) {
                     log(dir, `flush(${reason}): claimed=${summary.claimed} posted=${summary.posted} held=${summary.held}`);
                 }
             }
@@ -292,11 +324,7 @@ export async function runMeshDaemon(deps = {}) {
         watcher = fs.watch(path.dirname(spoolPath), { persistent: true }, (_event, filename) => {
             if (stopped)
                 return;
-            if (!filename ||
-                filename === "spool.jsonl" ||
-                filename === "held.jsonl" ||
-                String(filename).startsWith("spool.") ||
-                String(filename).startsWith("held.")) {
+            if (shouldFlushOnSpoolDirEvent(filename)) {
                 scheduleDebouncedFlush();
             }
         });

package/dist/lib/mesh/live/flush.d.ts

@@ -11,7 +11,11 @@
 import { type RandomFn, type SleepFn } from "./backoff.js";
 import { type SessionEventsPoster } from "./session-events-client.js";
 export declare const HELD_TTL_MS: number;
-export type HeldReason = "STATE_ABSENT" | "NEEDS_COMPANY" | "COMPANY_CONFLICT" | "HELD_EXPIRED";
+/** Re-attempt held events at most this often (spool still flushes every cycle). */
+export declare const HELD_RETRY_INTERVAL_MS: number;
+/** Cap held.jsonl size; oldest overflow is dead-lettered with HELD_OVERFLOW. */
+export declare const HELD_MAX_LINES = 20000;
+export type HeldReason = "STATE_ABSENT" | "NEEDS_COMPANY" | "COMPANY_CONFLICT" | "HELD_EXPIRED" | "HELD_OVERFLOW";
 export interface HeldLineRecord {
     /** Original spool event fields. */
     event: Record<string, unknown>;
@@ -26,6 +30,19 @@ export interface FlushDeps {
     sleep?: SleepFn;
     random?: RandomFn;
     maxAttempts?: number;
+    /**
+     * Minimum gap between held re-attempts. Default HELD_RETRY_INTERVAL_MS.
+     * Pass 0 in tests to re-claim held every flush.
+     */
+    heldRetryIntervalMs?: number;
+    /** Epoch ms of the last flush that claimed held (daemon keeps this in memory). */
+    lastHeldRetryAtMs?: number;
+    /** Invoked when this flush claims held, so the daemon can advance its timestamp. */
+    onHeldClaimed?: (atMs: number) => void;
+    /** Max lines retained in held.jsonl after a flush. Default HELD_MAX_LINES. */
+    heldMaxLines?: number;
+    /** Optional logger (daemon wires this); used once per overflow trim. */
+    log?: (message: string) => void;
 }
 export interface FlushSummary {
     claimed: number;
@@ -35,6 +52,10 @@ export interface FlushSummary {
     deadLettered: number;
     restored: number;
     batches: number;
+    /** True when this flush claimed/re-read held.jsonl. */
+    heldClaimed?: boolean;
+    /** Oldest held lines dead-lettered this flush due to HELD_MAX_LINES. */
+    heldOverflow?: number;
 }
 /**
  * Flush spool + held. Safe to call concurrently with enqueue (claim-by-rename).

package/dist/lib/mesh/live/flush.js

@@ -15,9 +15,13 @@ import { workContextRoot } from "../../work-context/paths.js";
 import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
 import { LOCAL_ONLY_FIELDS, stripLocalOnlyFields } from "./format-spool-line.js";
 import { SESSION_EVENTS_BATCH_MAX, WRITABLE_CONTEXT_STATUSES, parseSessionEventsBatchAck, } from "./session-events-client.js";
-import { appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendSpoolLine, claimHeld, claimSpool, recoverOrphanClaims, removeClaimFile, } from "./spool.js";
-import { workMeshRoot } from "./paths.js";
+import { appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendSpoolLine, claimHeld, claimSpool, countJsonlLines, ensureSpoolFile, recoverOrphanClaims, removeClaimFile, } from "./spool.js";
+import { workMeshHeldPath, workMeshRoot } from "./paths.js";
 export const HELD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** Re-attempt held events at most this often (spool still flushes every cycle). */
+export const HELD_RETRY_INTERVAL_MS = 5 * 60 * 1000;
+/** Cap held.jsonl size; oldest overflow is dead-lettered with HELD_OVERFLOW. */
+export const HELD_MAX_LINES = 20_000;
 function parseLine(line) {
     try {
         const v = JSON.parse(line);
@@ -101,10 +105,22 @@ export async function flushSessionEvents(deps) {
     const sleep = deps.sleep ?? defaultSleep;
     const random = deps.random ?? Math.random;
     const maxAttempts = deps.maxAttempts ?? FLUSH_MAX_ATTEMPTS;
-    const ts = `${now().getTime()}`;
+    const heldRetryIntervalMs = deps.heldRetryIntervalMs ?? HELD_RETRY_INTERVAL_MS;
+    const heldMaxLines = deps.heldMaxLines ?? HELD_MAX_LINES;
+    const nowMs = now().getTime();
+    const ts = `${nowMs}`;
     const orphans = recoverOrphanClaims(deps.workMeshRoot);
     const spoolClaim = claimSpool(deps.workMeshRoot, ts);
-    const heldClaim = claimHeld(deps.workMeshRoot, `${ts}.held`);
+    // Throttle held re-attempts; spool (fresh) events still flush every cycle.
+    const lastHeldRetryAtMs = deps.lastHeldRetryAtMs ?? 0;
+    const shouldClaimHeld = heldRetryIntervalMs <= 0 ||
+        nowMs - lastHeldRetryAtMs >= heldRetryIntervalMs;
+    const heldClaim = shouldClaimHeld
+        ? claimHeld(deps.workMeshRoot, `${ts}.held`)
+        : { claimPath: null, lines: [] };
+    if (shouldClaimHeld) {
+        deps.onHeldClaimed?.(nowMs);
+    }
     const claimPaths = [
         ...orphans.claimPaths,
         spoolClaim.claimPath,
@@ -118,42 +134,45 @@ export async function flushSessionEvents(deps) {
         deadLettered: 0,
         restored: 0,
         batches: 0,
+        heldClaimed: shouldClaimHeld,
+        heldOverflow: 0,
     };
-    /** Original events still awaiting disposition (restored on throw). */
-    const pendingRestore = [];
+    /** Original events still awaiting disposition (restored on throw). O(1) delete. */
+    const pendingRestore = new Set();
     const collected = [];
     try {
-        for (const line of [...orphans.lines, ...spoolClaim.lines, ...heldClaim.lines]) {
-            summary.claimed += 1;
-            const parsed = parseLine(line);
-            if (!parsed) {
-                appendDeadLetterLine(deadLetterEnvelope({ raw: line.slice(0, 200) }, "SCHEMA_REJECTED", "parse_error", now().toISOString()), deps.workMeshRoot);
-                summary.deadLettered += 1;
-                continue;
-            }
-            const { event, heldAt } = unwrapHeld(parsed);
-            if (!sessionIdOf(event)) {
-                appendDeadLetterLine(deadLetterEnvelope(event, "SCHEMA_REJECTED", "missing_sessionId", now().toISOString()), deps.workMeshRoot);
-                summary.deadLettered += 1;
-                continue;
-            }
-            // Expire held lines older than 7 days.
-            if (heldAt) {
-                const age = now().getTime() - Date.parse(heldAt);
-                if (Number.isFinite(age) && age > HELD_TTL_MS) {
-                    appendDeadLetterLine(deadLetterEnvelope(event, "HELD_EXPIRED", "held_ttl", now().toISOString()), deps.workMeshRoot);
+        // Iterate sources separately — avoid building one giant combined array.
+        for (const source of [orphans.lines, spoolClaim.lines, heldClaim.lines]) {
+            for (const line of source) {
+                summary.claimed += 1;
+                const parsed = parseLine(line);
+                if (!parsed) {
+                    appendDeadLetterLine(deadLetterEnvelope({ raw: line.slice(0, 200) }, "SCHEMA_REJECTED", "parse_error", now().toISOString()), deps.workMeshRoot);
+                    summary.deadLettered += 1;
+                    continue;
+                }
+                const { event, heldAt } = unwrapHeld(parsed);
+                if (!sessionIdOf(event)) {
+                    appendDeadLetterLine(deadLetterEnvelope(event, "SCHEMA_REJECTED", "missing_sessionId", now().toISOString()), deps.workMeshRoot);
                     summary.deadLettered += 1;
                     continue;
                 }
+                // Expire held lines older than 7 days.
+                if (heldAt) {
+                    const age = now().getTime() - Date.parse(heldAt);
+                    if (Number.isFinite(age) && age > HELD_TTL_MS) {
+                        appendDeadLetterLine(deadLetterEnvelope(event, "HELD_EXPIRED", "held_ttl", now().toISOString()), deps.workMeshRoot);
+                        summary.deadLettered += 1;
+                        continue;
+                    }
+                }
+                pendingRestore.add(event);
+                collected.push({ event, heldAt });
             }
-            pendingRestore.push(event);
-            collected.push({ event, heldAt });
         }
         const bySession = groupBySession(collected);
         const markDisposed = (event) => {
-            const idx = pendingRestore.indexOf(event);
-            if (idx >= 0)
-                pendingRestore.splice(idx, 1);
+            pendingRestore.delete(event);
         };
         for (const [sessionId, items] of bySession) {
             const state = readSessionState(sessionId, deps.workContextRoot);
@@ -238,13 +257,100 @@ export async function flushSessionEvents(deps) {
                 /* best-effort; orphan claim scan will retry next flush */
             }
         }
-        pendingRestore.length = 0;
+        pendingRestore.clear();
         for (const p of claimPaths) {
             removeClaimFile(p);
         }
     }
+    const overflowed = trimHeldOverflow(deps.workMeshRoot, heldMaxLines, now, summary);
+    if (overflowed > 0) {
+        deps.log?.(`held overflow: dead-lettered ${overflowed} oldest events (cap=${heldMaxLines})`);
+    }
     return summary;
 }
+/**
+ * After a flush, if held.jsonl exceeds maxLines, dead-letter the oldest
+ * overflow (by heldAt, not file position) with HELD_OVERFLOW and keep the rest.
+ *
+ * Durability rules:
+ * - Retained lines are APPENDED to held.jsonl, never written over it: another
+ *   flusher (`hq mesh flush` beside the daemon) may have appended to a fresh
+ *   held.jsonl after our claim renamed the old one away.
+ * - The overflow claim file is removed only after every dead letter and every
+ *   retained line is on disk. If anything throws, the claim stays behind and
+ *   recoverOrphanClaims re-reads it on the next flush (duplicates are possible,
+ *   loss is not).
+ */
+function trimHeldOverflow(meshRoot, maxLines, now, summary) {
+    if (maxLines <= 0)
+        return 0;
+    const heldPath = workMeshHeldPath(meshRoot);
+    if (countJsonlLines(heldPath) <= maxLines)
+        return 0;
+    const claim = claimHeld(meshRoot, `${now().getTime()}.overflow`);
+    if (!claim.claimPath)
+        return 0;
+    if (claim.lines.length === 0) {
+        removeClaimFile(claim.claimPath);
+        return 0;
+    }
+    try {
+        if (claim.lines.length <= maxLines) {
+            appendHeldLines(meshRoot, claim.lines);
+            removeClaimFile(claim.claimPath);
+            return 0;
+        }
+        const overflow = claim.lines.length - maxLines;
+        // Oldest by heldAt: retries regroup held by session, so file order is not
+        // chronological. Unparseable lines sort first (dead-lettered first).
+        const ordered = claim.lines
+            .map((line, idx) => ({ line, idx, atMs: heldAtMs(line) }))
+            .sort((a, b) => a.atMs - b.atMs || a.idx - b.idx);
+        const toDead = ordered.slice(0, overflow);
+        const toKeep = ordered
+            .slice(overflow)
+            .sort((a, b) => a.idx - b.idx)
+            .map((x) => x.line);
+        const at = now().toISOString();
+        for (const { line } of toDead) {
+            const parsed = parseLine(line);
+            if (!parsed) {
+                appendDeadLetterLine(deadLetterEnvelope({ raw: line.slice(0, 200) }, "HELD_OVERFLOW", "held_max_lines", at), meshRoot);
+            }
+            else {
+                const { event } = unwrapHeld(parsed);
+                appendDeadLetterLine(deadLetterEnvelope(event, "HELD_OVERFLOW", "held_max_lines", at), meshRoot);
+            }
+            summary.deadLettered += 1;
+        }
+        appendHeldLines(meshRoot, toKeep);
+        summary.heldOverflow = overflow;
+        removeClaimFile(claim.claimPath);
+        return overflow;
+    }
+    catch {
+        // Leave the claim for orphan recovery; never drop held events on a failed trim.
+        return 0;
+    }
+}
+/** heldAt of a held line as epoch ms; 0 when missing or unparseable. */
+function heldAtMs(line) {
+    const parsed = parseLine(line);
+    if (!parsed)
+        return 0;
+    const { heldAt } = unwrapHeld(parsed);
+    if (!heldAt)
+        return 0;
+    const ms = Date.parse(heldAt);
+    return Number.isFinite(ms) ? ms : 0;
+}
+function appendHeldLines(meshRoot, lines) {
+    if (lines.length === 0)
+        return;
+    const heldPath = workMeshHeldPath(meshRoot);
+    ensureSpoolFile(heldPath);
+    fs.appendFileSync(heldPath, `${lines.join("\n")}\n`, { mode: 0o600 });
+}
 /**
  * Account a 2xx batch: dead-letter rejected eventIds with their codes;
  * count accepted+duplicates as posted; restore any eventId not accounted for.

package/dist/lib/mesh/live/index.d.ts

@@ -13,7 +13,7 @@ export { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath,
 export { SPOOL_LINE_MAX_BYTES, SpoolWriteError, appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendJsonlLine, appendSpoolLine, claimHeld, claimJsonlByRename, claimSpool, countJsonlLines, deadLetterNonEmpty, ensureSpoolFile, removeClaimFile, } from "./spool.js";
 export { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent, resolveEnqueueSessionId, } from "./enqueue.js";
 export type { EnqueueOptions, EnqueueResult } from "./enqueue.js";
-export { HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
+export { HELD_MAX_LINES, HELD_RETRY_INTERVAL_MS, HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
 export type { FlushDeps, FlushSummary, HeldReason } from "./flush.js";
 export { BACKOFF_BASE_MS, BACKOFF_CAP_MS, FLUSH_MAX_ATTEMPTS, defaultSleep, fullJitterDelayMs, } from "./backoff.js";
 export { SESSION_EVENTS_BATCH_MAX, SESSION_EVENTS_PATH, WRITABLE_CONTEXT_STATUSES, classifySessionEventsResponse, createSessionEventsPoster, resolveVaultApiBase, } from "./session-events-client.js";

package/dist/lib/mesh/live/index.js

@@ -9,7 +9,7 @@ export { encodeCrockford, generateUlid, isUlid } from "./ulid.js";
 export { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "./paths.js";
 export { SPOOL_LINE_MAX_BYTES, SpoolWriteError, appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendJsonlLine, appendSpoolLine, claimHeld, claimJsonlByRename, claimSpool, countJsonlLines, deadLetterNonEmpty, ensureSpoolFile, removeClaimFile, } from "./spool.js";
 export { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent, resolveEnqueueSessionId, } from "./enqueue.js";
-export { HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
+export { HELD_MAX_LINES, HELD_RETRY_INTERVAL_MS, HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
 export { BACKOFF_BASE_MS, BACKOFF_CAP_MS, FLUSH_MAX_ATTEMPTS, defaultSleep, fullJitterDelayMs, } from "./backoff.js";
 export { SESSION_EVENTS_BATCH_MAX, SESSION_EVENTS_PATH, WRITABLE_CONTEXT_STATUSES, classifySessionEventsResponse, createSessionEventsPoster, resolveVaultApiBase, } from "./session-events-client.js";
 export * from "./daemon/index.js";

package/dist/lib/mesh/live/spool.js

@@ -153,7 +153,12 @@ export function recoverOrphanClaims(root) {
     const claimPaths = listOrphanClaimFiles(root);
     const lines = [];
     for (const p of claimPaths) {
-        lines.push(...readClaimFileLines(p));
+        // Plain loop: Array#push(...huge) exceeds V8's argument limit (~65k–128k)
+        // and throws RangeError ("Maximum call stack size exceeded").
+        const orphanLines = readClaimFileLines(p);
+        for (const line of orphanLines) {
+            lines.push(line);
+        }
     }
     return { lines, claimPaths };
 }

package/dist/lib/work-context/outbox.d.ts

@@ -5,7 +5,15 @@
 import type { DeliveryState } from "./contract.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
-export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "companyUid", "companySlug", "projectId", "taskId", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug"];
+export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "companyUid", "companySlug", "projectId", "taskId", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
+/** Base delay for outbox retry backoff (attempt 1 → 30s). */
+export declare const OUTBOX_RETRY_BASE_MS = 30000;
+/** Cap for outbox retry backoff (6 hours). */
+export declare const OUTBOX_RETRY_MAX_MS: number;
+/** Quarantine after this many delivery attempts on retryable failures. */
+export declare const OUTBOX_MAX_ATTEMPTS = 50;
+/** Max due operations processed per replayOutbox call. */
+export declare const OUTBOX_REPLAY_MAX_OPS = 200;
 export type OutboxKind = "register" | "reconcile" | "migrate";
 export interface OutboxOperation {
     contractVersion: typeof WORK_CONTEXT_CONTRACT_VERSION;
@@ -27,6 +35,8 @@ export interface OutboxOperation {
     /** Destination company for kind=migrate (source is companyUid). */
     destinationCompanyUid?: string;
     destinationCompanySlug?: string;
+    /** ISO time when the next delivery attempt is due (absent → due immediately). */
+    nextAttemptAt?: string;
 }
 export interface OutboxEnqueueInput {
     clientOperationId: string;
@@ -40,6 +50,7 @@ export interface OutboxEnqueueInput {
     destinationCompanySlug?: string;
     now?: () => Date;
 }
+export declare function clearOutboxListCache(): void;
 export declare function stableOperationId(clientOperationId: string, sessionId: string): string;
 export declare function digestOperation(parts: {
     sessionId: string;
@@ -52,6 +63,8 @@ export declare function digestOperation(parts: {
     destinationCompanyUid?: string;
     destinationCompanySlug?: string;
 }): string;
+/** Delay before next attempt: min(BASE * 2^(attemptCount-1), MAX), then [0.5, 1.0] jitter. */
+export declare function outboxRetryDelayMs(attemptCount: number, random?: () => number): number;
 /**
  * Atomically enqueue (or idempotently return) an outbox operation.
  * Disk/permission/lock failure → NotTrackingError (no network-only send).
@@ -60,9 +73,12 @@ export declare function enqueueOutbox(input: OutboxEnqueueInput, root: string):
 export declare function readOutboxOperation(operationId: string, root: string): OutboxOperation | null;
 export declare function updateOutboxOperation(op: OutboxOperation, root: string): void;
 export declare function markOutboxAcked(operationId: string, root: string, receiptId: string, now?: () => Date): OutboxOperation | null;
-export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date): OutboxOperation | null;
+export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number): OutboxOperation | null;
 export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date): OutboxOperation | null;
-export declare function listOutboxOperations(root: string): OutboxOperation[];
+export type OutboxListReadFile = (filePath: string) => string;
+export declare function listOutboxOperations(root: string, deps?: {
+    readFile?: OutboxListReadFile;
+}): OutboxOperation[];
 export interface OutboxStats {
     depth: number;
     quarantined: number;
@@ -81,14 +97,18 @@ export type DeliverFn = (op: OutboxOperation) => Promise<{
 /**
  * Replay queued (and recover lost-receipt) operations.
  * FIFO per sessionId; bounded parallelism across sessions.
+ * Skips ops whose nextAttemptAt is in the future; caps work per call.
  */
 export declare function replayOutbox(root: string, deliver: DeliverFn, opts?: {
     parallel?: number;
     now?: () => Date;
+    maxOps?: number;
+    random?: () => number;
 }): Promise<{
     delivered: number;
     queued: number;
     quarantined: number;
+    skipped: number;
 }>;
 /** Remove acked ops older than retention (optional GC; not required by AC). */
 export declare function removeAckedOutbox(root: string, olderThanMs: number, now?: number): number;

package/dist/lib/work-context/outbox.js

@@ -29,8 +29,24 @@ export const OUTBOX_ALLOWLIST = [
     "receiptId",
     "destinationCompanyUid",
     "destinationCompanySlug",
+    "nextAttemptAt",
 ];
+/** Base delay for outbox retry backoff (attempt 1 → 30s). */
+export const OUTBOX_RETRY_BASE_MS = 30_000;
+/** Cap for outbox retry backoff (6 hours). */
+export const OUTBOX_RETRY_MAX_MS = 6 * 60 * 60 * 1000;
+/** Quarantine after this many delivery attempts on retryable failures. */
+export const OUTBOX_MAX_ATTEMPTS = 50;
+/** Max due operations processed per replayOutbox call. */
+export const OUTBOX_REPLAY_MAX_OPS = 200;
 const DEFAULT_PARALLEL = 4;
+const outboxListCache = new Map();
+function invalidateOutboxListCacheEntry(filePath) {
+    outboxListCache.delete(filePath);
+}
+export function clearOutboxListCache() {
+    outboxListCache.clear();
+}
 export function stableOperationId(clientOperationId, sessionId) {
     const h = crypto
         .createHash("sha256")
@@ -85,8 +101,18 @@ function projectOutbox(op) {
     if (op.destinationCompanySlug) {
         out.destinationCompanySlug = op.destinationCompanySlug;
     }
+    if (op.nextAttemptAt)
+        out.nextAttemptAt = op.nextAttemptAt;
     return out;
 }
+/** Delay before next attempt: min(BASE * 2^(attemptCount-1), MAX), then [0.5, 1.0] jitter. */
+export function outboxRetryDelayMs(attemptCount, random = Math.random) {
+    const exp = Math.max(0, attemptCount - 1);
+    const delay = Math.min(OUTBOX_RETRY_BASE_MS * 2 ** exp, OUTBOX_RETRY_MAX_MS);
+    const unit = random();
+    const factor = 0.5 + 0.5 * Math.min(1, Math.max(0, unit));
+    return Math.floor(delay * factor);
+}
 /**
  * Atomically enqueue (or idempotently return) an outbox operation.
  * Disk/permission/lock failure → NotTrackingError (no network-only send).
@@ -182,6 +208,7 @@ export function enqueueOutbox(input, root) {
         catch {
             /* ignore */
         }
+        invalidateOutboxListCacheEntry(dest);
         return op;
     }
     catch (err) {
@@ -204,7 +231,9 @@ export function readOutboxOperation(operationId, root) {
     }
 }
 export function updateOutboxOperation(op, root) {
-    atomicWriteJson(workContextOutboxPath(op.operationId, root), projectOutbox(op));
+    const filePath = workContextOutboxPath(op.operationId, root);
+    atomicWriteJson(filePath, projectOutbox(op));
+    invalidateOutboxListCacheEntry(filePath);
 }
 export function markOutboxAcked(operationId, root, receiptId, now = () => new Date()) {
     const op = readOutboxOperation(operationId, root);
@@ -216,14 +245,17 @@ export function markOutboxAcked(operationId, root, receiptId, now = () => new Da
     updateOutboxOperation(op, root);
     return op;
 }
-export function markOutboxQueued(operationId, root, errorCode, now = () => new Date()) {
+export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
         return null;
     op.delivery = "queued";
     op.lastErrorCode = errorCode;
     op.attemptCount += 1;
-    op.updatedAt = now().toISOString();
+    const at = now();
+    op.updatedAt = at.toISOString();
+    const delayMs = outboxRetryDelayMs(op.attemptCount, random);
+    op.nextAttemptAt = new Date(at.getTime() + delayMs).toISOString();
     updateOutboxOperation(op, root);
     return op;
 }
@@ -238,17 +270,58 @@ export function markOutboxQuarantined(operationId, root, errorCode, now = () =>
     updateOutboxOperation(op, root);
     return op;
 }
-export function listOutboxOperations(root) {
+export function listOutboxOperations(root, deps = {}) {
+    const readFile = deps.readFile ?? ((filePath) => fs.readFileSync(filePath, "utf8"));
     const dir = workContextOutboxDir(root);
     if (!fs.existsSync(dir))
         return [];
     const ops = [];
+    const seen = new Set();
     for (const name of fs.readdirSync(dir)) {
         if (!name.endsWith(".json") || name.startsWith("."))
             continue;
-        const op = readOutboxOperation(name.replace(/\.json$/, ""), root);
-        if (op)
+        const operationId = name.replace(/\.json$/, "");
+        if (!isSafeWorkContextSegment(operationId))
+            continue;
+        const filePath = workContextOutboxPath(operationId, root);
+        seen.add(filePath);
+        let st;
+        try {
+            st = fs.statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        const cached = outboxListCache.get(filePath);
+        if (cached &&
+            cached.ino === st.ino &&
+            cached.mtimeMs === st.mtimeMs &&
+            cached.ctimeMs === st.ctimeMs &&
+            cached.size === st.size) {
+            ops.push(cached.op);
+            continue;
+        }
+        try {
+            const op = JSON.parse(readFile(filePath));
+            outboxListCache.set(filePath, {
+                ino: st.ino,
+                mtimeMs: st.mtimeMs,
+                ctimeMs: st.ctimeMs,
+                size: st.size,
+                op,
+            });
             ops.push(op);
+        }
+        catch {
+            /* ignore corrupt */
+        }
+    }
+    // Drop cache entries for paths no longer present under this listing pass
+    // only when they sit in this outbox dir (other roots may share the module cache).
+    for (const key of outboxListCache.keys()) {
+        if (key.startsWith(dir + path.sep) && !seen.has(key)) {
+            outboxListCache.delete(key);
+        }
     }
     return ops.sort((a, b) => {
         const byTime = a.createdAt.localeCompare(b.createdAt);
@@ -266,21 +339,68 @@ export function outboxStats(root) {
         acked: ops.filter((o) => o.delivery === "acked").length,
     };
 }
+function isOutboxDue(op, nowIso) {
+    return !op.nextAttemptAt || op.nextAttemptAt <= nowIso;
+}
+function outboxFifoCompare(a, b) {
+    const byCreated = a.createdAt.localeCompare(b.createdAt);
+    if (byCreated !== 0)
+        return byCreated;
+    return a.operationId.localeCompare(b.operationId);
+}
+/** Contiguous leading due ops; stops at the first not-yet-due op (no skip-ahead). */
+function duePrefixForSession(ops, nowIso) {
+    const prefix = [];
+    for (const op of ops) {
+        if (!isOutboxDue(op, nowIso))
+            break;
+        prefix.push(op);
+    }
+    return prefix;
+}
 /**
  * Replay queued (and recover lost-receipt) operations.
  * FIFO per sessionId; bounded parallelism across sessions.
+ * Skips ops whose nextAttemptAt is in the future; caps work per call.
  */
 export async function replayOutbox(root, deliver, opts = {}) {
     const parallel = opts.parallel ?? DEFAULT_PARALLEL;
     const now = opts.now ?? (() => new Date());
+    const random = opts.random ?? Math.random;
+    const maxOps = opts.maxOps ?? OUTBOX_REPLAY_MAX_OPS;
+    const nowIso = now().toISOString();
     const pending = listOutboxOperations(root).filter((o) => o.delivery === "queued" || (o.delivery === "acked" && !o.receiptId));
-    // Group by session, preserve FIFO within each.
-    const bySession = new Map();
+    // Group ALL pending by session first (FIFO), then take each session's due prefix.
+    const pendingBySession = new Map();
     for (const op of pending) {
-        const list = bySession.get(op.sessionId) ?? [];
+        const list = pendingBySession.get(op.sessionId) ?? [];
         list.push(op);
-        bySession.set(op.sessionId, list);
+        pendingBySession.set(op.sessionId, list);
+    }
+    for (const list of pendingBySession.values()) {
+        list.sort(outboxFifoCompare);
     }
+    const sessionPrefixes = [];
+    for (const [sessionId, list] of pendingBySession) {
+        const prefix = duePrefixForSession(list, nowIso);
+        if (prefix.length > 0) {
+            sessionPrefixes.push({ sessionId, ops: prefix });
+        }
+    }
+    // Cap by head age: oldest session heads first; take leading due ops only.
+    sessionPrefixes.sort((a, b) => outboxFifoCompare(a.ops[0], b.ops[0]));
+    const bySession = new Map();
+    let selectedCount = 0;
+    let eligibleDue = 0;
+    for (const { sessionId, ops } of sessionPrefixes) {
+        eligibleDue += ops.length;
+        if (selectedCount >= maxOps)
+            continue;
+        const take = Math.min(ops.length, maxOps - selectedCount);
+        bySession.set(sessionId, ops.slice(0, take));
+        selectedCount += take;
+    }
+    const skipped = Math.max(0, eligibleDue - selectedCount);
     let delivered = 0;
     let queued = 0;
     let quarantined = 0;
@@ -297,8 +417,14 @@ export async function replayOutbox(root, deliver, opts = {}) {
                 delivered += 1;
             }
             else if (result.retryable) {
-                markOutboxQueued(op.operationId, root, result.code, now);
-                queued += 1;
+                if (op.attemptCount + 1 >= OUTBOX_MAX_ATTEMPTS) {
+                    markOutboxQuarantined(op.operationId, root, `${result.code}_MAX_ATTEMPTS`, now);
+                    quarantined += 1;
+                }
+                else {
+                    markOutboxQueued(op.operationId, root, result.code, now, random);
+                    queued += 1;
+                }
                 // Stop this session's FIFO on transient failure.
                 break;
             }
@@ -320,7 +446,7 @@ export async function replayOutbox(root, deliver, opts = {}) {
     }
     const workers = Array.from({ length: Math.min(parallel, sessions.length) }, () => worker());
     await Promise.all(workers);
-    return { delivered, queued, quarantined };
+    return { delivered, queued, quarantined, skipped };
 }
 /** Remove acked ops older than retention (optional GC; not required by AC). */
 export function removeAckedOutbox(root, olderThanMs, now = Date.now()) {
@@ -330,8 +456,10 @@ export function removeAckedOutbox(root, olderThanMs, now = Date.now()) {
             continue;
         const age = now - Date.parse(op.updatedAt);
         if (Number.isFinite(age) && age > olderThanMs) {
+            const filePath = workContextOutboxPath(op.operationId, root);
             try {
-                fs.unlinkSync(workContextOutboxPath(op.operationId, root));
+                fs.unlinkSync(filePath);
+                invalidateOutboxListCacheEntry(filePath);
                 removed += 1;
             }
             catch {
@@ -349,6 +477,7 @@ export function quarantineCorruptOutboxFile(filePath, root) {
     const dest = path.join(workContextOutboxDir(root), `.quarantine.${base}`);
     try {
         fs.renameSync(filePath, dest);
+        invalidateOutboxListCacheEntry(filePath);
     }
     catch {
         /* ignore */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.108.14",
+  "version": "5.108.16",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {