@indigoai-us/hq-cli 5.345.74 → 5.345.76

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [5.345.76] — 2026-10-10
+
+- `hq bot` on macOS now finds the Codex CLI bundled in the ChatGPT or Codex
+  desktop app when `codex` is not on PATH, so a Mac with only the desktop app
+  can run a Codex assistant. PATH still wins.
+
+- `hq bot create --display-name` now accepts numbers after the first letter,
+  so names like "R2D2" or "StefanTest123" work.
+- Core delegate native commands now use the default-on kill-switch behavior when the flag snapshot or company context is unavailable. An explicit `core-native-delegate=false` override still selects the bundled shell.
+- `hq core rebuild-index companies` now renders the same company INDEX.md on every machine and every day, and skips the write
+  when the content is unchanged (logged as `unchanged`). The header line is now `> Auto-generated.` with no date. The `repos/`
+  and `data/` rows show fixed labels instead of local counts, `knowledge/` always shows a subdirectory count, symlinked
+  children are no longer counted, and project status comes from prd.json only, not local orchestrator state.
+- `hq lanes monitor-check` now recognizes a live `hq lanes watch` Monitor process when the hq
+  CLI is installed under a path containing spaces (for example the desktop toolchain under
+  `~/Library/Application Support/Indigo HQ/`). Previously those lanes stayed "uncovered" and the
+  Stop hook kept blocking the session.
+## [5.345.75] — 2026-10-10
+
+- Native delegate manifest updates now use mode 0600 on POSIX, matching the
+  shell commands and preventing the manifest from becoming readable by other
+  local users.
+- Lane lifecycle delivery, worker continuity, status-row fields, and operator-requested orphan stopping now stay enabled when their hq-flags registry rows are missing or unavailable.
+- `hq uninstall --global --runtime codex` is now idempotent: on a machine with
+  no global Codex installation it reports that there is nothing to remove and
+  exits successfully.
+- Delegate send now stops before DM delivery and reports the shell-compatible
+  error when saving the `sending` state fails.
+
 ## [5.345.74] — 2026-10-10
 
 - Lane envelope repair prompts now identify parser locations and schema fields,

package/assets/scaffold/core/scripts/hq-delegate-pickup.sh

@@ -59,9 +59,13 @@ case "$STATUS" in
 esac
 
 record_pickup() { # <kind> <detail>
-  jq --arg now "$NOW" --arg k "$1" --arg d "$2" \
+  local TMP_MANIFEST
+  TMP_MANIFEST="$(mktemp "${MANIFEST}.tmp.XXXXXX")" || exit 1
+  if ! jq --arg now "$NOW" --arg k "$1" --arg d "$2" \
     '.status = "picked-up" | .pickedUpAt = $now | .pickup = {kind: $k, detail: $d, recordedAt: $now}' \
-    "$MANIFEST" > "$MANIFEST.tmp" && mv "$MANIFEST.tmp" "$MANIFEST"
+    "$MANIFEST" > "$TMP_MANIFEST" || ! mv "$TMP_MANIFEST" "$MANIFEST"; then
+    rm -f "$TMP_MANIFEST"
+  fi
   echo "hq-delegate-pickup: $NAME picked up the delegation ($1) — status advanced to 'picked-up'"
   exit 0
 }
@@ -93,7 +97,10 @@ if [ "$age_h" -lt "$WINDOW" ]; then
   exit 6
 fi
 reason="no pickup evidence from $NAME within ${WINDOW}h of send (${SENT_AT:-unknown}): no acknowledgement, no commit by $TO on ${BRANCH:-the branch}"
-jq --arg now "$NOW" --arg r "$reason" '.status = "failed" | .failedAt = $now | .failure = {reason: $r, recordedAt: $now}' \
-  "$MANIFEST" > "$MANIFEST.tmp" && mv "$MANIFEST.tmp" "$MANIFEST"
+TMP_MANIFEST="$(mktemp "${MANIFEST}.tmp.XXXXXX")" || exit 1
+if ! jq --arg now "$NOW" --arg r "$reason" '.status = "failed" | .failedAt = $now | .failure = {reason: $r, recordedAt: $now}' \
+  "$MANIFEST" > "$TMP_MANIFEST" || ! mv "$TMP_MANIFEST" "$MANIFEST"; then
+  rm -f "$TMP_MANIFEST"
+fi
 echo "hq-delegate-pickup: FAILED — $reason. Re-send with a direct ask, or hand it to someone else." >&2
 exit 5

package/assets/scaffold/core/scripts/rebuild-companies-index.sh

@@ -2,11 +2,16 @@
 # rebuild-companies-index.sh — regenerate companies/{co}/INDEX.md for each company.
 #
 # Pure bash + jq. Zero Claude context. Iterates companies/*/ (skips _template,
-# dotfiles), summarizes top-level dirs, scans projects/*/prd.json and
-# workspace/orchestrator/{name}/state.json to populate the Projects table.
+# dotfiles), summarizes top-level dirs, scans projects/*/prd.json to populate
+# the Projects table.
+#
+# Output is deterministic: the same synced tree renders the same bytes on every
+# machine and every day. There is no date line, nothing reads local-only state
+# (repos/, data/, an embedded knowledge .git, workspace/orchestrator), and an
+# unchanged file is not rewritten.
 #
 # Schema per knowledge/public/hq-core/index-md-spec.md (Company Root variant):
-#   - "# {Company Title}" + "> Auto-generated. Updated: YYYY-MM-DD"
+#   - "# {Company Title}" + "> Auto-generated."
 #   - Top-level Name | Description table (dirs and 1-line desc)
 #   - "## Projects" table (Project | Status | Description)
 #   - "## Deployments" placeholder (None for now — manifest-driven enrichment deferred)
@@ -28,8 +33,6 @@ done
 HQ_ROOT="${HQ_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
 cd "$HQ_ROOT"
 
-DATE=$(date -u +%Y-%m-%d)
-
 # Title-case a slug: "example-co" -> "Example Co"
 titleize() {
   echo "$1" | awk -F'-' '{
@@ -47,18 +50,13 @@ describe_dir() {
   [[ -d "$path" ]] || return 0
   case "$d" in
     data)
-      local n
-      n=$(find "$path" -mindepth 1 -maxdepth 1 ! -name '.*' 2>/dev/null | wc -l | tr -d ' ')
-      echo "${n} item(s)"
+      echo "Company data"
       ;;
     knowledge)
