@indigoai-us/hq-cli 5.108.16 → 5.108.18

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [5.108.18] — 2026-09-07
+
+### Fixed
+
+- A global `hq` reinstall running underneath a starting command no longer
+  crashes it (Sentry HQ-CLI-1G/1H/1J/1K — 7713386011, 7713482655, 7713783135,
+  7714501738). `hq` resolves most of its command graph lazily as its first real
+  step, so when an external updater — the outpost `hq-cli-update` timer, an
+  agent box's self-update, or the desktop app — renames the installed package
+  aside and re-extracts it file by file (~16s every 6h on every box), a command
+  that started a moment earlier resolved a deferred import against a directory
+  that no longer held it and died with `ERR_MODULE_NOT_FOUND` /
+  `MODULE_NOT_FOUND`, filing a separate high-priority crash for each missing
+  path. hq-cli cannot stop the foreign updater, but the registration phase is
+  provably side-effect free (it runs before any command action), so a
+  resolution failure there is now caught: the CLI prints one informational line,
+  waits — bounded, default 90s, `HQ_INSTALL_SETTLE_TIMEOUT_MS` to override — for
+  the install to settle (shared update lock released, the missing target back,
+  the retired `.hq-cli-*` sibling gone, a healthy manifest), and then re-runs
+  the command once on the settled tree. A genuinely broken or incomplete install
+  still reports exactly once, with a reinstall remedy naming the missing module
+  and bounded diagnostics, so real packaging faults stay visible. The recovery
+  re-execs at most once per invocation and never runs a command twice.
+
+## [5.108.17] — 2026-09-07
+
+### Fixed
+
+- 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.16] — 2026-09-07
 
 ### Fixed
@@ -231,7 +269,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
@@ -1672,7 +1709,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/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.js

@@ -358,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) {
@@ -377,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