@indigoai-us/hq-cli 5.108.15 → 5.108.17

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.108.17] — 2026-09-07
+
+## [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
@@ -26,6 +41,15 @@
   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)
+- The Work Mesh Live daemon's transcript watcher no longer rescans every file
+  under `~/.claude/projects` and `~/.codex/sessions` every 15 seconds. It keeps a
+  per-directory mtime cache and only relists directories that changed, re-stats
+  recently active files, revalidates every cached directory at least every five
+  minutes (content appends do not change a directory's mtime, so a session that
+  resumes after idling is still picked up), backs the interval off from 30 s to
+  120 s on busy machines, caps the entries examined per tick with per-root
+  budgets, never runs two ticks at once, and bounds its cache. Capped ticks skip
+  disappearance reconciliation so an unvisited session is never ended falsely.
 
 ## [5.108.14] — 2026-09-07
 
@@ -57,6 +81,15 @@
   `incomplete_install` context so the next occurrence is attributable. The drop
   is wired both at the top-level boundary and in the shared `beforeSend`, so it
   covers every capture route.
+- The Work Mesh Live daemon's transcript watcher no longer rescans every file
+  under `~/.claude/projects` and `~/.codex/sessions` every 15 seconds. It keeps a
+  per-directory mtime cache and only relists directories that changed, re-stats
+  recently active files, revalidates every cached directory at least every five
+  minutes (content appends do not change a directory's mtime, so a session that
+  resumes after idling is still picked up), backs the interval off from 30 s to
+  120 s on busy machines, caps the entries examined per tick with per-root
+  budgets, never runs two ticks at once, and bounds its cache. Capped ticks skip
+  disappearance reconciliation so an unvisited session is never ended falsely.
 
 ## [5.108.13] — 2026-09-06
 
@@ -218,7 +251,6 @@
   and `hq reindex` now prunes local session-log copies 7 days after the vault
   confirms them (`HQ_SESSION_LOG_LOCAL_RETENTION_DAYS`, `off` to disable).
 
-
 ## [5.108.5] — 2026-09-04
 
 ### Added
@@ -1659,7 +1691,6 @@ All self-update behavior honors the existing `HQ_NO_UPDATE_CHECK=1` opt-out.
 
 - **`hq db provision` / `hq db status --remote` use Cognito + vault API** to call the live control plane (`POST /v1/db/provision`, `GET /v1/db/status`). Team plan required for provision; local `status|sql|migrate` unchanged.
 
-
 ## [5.55.1]
 
 ### 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/index.d.ts

@@ -19,6 +19,6 @@ export type { DaemonDoctorDeps, DaemonDoctorReport } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";
 export type { DaemonHandle, DaemonRunDeps } from "./run.js";
-export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, isTranscriptHookCovered, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, } from "./transcript-watch.js";
-export type { DiscoveredTranscript, TranscriptFs, TranscriptKind, TranscriptWatchDeps, TranscriptWatchTickResult, } from "./transcript-watch.js";
+export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_ENTRY_CAP, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
+export type { DiscoveredTranscript, DiscoverScanMeta, DiscoverTranscriptsResult, TranscriptDiscoverCache, TranscriptFs, TranscriptKind, TranscriptWatchDeps, TranscriptWatchTickResult, } from "./transcript-watch.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -10,5 +10,5 @@ export { buildInstallPaths, daemonServiceStatus, detectPlatform, installDaemonSe
 export { UNHEALTHY_SPOOL_AGE_MS, collectDaemonDoctor, formatDaemonDoctor, } from "./doctor.js";
 export { scopeBundleToAgentIdentity, } from "./credentials.js";
 export { FLUSH_INTERVAL_MS, SPOOL_DEBOUNCE_MS, runMeshDaemon, } from "./run.js";
