@indigoai-us/hq-cli 5.345.135 → 5.345.137

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [5.345.137] — 2026-10-15
+- The bundled sync engine now uses hq-cloud 6.18.76. On Windows, the hq-core update and rescue lay down native links after the overlay, turn git symlink stubs from Windows clones into real links, and upload symlinks with the correct target. Sync merges `board.json` by entry id instead of replacing it, merges append-only `.jsonl` conflicts instead of parking them, keeps any `.hqcloud` placeholder on pull, and no longer syncs live-meeting runtime state or server sync manifests.
+
+## [5.345.136] — 2026-10-15
+- The work-mesh daemon no longer dead-letters events for sessions another actor already reports (HTTP 403 `SESSION_OWNER_MISMATCH`, for example a local bot's own turns or checkpoint helper sessions). It drops them with a receipt in `dropped-receipts.jsonl`, stops posting that session while it stays bound to the same company, and `hq doctor` no longer marks the daemon unhealthy for them.
+
+- `hq storage offload --current [paths...]` now offloads idle working files. A file under `companies/<slug>/` is replaced with a placeholder that points at the object HQ sync already stored in that company's vault; nothing is uploaded, and you must be an active member of the company. A company file sync has not stored yet (new, edited since the last sync, or changed in the vault) is skipped, and the run lists those files with "run hq sync first". Any other file points at its personal-vault copy when sync stored this exact version, and is uploaded to your personal vault otherwise. `--idle-days 0` includes files edited today, and `--dry-run` lists each file with its size, target vault, sync state and action.
+- Current-file offload turns on only when the installed sync engine exports `CLOUD_PLACEHOLDER_HOLDS_ANY_SIBLING`, so sync never deletes or downloads over a `.hqcloud` placeholder. With an older `@indigoai-us/hq-cloud` it reports "update HQ sync" and changes nothing.
+- `hq storage offload` without `--current` now handles only old versions in history and no longer reports on current files.
+- Windows: the `ai.getindigo.hq-daemon` Scheduled Task now runs the hq-cli JS entry under node instead of the npm `hq.cmd` shim, so the daemon starts at logon. Re-run `hq daemon install` to rewrite an existing task.
+- Windows: the daemon now stages its hq child bootstrap and the packaged sync runner. Directory fsync, which Windows refuses with EPERM, is skipped on win32, so the updater, search-index, lanes-reconcile and housekeeping services no longer fall back to running `node hq.cmd` and crashing.
+- Windows: `hq doctor` no longer reports hook scripts and the Codex and Grok adapters as not executable. Windows has no execute bit, so the check now passes any present script there.
+- Windows: an `hq` started in the background (no terminal, as the desktop app, sync runner and hooks start it) now starts its child processes with hidden console windows, so they no longer flash on screen every minute or two.
+- `hq core checkpoint --backend auto` finds `claude.exe` and `grok.exe` on Windows, and after it finds no allowed backend it stops re-probing for six hours, or until PATH changes, instead of spawning version probes and printing "no allowed backend" on every checkpoint.
+- `hq mesh story` no longer stops at `Unknown story` when the story is in the project's local prd.json but not yet on the Board. It registers the project from that PRD (the same merge `hq mesh project ensure` does) and retries once. `--no-ensure` prints the ensure command instead.
+- `hq doctor --fix` now repairs a bot startup agent that points at a missing hq binary (`bots.<name>.daemon-binary`), the same way `hq bot daemon install <name>` does, so hq-checkup stops reporting safety checks off after the fix. It only points a bot at an installed hq, never at a worktree build.
+- hqd: when a policy check, journal append or presence call names no company and the cwd is not linked to one, hqd now uses the session's own bind in its `meta.yaml` (`company_slug`). A company bot at the HQ root can read its own company's files again, and the scope guard still limits it to that one company. The bind is ignored unless that company folder exists, and it never overrides an explicit company or a cwd link.
+- `hq integrations call` accepts tool arguments from a file with `--args-file <path>` or from stdin with `--args -`, so JSON that contains apostrophes or parentheses no longer has to pass through shell quoting. `--args` and `--args-file` together is an error, and invalid JSON in a file names the file.
+- `hq integrations audit` pages through the full activity feed instead of stopping at the latest 50 events, so `--limit` above 50 returns that many rows. A new `--since <ISO timestamp>` stops at older events, and `--provider` keeps paging until the limit is met. Against an older server it shows the latest 50 events and says so.
+- `hq meetings transcript`, `notes`, `get` and `set-company` resolve every short id `hq meetings list` prints. The lookup now follows the meeting list's pages instead of reading only the first one, which the server caps at 100 meetings and can end early when it runs short of time.
+- `hq integrations approve` no longer reports "the call ran" when the approved call failed at the provider. It prints the provider's error and exits 1, prints "the call ran" only for a resumed or completed call, and shows any other status as is. `--json` output is unchanged apart from the exit code.
+- `hq lanes monitor-check` now counts a live `hq lanes watch` process when the CLI
+  is installed through pnpm, where the process line runs node on the hq-cli
+  package entrypoint instead of an `hq` bin path.
+- `hq lanes admit` on a queued loop lane now starts the lane's loop controller, the
+  same way background admission does, instead of running the brief once with no
+  controller. Later phase envelopes no longer sit unprocessed.
+- An interrupt that HQ issues itself no longer records `operator_interrupt`. A loop
+  lane interrupted to recover a dead loop controller now shows
+  `loop_controller_recovery`; a stall restart shows `loop_stall_restart` and a
+  phase deadline shows `loop_phase_deadline`. Every interrupt now adds a stop-history
+  entry; an operator interrupt without `--reason` records the calling session or lane.
+- `hq lanes cancel <lane-id>` is now an alias of `hq lanes stop`.
+- `hq lanes create --placement local` no longer fails with `lane_placement_disabled`
+  when Outpost load balancing is off. Local placement is the default there, so the
+  flag is accepted as a no-op. Other placements still need the gate.
+- `--account auto` and `hq capacity route` no longer tell you to log in to an account
+  that simply has no usage reading yet. With fresh capacity data it is skipped as
+  "no usage reading for this account yet" (fix: `hq capacity doctor`); with the
+  collector off or stale data it is ranked with unknown usage.
+- `hq reindex` no longer removes a worktree under `workspace/worktrees/<repo>/<name>` that a session is still using. It keeps a worktree when a live process has its cwd inside it, when a Claude Code or Codex transcript from the last 7 days recorded a cwd inside it, when it has uncommitted or untracked changes, or when its branch has no upstream or commits not on a remote. It prints `reindex: kept stale worktree <path> (<reason>)` for each one and no longer passes `--force` to `git worktree remove`.
+- `hq core worktree-gc` applies the same session-ownership skips (`live-session`, `recent-session`) as `core/scripts/worktree-gc.sh`, and counts a recent commit or checkout in the worktree as activity.
+- Keep running Claude Remote Control account pools alive when a daemon restart temporarily cannot verify their HQ Secrets. A confirmed missing secret still stops its pool.
+
 ## [5.345.135] — 2026-10-15
 - `hq fingerprint self` prints the current session's HQ fingerprint, and `hq fingerprint <value>` resolves a fingerprint to its local session record. The commit-msg hook calls `hq fingerprint self --json --offline`, which stays offline and always exits 0.
 - Worker lanes get their own `HQ_SESSION_ID`, `HQ_LANE_ID`, `HQ_PARENT_SESSION_ID` and `HQ_COMPANY` with every inherited session id removed; lane records carry a `fingerprint` field shown by `lanes status --json` and `lanes show`; handoff commits add an `HQ-Fingerprint` trailer when a value exists. The handoff lookup is read-only and the offline builder never loads network modules (US-005).

package/assets/scaffold/core/scripts/worktree-gc.sh

@@ -20,8 +20,14 @@
 #                                         is already merged into the HQ root's
 #                                         local `main`. Fetch is best-effort; a
 #                                         failed fetch makes the worktree UNSAFE.
-#   4. Not in use                       — no active session references its path,
-#                                         and it was not touched in the last 2h.
+#   4. Not in use                       — no live process has its cwd inside it,
+#                                         no Claude Code / Codex session transcript
+#                                         written in the last 7 days (env
+#                                         HQ_WORKTREE_SESSION_WINDOW_HOURS) recorded
+#                                         a cwd inside it, no session / lock file
+#                                         references its path, and neither the
+#                                         directory nor its HEAD / HEAD reflog
+#                                         changed in the last 2h.
 #
 # Removal mechanics are the gentle git verbs only — never `rm -rf`, never
 # `--force`, never `branch -D`:
@@ -64,7 +70,7 @@ while [[ $# -gt 0 ]]; do
     --gated) GATED=1; shift ;;
     --json) JSON=1; shift ;;
     -h|--help)