-      if [[ -e "${path}/.git" ]]; then
-        echo "Embedded git repo"
-      else
-        local n
-        n=$(find "$path" -mindepth 1 -maxdepth 1 -type d ! -name '.*' 2>/dev/null | wc -l | tr -d ' ')
-        echo "Inline knowledge (${n} subdirs)"
-      fi
+      local n
+      # Trailing slash: a symlinked knowledge/ is listed through its target.
+      n=$(find "${path}/" -mindepth 1 -maxdepth 1 -type d ! -name '.*' 2>/dev/null | wc -l | tr -d ' ')
+      echo "Company knowledge (${n} subdirs)"
       ;;
     settings)
       local n
@@ -81,9 +79,7 @@ describe_dir() {
       echo "${n} worker(s)"
       ;;
     repos)
-      local n
-      n=$(find "$path" -mindepth 1 -maxdepth 1 \( -type d -o -type l \) ! -name '.*' 2>/dev/null | wc -l | tr -d ' ')
-      echo "${n} repo link(s)"
+      echo "Local repo links (not synced)"
       ;;
     registry)
       local n
@@ -101,22 +97,10 @@ describe_dir() {
   esac
 }
 
-# Resolve project status: orchestrator state.json wins, else story-pass fallback.
+# Resolve project status from prd.json alone (story-pass check). The local
+# workspace/orchestrator state is not synced, so it is not consulted.
 project_status() {
-  local project="$1"
-  local prd="$2"
-  local state="workspace/orchestrator/${project}/state.json"
-  if [[ -f "$state" ]]; then
-    local raw
-    raw=$(jq -r '.status // "active"' "$state" 2>/dev/null || echo "active")
-    case "$raw" in
-      completed|complete) echo "complete" ;;
-      in_progress|active|started) echo "active" ;;
-      archived) echo "archived" ;;
-      *) echo "$raw" ;;
-    esac
-    return
-  fi
+  local prd="$1"
   if [[ -f "$prd" ]]; then
     local total passes
     total=$(jq '[.userStories[]?] | length' "$prd" 2>/dev/null || echo 0)