-export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, isTranscriptHookCovered, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, } from "./transcript-watch.js";
+export { TRANSCRIPT_ADAPTER_VERSION, TRANSCRIPT_EVENT_SOURCE, TRANSCRIPT_FRESH_MS, TRANSCRIPT_HOOK_COVER_MS, TRANSCRIPT_MARKER, TRANSCRIPT_SESSION_END_MS, TRANSCRIPT_TURN_QUIET_MS, TRANSCRIPT_WATCH_BACKOFF_DURATION_MS, TRANSCRIPT_WATCH_BACKOFF_ENTRIES, TRANSCRIPT_WATCH_ENTRY_CAP, TRANSCRIPT_WATCH_INTERVAL_MAX_MS, TRANSCRIPT_WATCH_INTERVAL_MS, TRANSCRIPT_WATCH_REVALIDATE_MS, TranscriptWatcher, createTranscriptDiscoverCache, decodeClaudeProjectDirName, defaultTranscriptFs, discoverTranscripts, discoverTranscriptsWithMeta, isTranscriptHookCovered, nextTranscriptWatchIntervalMs, noteHookSessionsFromSpoolFile, resolveTranscriptRegistration, sessionIdFromClaudeTranscriptPath, sessionIdFromCodexTranscriptPath, sortDiscoveries, } from "./transcript-watch.js";
 //# sourceMappingURL=index.js.map

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

@@ -41,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