-      sed -n '2,45p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+      sed -n '2,51p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
       exit 0 ;;
     *) echo "worktree-gc: unknown arg: $1" >&2; exit 2 ;;
   esac
@@ -126,6 +132,76 @@ session_references() {
   return 1
 }
 
+# ---------------------------- session liveness ------------------------------
+# A worktree is owned by a live session when a running process has its cwd
+# inside it (lsof on macOS, /proc on Linux), or when a Claude Code / Codex
+# session transcript written within the session window recorded a cwd inside
+# it. Agent shells do not keep a process parked in the worktree between tool
+# calls, so the transcript cwd is what covers an idle but open session. Both
+# lists are gathered once per run. With no lsof and no /proc the process probe
+# yields nothing; the transcript, reference, and activity guards still apply.
+SESSION_WINDOW_HOURS="${HQ_WORKTREE_SESSION_WINDOW_HOURS:-168}"
+case "$SESSION_WINDOW_HOURS" in ''|*[!0-9]*) SESSION_WINDOW_HOURS=168 ;; esac
+LIVE_PROC_CWDS=""
+SESSION_CWDS=""
+collect_session_cwds() {
+  local _p d dirs
+  LIVE_PROC_CWDS="$(mktemp "${TMPDIR:-/tmp}/hq-wt-proc.XXXXXX" 2>/dev/null)" || LIVE_PROC_CWDS=""
+  SESSION_CWDS="$(mktemp "${TMPDIR:-/tmp}/hq-wt-sess.XXXXXX" 2>/dev/null)" || SESSION_CWDS=""
+  if [ -n "$LIVE_PROC_CWDS" ]; then
+    if [ -e /proc/self/cwd ]; then
+      for _p in /proc/[0-9]*; do readlink "$_p/cwd" 2>/dev/null || true; done > "$LIVE_PROC_CWDS"
+    elif command -v lsof >/dev/null 2>&1; then
+      { lsof -w -n -P -d cwd -Fn 2>/dev/null || true; } | sed -n 's/^n//p' > "$LIVE_PROC_CWDS"
+    fi
+  fi
+  if [ -n "$SESSION_CWDS" ]; then
+    dirs="${HQ_SESSION_TRANSCRIPT_DIRS:-$HOME/.claude/projects:$HOME/.codex/sessions}"
+    printf '%s\n' "$dirs" | tr ':' '\n' | while IFS= read -r d; do
+      [ -n "$d" ] && [ -d "$d" ] || continue
+      { find "$d" -type f -name '*.jsonl' -mmin "-$((SESSION_WINDOW_HOURS * 60))" -print0 2>/dev/null \
+          | xargs -0 grep -h -o '"cwd": *"[^"]*"' /dev/null 2>/dev/null || true; } \
+        | sed 's/^"cwd": *"//; s/"$//'
+    done | sort -u > "$SESSION_CWDS"
+  fi
+}
+
+# path_in_list <list-file> <path> [<alt-path>] — true when a listed cwd is the
+# path or lies inside it.
+path_in_list() {
+  local f="$1" a="${2:-}" b="${3:-}"
+  [ -n "$f" ] && [ -s "$f" ] || return 1
+  awk -v a="$a" -v b="$b" '
+    function hit(p, w) { return w != "" && (p == w || index(p, w "/") == 1) }
+    hit($0, a) || hit($0, b) { found = 1; exit }
+    END { exit found ? 0 : 1 }' "$f"
+}
+
+# session_owner_reason <wt> [<alt>] — prints live-session or recent-session and
+# succeeds when a session owns the worktree.
+session_owner_reason() {
+  if path_in_list "$LIVE_PROC_CWDS" "$1" "${2:-}"; then echo "live-session"; return 0; fi
+  if path_in_list "$SESSION_CWDS" "$1" "${2:-}"; then echo "recent-session"; return 0; fi
+  return 1
+}
+
+# worktree_activity_epoch <wt> — newest mtime of the worktree directory and its
+# per-worktree HEAD and HEAD reflog (commits, checkouts, resets). The index is
+# left out because `git status` may rewrite it on its own.
+worktree_activity_epoch() {
+  local wt="$1" gd newest f m
+  newest=$(path_mtime "$wt")
+  gd=$(git -C "$wt" rev-parse --path-format=absolute --git-dir 2>/dev/null || echo "")
+  if [[ -n "$gd" ]]; then
+    for f in "$gd/HEAD" "$gd/logs/HEAD"; do
+      [[ -e "$f" ]] || continue
+      m=$(path_mtime "$f")
+      if (( m > newest )); then newest=$m; fi
+    done
+  fi
+  echo "$newest"
+}
+
 # Optional timeout wrapper for network fetches (macOS has no `timeout`).
 _TIMEOUT_BIN=""
 if command -v timeout >/dev/null 2>&1; then _TIMEOUT_BIN="timeout"
