@indigoai-us/hq-cli 5.101.0 → 5.101.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [5.101.1] — 2026-08-14
+
+### Fixed
+
+- `hq core rebuild-index threads` no longer crashes with an `ENOENT` stat error
+  when a `workspace/threads/T-*.json` entry that the directory scan listed can no
+  longer be resolved — removed mid-scan by a concurrent writer (HQ Sync, another
+  session, or `archive-old-threads`) or left as a dangling symlink. The renderer
+  now stats each file exactly once before sorting (a Schwartzian transform rather
+  than statting inside the sort comparator), skips entries that vanished (logging
+  a single summary line by basename), and still fails loudly on a genuine stat
+  error such as `EACCES`. Both `INDEX.md` and `recent.md` are regenerated as
+  before. Sentry 7669694322 (HQ-CLI-P).
+
 ## [5.101.0] — 2026-08-13
 
 ### Added

package/dist/lib/index-render/shared.d.ts

@@ -31,5 +31,24 @@ export declare function projectStatus(root: string, project: string, prdPath: st
 export declare function basename(file: string): string;
 export declare function isHidden(name: string): boolean;
 export declare function mtime(file: string): number;
+/**
+ * Sort key for newest-first ordering: the file's modification time in
+ * nanoseconds. Stat the file exactly once, before sorting — never from inside a
+ * comparator, where a throw aborts `Array.sort` and an mtime that changes
+ * mid-sort makes the comparator inconsistent.
+ *
+ * Returns `undefined` when the entry a directory scan just listed can no longer
+ * be resolved: it was removed between the `readdirSync` snapshot and this stat
+ * (a time-of-check-to-time-of-use race in a hot, multi-writer directory), or it
+ * is a symlink whose target is missing (`statSync` follows symlinks). Callers
+ * drop such entries — mirroring how `immediateEntries` and `readJson` already
+ * tolerate a vanished file — so the render never crashes on a benign race.
+ *
+ * Any other stat failure (EACCES, EIO, …) is a genuine fault and is rethrown
+ * with the offending file's BASENAME attached, never its absolute path, which
+ * must not reach error reporting such as Sentry. The original errno `code` is
+ * preserved so upstream error classification is unaffected.
+ */
+export declare function sortKeyMtimeNs(file: string): bigint | undefined;
 export declare function tempDirectory(prefix: string): string;
 //# sourceMappingURL=shared.d.ts.map

package/dist/lib/index-render/shared.js

@@ -120,6 +120,38 @@ export function mtime(file) { try {
 catch {
     return 0;
 } }
+/**
+ * Sort key for newest-first ordering: the file's modification time in
+ * nanoseconds. Stat the file exactly once, before sorting — never from inside a
+ * comparator, where a throw aborts `Array.sort` and an mtime that changes
+ * mid-sort makes the comparator inconsistent.
+ *
+ * Returns `undefined` when the entry a directory scan just listed can no longer
+ * be resolved: it was removed between the `readdirSync` snapshot and this stat
+ * (a time-of-check-to-time-of-use race in a hot, multi-writer directory), or it
+ * is a symlink whose target is missing (`statSync` follows symlinks). Callers
+ * drop such entries — mirroring how `immediateEntries` and `readJson` already
+ * tolerate a vanished file — so the render never crashes on a benign race.
+ *
+ * Any other stat failure (EACCES, EIO, …) is a genuine fault and is rethrown
+ * with the offending file's BASENAME attached, never its absolute path, which
+ * must not reach error reporting such as Sentry. The original errno `code` is
+ * preserved so upstream error classification is unaffected.
+ */
+export function sortKeyMtimeNs(file) {
+    try {
+        return fs.statSync(file, { bigint: true }).mtimeNs;
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return undefined;
+        const wrapped = new Error(`failed to stat ${basename(file)} (${code ?? "unknown error"})`);
+        if (code !== undefined)
+            wrapped.code = code;
+        throw wrapped;
+    }
+}
 // Kept exported for primitive tests and consumers that need a temp base without
 // relying on an application-specific fixture location.
 export function tempDirectory(prefix) { return fs.mkdtempSync(path.join(os.tmpdir(), prefix)); }

package/dist/lib/index-render/threads.js

@@ -1,19 +1,40 @@
 import * as fs from "fs";
-import { at, log, readJson, sanitize, timestamp, write } from "./shared.js";
+import { at, basename, log, readJson, sanitize, sortKeyMtimeNs, timestamp, write } from "./shared.js";
 export function renderThreads(context, args = []) {
     const mode = args[0] ?? "--index";
     const directory = at(context.root, "workspace/threads");
     fs.mkdirSync(directory, { recursive: true });
     // Match `ls -t`: newest filesystem modification time first. `updated_at` is
     // rendered metadata only, and must not influence the order.
+    //
+    // Stat every listed file exactly once, BEFORE sorting (a Schwartzian
+    // transform), never from inside the comparator. workspace/threads is a hot,
+    // multi-writer directory (HQ Sync reconciliation, concurrent agent sessions,
+    // and `archive-old-threads` renaming T-*.json out of it), so an entry
+    // readdirSync just snapshotted can vanish before it is stat'ed. Statting
+    // inside the comparator turned that time-of-check-to-time-of-use window — and
+    // any dangling symlink — into an ENOENT that aborted the whole command before
+    // either file was written. Precompute the key, drop entries that no longer
+    // resolve (as `readJson` already drops unreadable files), then compare only
+    // precomputed keys so the comparator can neither throw nor be inconsistent.
+    const skipped = [];
     const files = fs.readdirSync(directory)
         .filter((name) => /^T-.*\.json$/.test(name) && !name.endsWith(".changeset.json"))
         .map((name) => `${directory}/${name}`)
-        .sort((a, b) => {
-        const aTime = fs.statSync(a, { bigint: true }).mtimeNs;
-        const bTime = fs.statSync(b, { bigint: true }).mtimeNs;
-        return bTime > aTime ? 1 : bTime < aTime ? -1 : 0;
-    });
+        .map((file) => ({ file, key: sortKeyMtimeNs(file) }))
+        .filter((entry) => {
+        if (entry.key === undefined) {
+            skipped.push(basename(entry.file));
+            return false;
+        }
+        return true;
+    })
+        .sort((a, b) => (b.key > a.key ? 1 : b.key < a.key ? -1 : 0))
+        .map((entry) => entry.file);
+    if (skipped.length > 0) {
+        const shown = skipped.slice(0, 10).join(", ");
+        log(context, `rebuild-threads-index: skipped ${skipped.length} thread file(s) that vanished during the scan: ${shown}${skipped.length > 10 ? ", …" : ""}`);
+    }
     const rows = files.flatMap((file) => {
         const data = readJson(file);
         if (!data)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.101.0",
+  "version": "5.101.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -29,7 +29,7 @@
   "dependencies": {
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
-    "@indigoai-us/hq-cloud": "^6.14.50",
+    "@indigoai-us/hq-cloud": "~6.15.0",
     "@indigoai-us/hq-onboarding": "^0.1.0",
     "@sentry/node": "^10.49.0",
     "@tobilu/qmd": "2.5.3",