@@ -255,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);
@@ -351,6 +358,17 @@ export async function runMeshDaemon(deps = {}) {
             return;
         try {
             const summary = await transcriptWatcher.tick();
+            if (summary.skippedConcurrent)
+                return;
+            if (summary.intervalChanged) {
+                log(dir, `transcript-watch interval ${summary.previousIntervalMs}ms -> ${summary.intervalMs}ms`);
+            }
+            if (summary.capEpisodeStart) {
+                log(dir, `transcript-watch entry cap hit (examined=${summary.entriesExamined})`);
+            }
+            if (summary.cacheOverflowCleared) {
+                log(dir, "transcript-watch cache overflow; cleared for full rescan");
+            }
             if (summary.started > 0 ||
                 summary.turns > 0 ||
                 summary.ended > 0) {
@@ -370,7 +388,8 @@ export async function runMeshDaemon(deps = {}) {
             void runTranscriptTick().finally(() => {
                 if (stopped)
                     return;
-                transcriptIntervalHandle = timers.setTimeout(transcriptTick, TRANSCRIPT_WATCH_INTERVAL_MS);
+                const delay = transcriptWatcher?.getIntervalMs() ?? TRANSCRIPT_WATCH_INTERVAL_MS;
+                transcriptIntervalHandle = timers.setTimeout(transcriptTick, delay);
             });
         }, TRANSCRIPT_WATCH_INTERVAL_MS);
     }

package/dist/lib/mesh/live/daemon/transcript-watch.d.ts

@@ -2,7 +2,16 @@
  * Transcript-watch fallback for hookless hosts (US-018 / AMEND-001).
  *
  * Enumerates ~/.claude/projects/ (recursive *.jsonl) and ~/.codex/sessions/
- * every 15s using only readdir + stat (mtime). Never opens or reads transcript bytes.
+ * on an adaptive interval (default 30s, backoff to 120s) using only readdir +
+ * stat (mtime). Never opens or reads transcript bytes.
+ *
+ * Scans are incremental: directory mtime is cached so unchanged directories are
+ * not re-listed; only files in changed directories (plus files still inside the
+ * active mtime window) are re-statted. Every TRANSCRIPT_WATCH_REVALIDATE_MS a
+ * cached directory is force-relisted so idle appends and coarse mtimes cannot
+ * hide changes forever. A per-tick entry cap (split across Claude/Codex roots)
+ * bounds pathological trees; capped ticks skip disappearance reconciliation.
+ * Ticks never overlap (a concurrent call is skipped).
  *
  * Session identity (deterministic):
  * - Claude: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
@@ -22,7 +31,21 @@ import { reconcileObservation, type ReconcileDeps } from "../../../work-context/
 import { readSessionState, writeSessionState, type SessionStateFile } from "../../../work-context/state.js";
 import { enqueueSessionEvent } from "../enqueue.js";
 import type { SessionEventHarness } from "../format-spool-line.js";
-export declare const TRANSCRIPT_WATCH_INTERVAL_MS = 15000;
+export declare const TRANSCRIPT_WATCH_INTERVAL_MS = 30000;
+/** Ceiling for adaptive backoff after heavy ticks. */
+export declare const TRANSCRIPT_WATCH_INTERVAL_MAX_MS = 120000;
+/** Double the interval when a tick examines more than this many entries. */
+export declare const TRANSCRIPT_WATCH_BACKOFF_ENTRIES = 2000;
+/** Double the interval when a tick takes longer than this many ms. */
+export declare const TRANSCRIPT_WATCH_BACKOFF_DURATION_MS = 500;
+/** Hard cap on entries examined (dir stats, readdir children, file stats) per tick. */
+export declare const TRANSCRIPT_WATCH_ENTRY_CAP = 20000;
+/**
+ * Even when a directory mtime matches the cache, force a full relist (readdir +
+ * re-stat) after this many ms so content appends and coarse mtime granularity
+ * cannot hide membership or mtime changes indefinitely.
+ */
+export declare const TRANSCRIPT_WATCH_REVALIDATE_MS: number;
 export declare const TRANSCRIPT_TURN_QUIET_MS = 5000;
 export declare const TRANSCRIPT_SESSION_END_MS: number;
 export declare const TRANSCRIPT_HOOK_COVER_MS = 60000;
@@ -86,6 +109,8 @@ export interface TranscriptWatchDeps {
     reconcile?: typeof reconcileObservation;
     claudeProjectsDir?: string;
     codexSessionsDir?: string;
+    /** Override entry cap (tests). Defaults to TRANSCRIPT_WATCH_ENTRY_CAP. */
+    entryCap?: number;
 }
 export interface TranscriptWatchTickResult {
     discovered: number;
@@ -94,7 +119,43 @@ export interface TranscriptWatchTickResult {
     ended: number;
     skippedHookCovered: number;
     skippedStale: number;
+    /** Dir stats + readdir children + file stats examined this tick. */
+    entriesExamined: number;
+    durationMs: number;
+    /** True when TRANSCRIPT_WATCH_ENTRY_CAP stopped the walk early. */
+    capped: boolean;
+    /** True on the first capped tick of a contiguous capped episode (for logging). */
+    capEpisodeStart: boolean;
+    /** True when the discover cache was cleared due to exceeding the file cap. */
+    cacheOverflowCleared: boolean;
+    /** Interval after this tick's adaptive backoff adjustment. */
+    intervalMs: number;
+    previousIntervalMs: number;
+    intervalChanged: boolean;
+    /** True when a previous tick was still running (this call was a no-op). */
+    skippedConcurrent: boolean;
+}
+/** Per-directory mtime + child cache for incremental discovery. */
+export interface TranscriptDirCacheEntry {
+    mtimeMs: number;
+    files: DiscoveredTranscript[];
+    subdirs: string[];
+    /** Wall time of the last complete listing of this directory. */
+    lastFullStatAtMs: number;
+}
+export interface TranscriptDiscoverCache {
+    dirs: Map<string, TranscriptDirCacheEntry>;
 }
+export interface DiscoverScanMeta {
+    entriesExamined: number;
+    dirsListed: number;
+    dirsSkipped: number;
+    filesStatted: number;
+    capped: boolean;
+    /** True when cache file count exceeded the entry cap and the cache was cleared. */
+    cacheOverflowCleared: boolean;
+}
+export declare function createTranscriptDiscoverCache(): TranscriptDiscoverCache;
 /**
  * Claude Code encodes an absolute cwd as a directory name by replacing every
  * "/" with "-". Decoding is best-effort (hyphenated path segments are ambiguous).
@@ -110,15 +171,41 @@ export declare function sessionIdFromClaudeTranscriptPath(filePath: string): str
  * Rule: trailing UUID in basename, else basename without extension.
  */
 export declare function sessionIdFromCodexTranscriptPath(filePath: string): string | null;
-/**
- * Enumerate transcript files with mtime only (no content read).
- */
-export declare function discoverTranscripts(opts: {
+export interface DiscoverTranscriptsOptions {
     home?: string;
     fs?: TranscriptFs;
     claudeProjectsDir?: string;
     codexSessionsDir?: string;
-}): DiscoveredTranscript[];
+    /** When set, reuse/update this cache for incremental scans. */
+    cache?: TranscriptDiscoverCache;
+    /** Clock for active-window re-stat decisions. Defaults to Date.now(). */
+    nowMs?: number;
+    /** Override entry cap (tests). Defaults to TRANSCRIPT_WATCH_ENTRY_CAP. */
+    entryCap?: number;
+    /** Active mtime window for re-stat in unchanged dirs. */
+    activeWindowMs?: number;
+}
+export interface DiscoverTranscriptsResult {
+    transcripts: DiscoveredTranscript[];
+    meta: DiscoverScanMeta;
+}
+/**
+ * Enumerate transcript files with mtime only (no content read).
+ * Pass `cache` to skip readdir on directories whose mtime is unchanged
+ * (until TRANSCRIPT_WATCH_REVALIDATE_MS forces a relist).
+ *
+ * Each root gets half of `entryCap`; unused budget from the first root is
+ * available to the second so a huge Claude tree cannot starve Codex.
+ */
+export declare function discoverTranscriptsWithMeta(opts?: DiscoverTranscriptsOptions): DiscoverTranscriptsResult;
+/**
+ * Enumerate transcript files with mtime only (no content read).
+ * Without a cache this is a full walk; with `cache` it is incremental.
+ */
+export declare function discoverTranscripts(opts?: DiscoverTranscriptsOptions): DiscoveredTranscript[];
+/** Sort key for comparing discovery results independent of walk order. */
+export declare function discoveryFingerprint(d: DiscoveredTranscript): string;
+export declare function sortDiscoveries(items: DiscoveredTranscript[]): DiscoveredTranscript[];
 /**
  * Whether hooks already cover this session: durable hook-written state, or a
  * hook event observed within the last TRANSCRIPT_HOOK_COVER_MS.
@@ -156,10 +243,23 @@ export declare class TranscriptWatcher {
     private readonly readState;
     private readonly writeState;
     private readonly reconcileFn;
+    private readonly discoverCache;
+    private intervalMs;
+    private tickInFlight;
+    /** Tracks contiguous capped ticks so we log once per cap episode. */
+    private inCapEpisode;
     constructor(deps: TranscriptWatchDeps);
+    /** Current adaptive poll interval (after the last tick's backoff). */
+    getIntervalMs(): number;
+    /** Expose discovery cache for tests. */
+    getDiscoverCache(): TranscriptDiscoverCache;
     /** Record that a hook path emitted an event for sessionId (daemon flush). */
     noteHookEvent(sessionId: string, atMs?: number): void;
     tick(): Promise<TranscriptWatchTickResult>;
+    /**
+     * Heavy ticks double the poll interval up to MAX; a quiet tick resets to base.
+     */
+    private applyIntervalBackoff;
     /**
      * Register via reconcileObservation (membership-validated slug→uid), then
      * enqueue session_start. Never overwrites a hook-written state.
@@ -167,4 +267,11 @@ export declare class TranscriptWatcher {
     private emitStart;
     private emitKind;
 }
+/**
+ * Adaptive interval: busy ticks double up to MAX; quiet ticks return to base.
+ */
+export declare function nextTranscriptWatchIntervalMs(currentMs: number, opts: {
+    entriesExamined: number;
+    durationMs: number;
+}): number;
 //# sourceMappingURL=transcript-watch.d.ts.map