@@ -160,7 +236,7 @@ SELF_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
 # --------------------------- results / counters -----------------------------
 REC_NDJSON="$(mktemp 2>/dev/null || echo "/tmp/worktree-gc-rec.$$")"
 : > "$REC_NDJSON"
-cleanup_rec() { rm -f "$REC_NDJSON"; }
+cleanup_rec() { rm -f "$REC_NDJSON" "${LIVE_PROC_CWDS:-}" "${SESSION_CWDS:-}"; }
 trap cleanup_rec EXIT
 
 examined=0
@@ -169,6 +245,9 @@ would=0
 reclaimed_kb=0
 declare -i skip_total=0
 
+if [[ "${#CANDIDATES[@]}" -gt 0 ]]; then collect_session_cwds; fi
+HQ_ROOT_PHYS="$(cd "$HQ_ROOT" && pwd -P)"
+
 # wt_git <git-args...> — run git against the current worktree's main repo, adding
 # the HQ_ALLOW_HQ_ROOT_GIT escape hatch only for HQ-root-class worktrees (whose
 # mutations touch the HQ root object store and are otherwise hook-blocked).
@@ -225,8 +304,19 @@ for wt in "${CANDIDATES[@]:-}"; do
   branch=$(git -C "$wt" symbolic-ref --short HEAD 2>/dev/null || echo "")
   head_sha=$(git -C "$wt" rev-parse HEAD 2>/dev/null || echo "")
 
