@indigoai-us/hq-cli 5.92.0 → 5.93.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [5.93.0]
+
+### Fixed
+
+- `hq core archive-old-threads --gated` no longer fails on Linux. The retained
+  shell asset probed `stat -f %m` first, which on GNU coreutils is a filesystem
+  query: it consumed the format string as a path, printed `File: …` for the
+  real argument, and exited 0, so the `stat -c %Y` fallback never ran and the
+  age arithmetic aborted on an unbound `File`. The once-per-day gate exited 1
+  instead of gating. Probes GNU first now. (#327)
+
+### Changed
+
+- `hq core archive-old-threads` and `hq core qmd-reindex-after-sync` run as
+  native, tested TypeScript instead of bundled shell assets, proven equivalent
+  by a shell-vs-native differential suite. The reindex command now reuses the
+  existing search-index collection policy rather than restating the
+  registration convention, so the two can no longer drift. Scaffold scripts
+  still ship for loose HQ trees. (#327)
+
 ## [5.92.0]
 
 ### Changed

package/assets/scaffold/core/scripts/archive-old-threads.sh

@@ -32,8 +32,12 @@ done
 
 TOUCHFILE="workspace/.last-archive-run"
 if [[ "$GATED" == "true" && -f "$TOUCHFILE" ]]; then
-  # macOS `stat -f %m` gives mtime epoch; GNU `stat -c %Y`. Try both.
-  mtime=$(stat -f %m "$TOUCHFILE" 2>/dev/null || stat -c %Y "$TOUCHFILE" 2>/dev/null || echo 0)
+  # GNU `stat -c %Y` first, then macOS `stat -f %m`. Order matters: on GNU,
+  # `-f` queries a FILE SYSTEM, so `stat -f %m <file>` treats `%m` as a path,
+  # prints `File: …` for the real argument, and still exits 0 — the fallback
+  # never fired and the arithmetic below died on unbound `File`, breaking
+  # --gated on Linux entirely. Matches core/scripts/lib/portable.sh.
+  mtime=$(stat -c %Y "$TOUCHFILE" 2>/dev/null || stat -f %m "$TOUCHFILE" 2>/dev/null || echo 0)
   now=$(date +%s)
   if [[ $((now - mtime)) -lt 86400 ]]; then
     echo "archive-old-threads: gated (ran <24h ago, skipping)" >&2

package/dist/commands/core.js

@@ -42,6 +42,8 @@ import { resizeScreenshot } from "../lib/core-utils/resize-screenshot.js";
 import { tokenUsageReport } from "../lib/core-utils/token-usage-report.js";
 import { createWorktree } from "../lib/core-utils/worktree.js";
 import { runCodexSkillBridgeCommand } from "../lib/core-utils/codex-skill-bridge-entry.js";
+import { archiveOldThreads } from "../lib/core-utils/archive-old-threads.js";
+import { qmdReindexAfterSync } from "../lib/core-utils/qmd-reindex-after-sync.js";
 /**
  * These commands are now native implementations. Their retained shell assets
  * are deliberately claimed in SCAFFOLD_ONLY_ASSETS: loose HQ trees still ship
@@ -55,6 +57,8 @@ export const NATIVE_UTILITY_COMMANDS = [
     { name: "token-usage-report", root: "cwd", summary: "Report session token usage", run: (args) => tokenUsageReport(args) },
     { name: "worktree", root: "live", summary: "Create a git worktree under workspace/worktrees/", run: (args, context) => createWorktree(args, { cwd: context.cwd, hqRoot: context.hqRoot }) },
     { name: "codex-skill-bridge", root: "live", summary: "Install/inspect the Codex skill bridge", run: (args, context) => runCodexSkillBridgeCommand(args, { root: context.hqRoot ?? context.cwd }) },
+    { name: "archive-old-threads", root: "live", summary: "Archive aged session-thread files", run: (args, context) => archiveOldThreads(args, { hqRoot: context.hqRoot ?? context.cwd }) },
+    { name: "qmd-reindex-after-sync", root: "cwd", summary: "Refresh qmd collections after a sync", run: (args, context) => qmdReindexAfterSync(args, { cwd: context.cwd }) },
 ];
 export const NATIVE_SCAFFOLD_COMMANDS = [
     {
@@ -161,12 +165,6 @@ export const REBUILD_INDEX_TARGETS = [
  */
 export const SCAFFOLD_COMMANDS = [
     // ---- One-shot migrations and maintenance (live tree) ----
-    {
-        name: "archive-old-threads",
-        asset: "core/scripts/archive-old-threads.sh",
-        root: "live",
-        summary: "Archive aged session-thread files",
-    },
     {
         name: "backfill-company-skill-mirrors",
         asset: "core/scripts/backfill-company-skill-mirrors.sh",
@@ -179,12 +177,6 @@ export const SCAFFOLD_COMMANDS = [
         root: "cwd",
         summary: "One-shot: mirror threads into company workspaces",
     },
-    {
-        name: "qmd-reindex-after-sync",
-        asset: "core/scripts/qmd-reindex-after-sync.sh",
-        root: "cwd",
-        summary: "Refresh qmd collections after a sync",
-    },
 ];
 /**
  * Bundled solely for HQ-root scaffolds, which still need these as loose files.
@@ -192,7 +184,9 @@ export const SCAFFOLD_COMMANDS = [
  * direct `hq core` command.
  */
 export const SCAFFOLD_ONLY_ASSETS = [
+    { asset: "core/scripts/archive-old-threads.sh", root: "live", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/codex-skill-bridge.sh", root: "live", summary: "Scaffold-only native utility companion" },
+    { asset: "core/scripts/qmd-reindex-after-sync.sh", root: "cwd", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/detect-stale-core-policy-mirror.sh", root: "live", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/hq-status-summary.sh", root: "cwd", summary: "Scaffold-only native utility companion" },
     { asset: "core/scripts/ontology-readme-drift.sh", root: "live", summary: "Scaffold-only native utility companion" },

package/dist/lib/core-utils/archive-old-threads.d.ts

@@ -0,0 +1,8 @@
+import { type UtilityIo } from "./common.js";
+export type ArchiveOptions = UtilityIo & {
+    hqRoot?: string;
+    /** Injected for tests; defaults to the wall clock. */
+    now?: () => Date;
+};
+export declare function archiveOldThreads(args?: string[], options?: ArchiveOptions): number;
+//# sourceMappingURL=archive-old-threads.d.ts.map

package/dist/lib/core-utils/archive-old-threads.js

@@ -0,0 +1,97 @@
+/**
+ * Native implementation of `core/scripts/archive-old-threads.sh`.
+ *
+ * Moves `workspace/threads/T-YYYYMMDD-*.json` older than the cutoff into
+ * `workspace/threads/archive/YYYY-MM/`. Idempotent: files already under
+ * `archive/` are never listed, so repeat runs are no-ops.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ioFor, line } from "./common.js";
+/** `date -v-Nd +%Y%m%d` / `date -d "-N days" +%Y%m%d`, in local time. */
+function cutoffStamp(now, days) {
+    const cutoff = new Date(now.getTime());
+    cutoff.setDate(cutoff.getDate() - days);
+    const year = cutoff.getFullYear();
+    const month = `${cutoff.getMonth() + 1}`.padStart(2, "0");
+    const day = `${cutoff.getDate()}`.padStart(2, "0");
+    return `${year}${month}${day}`;
+}
+export function archiveOldThreads(args = [], options = {}) {
+    const { stderr } = ioFor(options);
+    const hqRoot = options.hqRoot ?? process.env.HQ_ROOT ?? process.cwd();
+    const now = options.now ?? (() => new Date());
+    let cutoffDays = 60;
+    let dryRun = false;
+    let gated = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === "--days") {
+            cutoffDays = Number(args[++index]);
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--gated") {
+            gated = true;
+        }
+        else {
+            line(stderr, `Unknown arg: ${arg}`);
+            return 2;
+        }
+    }
+    const touchfile = path.join(hqRoot, "workspace/.last-archive-run");
+    if (gated && fs.existsSync(touchfile)) {
+        const mtime = Math.floor(fs.statSync(touchfile).mtimeMs / 1000);
+        const seconds = Math.floor(now().getTime() / 1000);
+        if (seconds - mtime < 86_400) {
+            line(stderr, "archive-old-threads: gated (ran <24h ago, skipping)");
+            return 0;
+        }
+    }
+    const threadsDir = path.join(hqRoot, "workspace/threads");
+    const archiveRoot = path.join(threadsDir, "archive");
+    fs.mkdirSync(archiveRoot, { recursive: true });
+    const cutoff = cutoffStamp(now(), cutoffDays);
+    // `ls workspace/threads/T-*.json`: top level only, name-ordered, archive/ excluded.
+    let names;
+    try {
+        names = fs
+            .readdirSync(threadsDir)
+            .filter((name) => name.startsWith("T-") && name.endsWith(".json"))
+            .filter((name) => fs.lstatSync(path.join(threadsDir, name)).isFile())
+            .sort();
+    }
+    catch {
+        names = [];
+    }
+    let moved = 0;
+    let skipped = 0;
+    for (const name of names) {
+        const match = name.match(/^T-(\d{8})-/);
+        if (!match) {
+            skipped += 1;
+            continue;
+        }
+        const datePart = match[1];
+        // Both stamps are 8-digit YYYYMMDD, so numeric and lexical order agree.
+        if (Number(datePart) >= Number(cutoff))
+            continue;
+        const bucket = path.join(archiveRoot, `${datePart.slice(0, 4)}-${datePart.slice(4, 6)}`);
+        if (dryRun) {
+            line(stderr, `WOULD MOVE: ${path.join("workspace/threads", name)} -> ${path.relative(hqRoot, bucket)}/`);
+        }
+        else {
+            fs.mkdirSync(bucket, { recursive: true });
+            fs.renameSync(path.join(threadsDir, name), path.join(bucket, name));
+        }
+        moved += 1;
+    }
+    if (!dryRun && gated) {
+        fs.mkdirSync(path.dirname(touchfile), { recursive: true });
+        fs.writeFileSync(touchfile, "");
+    }
+    line(stderr, `archive-old-threads: cutoff=${cutoffDays}d (before ${cutoff}) moved=${moved} skipped=${skipped} dry_run=${dryRun}`);
+    return 0;
+}
+//# sourceMappingURL=archive-old-threads.js.map

package/dist/lib/core-utils/qmd-reindex-after-sync.d.ts

@@ -0,0 +1,15 @@
+import type { UtilityIo } from "./common.js";
+export type QmdReindexOptions = UtilityIo & {
+    cwd?: string;
+    /** Test seams; default to the real search-index implementations. */
+    resolveBin?: () => string;
+    reconcile?: (hqRoot: string, options: {
+        bin: string;
+    }) => unknown;
+    run?: (args: string[], options: {
+        bin: string;
+        cwd: string;
+    }) => unknown;
+};
+export declare function qmdReindexAfterSync(args?: string[], options?: QmdReindexOptions): number;
+//# sourceMappingURL=qmd-reindex-after-sync.d.ts.map

package/dist/lib/core-utils/qmd-reindex-after-sync.js

@@ -0,0 +1,62 @@
+/**
+ * Native implementation of `core/scripts/qmd-reindex-after-sync.sh`.
+ *
+ * The shell script restated the collection-registration convention that
+ * `src/lib/search-index` already owns; this port reuses that single source
+ * instead, so the two can no longer drift.
+ *
+ * Contract preserved verbatim: a missing qmd or a non-HQ path is a silent
+ * success (a sync must never fail because indexing could not run), the lexical
+ * update always runs, and embeddings rebuild only on `--embed`.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { reconcileCollections, resolveQmdBin, runQmd } from "../search-index/index.js";
+export function qmdReindexAfterSync(args = [], options = {}) {
+    let hqRoot = "";
+    let embed = false;
+    for (const arg of args) {
+        if (arg === "--embed")
+            embed = true;
+        else if (arg.startsWith("--"))
+            continue; // unknown flags are ignored, as in the shell
+        else if (!hqRoot)
+            hqRoot = arg;
+    }
+    if (!hqRoot)
+        hqRoot = options.cwd ?? process.cwd();
+    let bin;
+    try {
+        bin = (options.resolveBin ?? resolveQmdBin)();
+    }
+    catch {
+        return 0; // qmd absent: silent no-op.
+    }
+    if (!fs.existsSync(path.join(hqRoot, "core/core.yaml")))
+        return 0;
+    const reconcile = options.reconcile ?? ((root, opts) => reconcileCollections(root, opts));
+    const run = options.run ?? ((argv, opts) => runQmd(argv, opts));
+    // Every qmd interaction is best-effort: the shell suffixed each with `|| true`.
+    try {
+        reconcile(hqRoot, { bin });
+    }
+    catch {
+        /* registration is advisory; an update still helps */
+    }
+    try {
+        run(["update"], { bin, cwd: hqRoot });
+    }
+    catch {
+        /* never fail a sync on index freshness */
+    }
+    if (embed) {
+        try {
+            run(["embed"], { bin, cwd: hqRoot });
+        }
+        catch {
+            /* embeddings are deferred-cost and optional */
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=qmd-reindex-after-sync.js.map

package/package.json

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