@indigoai-us/hq-cli 5.345.135 → 5.345.137

package/dist/hq-cloud-sync-runner/package.json

@@ -1 +1 @@
-{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.71","bundleSha256":"809fe7fd214f197c14df0586b2bf4e4536002cd122eb61a6817af4f7ba478637","formatVersion":1}
+{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.76","bundleSha256":"77b46d74eee514c5c0231766a9b361481d6ada90fdbddba84d37fff827547f7c","formatVersion":1}

package/dist/index.js

@@ -12,6 +12,7 @@ import { CLI_COMMAND_HELP_CATALOG_FLAG } from "./lib/cli-flag-keys.js";
 // heavy import (main.js) is lazy and reached only when a rejection fires.
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
 import { installFastPathStreamErrorHandlers } from "./utils/fast-stream-errors.js";
+import { installWindowsHideDefault } from "./utils/windows-hide-default.js";
 import { fileURLToPath } from "node:url";
 import { parseMonitorCheckFastRequest } from "./lanes-monitor-check-argv.js";
 import { createRequire } from "node:module";
@@ -155,6 +156,9 @@ async function runMonitorCheckFastWithRecovery(request) {
     await runMainWithInstallTreeRecovery();
 }
 function dispatchCliEntry() {
+    // Before anything spawns: a background hq on Windows (no terminal) hides the
+    // console window of every child it starts (feedback_351a40d5).
+    installWindowsHideDefault();
     if (process.platform === "win32" && coreCommandHasPathOperands(process.argv)) {
         // Keep cygpath off non-Windows and non-path command routes.
         process.argv = normalizeCorePathOperands(process.argv, "win32", cygpathMixedPath);

package/dist/lib/capacity/route.js

@@ -258,6 +258,30 @@ export function pickAccount(input) {
                 continue;
             }
             const authState = account.authState ?? "unknown";
+            // authState "unknown" means the ledger has no usage reading for the
+            // account, not that its sign-in failed. Do not send the user to log in
+            // for it: rank it as unknown when readings are unreliable, otherwise
+            // skip it as a missing reading.
+            if (!account.signedOut && authState === "unknown") {
+                if (!laneMatch.enabled) {
+                    skipped.push({
+                        ...base,
+                        reason: "usage-only, lanes cannot run on it",
+                        fix: `hq lanes accounts enable ${providerId} ${laneMatch.id}`,
+                    });
+                    continue;
+                }
+                if (readingsUnreliable) {
+                    rankUnknown(base, laneMatch.id, false);
+                    continue;
+                }
+                skipped.push({
+                    ...base,
+                    reason: "no usage reading for this account yet",
+                    fix: "hq capacity doctor",
+                });
+                continue;
+            }
             if (account.signedOut || !RUNNABLE_AUTH.has(authState)) {
                 skipped.push({
                     ...base,

package/dist/lib/core-utils/session-company.d.ts

@@ -1,3 +1,14 @@
 /** Reads the active session's company lock without importing the full hq-session command. */
 export declare function sessionCompanySlugs(root: string, env?: NodeJS.ProcessEnv, multiCompanyLockEnabled?: boolean): string[];
+/**
+ * The company a session bound itself to, from
+ * workspace/sessions/<sessionId>/meta.yaml `company_slug`. This is the bind a
+ * company bot's runner and `hq-session.sh add company` write, and that the
+ * HQ hooks read.
+ *
+ * Returns undefined unless the slug names a real (non-symlink) directory
+ * under companies/. hqd's own synthetic `hqd-*` check sessions are ignored,
+ * so a caller cannot borrow the binding hqd wrote for a different check.
+ */
+export declare function sessionMetaCompany(root: string, sessionId: string): string | undefined;
 //# sourceMappingURL=session-company.d.ts.map

package/dist/lib/core-utils/session-company.js

@@ -75,4 +75,38 @@ export function sessionCompanySlugs(root, env = process.env, multiCompanyLockEna
     }
     return listedCompanySlugs(contents).filter((slug) => slug === "personal" || isExactCompanyDirectory(root, slug));
 }
+/** A caller session id that is safe to use as one path segment. */
+const SESSION_DIR_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+/**
+ * The company a session bound itself to, from
+ * workspace/sessions/<sessionId>/meta.yaml `company_slug`. This is the bind a
+ * company bot's runner and `hq-session.sh add company` write, and that the
+ * HQ hooks read.
+ *
+ * Returns undefined unless the slug names a real (non-symlink) directory
+ * under companies/. hqd's own synthetic `hqd-*` check sessions are ignored,
+ * so a caller cannot borrow the binding hqd wrote for a different check.
+ */
+export function sessionMetaCompany(root, sessionId) {
+    if (!SESSION_DIR_RE.test(sessionId) || sessionId.includes("..") || sessionId.startsWith("hqd-"))
+        return undefined;
+    const metaPath = path.join(root, "workspace", "sessions", sessionId, "meta.yaml");
+    let contents;
+    try {
+        const stat = fs.lstatSync(metaPath);
+        if (!stat.isFile())
+            return undefined;
+        contents = fs.readFileSync(metaPath, "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "ELOOP")
+            return undefined;
+        throw error;
+    }
+    const slug = metaValue(contents, "company_slug").replace(/\r$/, "");
+    if (!slug || slug === "personal" || !/^[A-Za-z0-9_-]+$/.test(slug))
+        return undefined;
+    return isExactCompanyDirectory(root, slug) ? slug : undefined;
+}
 //# sourceMappingURL=session-company.js.map

package/dist/lib/core-utils/worktree-resume.js

@@ -6,6 +6,7 @@ import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { serializeJqJson } from "./jq-json-serializer.js";
 import { shellDisplayPath } from "./shell-display-path.js";
+import { liveProcessCwds, recentTranscriptCwds, sessionOwnerReason } from "./worktree-session-owner.js";
 export const WORKTREE_GC_ASSET = "core/scripts/worktree-gc.sh";
 export const CLEAN_HANDOFF_ASSET = "core/scripts/clean-worktree-reconcile-handoff.sh";
 export const RESUME_LOCK_ASSET = "core/scripts/resume-thread-lock.sh";
@@ -255,8 +256,14 @@ DATA SAFETY IS PARAMOUNT. A worktree is removed only when EVERY guard holds:
                                         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\`:
@@ -363,6 +370,17 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
         }
     }).filter((value, index, all) => all.indexOf(value) === index));
     const selfDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+    // Session ownership: live process cwds and recent transcript cwds, gathered
+    // once per run (same sources as worktree-gc.sh).
+    const processCwds = candidates.length > 0 ? liveProcessCwds() ?? [] : [];
+    const transcriptCwds = candidates.length > 0
+        ? recentTranscriptCwds({ env, nowMs: nowOf(io).getTime() }) ?? []
+        : [];
+    let hqRootPhys = hqRoot;
+    try {
+        hqRootPhys = fs.realpathSync(hqRoot);
+    }
+    catch { /* compare the given spelling */ }
     const records = [];
     let examined = 0, removed = 0, would = 0, reclaimedKb = 0, skipped = 0;
     const record = (values) => { records.push(values); };
@@ -408,7 +426,17 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
         const branch = branchResult.status === 0 ? commandOutput(branchResult) : "";
         const headResult = gitText(["-C", wt, "rev-parse", "HEAD"]);
         const head = headResult.status === 0 ? commandOutput(headResult) : "";
-        const statusResult = gitText(["-C", wt, "status", "--porcelain"]);
+        // Session ownership is checked before anything else inspects the tree.
+        // wt is the physical path; the spelling under the given HQ root counts too.
+        const wtAlt = wt.startsWith(`${hqRootPhys}${path.sep}`) ? path.join(hqRoot, wt.slice(hqRootPhys.length + 1)) : wt;
+        const owner = sessionOwnerReason(processCwds, transcriptCwds, wt, wtAlt);
+        if (owner) {
+            skip(wt, mainRepo, branch, isHqRoot, null, null, owner);
+            continue;
+        }
+        // --no-optional-locks keeps the scan from rewriting the index. Untracked
+        // files count as dirty even when status.showUntrackedFiles=no.
+        const statusResult = gitText(["--no-optional-locks", "-C", wt, "status", "--porcelain", "--untracked-files=all"]);
         const porcelain = statusResult.status === 0 ? stripTrailingNewlines(statusResult.text) : "__ERR__";
         if (porcelain === "__ERR__") {
             skip(wt, mainRepo, branch, isHqRoot, null, null, "git-error");
@@ -419,7 +447,19 @@ export function runWorktreeGc(args, hqRoot, io = {}) {
             continue;
         }
         const wtMtime = statMtime(wt);
-        if (wtMtime > recentEpoch) {
+        // Newest of the 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.
+        let activityEpoch = wtMtime;
+        const gitDirResult = gitText(["-C", wt, "rev-parse", "--path-format=absolute", "--git-dir"]);
+        const gitDir = gitDirResult.status === 0 ? commandOutput(gitDirResult) : "";
+        if (gitDir) {
+            for (const file of [path.join(gitDir, "HEAD"), path.join(gitDir, "logs", "HEAD")]) {
+                if (fileExists(file))
+                    activityEpoch = Math.max(activityEpoch, statMtime(file));
+            }
+        }
+        if (activityEpoch > recentEpoch) {
             skip(wt, mainRepo, branch, isHqRoot, null, null, "recent-activity");
             continue;
         }

package/dist/lib/core-utils/worktree-session-owner.d.ts

@@ -0,0 +1,27 @@
+export declare const SESSION_WINDOW_DEFAULT_HOURS = 168;
+export type SessionOwnerReason = "live-session" | "recent-session";
+/** Session window in hours from HQ_WORKTREE_SESSION_WINDOW_HOURS (default 168). */
+export declare function sessionWindowHours(env?: NodeJS.ProcessEnv): number;
+/** Transcript roots from HQ_SESSION_TRANSCRIPT_DIRS, else ~/.claude/projects and ~/.codex/sessions. */
+export declare function transcriptRoots(env?: NodeJS.ProcessEnv): string[];
+/**
+ * The cwd of every process this user can see. Linux reads /proc; macOS asks
+ * lsof. Returns [] when neither probe exists (the other guards still apply) and
+ * undefined when a probe exists but did not finish, so callers fail closed.
+ */
+export declare function liveProcessCwds(timeoutMs?: number): string[] | undefined;
+/**
+ * Every cwd recorded by a *.jsonl transcript under the transcript roots whose
+ * mtime falls inside the session window. Returns undefined when the deadline
+ * passes first, so callers fail closed.
+ */
+export declare function recentTranscriptCwds(options?: {
+    env?: NodeJS.ProcessEnv;
+    nowMs?: number;
+    deadline?: number;
+}): string[] | undefined;
+/** True when a listed cwd is one of the spellings or lies inside one. */
+export declare function pathInList(list: readonly string[], ...spellings: string[]): boolean;
+/** live-session, recent-session, or undefined when no session owns the worktree. */
+export declare function sessionOwnerReason(processCwds: readonly string[], transcriptCwds: readonly string[], ...spellings: string[]): SessionOwnerReason | undefined;
+//# sourceMappingURL=worktree-session-owner.d.ts.map

package/dist/lib/core-utils/worktree-session-owner.js

@@ -0,0 +1,157 @@
+/**
+ * Session ownership for HQ worktree garbage collection.
+ *
+ * A worktree is owned by a session when a running process has its cwd inside
+ * it, 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
+ * protects an open but idle session. Every GC path (`hq reindex`, native
+ * `hq core worktree-gc`, core/scripts/worktree-gc.sh, free-disk-space.sh) skips
+ * owned worktrees. The shell scripts implement the same rule.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const SESSION_WINDOW_DEFAULT_HOURS = 168;
+/** Session window in hours from HQ_WORKTREE_SESSION_WINDOW_HOURS (default 168). */
+export function sessionWindowHours(env = process.env) {
+    const raw = env.HQ_WORKTREE_SESSION_WINDOW_HOURS ?? "";
+    return /^\d+$/u.test(raw) ? Number(raw) : SESSION_WINDOW_DEFAULT_HOURS;
+}
+/** Transcript roots from HQ_SESSION_TRANSCRIPT_DIRS, else ~/.claude/projects and ~/.codex/sessions. */
+export function transcriptRoots(env = process.env) {
+    const raw = env.HQ_SESSION_TRANSCRIPT_DIRS;
+    if (raw !== undefined) {
+        const separator = process.platform === "win32" ? ";" : ":";
+        return raw.split(separator).filter(Boolean);
+    }
+    const home = env.HOME || os.homedir();
+    return [path.join(home, ".claude", "projects"), path.join(home, ".codex", "sessions")];
+}
+/**
+ * The cwd of every process this user can see. Linux reads /proc; macOS asks
+ * lsof. Returns [] when neither probe exists (the other guards still apply) and
+ * undefined when a probe exists but did not finish, so callers fail closed.
+ */
+export function liveProcessCwds(timeoutMs = 30_000) {
+    if (process.platform === "win32")
+        return [];
+    if (fs.existsSync("/proc/self/cwd")) {
+        const cwds = [];
+        let entries;
+        try {
+            entries = fs.readdirSync("/proc");
+        }
+        catch {
+            return undefined;
+        }
+        for (const entry of entries) {
+            if (!/^\d+$/u.test(entry))
+                continue;
+            try {
+                cwds.push(fs.readlinkSync(`/proc/${entry}/cwd`));
+            }
+            catch { /* exited or not ours */ }
+        }
+        return cwds;
+    }
+    const result = spawnSync("lsof", ["-w", "-n", "-P", "-d", "cwd", "-Fn"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: Math.max(1, timeoutMs),
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    if (result.error) {
+        return result.error.code === "ENOENT" ? [] : undefined;
+    }
+    if (result.signal)
+        return undefined;
+    return (result.stdout ?? "").split("\n").filter((line) => line.startsWith("n")).map((line) => line.slice(1));
+}
+const CWD_KEY = Buffer.from('"cwd"');
+/** Adds every `"cwd": *"<value>"` value in buf (same match as grep -o '"cwd": *"[^"]*"'). */
+function collectCwdValues(buf, out) {
+    let index = buf.indexOf(CWD_KEY);
+    while (index !== -1) {
+        let cursor = index + CWD_KEY.length;
+        if (buf[cursor] === 0x3a) {
+            cursor++;
+            while (buf[cursor] === 0x20)
+                cursor++;
+            if (buf[cursor] === 0x22) {
+                const end = buf.indexOf(0x22, cursor + 1);
+                const newline = buf.indexOf(0x0a, cursor + 1);
+                if (end !== -1 && (newline === -1 || end < newline))
+                    out.add(buf.toString("utf8", cursor + 1, end));
+            }
+        }
+        index = buf.indexOf(CWD_KEY, index + CWD_KEY.length);
+    }
+}
+/**
+ * Every cwd recorded by a *.jsonl transcript under the transcript roots whose
+ * mtime falls inside the session window. Returns undefined when the deadline
+ * passes first, so callers fail closed.
+ */
+export function recentTranscriptCwds(options = {}) {
+    const env = options.env ?? process.env;
+    const nowMs = options.nowMs ?? Date.now();
+    const deadline = options.deadline ?? Number.POSITIVE_INFINITY;
+    const cutoffMs = nowMs - sessionWindowHours(env) * 60 * 60 * 1000;
+    const cwds = new Set();
+    let expired = false;
+    const visit = (target) => {
+        if (expired)
+            return;
+        if (Date.now() >= deadline) {
+            expired = true;
+            return;
+        }
+        let info;
+        try {
+            info = fs.statSync(target);
+        }
+        catch {
+            return;
+        }
+        if (info.isDirectory()) {
+            let names;
+            try {
+                names = fs.readdirSync(target);
+            }
+            catch {
+                return;
+            }
+            for (const name of names)
+                visit(path.join(target, name));
+            return;
+        }
+        // find -mmin -N keeps files modified strictly inside the window.
+        if (!info.isFile() || !target.endsWith(".jsonl") || info.mtimeMs <= cutoffMs)
+            return;
+        try {
+            collectCwdValues(fs.readFileSync(target), cwds);
+        }
+        catch { /* unreadable transcript */ }
+    };
+    for (const root of transcriptRoots(env))
+        visit(root);
+    if (expired)
+        return undefined;
+    return [...cwds];
+}
+/** True when a listed cwd is one of the spellings or lies inside one. */
+export function pathInList(list, ...spellings) {
+    const targets = spellings.filter(Boolean);
+    return list.some((entry) => targets.some((target) => entry === target || entry.startsWith(`${target}/`)));
+}
+/** live-session, recent-session, or undefined when no session owns the worktree. */
+export function sessionOwnerReason(processCwds, transcriptCwds, ...spellings) {
+    if (pathInList(processCwds, ...spellings))
+        return "live-session";
+    if (pathInList(transcriptCwds, ...spellings))
+        return "recent-session";
+    return undefined;
+}
+//# sourceMappingURL=worktree-session-owner.js.map

package/dist/lib/daemon/catalog.d.ts

@@ -43,6 +43,8 @@ interface UnitBlock {
     /** `waiting` clears on its own once the requirement appears; `unavailable` needs a newer CLI. */
     state: "waiting" | "unavailable";
     reason: string;
+    /** A failed availability probe must not stop an already running service. */
+    keepRunning?: true;
 }
 export interface UnitPlan {
     /** Service name, or `<service>:<instance>` for per-instance services (bots). */

package/dist/lib/daemon/catalog.js

@@ -95,7 +95,7 @@ function unavailable(service, reason, over = {}) {
 }
 function firstBlock(checks) {
     const hit = checks.find(([blocked]) => blocked);
-    return hit ? { state: "waiting", reason: hit[1] } : undefined;
+    return hit ? { state: "waiting", reason: hit[1], ...hit[2] } : undefined;
 }
 /**
  * The units that run hq-cloud's code on this host, restarted after the updater
@@ -377,7 +377,7 @@ export function planUnits(services, ctx) {
                 [ctx.platform !== "linux", "Remote Control account pools require Linux mount namespaces"],
                 [!ctx.hqRoot, NO_HQ_ROOT],
                 [ctx.invalidPoolServiceSessions?.has(pool.accountId) === true, "configured serviceSessionId must reference an existing personal-only scope capability"],
-                [ctx.unverifiablePoolSecrets?.has(pool.secretName) === true, "could not verify the configured HQ Secret"],
+                [ctx.unverifiablePoolSecrets?.has(pool.secretName) === true, "could not verify the configured HQ Secret", { keepRunning: true }],
                 [ctx.availablePoolSecrets?.has(pool.secretName) !== true, "the configured HQ Secret is missing"],
             ]),
         }));
@@ -397,7 +397,7 @@ export function planUnits(services, ctx) {
                 [!ctx.tmuxPath, "tmux is not installed (remote control runs Claude inside tmux)"],
                 [!ctx.hqRoot, NO_HQ_ROOT],
                 [ctx.invalidPoolServiceSessions?.has(pool.accountId) === true, "configured serviceSessionId must reference an existing personal-only scope capability"],
-                [ctx.unverifiablePoolSecrets?.has(pool.secretName) === true, "could not verify the configured HQ Secret"],
+                [ctx.unverifiablePoolSecrets?.has(pool.secretName) === true, "could not verify the configured HQ Secret", { keepRunning: true }],
                 [ctx.availablePoolSecrets?.has(pool.secretName) !== true, "the configured HQ Secret is missing"],
                 [ctx.unverifiablePoolFrontends?.has(pool.accountId) === true, "could not verify the configured nginx frontend"],
                 [ctx.availablePoolFrontends?.has(pool.accountId) !== true, "the configured nginx frontend is not responding on HTTPS port 443"],

package/dist/lib/daemon/hq-child-bootstrap-stage.d.ts

@@ -1,5 +1,6 @@
 /** Atomic, content-addressed staging for the daemon's replace-independent hq launcher. */
 import * as fs from "node:fs";
+import { type DirectorySyncIo } from "../../utils/fsync-directory.js";
 export declare const HQ_CHILD_BOOTSTRAP_FILE = "hq-child-bootstrap.mjs";
 export type HqChildBootstrapStageErrorCode = "SOURCE_MISSING" | "STAGE_INVALID" | "COPY_FAILED" | "HASH_MISMATCH" | "FSYNC_FAILED" | "RENAME_FAILED";
 export declare class HqChildBootstrapStageError extends Error {
@@ -16,6 +17,10 @@ export interface StageHqChildBootstrapOptions {
     daemonRoot: string;
     copyFile?: typeof fs.copyFileSync;
     renameDirectory?: (from: string, to: string) => void;
+    /** Platform for the directory-fsync decision (tests); defaults to process.platform. */
+    platform?: NodeJS.Platform;
+    /** Directory fsync seam (tests). */
+    directorySyncIo?: DirectorySyncIo;
 }
 /** Stage only a complete, content-verified bootstrap; temporary siblings are never selected. */
 export declare function stageHqChildBootstrap(options: StageHqChildBootstrapOptions): StagedHqChildBootstrap;

package/dist/lib/daemon/hq-child-bootstrap-stage.js

@@ -2,6 +2,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fsyncDirectory } from "../../utils/fsync-directory.js";
 import { fileURLToPath } from "node:url";
 import { ensurePrivateDir } from "./paths.js";
 export const HQ_CHILD_BOOTSTRAP_FILE = "hq-child-bootstrap.mjs";
@@ -30,15 +31,6 @@ function syncFile(file) {
         fs.closeSync(fd);
     }
 }
-function syncDirectory(directory) {
-    const fd = fs.openSync(directory, fs.constants.O_RDONLY);
-    try {
-        fs.fsyncSync(fd);
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
 function readStage(directory, expectedHash) {
     if (!fs.existsSync(directory))
         return null;
@@ -87,7 +79,7 @@ export function stageHqChildBootstrap(options) {
             fail("HASH_MISMATCH", "The staged daemon hq bootstrap hash does not match");
         failureCode = "FSYNC_FAILED";
         syncFile(stagedPath);
-        syncDirectory(tempDirectory);
+        fsyncDirectory(tempDirectory, options.platform, options.directorySyncIo);
         failureCode = "RENAME_FAILED";
         try {
             (options.renameDirectory ?? fs.renameSync)(tempDirectory, selectedDirectory);
@@ -104,7 +96,7 @@ export function stageHqChildBootstrap(options) {
         }
         tempDirectory = undefined;
         failureCode = "FSYNC_FAILED";
-        syncDirectory(stageRoot);
+        fsyncDirectory(stageRoot, options.platform, options.directorySyncIo);
     }
     catch (error) {
         if (tempDirectory) {

package/dist/lib/daemon/server.js

@@ -15,6 +15,7 @@ import { canonicalDir, emptyRegistry, readRegistry, registryFile, resolveCompany
 import { readCompaniesManifestMap } from "../work-context/repo-remote.js";
 import { createLineSplitter, encodeMessage, HQD_DEFAULT_REQUEST_TIMEOUT_MS, HQD_MAX_LINE_BYTES, parseRequestLine } from "./protocol.js";
 import { SessionRegistry } from "./session-registry.js";
+import { sessionMetaCompany } from "../core-utils/session-company.js";
 import { journalAppend, JournalOpError } from "./ops/journal.js";
 import { memoryGet, memoryPut, MemoryOpError } from "./ops/memory.js";
 import { meshPresence, MeshOpError } from "./ops/mesh.js";
@@ -420,7 +421,15 @@ export async function startHqdServer(opts) {
         }
         const boundCompany = session?.company ?? cwdCompany;
         assertCompanyMatchesBinding(explicit, boundCompany);
-        return explicit ?? boundCompany;
+        if (explicit ?? boundCompany)
+            return explicit ?? boundCompany;
+        // Neither the call, the in-memory session nor the cwd names a company:
+        // fall back to the session's own persisted bind (meta.yaml company_slug),
+        // which a company bot's runner writes for every turn and which survives a
+        // daemon restart. A bot at the unlinked HQ root then resolves its own
+        // company, and the policy check still scopes it to that one company
+        // (feedback_578dd8ff).
+        return opts.hqRoot && sessionId ? sessionMetaCompany(opts.hqRoot, sessionId) : undefined;
     };
     let hqMcp = opts.mcpBridge;
     if (!isPipe) {

package/dist/lib/daemon/supervisor.js

@@ -751,6 +751,12 @@ export function createSupervisor(deps) {
                 continue;
             }
             next.set(plan.id, existing);
+            // A secret availability probe can fail while the new daemon is signing
+            // in. Keep an already authorized pool running until the probe succeeds
+            // or positively reports that its secret is missing.
+            if (plan.blocked?.keepRunning && existing.child && existing.plan.blocked === undefined) {
+                continue;
+            }
             // A remote-control host is what people's sessions run in. Its tool can
             // look missing for one plan read while it is being reinstalled, so it is
             // only paused once the tool is missing on two reads in a row.

package/dist/lib/daemon/sync-runner-bundle.d.ts

@@ -1,5 +1,6 @@
 /** Atomic staging for the sync-runner bundle shipped with hq-cli. */
 import * as fs from "node:fs";
+import { type DirectorySyncIo } from "../../utils/fsync-directory.js";
 export declare const SYNC_RUNNER_BUNDLE_RUNNER_FILE = "bin/sync-runner.js";
 export declare const SYNC_RUNNER_BUNDLE_METADATA_FILE = "package.json";
 export declare const SYNC_RUNNER_BUNDLE_DIRECTORY = "hq-cloud-sync-runner";
@@ -33,6 +34,10 @@ export interface StageSyncRunnerBundleOptions {
     /** Test seams for the file copy and atomic directory rename. */
     copyFile?: typeof fs.copyFileSync;
     renameDirectory?: (from: string, to: string) => void;
+    /** Platform for the directory-fsync decision (tests); defaults to process.platform. */
+    platform?: NodeJS.Platform;
+    /** Directory fsync seam (tests). */
+    directorySyncIo?: DirectorySyncIo;
 }
 /** Read the validated metadata version for a runner inside its staged bundle. */
 export declare function stagedSyncRunnerVersion(runnerPath: string): string;

package/dist/lib/daemon/sync-runner-bundle.js

@@ -2,6 +2,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fsyncDirectory } from "../../utils/fsync-directory.js";
 import { fileURLToPath } from "node:url";
 import semver from "semver";
 import { ensurePrivateDir } from "./paths.js";
@@ -89,15 +90,6 @@ function syncFile(file) {
         fs.closeSync(fd);
     }
 }
-function syncDirectory(directory) {
-    const fd = fs.openSync(directory, fs.constants.O_RDONLY);
-    try {
-        fs.fsyncSync(fd);
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
 function readStaged(directory, expected, range) {
     if (!fs.existsSync(directory))
         return null;
@@ -167,8 +159,8 @@ export function stageSyncRunnerBundle(options) {
         failureCode = "FSYNC_FAILED";
         syncFile(path.join(tempDirectory, SYNC_RUNNER_BUNDLE_RUNNER_FILE));
         syncFile(path.join(tempDirectory, SYNC_RUNNER_BUNDLE_METADATA_FILE));
-        syncDirectory(path.join(tempDirectory, "bin"));
-        syncDirectory(tempDirectory);
+        fsyncDirectory(path.join(tempDirectory, "bin"), options.platform, options.directorySyncIo);
+        fsyncDirectory(tempDirectory, options.platform, options.directorySyncIo);
         failureCode = "RENAME_FAILED";
         try {
             (options.renameDirectory ?? fs.renameSync)(tempDirectory, selectedDirectory);
@@ -185,7 +177,7 @@ export function stageSyncRunnerBundle(options) {
         }
         tempDirectory = undefined;
         failureCode = "FSYNC_FAILED";
-        syncDirectory(stageRoot);
+        fsyncDirectory(stageRoot, options.platform, options.directorySyncIo);
     }
     catch (error) {
         if (tempDirectory) {

package/dist/lib/doctor/checks/claude-wiring.js

@@ -24,6 +24,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { GATE_PROFILES, gateMembership, parseHookGateProfiles, } from "../hook-gate-profiles.js";
+import { modeIsExecutable } from "../shared.js";
 import { countStrayGateEntries } from "../stray-gate-entries.js";
 /** Common id prefix for every result this check family emits. */
 export const CLAUDE_WIRING_PREFIX = "hooks.claude";
@@ -550,7 +551,7 @@ function statSafe(file) {
     }
 }
 function isExecutable(mode) {
-    return (mode & 0o111) !== 0;
+    return modeIsExecutable(mode);
 }
 /** Top-level `*.sh` filenames in `dir`, sorted; empty when `dir` is absent. */
 function listShellScripts(dir) {

package/dist/lib/doctor/fix/apply.d.ts

@@ -87,6 +87,15 @@ export interface ApplyFixesOptions {
         from: string;
         to: string;
     } | null;
+    /**
+     * Reinstall used by the `bot-hq-binary` class: rewrite the bot's
+     * LaunchAgent against the installed hq and reload it, as
+     * `hq bot daemon install <name>` does. Tests inject a stub.
+     */
+    repairBotHqBinary?: (name: string) => {
+        from: string | null;
+        to: string;
+    } | null;
 }
 /** One company or personal vault the `refresh-sync` class will pull. */
 export interface RefreshSyncTarget {
@@ -183,6 +192,17 @@ export declare function defaultRewriteBotNodePath(name: string): {
     from: string;
     to: string;
 } | null;
+/**
+ * An hq path a bot may be pointed at unattended: an installed package entry
+ * or its stable shim, never a worktree or one-off build that happens to be
+ * running `hq doctor --fix`.
+ */
+export declare function isInstalledHqBinary(hqBinary: string): boolean;
+/** Default `bot-hq-binary` repair against the real bot state and LaunchAgents. */
+export declare function defaultRepairBotHqBinary(name: string): {
+    from: string | null;
+    to: string;
+} | null;
 /**
  * Insert a new `case` arm allowlisting `hookId` (leading to `return 0`) at the
  * top of each named profile function's `case "$1" in` block. Additive: it never