+  # ---- guard 4a: owned by a live session ----
+  # Checked before anything else inspects the tree. wt is the physical path;
+  # the spelling under the given HQ_ROOT is matched too.
+  wt_alt="$wt"
+  [[ "$wt" == "$HQ_ROOT_PHYS"/* ]] && wt_alt="$HQ_ROOT/${wt#"$HQ_ROOT_PHYS"/}"
+  if owner=$(session_owner_reason "$wt" "$wt_alt"); then
+    skip "$wt" "$main_repo" "$branch" "$is_hq_root" "" "" "$owner"; continue
+  fi
+
   # ---- guard 1: clean working tree ----
-  porcelain=$(git -C "$wt" status --porcelain 2>/dev/null || echo "__ERR__")
+  # --no-optional-locks keeps the scan from rewriting the index. Untracked files
+  # count as dirty even when status.showUntrackedFiles=no.
+  porcelain=$(git --no-optional-locks -C "$wt" status --porcelain --untracked-files=all 2>/dev/null || echo "__ERR__")
   if [[ "$porcelain" == "__ERR__" ]]; then
     skip "$wt" "$main_repo" "$branch" "$is_hq_root" "" "" "git-error"; continue
   fi
@@ -234,13 +324,13 @@ for wt in "${CANDIDATES[@]:-}"; do
     skip "$wt" "$main_repo" "$branch" "$is_hq_root" "" "" "dirty"; continue
   fi
 
-  # ---- guard 4a: recent activity (in-use heuristic) ----
+  # ---- guard 4b: recent activity (in-use heuristic) ----
   wt_mtime=$(path_mtime "$wt")
-  if (( wt_mtime > RECENT_EPOCH )); then
+  if (( $(worktree_activity_epoch "$wt") > RECENT_EPOCH )); then
     skip "$wt" "$main_repo" "$branch" "$is_hq_root" "" "" "recent-activity"; continue
   fi
 
-  # ---- guard 4b: active-session reference ----
+  # ---- guard 4c: active-session reference ----
   if session_references "$wt"; then
     skip "$wt" "$main_repo" "$branch" "$is_hq_root" "" "" "active-session"; continue
   fi

package/dist/command-catalog.generated.d.ts

@@ -3245,7 +3245,7 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly subcommands: readonly [];
     }, {
         readonly name: "offload";
-        readonly description: "Move big files to your personal HQ cloud storage and leave links behind (old versions in history; idle current files)";
+        readonly description: "Move big files to HQ cloud storage and leave links behind (old versions in history; with --current, idle working files to the vault that owns them)";
         readonly aliases: readonly [];
         readonly hidden: false;
         readonly helpOption: true;
@@ -3267,8 +3267,8 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Only old versions in local autosave history";
             readonly hidden: false;
         }, {
-            readonly flags: "--current";
-            readonly description: "Only idle files in the working tree";
+            readonly flags: "--current [paths...]";
+            readonly description: "Idle working files instead of history; optional HQ paths limit it to those files or folders";
             readonly hidden: false;
         }, {
             readonly flags: "--dry-run";
@@ -4813,9 +4813,12 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }, {
             readonly flags: "--args <json>";
-            readonly description: "Tool arguments as JSON";
+            readonly description: "Tool arguments as a JSON object (default {}); use - to read the JSON from stdin";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--args-file <path>";
+            readonly description: "Read tool arguments from a JSON file (use - for stdin); avoids shell quoting of apostrophes and parentheses";
             readonly hidden: false;
-            readonly defaultValue: "{}";
         }, {
             readonly flags: "--idempotency-key <key>";
             readonly description: "Stable key so retries execute at most once (default: generated)";
@@ -5492,6 +5495,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "How many events to show";
             readonly hidden: false;
             readonly defaultValue: "20";
+        }, {
+            readonly flags: "--since <iso>";
+            readonly description: "Only events at or after this ISO timestamp, e.g. 2026-10-01T00:00:00Z";
+            readonly hidden: false;
         }, {
             readonly flags: "--json";
             readonly description: "Machine-readable output";
@@ -10581,6 +10588,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly flags: "--force";
             readonly description: "Override another holder's assignment";
             readonly hidden: false;
+        }, {
+            readonly flags: "--no-ensure";
+            readonly description: "Do not register the project from its local prd.json when the story is not on the Board";
+            readonly hidden: false;
         }, {
             readonly flags: "--company <slug|uid>";
             readonly description: "Company slug or cloud uid";
@@ -14985,7 +14996,7 @@ export declare const COMMAND_CATALOG: readonly [{
     }, {
         readonly name: "stop";
         readonly description: "Cancel a queued lane or kill a running one (terminal; use interrupt to keep it resumable)";
-        readonly aliases: readonly [];
+        readonly aliases: readonly ["cancel"];
         readonly hidden: false;
         readonly helpOption: true;
         readonly helpCommand: false;

package/dist/command-catalog.generated.js

@@ -3912,7 +3912,7 @@ export const COMMAND_CATALOG = [
             },
             {
                 "name": "offload",
-                "description": "Move big files to your personal HQ cloud storage and leave links behind (old versions in history; idle current files)",
+                "description": "Move big files to HQ cloud storage and leave links behind (old versions in history; with --current, idle working files to the vault that owns them)",
                 "aliases": [],
                 "hidden": false,
                 "helpOption": true,
@@ -3938,8 +3938,8 @@ export const COMMAND_CATALOG = [
                         "hidden": false
                     },
                     {
-                        "flags": "--current",
-                        "description": "Only idle files in the working tree",
+                        "flags": "--current [paths...]",
+                        "description": "Idle working files instead of history; optional HQ paths limit it to those files or folders",
                         "hidden": false
                     },
                     {
@@ -5820,9 +5820,13 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--args <json>",
-                        "description": "Tool arguments as JSON",
-                        "hidden": false,
-                        "defaultValue": "{}"
+                        "description": "Tool arguments as a JSON object (default {}); use - to read the JSON from stdin",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--args-file <path>",
+                        "description": "Read tool arguments from a JSON file (use - for stdin); avoids shell quoting of apostrophes and parentheses",
+                        "hidden": false
                     },
                     {
                         "flags": "--idempotency-key <key>",
@@ -6667,6 +6671,11 @@ export const COMMAND_CATALOG = [
                         "hidden": false,
                         "defaultValue": "20"
                     },
+                    {
+                        "flags": "--since <iso>",
+                        "description": "Only events at or after this ISO timestamp, e.g. 2026-10-01T00:00:00Z",
+                        "hidden": false
+                    },
                     {
                         "flags": "--json",
                         "description": "Machine-readable output",
@@ -12821,6 +12830,11 @@ export const COMMAND_CATALOG = [
                         "description": "Override another holder's assignment",
                         "hidden": false
                     },
+                    {
+                        "flags": "--no-ensure",
+                        "description": "Do not register the project from its local prd.json when the story is not on the Board",
+                        "hidden": false
+                    },
                     {
                         "flags": "--company <slug|uid>",
                         "description": "Company slug or cloud uid",
@@ -18231,7 +18245,9 @@ export const COMMAND_CATALOG = [
             {
                 "name": "stop",
                 "description": "Cancel a queued lane or kill a running one (terminal; use interrupt to keep it resumable)",
-                "aliases": [],
+                "aliases": [
+                    "cancel"
+                ],
                 "hidden": false,
                 "helpOption": true,
                 "helpCommand": false,

package/dist/commands/core-checkpoint-native.d.ts

@@ -13,6 +13,14 @@ import { Command } from "commander";
  * transient failure (a DNS blip, a brief outage) must not pin the choice.
  */
 export declare const CRASHED_RUN_MAX_AGE_MS: number;
+/**
+ * After `--backend auto` finds no allowed backend, later checkpoints skip the
+ * PATH scan and `--version` probes for this long, unless PATH changes. Each
+ * probe is a child process, and on Windows each one could open a console
+ * window; a Stop hook that checkpoints every turn re-ran them every minute or
+ * two, all day, to reach the same answer (feedback_351a40d5).
+ */
+export declare const NO_BACKEND_RETRY_MS: number;
 /**
  * Wall-clock cap on one sibling run. The supervisor kills the sibling and its
  * descendants at this point. It stays under the lock TTL so a capped run
@@ -89,6 +97,8 @@ export declare function autoBackendPreference(preferGrok?: boolean): SpawnableBa
  * registry; a flag change takes effect from the checkpoint after the next plan.
  */
 export declare function companyPrefersGrok(liveRoot: string, companySlug: string | null | undefined): Promise<boolean>;
+/** True while a recent "no allowed backend" result still holds for this PATH. */
+export declare function noBackendRecentlyFound(liveRoot: string, now?: number): boolean;
 export declare function siblingArgs(backend: SpawnableBackend, prompt: string): string[];
 /**
  * Supervisor for a detached sibling on POSIX. It forks the backend, records

package/dist/commands/core-checkpoint-native.js

@@ -8,11 +8,12 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { execFileSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { toHqStateWriteError } from "../utils/hq-state-write-error.js";
 import { checkpointStampWriteErrorFor, isCheckpointStampWriteError, } from "../utils/checkpoint-stamp-write-error.js";
+import { isExecutableOnPath } from "../utils/resolve-executable.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
 const DEFAULT_TRIGGER = "stop-gate";
 const BACKENDS = new Set(["auto", "claude", "codex", "grok", "none"]);
@@ -73,6 +74,14 @@ const BACKEND_SETTING = "HQ_CHECKPOINT_BACKEND";
 export const CRASHED_RUN_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 /** A backend that cannot answer `--version` this fast is treated as broken. */
 const BACKEND_PROBE_TIMEOUT_MS = 10_000;
+/**
+ * After `--backend auto` finds no allowed backend, later checkpoints skip the
+ * PATH scan and `--version` probes for this long, unless PATH changes. Each
+ * probe is a child process, and on Windows each one could open a console
+ * window; a Stop hook that checkpoints every turn re-ran them every minute or
+ * two, all day, to reach the same answer (feedback_351a40d5).
+ */
+export const NO_BACKEND_RETRY_MS = 6 * 60 * 60 * 1000;
 /** A sibling still holding the lock after this long is treated as abandoned. */
 const SIBLING_LOCK_TTL_MS = 60 * 60 * 1000;
 /**
@@ -392,6 +401,7 @@ function readGitState(repoDir) {
         const read = (args) => execFileSync("git", ["-C", repoDir, ...args], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
         }).trim();
         if (read(["rev-parse", "--is-inside-work-tree"]) !== "true")
             return null;
@@ -415,7 +425,7 @@ function readGitState(repoDir) {
 }
 function commitsSince(repoDir, initialCommit) {
     try {
-        const output = execFileSync("git", ["-C", repoDir, "log", "--no-decorate", "--pretty=format:%h: %s", `${initialCommit}..HEAD`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const output = execFileSync("git", ["-C", repoDir, "log", "--no-decorate", "--pretty=format:%h: %s", `${initialCommit}..HEAD`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
         return output ? output.split("\n") : [];
     }
     catch {
@@ -590,17 +600,8 @@ function backendOnPath(name) {
     const pathValue = process.env.PATH;
     if (!pathValue)
         return false;
-    return pathValue.split(path.delimiter).some((directory) => {
-        if (!directory)
-            return false;
-        try {
-            fs.accessSync(path.join(directory, name), fs.constants.X_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    });
+    // PATHEXT-aware on Windows, where the binary is claude.exe, not claude.
+    return isExecutableOnPath(name, pathValue);
 }
 /**
  * An installed binary is not necessarily a working one: a partial install, a
@@ -613,6 +614,7 @@ function backendResponds(name) {
         execFileSync(name, ["--version"], {
             timeout: BACKEND_PROBE_TIMEOUT_MS,
             stdio: "ignore",
+            windowsHide: true,
         });
         return true;
     }
@@ -835,7 +837,43 @@ function backendSetting(liveRoot) {
     const lookup = settingsEnvValue(liveRoot, BACKEND_SETTING);
     return lookup.kind === "value" ? lookup.value.trim().toLowerCase() || undefined : undefined;
 }
-async function resolveBackend(requested, liveRoot, company) {
+function noBackendMarkerPath(liveRoot) {
+    return path.join(liveRoot, "workspace", "orchestrator", "hook-state", "checkpoint-no-backend.json");
+}
+function pathFingerprint() {
+    return createHash("sha256").update(process.env.PATH ?? "").digest("hex").slice(0, 16);
+}
+/** True while a recent "no allowed backend" result still holds for this PATH. */
+export function noBackendRecentlyFound(liveRoot, now = Date.now()) {
+    try {
+        const marker = JSON.parse(fs.readFileSync(noBackendMarkerPath(liveRoot), "utf8"));
+        if (typeof marker.at !== "number" || marker.path !== pathFingerprint())
+            return false;
+        return now - marker.at >= 0 && now - marker.at < NO_BACKEND_RETRY_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function recordNoBackend(liveRoot, now = Date.now()) {
+    try {
+        const marker = noBackendMarkerPath(liveRoot);
+        fs.mkdirSync(path.dirname(marker), { recursive: true });
+        fs.writeFileSync(marker, `${JSON.stringify({ at: now, path: pathFingerprint() })}\n`);
+    }
+    catch {
+        // Best effort: without the marker the next checkpoint probes again.
+    }
+}
+function clearNoBackend(liveRoot) {
+    try {
+        fs.rmSync(noBackendMarkerPath(liveRoot), { force: true });
+    }
+    catch {
+        // Best effort.
+    }
+}
+async function resolveBackend(requested, liveRoot, company, options = {}) {
     let value = assertKnownBackend(requested);
     if (value === "auto") {
         const setting = backendSetting(liveRoot);
@@ -849,12 +887,19 @@ async function resolveBackend(requested, liveRoot, company) {
     // An explicitly named backend is honoured as given; only `auto` shops around.
     if (value !== "auto")
         return value;
+    // A recent identical miss: skip the probes rather than spawn them again.
+    if (noBackendRecentlyFound(liveRoot))
+        return "none";
     const available = autoBackendPreference(await companyPrefersGrok(liveRoot, company)).filter((name) => backendOnPath(name) && backendResponds(name));
     if (available.length === 0) {
         printError("checkpoint: sibling skipped: no allowed backend available (claude, grok); " +
             `codex runs only with --backend codex or ${BACKEND_SETTING}=codex`);
+        if (!options.dryRun)
+            recordNoBackend(liveRoot);
         return "none";
     }
+    if (!options.dryRun)
+        clearNoBackend(liveRoot);
     const crashed = crashedBackends(path.join(liveRoot, "workspace", "checkpoints", "sibling"));
     // If every candidate failed last time, still try the preferred one: a stale
     // failure is a weaker signal than running no maintenance sibling at all.
@@ -1255,7 +1300,7 @@ async function runCheckpoint(options, command, group, preResolvedHqRoot) {
     const siblingOptOut = options.agent === false || !siblingEnabledBySetting(liveRoot);
     // Validated even when nothing will spawn, so `--backend bogus` is still an error.
     const requestedBackend = assertKnownBackend(options.backend);
-    const backend = siblingOptOut ? "none" : await resolveBackend(requestedBackend, liveRoot, input.company);
+    const backend = siblingOptOut ? "none" : await resolveBackend(requestedBackend, liveRoot, input.company, { dryRun: options.dryRun });
     const now = new Date();
     const threadId = `T-${formatTimestamp(now)}-auto-${summarySlug(input.summary)}`;
     const threadPath = path.join(liveRoot, "workspace", "threads", `${threadId}.json`);

package/dist/commands/daemon.js

@@ -112,7 +112,9 @@ async function loadDefaults(over) {
         err: over.err ?? ((l) => console.error(l)),
         run,
         nodeBinary: over.nodeBinary ?? mesh.resolveAbsoluteNodeBinary(),
-        hqBinary: over.hqBinary ?? mesh.resolveHqBinary(),
+        // `node <hqBinary>` runs the task and every child service, so on Windows
+        // this must be the package's JS entry rather than the npm hq.cmd shim.
+        hqBinary: over.hqBinary ?? mesh.nodeRunnableHqEntry(mesh.resolveHqBinary(), platform),
         uid: over.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0),
         isRoot: over.isRoot ?? (typeof process.getuid === "function" && process.getuid() === 0),
         fileExists: over.fileExists ?? fs.existsSync,

package/dist/commands/integrations-core.d.ts

@@ -224,6 +224,28 @@ export declare function toolPrefixForProvider(provider: string): string;
  * projection over it.
  */
 export declare function fetchAdminSurface(token: string, companyUid: string): Promise<AdminSurface>;
+/** One page of the company's integration audit feed. */
+export interface AuditPage {
+    /**
+     * True when the server answered the paged audit view. False means an older
+     * server ignored `view=audit` and returned the full admin surface, whose
+     * audit feed is capped at the latest 50 events and has no cursor.
+     */
+    paged: boolean;
+    audit: AdminAuditEvent[];
+    nextCursor?: string;
+}
+/** Most rows the paged audit view returns per request. */
+export declare const AUDIT_PAGE_MAX = 100;
+/**
+ * Read one page of the audit feed via the admin route's paged view
+ * (`view=audit&limit=&cursor=`), newest first. Falls back to the surface's
+ * capped feed when the server does not know the view.
+ */
+export declare function fetchAuditPage(token: string, companyUid: string, opts: {
+    limit: number;
+    cursor?: string;
+}): Promise<AuditPage>;
 export declare function fetchConnections(token: string, companyUid: string): Promise<AdminConnection[]>;
 /**
  * One app the caller can use right now through the HQ gateway. Field names

package/dist/commands/integrations-core.js

@@ -352,6 +352,31 @@ export async function fetchAdminSurface(token, companyUid) {
         audit: data.audit ?? [],
     };
 }
+/** Most rows the paged audit view returns per request. */
+export const AUDIT_PAGE_MAX = 100;
+/**
+ * Read one page of the audit feed via the admin route's paged view
+ * (`view=audit&limit=&cursor=`), newest first. Falls back to the surface's
+ * capped feed when the server does not know the view.
+ */
+export async function fetchAuditPage(token, companyUid, opts) {
+    const limit = Math.max(1, Math.min(AUDIT_PAGE_MAX, Math.floor(opts.limit)));
+    const query = { companyUid, view: "audit", limit: String(limit) };
+    if (opts.cursor)
+        query.cursor = opts.cursor;
+    const res = await vaultApiFetch({ token, path: "/v1/integrations/admin", query });
+    if (!res.ok)
+        await raiseForResponse(res, "Failed to read integration activity");
+    const data = (await res.json());
+    const audit = Array.isArray(data.audit) ? data.audit : [];
+    if (data.view !== "audit")
+        return { paged: false, audit };
+    return {
+        paged: true,
+        audit,
+        ...(typeof data.nextCursor === "string" && data.nextCursor ? { nextCursor: data.nextCursor } : {}),
+    };
+}
 export async function fetchConnections(token, companyUid) {
     return (await fetchAdminSurface(token, companyUid)).connections;
 }

package/dist/commands/integrations-manage.d.ts

@@ -13,7 +13,7 @@
  *           and layered under the connection's write policy.
  */
 import { Command } from "commander";
-import { type GranteeType, type Permission, type WriteAllowlistGrant } from "./integrations-core.js";
+import { type AdminAuditEvent, type GranteeType, type Permission, type WriteAllowlistGrant } from "./integrations-core.js";
 interface Principal {
     granteeType: GranteeType;
     granteeId?: string;
@@ -46,5 +46,28 @@ export declare function mergeGrant(current: WriteAllowlistGrant[], toolName: str
  * dropped entirely rather than persisted as an empty rule.
  */
 export declare function removeGrant(current: WriteAllowlistGrant[], toolName: string, principal: Principal): WriteAllowlistGrant[] | null;
+/** Upper bound on audit pages one `hq integrations audit` run reads. */
+export declare const AUDIT_MAX_PAGES = 200;
+export interface CollectedAudit {
+    rows: AdminAuditEvent[];
+    /** False when the server only returned its capped surface feed. */
+    paged: boolean;
+    /** Rows in the surface feed (fallback path only), before filtering. */
+    feedSize: number;
+    /** More matching rows may exist past what was collected. */
+    more: boolean;
+    pageCapHit: boolean;
+}
+/**
+ * Page the audit feed (newest first) until `limit` rows match, the cursor runs
+ * out, a row is older than `sinceMs`, or AUDIT_MAX_PAGES pages were read.
+ * `provider` is matched client-side on the bare slug, so the qualified
+ * `factory:linear` form copied from JSON output matches bare stored rows.
+ */
+export declare function collectAuditRows(token: string, companyUid: string, opts: {
+    limit: number;
+    provider?: string;
+    sinceMs?: number;
+}): Promise<CollectedAudit>;
 export {};
 //# sourceMappingURL=integrations-manage.d.ts.map