@indigoai-us/hq-cli 5.323.0 → 5.324.0

package/dist/lib/daemon/ops/policy.js

@@ -0,0 +1,283 @@
+/**
+ * policy.check and policy.index ops (hq-anywhere US-009).
+ *
+ * Verdicts come from the hq-core hook scripts under HQ_ROOT, run as child
+ * processes with a synthesized hook payload, so hookless hosts and sub-agents
+ * get the same answer a hook-dispatching session would. No rule is
+ * reimplemented here:
+ *   - .claude/hooks/mandatory-scope-authorizer.sh decides allow/block
+ *     (exit 2 = block, reason on stderr).
+ *   - .claude/hooks/inject-policy-on-trigger.sh supplies additionalContext.
+ *
+ * The policy index (which policy files exist for a company) is cached
+ * in-process and invalidated by fs.watch on core/policies, personal/policies
+ * and companies/<co>/policies.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const SCOPE_AUTHORIZER = ".claude/hooks/mandatory-scope-authorizer.sh";
+export const POLICY_TRIGGER = ".claude/hooks/inject-policy-on-trigger.sh";
+const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SESSION_RE = /^[A-Za-z0-9._-]+$/;
+export class PolicyOpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PolicyOpError";
+    }
+}
+/** Cached list of policy files under HQ_ROOT, invalidated by fs.watch. */
+export class PolicyIndex {
+    hqRoot;
+    log;
+    entries = null;
+    watchers = [];
+    closed = false;
+    /** Bumped on every invalidation; lets callers see that the cache was rebuilt. */
+    version = 0;
+    constructor(hqRoot, log = () => { }) {
+        this.hqRoot = hqRoot;
+        this.log = log;
+    }
+    /** Policies visible to `company`: core, personal, and that company only. */
+    list(company) {
+        if (!this.entries)
+            this.rebuild();
+        return this.entries.filter((e) => e.scope !== "company" || e.company === company);
+    }
+    invalidate() {
+        if (this.entries === null)
+            return;
+        this.entries = null;
+        this.version += 1;
+    }
+    close() {
+        this.closed = true;
+        for (const w of this.watchers)
+            w.close();
+        this.watchers = [];
+    }
+    rebuild() {
+        const dirs = [
+            { dir: path.join(this.hqRoot, "core", "policies"), scope: "core" },
+            { dir: path.join(this.hqRoot, "personal", "policies"), scope: "personal" },
+        ];
+        const companiesDir = path.join(this.hqRoot, "companies");
+        const companyDirs = [];
+        for (const co of readDirNames(companiesDir)) {
+            if (!SLUG_RE.test(co))
+                continue;
+            const companyDir = path.join(companiesDir, co);
+            if (isDir(companyDir))
+                companyDirs.push(companyDir);
+            const dir = path.join(companiesDir, co, "policies");
+            if (isDir(dir))
+                dirs.push({ dir, scope: "company", company: co });
+        }
+        const entries = [];
+        for (const d of dirs) {
+            for (const name of readDirNames(d.dir)) {
+                if (!name.endsWith(".md") || name.startsWith("_"))
+                    continue;
+                entries.push({ slug: name.slice(0, -3), path: path.join(d.dir, name), scope: d.scope, ...(d.company ? { company: d.company } : {}) });
+            }
+        }
+        this.entries = entries;
+        this.rewatch([...dirs.map((d) => d.dir), ...companyDirs, companiesDir]);
+    }
+    rewatch(dirs) {
+        for (const w of this.watchers)
+            w.close();
+        this.watchers = [];
+        if (this.closed)
+            return;
+        for (const dir of dirs) {
+            if (!isDir(dir))
+                continue;
+            try {
+                const w = fs.watch(dir, () => this.invalidate());
+                w.on("error", (err) => {
+                    this.log("warn", `policy index watch on ${dir} failed: ${err.message}`);
+                    this.invalidate();
+                });
+                this.watchers.push(w);
+            }
+            catch (err) {
+                this.log("warn", `could not watch ${dir}: ${err.message}`);
+            }
+        }
+    }
+}
+function readDirNames(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT" || err.code === "ENOTDIR")
+            return [];
+        throw err;
+    }
+}
+function isDir(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function runScript(script, payload, env, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("bash", [script], { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        child.stdout.on("data", (c) => (stdout += c.toString("utf8")));
+        child.stderr.on("data", (c) => (stderr += c.toString("utf8")));
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut });
+        });
+        child.stdin.on("error", () => {
+            // The script may exit before reading stdin; its exit code still decides.
+        });
+        child.stdin.end(payload);
+    });
+}
+/**
+ * The scope authorizer reads the session's company from
+ * workspace/sessions/<sid>/meta.yaml (or scope-capability.json). hqd binds a
+ * session id of its own per company + caller, so a check never borrows the
+ * binding of an unrelated session.
+ */
+export function bindCheckSession(hqRoot, company, callerSession, now) {
+    const caller = (callerSession ?? "default").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80) || "default";
+    const sid = `hqd-${company}-${caller}`;
+    if (!SESSION_RE.test(sid))
+        throw new PolicyOpError("bad_args", "sessionId has no usable characters");
+    const dir = path.join(hqRoot, "workspace", "sessions", sid);
+    const meta = path.join(dir, "meta.yaml");
+    const body = `session_id: ${sid}\nstarted_at: ${now.toISOString()}\nsenior: user\ncompany_slug: ${company}\nsource: hqd\n`;
+    let current = "";
+    try {
+        current = fs.readFileSync(meta, "utf8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    if (!current.includes(`\ncompany_slug: ${company}\n`)) {
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = `${meta}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, body);
+        fs.renameSync(tmp, meta);
+    }
+    return sid;
+}
+function extractContext(stdout) {
+    const text = stdout.trim();
+    if (!text)
+        return "";
+    try {
+        const parsed = JSON.parse(text);
+        const ctx = parsed.hookSpecificOutput?.additionalContext ?? parsed.additionalContext;
+        return typeof ctx === "string" ? ctx : "";
+    }
+    catch {
+        return text;
+    }
+}
+function blockFromJson(stdout) {
+    try {
+        const parsed = JSON.parse(stdout.trim());
+        if (parsed.decision === "block")
+            return typeof parsed.reason === "string" ? parsed.reason : "blocked";
+        if (parsed.hookSpecificOutput?.permissionDecision === "deny") {
+            const r = parsed.hookSpecificOutput.permissionDecisionReason;
+            return typeof r === "string" ? r : "denied";
+        }
+    }
+    catch {
+        // Plain-text stdout is not a verdict.
+    }
+    return null;
+}
+export async function policyCheck(args, deps) {
+    const { hqRoot } = deps;
+    if (!SLUG_RE.test(args.company))
+        throw new PolicyOpError("bad_args", "company must be a company slug");
+    if (!isDir(path.join(hqRoot, "companies", args.company))) {
+        throw new PolicyOpError("unknown_company", `no companies/${args.company} under ${hqRoot}`);
+    }
+    const authorizer = path.join(hqRoot, SCOPE_AUTHORIZER);
+    const trigger = path.join(hqRoot, POLICY_TRIGGER);
+    if (!fs.existsSync(authorizer)) {
+        throw new PolicyOpError("policy_engine_unavailable", `scope authorizer not found at ${authorizer}`);
+    }
+    const event = args.event ?? "PreToolUse";
+    const session = bindCheckSession(hqRoot, args.company, args.sessionId, (deps.now ?? (() => new Date()))());
+    const payload = JSON.stringify({
+        session_id: session,
+        hook_event_name: event,
+        tool_name: args.tool,
+        tool_input: args.input ?? {},
+        cwd: args.cwd ?? hqRoot,
+    });
+    const env = {
+        ...(deps.env ?? process.env),
+        HQ_ROOT: hqRoot,
+        CLAUDE_PROJECT_DIR: hqRoot,
+        HQ_POLICY_COMPANY: args.company,
+        BASH_ENV: "/dev/null",
+    };
+    delete env.HQ_HOOK_SESSION_ID;
+    delete env.HQ_HOOK_TOOL_NAME;
+    const timeoutMs = deps.timeoutMs ?? 15_000;
+    const reasons = [];
+    let decision = "allow";
+    if (event === "PreToolUse") {
+        const r = await runScript(authorizer, payload, env, hqRoot, timeoutMs);
+        const jsonBlock = blockFromJson(r.stdout);
+        if (r.timedOut) {
+            decision = "block";
+            reasons.push(`scope authorizer timed out after ${timeoutMs}ms; failing closed`);
+        }
+        else if (r.code === 2 || jsonBlock) {
+            decision = "block";
+            reasons.push((jsonBlock ?? r.stderr).trim() || "blocked by scope authorizer");
+        }
+        else if (r.code !== 0) {
+            decision = "block";
+            reasons.push(`scope authorizer exited ${r.code}; failing closed: ${r.stderr.trim()}`);
+        }
+    }
+    let additionalContext = "";
+    if (fs.existsSync(trigger)) {
+        const r = await runScript(trigger, payload, env, hqRoot, timeoutMs);
+        if (r.code === 0 && !r.timedOut)
+            additionalContext = extractContext(r.stdout);
+        else
+            reasons.push(`policy trigger hook did not complete (exit ${r.code}${r.timedOut ? ", timed out" : ""}); no policy context`);
+    }
+    else {
+        reasons.push(`policy trigger hook not found at ${trigger}; no policy context`);
+    }
+    return {
+        decision,
+        reasons,
+        additionalContext,
+        session,
+        policies: { count: deps.index.list(args.company).length, version: deps.index.version },
+    };
+}
+//# sourceMappingURL=policy.js.map

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

@@ -0,0 +1,68 @@
+/**
+ * hqd wire protocol (hq-anywhere US-008).
+ *
+ * One Unix domain socket (a named pipe on Windows) carrying newline-delimited
+ * JSON. Requests are `{id, op, args}`; each gets exactly one response
+ * `{id, ok: true, result}` or `{id, ok: false, error}`. Responses may arrive
+ * out of order, so clients match them by `id`.
+ */
+export declare const HQD_SOCKET_NAME = "hqd.sock";
+export declare const HQD_OPS: readonly ["ping", "resolve", "session.open", "session.get", "session.close", "policy.check", "policy.index", "journal.append", "memory.get", "memory.put", "mesh.presence", "shutdown"];
+export type HqdOp = (typeof HQD_OPS)[number];
+/** A request line larger than this is rejected and the connection closed. */
+export declare const HQD_MAX_LINE_BYTES: number;
+export interface HqdRequest {
+    id: string | number;
+    op: string;
+    args?: Record<string, unknown>;
+}
+export interface HqdError {
+    code: string;
+    message: string;
+}
+export type HqdResponse = {
+    id: string | number | null;
+    ok: true;
+    result: unknown;
+} | {
+    id: string | number | null;
+    ok: false;
+    error: HqdError;
+};
+/**
+ * Socket path: HQ_HQD_SOCKET, else <HQ_REGISTRY_DIR or ~/.hq>/hqd.sock.
+ * On Windows the socket is a per-user named pipe.
+ */
+export declare function hqdSocketPath(home?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export declare function encodeMessage(message: HqdRequest | HqdResponse): string;
+export type ParsedLine = {
+    ok: true;
+    request: HqdRequest;
+} | {
+    ok: false;
+    id: string | number | null;
+    error: HqdError;
+};
+/** Validate one request line. Never throws. */
+export declare function parseRequestLine(line: string): ParsedLine;
+/**
+ * Split a byte stream into lines. Returns a push function that hands each
+ * complete line to `onLine`, and reports overflow when a partial line grows
+ * past `maxBytes`.
+ */
+export declare function createLineSplitter(onLine: (line: string) => void, onOverflow: () => void, maxBytes?: number): (chunk: Buffer | string) => void;
+export declare class HqdClientError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface HqdRequestOptions {
+    socketPath?: string;
+    /** Whole-request budget, including connect. Default 2000ms. */
+    timeoutMs?: number;
+}
+/**
+ * Send one request and wait for its response. A daemon that is not running
+ * fails fast with the socket error code (ENOENT or ECONNREFUSED).
+ */
+export declare function hqdRequest(op: HqdOp | string, args?: Record<string, unknown>, opts?: HqdRequestOptions): Promise<unknown>;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/lib/daemon/protocol.js

@@ -0,0 +1,154 @@
+/**
+ * hqd wire protocol (hq-anywhere US-008).
+ *
+ * One Unix domain socket (a named pipe on Windows) carrying newline-delimited
+ * JSON. Requests are `{id, op, args}`; each gets exactly one response
+ * `{id, ok: true, result}` or `{id, ok: false, error}`. Responses may arrive
+ * out of order, so clients match them by `id`.
+ */
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+export const HQD_SOCKET_NAME = "hqd.sock";
+export const HQD_OPS = [
+    "ping",
+    "resolve",
+    "session.open",
+    "session.get",
+    "session.close",
+    "policy.check",
+    "policy.index",
+    "journal.append",
+    "memory.get",
+    "memory.put",
+    "mesh.presence",
+    "shutdown",
+];
+/** A request line larger than this is rejected and the connection closed. */
+export const HQD_MAX_LINE_BYTES = 1024 * 1024;
+/**
+ * Socket path: HQ_HQD_SOCKET, else <HQ_REGISTRY_DIR or ~/.hq>/hqd.sock.
+ * On Windows the socket is a per-user named pipe.
+ */
+export function hqdSocketPath(home = os.homedir(), env = process.env, platform = process.platform) {
+    const override = env.HQ_HQD_SOCKET?.trim();
+    if (override)
+        return override;
+    if (platform === "win32") {
+        const user = (env.USERNAME ?? os.userInfo().username).replace(/[^A-Za-z0-9_.-]/g, "-");
+        return `\\\\.\\pipe\\hqd-${user}`;
+    }
+    const dir = env.HQ_REGISTRY_DIR?.trim() ? path.resolve(env.HQ_REGISTRY_DIR.trim()) : path.join(home, ".hq");
+    return path.join(dir, HQD_SOCKET_NAME);
+}
+export function encodeMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+/** Validate one request line. Never throws. */
+export function parseRequestLine(line) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return { ok: false, id: null, error: { code: "bad_json", message: "request is not valid JSON" } };
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return { ok: false, id: null, error: { code: "bad_request", message: "request must be a JSON object" } };
+    }
+    const obj = raw;
+    const id = typeof obj.id === "string" || typeof obj.id === "number" ? obj.id : null;
+    if (id === null)
+        return { ok: false, id: null, error: { code: "bad_request", message: "request needs a string or number id" } };
+    if (typeof obj.op !== "string" || !obj.op)
+        return { ok: false, id, error: { code: "bad_request", message: "request needs an op" } };
+    if (obj.args !== undefined && (obj.args === null || typeof obj.args !== "object" || Array.isArray(obj.args))) {
+        return { ok: false, id, error: { code: "bad_request", message: "args must be an object" } };
+    }
+    return { ok: true, request: { id, op: obj.op, args: obj.args ?? {} } };
+}
+/**
+ * Split a byte stream into lines. Returns a push function that hands each
+ * complete line to `onLine`, and reports overflow when a partial line grows
+ * past `maxBytes`.
+ */
+export function createLineSplitter(onLine, onOverflow, maxBytes = HQD_MAX_LINE_BYTES) {
+    let buffer = "";
+    let overflowed = false;
+    return (chunk) => {
+        if (overflowed)
+            return;
+        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        let nl = buffer.indexOf("\n");
+        while (nl !== -1) {
+            const line = buffer.slice(0, nl).replace(/\r$/, "");
+            buffer = buffer.slice(nl + 1);
+            if (Buffer.byteLength(line, "utf8") > maxBytes) {
+                overflowed = true;
+                buffer = "";
+                onOverflow();
+                return;
+            }
+            if (line.trim())
+                onLine(line);
+            nl = buffer.indexOf("\n");
+        }
+        if (Buffer.byteLength(buffer, "utf8") > maxBytes) {
+            overflowed = true;
+            buffer = "";
+            onOverflow();
+        }
+    };
+}
+export class HqdClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "HqdClientError";
+    }
+}
+let nextClientId = 0;
+/**
+ * Send one request and wait for its response. A daemon that is not running
+ * fails fast with the socket error code (ENOENT or ECONNREFUSED).
+ */
+export function hqdRequest(op, args = {}, opts = {}) {
+    const socketPath = opts.socketPath ?? hqdSocketPath();
+    const timeoutMs = opts.timeoutMs ?? 2_000;
+    const id = `c${process.pid}-${(nextClientId += 1)}`;
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            fn();
+        };
+        const timer = setTimeout(() => finish(() => reject(new HqdClientError("ETIMEDOUT", `hqd did not answer ${op} within ${timeoutMs}ms`))), timeoutMs);
+        const push = createLineSplitter((line) => {
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                finish(() => reject(new HqdClientError("bad_response", "hqd sent a line that is not JSON")));
+                return;
+            }
+            if (msg.id !== id)
+                return;
+            if (msg.ok)
+                finish(() => resolve(msg.result));
+            else
+                finish(() => reject(new HqdClientError(msg.error.code, msg.error.message)));
+        }, () => finish(() => reject(new HqdClientError("bad_response", "hqd response too large"))));
+        socket.on("connect", () => socket.write(encodeMessage({ id, op, args })));
+        socket.on("data", push);
+        socket.on("error", (err) => finish(() => reject(new HqdClientError(err.code ?? "ESOCKET", `hqd is not reachable at ${socketPath}: ${err.message}`))));
+        socket.on("close", () => finish(() => reject(new HqdClientError("ECONNRESET", "hqd closed the connection before answering"))));
+    });
+}
+//# sourceMappingURL=protocol.js.map

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

@@ -7,11 +7,21 @@
  */
 import { type UnitPlan } from "./catalog.js";
 import { type LegacyUnit } from "./legacy.js";
+import { type DaemonLockResult } from "./lock.js";
 import { type MachineType } from "./machine-type.js";
 import { type HostApp } from "./supervisor.js";
 export declare const LOG_ROTATE_BYTES: number;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export declare const RESTART_EXIT_CODE = 75;
+export interface DaemonLockConflictOutcome {
+    exitCode: 0 | 1;
+    stdout?: string;
+    stderr?: string;
+}
+/** Preserve the legacy lock failure unless Anywhere explicitly enables the no-op behavior. */
+export declare function daemonLockConflictOutcome(lock: DaemonLockResult, anywhereEnabled: boolean): DaemonLockConflictOutcome | null;
+/** Node's Windows named-pipe API uses a default DACL that is not user-scoped. */
+export declare function hqdStartupRefusal(platform: NodeJS.Platform, anywhereEnabled: boolean): string | null;
 /** Route an updater request through the daemon's existing graceful handoff. */
 export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {

package/dist/lib/daemon/run.js

@@ -12,6 +12,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { CLI_VERSION } from "../../cli-version.js";
+import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
 import { currentPackageUseUpdateRequested } from "../../utils/package-use-lease.js";
 import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/version-gate.js";
 import { agentKitPaths } from "../agent-kit/paths.js";
@@ -26,9 +27,13 @@ import { acquireDaemonLock, isProcessAlive, processCommandLine, releaseDaemonLoc
 import { retireLegacyMeshUnits } from "./migrate.js";
 import { daemonDir as meshDaemonDir, daemonPidPath as meshDaemonPidPath } from "../mesh/live/daemon/paths.js";
 import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
+import { registryDir, registryFile } from "../registry/registry.js";
 import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
+import { hqdSocketPath } from "./protocol.js";
+import { startHqdServer } from "./server.js";
+import { heartbeatFile, startHeartbeat } from "./heartbeat.js";
 import { createProtocolTail, ensureProtocolFifo, openProtocolWriter } from "./protocol-tail.js";
 import { takeControlRequests } from "./requests.js";
 import { currentHqCloud, hqCloudRunners } from "./hq-cloud.js";
@@ -40,6 +45,26 @@ import { userToolDirs } from "./tools.js";
 export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export const RESTART_EXIT_CODE = 75;
+/** Preserve the legacy lock failure unless Anywhere explicitly enables the no-op behavior. */
+export function daemonLockConflictOutcome(lock, anywhereEnabled) {
+    if (lock.ok)
+        return null;
+    if (lock.owner && anywhereEnabled) {
+        return { exitCode: 0, stdout: `hq daemon is already running (pid ${lock.owner.pid}).\n` };
+    }
+    return {
+        exitCode: 1,
+        stderr: lock.owner
+            ? `hq daemon is already running (pid ${lock.owner.pid}).\n`
+            : "another hq daemon is starting up.\n",
+    };
+}
+/** Node's Windows named-pipe API uses a default DACL that is not user-scoped. */
+export function hqdStartupRefusal(platform, anywhereEnabled) {
+    if (platform !== "win32" || !anywhereEnabled)
+        return null;
+    return "hqd is disabled on Windows because the default named-pipe ACL grants read access to Everyone and Anonymous accounts.";
+}
 /** Route an updater request through the daemon's existing graceful handoff. */
 export function handoffForPackageUpdateRequest(requested, restartDaemon) {
     if (requested)
@@ -280,9 +305,13 @@ export async function runDaemon(opts) {
     const paths = daemonPaths(home, env);
     const log = makeLogger(paths, opts.foreground === true);
     const lock = acquireDaemonLock(paths.lockPath);
-    if (!lock.ok) {
-        process.stderr.write(lock.owner ? `hq daemon is already running (pid ${lock.owner.pid}).\n` : "another hq daemon is starting up.\n");
-        return 1;
+    const lockConflict = daemonLockConflictOutcome(lock, !lock.ok && lock.owner ? anywhereRuntimeEnabled(env) : false);
+    if (lockConflict) {
+        if (lockConflict.stdout)
+            process.stdout.write(lockConflict.stdout);
+        if (lockConflict.stderr)
+            process.stderr.write(lockConflict.stderr);
+        return lockConflict.exitCode;
     }
     const initial = readDaemonConfig(paths.configPath);
     const detected = detectMachineType(undefined, {
@@ -659,6 +688,45 @@ export async function runDaemon(opts) {
         clearTimeout(timer);
         return on;
     };
+    // hqd: the session/company socket every runtime talks to (hq-anywhere US-008).
+    let hqd = null;
+    let hqdShutdown = null;
+    if (anywhereRuntimeEnabled()) {
+        const refusal = hqdStartupRefusal(platform, true);
+        if (refusal) {
+            log("error", refusal);
+        }
+        else {
+            try {
+                const startConfig = readDaemonConfig(paths.configPath);
+                hqd = await startHqdServer({
+                    socketPath: hqdSocketPath(home, env),
+                    registryPath: registryFile(registryDir(home, env)),
+                    hqRoot: startConfig.hqRoot ?? (env.HQ_ROOT?.trim() || undefined),
+                    log,
+                    onShutdown: () => hqdShutdown?.(),
+                    reportError: reportHqdCrash,
+                });
+            }
+            catch (err) {
+                log("error", `hqd socket did not start; services run without it: ${err.message}`);
+            }
+        }
+    }
+    // US-012: 60s presence heartbeat with version and session count.
+    const liveHqd = hqd;
+    const stopHeartbeat = liveHqd
+        ? startHeartbeat({
+            version: CLI_VERSION,
+            sessionCount: () => liveHqd.sessions.size,
+            file: heartbeatFile(home, env),
+            log,
+        })
+        : () => { };
+    const closeHqd = () => {
+        stopHeartbeat();
+        void hqd?.close().catch((err) => log("warn", `hqd socket did not close cleanly: ${err.message}`));
+    };
     return await new Promise((resolve) => {
         let stopping = false;
         let restartPending = false;
@@ -667,6 +735,7 @@ export async function runDaemon(opts) {
                 return;
             stopping = true;
             log("info", `${why}; stopping services`);
+            closeHqd();
             // The supervisor escalates to SIGKILL after STOP_ESCALATION_MS; the extra
             // margin only covers a child that survives even that.
             let capTimer;
@@ -691,6 +760,7 @@ export async function runDaemon(opts) {
             if (stopping)
                 return;
             stopping = true;
+            closeHqd();
             const released = supervisor.release();
             // What these readers have not read stays in the FIFO for the next daemon.
             for (const tail of protocolTails)
@@ -748,6 +818,7 @@ export async function runDaemon(opts) {
                 return true;
             });
         };
+        hqdShutdown = () => shutdown("hqd shutdown request");
         process.on("SIGTERM", () => shutdown("received SIGTERM"));
         process.on("SIGINT", () => shutdown("received SIGINT"));
         if (platform !== "win32")
@@ -757,9 +828,20 @@ export async function runDaemon(opts) {
         }
         catch (err) {
             log("error", `supervisor failed to start: ${err.message}`);
+            closeHqd();
             releaseDaemonLock(paths.lockPath);
             resolve(1);
         }
     });
 }
+/** Report an hqd op crash to the CLI's existing Sentry integration, tagged with the failing op. */
+function reportHqdCrash(op, err) {
+    void import("../../sentry.js").then(({ Sentry }) => {
+        Sentry.withScope((scope) => {
+            scope.setTag("component", "hqd");
+            scope.setTag("hqd.op", op);
+            Sentry.captureException(err);
+        });
+    }, (importErr) => process.stderr.write(`hqd could not load Sentry to report a ${op} failure: ${String(importErr)}\n`));
+}
 //# sourceMappingURL=run.js.map