@@ -148,6 +132,7 @@ trunc() {
 write_company_index() {
   local co="$1"
   local out="companies/${co}/INDEX.md"
+  local tmp="companies/${co}/.INDEX.md.$$.tmp"
   local title
   title=$(titleize "$co")
 
@@ -155,7 +140,7 @@ write_company_index() {
   {
     echo "# ${title}"
     echo ""
-    echo "> Auto-generated. Updated: ${DATE}"
+    echo "> Auto-generated."
     echo ""
     echo "| Name | Description |"
     echo "|------|-------------|"
@@ -187,7 +172,7 @@ write_company_index() {
           desc=$(jq -r '.description // ""' "$prd" 2>/dev/null || echo "")
         fi
         local status
-        status=$(project_status "$name" "$prd")
+        status=$(project_status "$prd")
         desc=$(sanitize_cell "$desc")
         desc=$(trunc "$desc" 110)
         [[ -z "$desc" ]] && desc="—"
@@ -201,9 +186,17 @@ write_company_index() {
     echo "## Deployments"
     echo ""
     echo "_See \`companies/manifest.yaml\` for deployment targets._"
-  } > "$out"
+  } > "$tmp"
 
-  echo "rebuild-companies-index: wrote ${out}" >&2
+  # Rewrite only when the content changed, so an unchanged index keeps its
+  # mtime and is not re-uploaded by HQ Sync.
+  if [[ -f "$out" ]] && cmp -s "$tmp" "$out"; then
+    rm -f "$tmp"
+    echo "rebuild-companies-index: unchanged ${out}" >&2
+  else
+    mv -f "$tmp" "$out"
+    echo "rebuild-companies-index: wrote ${out}" >&2
+  fi
 }
 
 COUNT=0

package/dist/commands/core-delegate-w1b.js

@@ -174,6 +174,23 @@ function parseFlags(args, allowed) {
 }
 function usage(name) { return USAGE[name] ?? ""; }
 function usageFailure(name) { err(usage(name)); return 1; }
+function grantHasDanglingManifestFlag(args) {
+    for (let i = 0; i < args.length;) {
+        const key = args[i] ?? "";
+        if (key === "--yes") {
+            i += 1;
+            continue;
+        }
+        if (key === "--manifest") {
+            if (i + 1 >= args.length)
+                return true;
+            i += 2;
+            continue;
+        }
+        return false;
+    }
+    return false;
+}
 function bashPath(value) {
     if (process.platform !== "win32")
         return value;
@@ -205,6 +222,10 @@ function runBundle(args, context, onMalformedWhoami) {
     const root = context.root ?? context.cwd;
     if (args[0] !== "build")
         return usageFailure("bundle");
+    // The shell uses `shift 2` for these options. With no value at end of argv,
+    // Bash exits nonzero before it reaches the required-field diagnostics.
+    if (["--company", "--project", "--to", "--to-kind", "--to-name", "--mode"].includes(args.at(-1) ?? ""))
+        return 1;
     const parsed = parseFlags(args.slice(1), ["--company", "--project", "--to", "--to-kind", "--to-name", "--mode", "--dry-run"]);
     if (parsed.help) {
         out(usage("bundle"));
@@ -326,7 +347,7 @@ function runBundle(args, context, onMalformedWhoami) {
     const next = stories.filter((story) => !isRecord(story) || story.passes !== true)
         .sort((a, b) => Number(getPath(a, "priority", 0)) - Number(getPath(b, "priority", 0))).slice(0, 3);
     const doneList = done.map((story) => `- ${text(getPath(story, "id"))}: ${text(getPath(story, "title"))}`).join("\n");
-    const nextList = next.map((story) => `### ${text(getPath(story, "id"))}: ${text(getPath(story, "title"))}\n\n${text(getPath(story, "description"))}\n`).join("\n");
+    const nextList = next.map((story) => `### ${text(getPath(story, "id"))}: ${text(getPath(story, "title"))}\n\n${text(getPath(story, "description"))}\n`).join("\n").replace(/\n+$/, "");
     const questions = list(getPath(prd, "metadata.openQuestions", [])).map((entry) => `- ${text(entry)}`).join("\n");
     const traps = [
         ...list(getPath(prd, "metadata.securityNotes", [])),
@@ -410,6 +431,10 @@ const ACL_FILTER = `
     (.direct | type == "array") and (.exists | type == "boolean")
   `;
 function runGrant(args, context) {
+    // The shell companion's `shift 2` runs under `set -e`; a final bare
+    // --manifest exits 1 without diagnostics. Preserve that observable contract.
+    if (grantHasDanglingManifestFlag(args))
+        return 1;
     const parsed = parseFlags(args, ["--manifest", "--yes"]);
     if (parsed.help) {
         out(usage("grant"));
@@ -618,10 +643,14 @@ function runGrant(args, context) {
     out(`hq-delegate-grant: all ${prefixes.length} grants verified — manifest status advanced to 'granted'\n`);
     return 0;
 }
-function atomicCopy(source, target) {
+function atomicCopy(source, target, mode) {
     const temporary = `${target}.tmp.${process.pid}.${Math.random().toString(16).slice(2)}`;
     try {
-        fs.copyFileSync(source, temporary);
+        const contents = fs.readFileSync(source);
+        if (mode === undefined)
+            fs.writeFileSync(temporary, contents, { flag: "wx" });
+        else
+            fs.writeFileSync(temporary, contents, { flag: "wx", mode });
         moveFile(temporary, target);
     }
     catch (error) {
@@ -745,9 +774,9 @@ function runPublish(args, context) {
         if (shareSession.test(fs.readFileSync(stagedManifest, "utf8")) || shareSession.test(fs.readFileSync(stagedBrief, "utf8")))
             return fail("publish", "share-session capability in dossier; nothing published");
         fs.mkdirSync(dest, { recursive: true });
-        atomicCopy(stagedBrief, path.join(dest, "BRIEF.md"));
-        atomicCopy(stagedManifest, path.join(dest, "manifest.json"));
-        atomicCopy(stagedManifest, manifestPath);
+        atomicCopy(stagedBrief, path.join(dest, "BRIEF.md"), 0o600);
+        atomicCopy(stagedManifest, path.join(dest, "manifest.json"), 0o600);
+        atomicCopy(stagedManifest, manifestPath, 0o600);
         const push = runHq(["sync", "push", `${relative}/`, "--company", company, "--on-conflict", "keep"], context, "inherit");
         if (push.code !== 0)
             return fail("publish", "final dossier push failed; resume publication");
@@ -775,7 +804,7 @@ function runPublish(args, context) {
         const publication = { verifiedAt: currentTime(), manifestPath: `${relative}/delegation/${id}/manifest.json`, files: receipts };
         const updated = { ...canonical, publication, recipientAccess: "unconfirmed" };
         fs.writeFileSync(stagedManifest, jsonText(updated));
-        atomicCopy(stagedManifest, manifestPath);
+        atomicCopy(stagedManifest, manifestPath, 0o600);
         out("hq-delegate-publish: canonical dossier bytes verified as sender; recipient access unconfirmed\n");
         return 0;
     }
@@ -794,6 +823,10 @@ function sortedJson(value) {
     return serializeJqJson(sort(value), "compact").replace(/\n+$/, "");
 }
 function runSend(args, context) {
+    // The shell shifts two arguments for value options. Under `set -e`, a
+    // trailing option without its value exits 1 before printing diagnostics.
+    if (["--manifest", "--headline", "--note"].includes(args.at(-1) ?? ""))
+        return 1;
     const parsed = parseFlags(args, ["--manifest", "--send", "--headline", "--note"]);
     if (parsed.help) {
         out(usage("send"));
@@ -884,7 +917,7 @@ function runSend(args, context) {
             const access = jqRawPath(manifest, "repo.accessNote");
             const branchCheck = branch ? subprocess("git", ["check-ref-format", "--branch", branch], context.cwd, { stdout: "ignore", stderr: "ignore" }) : { code: 1 };
             if (branch && branchCheck.code === 0 && sha) {
-                repoSection = `## Get the code\n\nThe work lives on branch \`${branch}\` (base: \`${base}\`) at \`${sha}\`.\n\n\`\`\`bash\n# From your HQ root; clone first if the repo is not present${remote ? ` (remote: ${remote})` : ""}:\ngit -C ${quoteBash(repoPath)} fetch origin\ngit -C ${quoteBash(repoPath)} switch -- ${quoteBash(branch)}\n\`\`\`${access ? `\n\n> ${access}` : ""}`;
+                repoSection = `## Get the code\n\nThe work lives on branch \`${branch}\` (base: \`${base}\`) at \`${sha}\`.\n\n\`\`\`bash\n# From your HQ root; clone first if the repo is not present${remote ? ` (remote: ${remote})` : ""}:\ngit -C ${quoteBash(repoPath)} fetch origin\ngit -C ${quoteBash(repoPath)} switch -- ${quoteBash(branch)}\n\`\`\`${access ? `\n\n> ${access}` : "\n"}`;
             }
         }
         const secretNames = list(getPath(manifest, "secrets", [])).map((entry) => text(entry)).join(",");
@@ -906,7 +939,7 @@ function runSend(args, context) {
         if (repoSection)
             body += `${repoSection}\n\n`;
         if (secretsSection)
-            body += `${secretsSection}\n`;
+            body += `${secretsSection}\n\n`;
         if (nextSteps)
             body += `## Your next three steps\n\n${nextSteps}\n\n`;
         body += `## If something is off\n\nThe manifest and BRIEF.md are published under \`delegation/${delegationId}/\` within \`companies/${company}/projects/${project}/\`. If a pull fails or a path looks empty, report it to ${from}.\n`;
@@ -956,7 +989,12 @@ function runSend(args, context) {
         if (checksum(brief) !== checksum(path.join(path.dirname(publishedManifestPath), "BRIEF.md")))
             return fail("send", "brief changed since publication; run verification again");
         manifest.status = "sending";
-        writeJsonAtomically(manifestPath, manifest, true);
+        try {
+            writeJsonAtomically(manifestPath, manifest, true, context.atomicWriteFileSystem);
+        }
+        catch {
+            return fail("send", "could not persist sending state; no DM attempted");
+        }
         const dm = runHq(["dm", principal, headline, "--prompt-file", prompt, "--details-file", brief], context);
         if (dm.code !== 0)
             return fail("send", "hq dm delivery outcome is uncertain; status is sending, inspect DM history before retrying");
@@ -994,6 +1032,10 @@ function captureRun(run) {
     }
 }
 function runVerify(args, context) {
+    // The shell shifts a value-taking option and its value under `set -e`.
+    // A trailing option therefore exits 1 before any diagnostic is printed.
+    if (["--manifest", "--company", "--project", "--to", "--mode"].includes(args.at(-1) ?? ""))
+        return 1;
     const parsed = parseFlags(args, ["--manifest", "--dry-run", "--company", "--project", "--to", "--mode"]);
     if (parsed.help) {
         out(usage("verify"));
@@ -1051,7 +1093,7 @@ function runVerify(args, context) {
         out(`  Recipient:  ${recipient}\n  Mode:       ${mode}\n  Company:    ${company}\n  Project:    ${project}\n\n`);
         out("  Vault grants that would be written:\n");
         for (const entry of list(getPath(manifest, "vaultPrefixes", [])))
-            out(`    ${jqRawPath(entry, "permission")}\t on ${jqRawPath(entry, "prefix")}\t(${jqRawPath(entry, "reason")})\n`);
+            out(`    ${jqRawPath(entry, "permission")}\ton ${jqRawPath(entry, "prefix")}\t(${jqRawPath(entry, "reason")})\n`);
         out(`\n  Secret names that would be granted (read): ${secretNames}\n\n`);
         const repoValue = getPath(manifest, "repo");
         if (repoValue !== null && repoValue !== undefined)

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

@@ -1,11 +1,14 @@
 /** Native implementations of the five `hq core delegate` shell companions. */
+import * as fs from "node:fs";
 import { Command } from "commander";
 import { type SpawnPlan } from "../utils/windows-spawn.js";
 export declare const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
 export type DelegateContext = {
     cwd: string;
     root?: string;
+    atomicWriteFileSystem?: DelegateAtomicWriteFileSystem;
 };
+export type DelegateAtomicWriteFileSystem = Pick<typeof fs, "openSync" | "writeFileSync" | "closeSync" | "renameSync" | "copyFileSync" | "unlinkSync" | "rmSync">;
 type CommandResult = {
     code: number;
     stdout?: string;
@@ -38,8 +41,8 @@ export declare function rawJsonValue(value: unknown): string;
 export declare function jqRawPath(value: unknown, dottedPath: string, fallback?: unknown): string;
 export declare function jqRawPaths(value: unknown, dottedPaths: string[], fallback?: unknown): string;
 export declare function requireRecord(value: unknown, property: string): JsonRecord;
-export declare function moveFile(source: string, target: string): void;
-export declare function writeJsonAtomically(target: string, value: unknown, siblingTemp?: boolean): void;
+export declare function moveFile(source: string, target: string, fileSystem?: Pick<DelegateAtomicWriteFileSystem, "renameSync" | "copyFileSync" | "unlinkSync">): void;
+export declare function writeJsonAtomically(target: string, value: unknown, siblingTemp?: boolean, fileSystem?: DelegateAtomicWriteFileSystem): void;
 export declare function delegateDiagnosticPath(argument: string): string;
 export declare function scanSecretFiles(file: string): string[] | undefined;
 /** Fast-entry adapter; family gating and shell fallback happen before import. */

package/dist/commands/core-delegate.js

@@ -1,5 +1,6 @@
 /** Native implementations of the five `hq core delegate` shell companions. */
 import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -174,25 +175,59 @@ export function requireRecord(value, property) {
         throw new TypeError(`Cannot update non-object field ${property}`);
     return result;
 }
-export function moveFile(source, target) {
+export function moveFile(source, target, fileSystem = fs) {
     try {
-        fs.renameSync(source, target);
+        fileSystem.renameSync(source, target);
     }
     catch (error) {
         if (error.code !== "EXDEV")
             throw error;
         // The shell companion uses `mv`, which copies across filesystem boundaries.
-        fs.copyFileSync(source, target);
-        fs.unlinkSync(source);
+        fileSystem.copyFileSync(source, target);
+        fileSystem.unlinkSync(source);
     }
 }
-export function writeJsonAtomically(target, value, siblingTemp = false) {
+export function writeJsonAtomically(target, value, siblingTemp = false, fileSystem = fs) {
     const serialized = serializeJqJson(value, "pretty");
     // Native delegate JSON writers use LF on every platform.
     if (siblingTemp) {
-        const temporary = `${target}.tmp`;
-        fs.writeFileSync(temporary, serialized);
-        moveFile(temporary, target);
+        const temporary = `${target}.tmp.${randomBytes(6).toString("hex")}`;
+        let fd;
+        let descriptorOpen = false;
+        let temporaryCreated = false;
+        try {
+            fd = fileSystem.openSync(temporary, "wx", 0o600);
+            descriptorOpen = true;
+            temporaryCreated = true;
+            fileSystem.writeFileSync(fd, serialized);
+            fileSystem.closeSync(fd);
+            descriptorOpen = false;
+            moveFile(temporary, target, fileSystem);
+        }
+        catch (error) {
+            const failures = [error];
+            if (descriptorOpen && fd !== undefined) {
+                try {
+                    fileSystem.closeSync(fd);
+                    descriptorOpen = false;
+                }
+                catch (closeError) {
+                    failures.push(closeError);
+                }
+            }
+            if (temporaryCreated) {
+                try {
+                    fileSystem.rmSync(temporary, { force: true });
+                }
+                catch (cleanupError) {
+                    failures.push(cleanupError);
+                }
+            }
+            if (failures.length > 1) {
+                throw new AggregateError(failures, "Failed to write and clean up delegate manifest temporary file");
+            }
+            throw error;
+        }
         return;
     }
     const temporaryDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-delegate-"));

package/dist/commands/core-native-family-flag.js

@@ -13,7 +13,7 @@ export async function coreNativeFamilyEnabled(flagKey) {
 export const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
 export const CORE_NATIVE_ONTOLOGY_FLAG = "core-native-ontology";
 export function coreNativeDelegateEnabled() {
-    return import("../lib/flag-registry.js").then(({ resolveProcessFlagGate }) => resolveProcessFlagGate(CORE_NATIVE_DELEGATE_FLAG, { fallback: false }, () => false));
+    return coreNativeFamilyEnabled(CORE_NATIVE_DELEGATE_FLAG);
 }
 export function coreNativeOntologyEnabled() {
     return coreNativeFamilyEnabled(CORE_NATIVE_ONTOLOGY_FLAG);

package/dist/commands/install-global.js

@@ -919,8 +919,10 @@ export function uninstallGlobalCodex(opts = {}) {
     const hqPointer = claudeTargets(home).hqPointer;
     const state = readCodexState(t);
     const hqRoot = state?.hqRoot ?? opts.hqRoot ?? readOrNull(hqPointer)?.trim();
-    if (!hqRoot)
-        throw new Error('No HQ global install found (no install state and no ~/.hq/root).');
+    if (!hqRoot) {
+        log('No HQ global Codex install found; nothing to remove.');
+        return [];
+    }
     const regFile = opts.registryFile ?? registryFile(registryDir(home, env));
     const claudeStillInstalled = fs.existsSync(claudeTargets(home).stateFile);
     const providerBin = path.join(home, '.hq', 'bin');

package/dist/commands/lanes.d.ts

@@ -158,5 +158,6 @@ export declare function pickupFailureUpdater(reasonRaw: string, details: Record<
 export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string, modelDeps?: KnownModelsDeps): LaneRecord;
 export declare function cancelPendingQuestionsForLane(hqRoot: string, laneId: string, nowIso: string, operatorReason?: string): QuestionRecord[];
 export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
+export declare function readLaneReapStopEnabled(hqRoot: string, lane: LaneRecord, env: NodeJS.ProcessEnv): Promise<boolean>;
 export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;
 //# sourceMappingURL=lanes.d.ts.map

package/dist/commands/lanes.js

@@ -3392,7 +3392,7 @@ async function runCreate(ctx, opts) {
     const provider = explicitProvider ??
         profile?.meta.provider ??
         parseLaneProvider("codex");
-    const continuityEnabled = opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env });
+    const continuityEnabled = opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env, defaultValue: true });
     let workerContinuity = continuityEnabled
         ? findWorkerContinuityLane(loadAllLanes(hqRoot), {
             senior,
@@ -5456,6 +5456,7 @@ async function laneStatusFieldsForCommand(ctx, hqRoot, lane, now) {
         enabled = await readLanesRegistryFlagFailOpen(LANE_STATUS_ROW_FIELDS_FLAG, {
             ...(resolved ? { company: resolved } : {}),
             env: ctx.env,
+            defaultValue: true,
         });
     }
     catch (err) {
@@ -9365,6 +9366,16 @@ function attachJsonNoop(cmd) {
     for (const child of cmd.commands)
         attachJsonNoop(child);
 }
+export async function readLaneReapStopEnabled(hqRoot, lane, env) {
+    const resolution = resolveLaneCompany(hqRoot, lane);
+    const company = resolution.company ?? undefined;
+    return readLanesRegistryFlagFailOpen(LANE_REAP_STOP_FLAG, {
+        company,
+        ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+        env,
+        defaultValue: true,
+    });
+}
 export function registerLanesCommand(parent, deps = {}) {
     const ctx = resolveDeps(deps);
     const storyHandlers = createLaneStoryHandlers({
@@ -9566,15 +9577,7 @@ export function registerLanesCommand(parent, deps = {}) {
             presenceConnected: ctx.presenceConnected ?? false,
             deps: ctx.livenessDeps,
         }),
-        stopEnabled: (lane) => {
-            const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
-            const company = resolution.company ?? undefined;
-            return readLanesRegistryFlag(LANE_REAP_STOP_FLAG, {
-                company,
-                ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
-                env: ctx.env,
-            });
-        },
+        stopEnabled: (lane) => readLaneReapStopEnabled(ctx.hqRoot(), lane, ctx.env),
     }, wrap);
     registerLaneDropboxRepairCommand(lanes, {
         hqRoot: ctx.hqRoot,

package/dist/fast-scaffold.d.ts

@@ -50,7 +50,7 @@ export type FastScaffoldScript = {
     requiresNodeNetworkCompatibility?: boolean;
 };
 /** Family kill switches whose owner-approved default is enabled. */
-export declare const CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS: readonly ["core-native-session", "core-native-hook-helpers", "core-native-policy", "core-native-utilities", "core-native-jobs", "core-native-ontology", "core-native-handoff"];
+export declare const CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS: readonly ["core-native-session", "core-native-hook-helpers", "core-native-policy", "core-native-utilities", "core-native-jobs", "core-native-ontology", "core-native-handoff", "core-native-delegate"];
 export declare function isDefaultOnFastFamily(flagKey: string): boolean;
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export declare const FAST_SCAFFOLD_SCRIPTS: readonly FastScaffoldScript[];

package/dist/fast-scaffold.js

@@ -18,6 +18,7 @@ export const CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS = [
     "core-native-jobs",
     "core-native-ontology",
     "core-native-handoff",
+    "core-native-delegate",
 ];
 const defaultOnFamilyFlags = new Set(CORE_NATIVE_DEFAULT_ON_FAMILY_FLAGS);
 export function isDefaultOnFastFamily(flagKey) {

package/dist/lib/bot/config.js

@@ -138,8 +138,10 @@ export function validateBotDisplayName(text) {
             expected: true,
         });
     }
-    if (!/^[\p{L}\p{M}][\p{L}\p{M} .'-]*$/u.test(trimmed)) {
-        throw Object.assign(new Error("--display-name can use letters, spaces, apostrophes, periods and hyphens."), {
+    // A letter first, then letters, numbers, spaces, apostrophes, periods and
+    // hyphens ("R2D2", "Scout 2").
+    if (!/^[\p{L}\p{M}][\p{L}\p{M}\p{N} .'-]*$/u.test(trimmed)) {
+        throw Object.assign(new Error("--display-name can use letters, numbers, spaces, apostrophes, periods and hyphens."), {
             expected: true,
         });
     }

package/dist/lib/bot/runtime/codex.d.ts

@@ -24,5 +24,27 @@ export declare function codexPrompt(input: RuntimeTurnInput): string;
  * warnings (`item.completed` with `item.type === "error"`) are not failures.
  */
 export declare function codexFailureReason(stdout: string): string | undefined;
+/** True when `candidate` is a regular file the current user can execute. */
+export type IsExecutableFile = (candidate: string) => boolean;
+export declare function isExecutableFile(candidate: string): boolean;
+/** App bundles that carry the Codex CLI, in the HQ desktop app's lookup order. */
+export declare const CODEX_APP_BUNDLES: readonly ["ChatGPT.app", "Codex.app"];
+/** Where the CLI sits inside a bundle: current layout first, then the older one. */
+export declare const CODEX_BUNDLE_CLI_PATHS: readonly [string, string];
+/**
+ * The Codex CLI shipped inside the ChatGPT or Codex desktop app. A Mac that
+ * only has the desktop app has no `codex` on PATH, yet the HQ app counts it as
+ * installed, so a bot must be able to use it too. Order matches the HQ desktop
+ * app (apps/sync/src-tauri/src/commands/launch.rs, bundled_codex_bin_in):
+ * /Applications before ~/Applications, ChatGPT.app before Codex.app, and the
+ * codex-cli/bin layout before the older Resources/codex one.
+ */
+export declare function bundledCodexBin(homeDir?: string, isExecutable?: IsExecutableFile): string | null;
+/**
+ * PATH wins. On macOS, fall back to the desktop app's bundled CLI. When
+ * nothing is found the bare name is returned, so the spawn fails with the
+ * usual "codex is not installed or not on PATH" error.
+ */
+export declare function resolveCodexBinary(env: NodeJS.ProcessEnv, homeDir?: string, platform?: NodeJS.Platform, cwd?: string, isExecutable?: IsExecutableFile): string;
 export declare function createCodexRuntime(): BotRuntime;
 //# sourceMappingURL=codex.d.ts.map

package/dist/lib/bot/runtime/codex.js

@@ -13,6 +13,9 @@
  * Verified against Codex CLI on 2026-09-10 (event names; the model itself
  * cannot run under this machine's account).
  */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { parseJsonLine, RuntimeError } from "./types.js";
 import { resolveRuntimeBinary } from "./windows.js";
 /** Progress events in one codex JSONL line: finished agent messages and tool starts. */
@@ -79,11 +82,70 @@ function unwrapApiError(raw) {
     }
     return t;
 }
+export function isExecutableFile(candidate) {
+    try {
+        if (!fs.statSync(candidate).isFile())
+            return false;
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** App bundles that carry the Codex CLI, in the HQ desktop app's lookup order. */
+export const CODEX_APP_BUNDLES = ["ChatGPT.app", "Codex.app"];
+/** Where the CLI sits inside a bundle: current layout first, then the older one. */
+export const CODEX_BUNDLE_CLI_PATHS = [
+    path.join("Contents", "Resources", "codex-cli", "bin", "codex"),
+    path.join("Contents", "Resources", "codex"),
+];
+/**
+ * The Codex CLI shipped inside the ChatGPT or Codex desktop app. A Mac that
+ * only has the desktop app has no `codex` on PATH, yet the HQ app counts it as
+ * installed, so a bot must be able to use it too. Order matches the HQ desktop
+ * app (apps/sync/src-tauri/src/commands/launch.rs, bundled_codex_bin_in):
+ * /Applications before ~/Applications, ChatGPT.app before Codex.app, and the
+ * codex-cli/bin layout before the older Resources/codex one.
+ */
+export function bundledCodexBin(homeDir = os.homedir(), isExecutable = isExecutableFile) {
+    const appDirs = ["/Applications", path.join(homeDir, "Applications")];
+    for (const dir of appDirs) {
+        for (const bundle of CODEX_APP_BUNDLES) {
+            for (const rel of CODEX_BUNDLE_CLI_PATHS) {
+                const candidate = path.join(dir, bundle, rel);
+                if (isExecutable(candidate))
+                    return candidate;
+            }
+        }
+    }
+    return null;
+}
+function codexOnPath(env, isExecutable) {
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (dir && isExecutable(path.join(dir, "codex")))
+            return true;
+    }
+    return false;
+}
+/**
+ * PATH wins. On macOS, fall back to the desktop app's bundled CLI. When
+ * nothing is found the bare name is returned, so the spawn fails with the
+ * usual "codex is not installed or not on PATH" error.
+ */
+export function resolveCodexBinary(env, homeDir, platform = process.platform, cwd = process.cwd(), isExecutable = isExecutableFile) {
+    if (platform === "win32")
+        return resolveRuntimeBinary("codex", env, platform, undefined, cwd);
+    if (platform !== "darwin" || codexOnPath(env, isExecutable))
+        return "codex";
+    // `||`, not `??`: an empty HOME must not turn ~/Applications into a relative path.
+    return bundledCodexBin(homeDir || env.HOME || os.homedir(), isExecutable) ?? "codex";
+}
 export function createCodexRuntime() {
     return {
         id: "codex",
         binary: "codex",
-        resolveBinary: (env, cwd, platform) => resolveRuntimeBinary("codex", env, platform ?? process.platform, undefined, cwd),
+        resolveBinary: (env, cwd, platform) => resolveCodexBinary(env, undefined, platform ?? process.platform, cwd),
         buildArgs(input, scratch) {
             const promptArg = input.platform === "win32" ? "-" : codexPrompt(input);
             const common = ["--json", "--skip-git-repo-check", "-o", scratch.outputFile];

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

@@ -1,26 +1,35 @@
 import * as fs from "fs";
 import * as path from "path";
-import { basename, countImmediate, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, titleize, truncate, write } from "./shared.js";
+import { basename, countImmediate, exists, immediateEntries, isHidden, log, prdProjectStatus, readJson, sanitize, titleize, truncate, writeIfChanged } from "./shared.js";
 export class CompanyIndexUserError extends Error {
     constructor(message) {
         super(message);
         this.name = "CompanyIndexUserError";
     }
 }
+/**
+ * One-line summary for a top-level company directory.
+ *
+ * Output must be identical on every machine that holds the same synced tree,
+ * because company INDEX.md files are synced. So nothing here reads local-only
+ * state: `repos/` (never synced), `data/` (partly synced), whether
+ * `knowledge/` is an embedded git checkout, or symlink targets. Counts use
+ * lstat so a symlinked child is never counted as a directory or file.
+ */
 function description(root, company, name) {
     const base = `companies/${company}/${name}`;
-    const nonHidden = (child) => !isHidden(child);
+    const realDirectory = (n, f) => !isHidden(n) && fs.lstatSync(f).isDirectory();
     switch (name) {
-        case "data": return `${countImmediate(root, base, nonHidden)} item(s)`;
-        case "knowledge": return exists(root, `${base}/.git`) ? "Embedded git repo" : `Inline knowledge (${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} subdirs)`;
-        case "settings": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} integration(s)`;
+        case "data": return "Company data";
+        case "knowledge": return `Company knowledge (${countImmediate(root, base, realDirectory)} subdirs)`;
+        case "settings": return `${countImmediate(root, base, realDirectory)} integration(s)`;
         case "policies": return `${countImmediate(root, base, (n) => n.endsWith(".md"))} policy file(s)`;
         // Match `find -type d`: count actual directories, not symlinks to directories.
-        case "projects": return `${countImmediate(root, base, (n, f) => !n.startsWith("_") && !isHidden(n) && fs.lstatSync(f).isDirectory())} project(s)`;
-        case "workers": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} worker(s)`;
-        case "repos": return `${countImmediate(root, base, (n, f) => { const s = fs.lstatSync(f); return !isHidden(n) && (s.isDirectory() || s.isSymbolicLink()); })} repo link(s)`;
+        case "projects": return `${countImmediate(root, base, (n, f) => !n.startsWith("_") && realDirectory(n, f))} project(s)`;
+        case "workers": return `${countImmediate(root, base, realDirectory)} worker(s)`;
+        case "repos": return "Local repo links (not synced)";
         case "registry": return `Resource registry (${countImmediate(root, `${base}/resources`, (n) => n.endsWith(".yaml"))} resource(s))`;
-        case "scripts": return `${countImmediate(root, base, (_n, f) => fs.statSync(f).isFile())} script(s)`;
+        case "scripts": return `${countImmediate(root, base, (_n, f) => fs.lstatSync(f).isFile())} script(s)`;
         default: return "—";
     }
 }
@@ -56,6 +65,7 @@ export function renderCompanies(context, args = []) {
         }
     }
     const written = [];
+    const unchanged = [];
     let scopedDirectories;
     if (selectedCompany === undefined) {
         scopedDirectories = immediateEntries(context.root, "companies", "dir");
@@ -87,7 +97,9 @@ export function renderCompanies(context, args = []) {
         const company = basename(directory);
         if (company.startsWith("_") || isHidden(company))
             continue;
-        const lines = [`# ${titleize(company)}`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+        // No date line: the file must only change when its content changes. The
+        // `> Auto-generated.` marker stays, since hq-cloud detects generated INDEX.md by it.
+        const lines = [`# ${titleize(company)}`, "", "> Auto-generated.", "", "| Name | Description |", "|------|-------------|"];
         for (const name of ["data", "knowledge", "policies", "projects", "registry", "repos", "scripts", "settings", "workers"]) {
             if (exists(context.root, `companies/${company}/${name}`))
                 lines.push(`| \`${name}/\` | ${sanitize(description(context.root, company, name))} |`);
@@ -104,18 +116,23 @@ export function renderCompanies(context, args = []) {
                 const parsed = readJson(prd);
                 let text = typeof parsed?.description === "string" ? parsed.description : "";
                 text = truncate(sanitize(text), 110) || "—";
-                lines.push(`| \`${project}\` | ${projectStatus(context.root, project, prd, "active", prd)} | ${text} |`);
+                lines.push(`| \`${project}\` | ${prdProjectStatus(prd, "active")} | ${text} |`);
             }
         }
         else
             lines.push("_No projects directory._");
         lines.push("", "## Deployments", "", "_See `companies/manifest.yaml` for deployment targets._", "");
         const output = `companies/${company}/INDEX.md`;
-        write(context, output, lines.join("\n"));
-        written.push(output);
-        log(context, `rebuild-companies-index: wrote ${output}`);
+        if (writeIfChanged(context, output, lines.join("\n"))) {
+            written.push(output);
+            log(context, `rebuild-companies-index: wrote ${output}`);
+        }
+        else {
+            unchanged.push(output);
+            log(context, `rebuild-companies-index: unchanged ${output}`);
+        }
     }
-    log(context, `rebuild-companies-index: regenerated ${written.length} company INDEX.md file(s)`);
-    return { written };
+    log(context, `rebuild-companies-index: regenerated ${written.length + unchanged.length} company INDEX.md file(s)`);
+    return { written, unchanged };
 }
 //# sourceMappingURL=companies.js.map

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

@@ -10,6 +10,8 @@ export type RenderContext = {
 };
 export type RenderResult = {
     written: string[];
+    /** Relative paths whose rendered content matched the file on disk, so no write happened. */
+    unchanged?: string[];
 };
 export declare function rel(root: string, file: string): string;
 export declare function at(root: string, relative: string): string;
@@ -32,6 +34,15 @@ export declare function atomicWrite(file: string, content: string | Buffer, opti
     mode?: number;
 }): void;
 export declare function write(context: RenderContext, relative: string, content: string): string;
+/**
+ * Write only when the rendered bytes differ from the file on disk. Returns
+ * true when the file was written, false when it was already identical.
+ *
+ * The comparison is exact rather than `generatedFingerprint`: that fingerprint
+ * drops keep fences and trailing newlines, which would hide real differences.
+ * Callers that want a skip must render deterministic content (no dates).
+ */
+export declare function writeIfChanged(context: RenderContext, relative: string, content: string): boolean;
 /** Drop keep fences, the generated stamp, and the rolling date so two generated bodies can be compared. */
 export declare function generatedFingerprint(content: string): string;
 /** Insert a content stamp after the Auto-generated line. Idempotent. */
@@ -42,6 +53,13 @@ export declare function looksAutoGenerated(content: string): boolean;
 export declare function generatedStamp(content: string): string | undefined;
 export declare function log(context: RenderContext, message: string): void;
 export declare function projectStatus(root: string, project: string, prdPath: string, fallback: string, expectedStatePrdPath?: string): string;
+/**
+ * Project status from prd.json alone: "complete" when every story passes,
+ * otherwise `fallback`. Unlike `projectStatus`, this never reads the
+ * machine-local `workspace/orchestrator/<project>/state.json`, so synced
+ * output renders the same on every machine.
+ */
+export declare function prdProjectStatus(prdPath: string, fallback: string): string;
 export declare function basename(file: string): string;
 export declare function isHidden(name: string): boolean;
 export declare function mtime(file: string): number;

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

@@ -100,6 +100,21 @@ export function write(context, relative, content) {
     atomicWrite(at(context.root, relative), content);
     return relative;
 }
+/**
+ * Write only when the rendered bytes differ from the file on disk. Returns
+ * true when the file was written, false when it was already identical.
+ *
+ * The comparison is exact rather than `generatedFingerprint`: that fingerprint
+ * drops keep fences and trailing newlines, which would hide real differences.
+ * Callers that want a skip must render deterministic content (no dates).
+ */
+export function writeIfChanged(context, relative, content) {
+    const file = at(context.root, relative);
+    if (readText(file) === content)
+        return false;
+    atomicWrite(file, content);
+    return true;
+}
 const GENERATED_DATE_LINE = /^> Auto-generated\. Updated: \d{4}-\d{2}-\d{2}$/m;
 const GENERATED_STAMP_LINE = /^<!-- hq-generated-sha256: [a-f0-9]{64} -->\n?/m;
 function keepFencePattern() {
@@ -149,6 +164,15 @@ export function projectStatus(root, project, prdPath, fallback, expectedStatePrd
             return "active";
         return raw;
     }
+    return prdProjectStatus(prdPath, fallback);
+}
+/**
+ * Project status from prd.json alone: "complete" when every story passes,
+ * otherwise `fallback`. Unlike `projectStatus`, this never reads the
+ * machine-local `workspace/orchestrator/<project>/state.json`, so synced
+ * output renders the same on every machine.
+ */
+export function prdProjectStatus(prdPath, fallback) {
     const prd = readJson(prdPath);
     if (prd && Array.isArray(prd.userStories) && prd.userStories.length > 0 && prd.userStories.every((story) => Boolean(story.passes)))
         return "complete";

package/dist/lib/lanes/dropbox.js

@@ -595,6 +595,7 @@ export async function runDrainHook(env, input = {}, deps = {}) {
                 : await readLanesRegistryFlagFailOpen(LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG, {
                     ...(company ? { company } : {}),
                     env,
+                    defaultValue: true,
                 });
         }
         catch (err) {

package/dist/lib/lanes/monitor.js

@@ -347,26 +347,41 @@ function defaultProcessCommands() {
         return [];
     }
 }
+const WATCH_RUNTIME_EXECUTABLES = ["bun", "deno", "node", "nodejs", "ts-node", "tsx"];
+// The hq executable path may contain spaces (the desktop toolchain installs
+// under "~/Library/Application Support/Indigo HQ/..."), so the ps line cannot
+// be split on whitespace to find it. Match the fixed "lanes watch <ids>" suffix
+// on the raw line, then validate whatever precedes it as an hq invocation.
+// A path form (absolute or ./, ../) is required so an unrelated leading
+// command such as "vim /tmp/hq" is not absorbed into the path.
+function isHqExecutablePath(candidate) {
+    if (candidate === "hq")
+        return true;
+    if (!/^\.{0,2}\//u.test(candidate) || path.basename(candidate) !== "hq") {
+        return false;
+    }
+    return !candidate.split(" ").some((piece) => piece.startsWith("-"));
+}
+function isHqInvocationPrefix(prefix) {
+    if (isHqExecutablePath(prefix))
+        return true;
+    const runtimeEnd = prefix.indexOf(" ");
+    if (runtimeEnd === -1)
+        return false;
+    const runtime = path.basename(prefix.slice(0, runtimeEnd));
+    return (WATCH_RUNTIME_EXECUTABLES.includes(runtime) &&
+        isHqExecutablePath(prefix.slice(runtimeEnd + 1)));
+}
 function processHasExactCommand(processCommands, command) {
     const laneIds = parseCanonicalWatchCommand(command);
     if (!laneIds)
         return false;
-    const expectedSuffix = ["lanes", "watch", ...laneIds];
-    return processCommands.some((line) => {
-        const tokens = line.trim().split(/\s+/u);
-        const suffixStart = tokens.length - expectedSuffix.length;
-        if (suffixStart < 1)
-            return false;
-        if (!expectedSuffix.every((token, index) => tokens[suffixStart + index] === token)) {
-            return false;
-        }
-        const hqToken = tokens[suffixStart - 1];
-        if (path.basename(hqToken) !== "hq")
+    const expectedSuffix = ` lanes watch ${laneIds.join(" ")}`;
+    return processCommands.some((rawLine) => {
+        const line = rawLine.trim().replace(/\s+/gu, " ");
+        if (!line.endsWith(expectedSuffix))
             return false;
-        const prefix = tokens.slice(0, suffixStart - 1);
-        return (prefix.length === 0 ||
-            (prefix.length === 1 &&
-                ["bun", "deno", "node", "nodejs", "ts-node", "tsx"].includes(path.basename(prefix[0]))));
+        return isHqInvocationPrefix(line.slice(0, -expectedSuffix.length));
     });
 }
 export function readLiveMonitorEvidence(sessionId, options = {}) {

package/package.json

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