@indigoai-us/hq-cli 5.323.0 → 5.325.0

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

@@ -0,0 +1,36 @@
+/**
+ * hqd socket server (hq-anywhere US-008).
+ *
+ * Hosted inside the `hq daemon run` supervisor, which already runs the mesh
+ * drainer as one of its services, so there is still one resident process per
+ * machine. Sessions in any repo ask it which company they belong to and
+ * register themselves here.
+ */
+import { type ResolveResult } from "../registry/registry.js";
+import { SessionRegistry } from "./session-registry.js";
+export interface HqdServerOptions {
+    socketPath: string;
+    /** registry.json to resolve against (US-004). */
+    registryPath?: string;
+    hqRoot?: string;
+    version?: string;
+    now?: () => Date;
+    /** Called after a `shutdown` request has been answered. */
+    onShutdown?: () => void;
+    log?: (level: "info" | "warn" | "error", message: string) => void;
+    /** Environment for policy scripts and the mesh spool (tests sandbox HOME here). */
+    env?: NodeJS.ProcessEnv;
+    /** Work-mesh root override for mesh.presence (tests). */
+    workMeshRoot?: string;
+    /** Crash reporter for internal op failures (US-012); run.ts wires Sentry here. */
+    reportError?: (op: string, err: unknown) => void;
+}
+export interface HqdServer {
+    socketPath: string;
+    sessions: SessionRegistry;
+    close(): Promise<void>;
+}
+/** Resolve cwd → company through the registry, cached until registry.json changes. */
+export declare function createResolver(registryPath: string): (cwd: string) => ResolveResult;
+export declare function startHqdServer(opts: HqdServerOptions): Promise<HqdServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/lib/daemon/server.js

@@ -0,0 +1,306 @@
+/**
+ * hqd socket server (hq-anywhere US-008).
+ *
+ * Hosted inside the `hq daemon run` supervisor, which already runs the mesh
+ * drainer as one of its services, so there is still one resident process per
+ * machine. Sessions in any repo ask it which company they belong to and
+ * register themselves here.
+ */
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { CLI_VERSION } from "../../cli-version.js";
+import { canonicalDir, readRegistry, registryFile, resolveCompanyForDir } from "../registry/registry.js";
+import { createLineSplitter, encodeMessage, parseRequestLine } from "./protocol.js";
+import { SessionRegistry } from "./session-registry.js";
+import { journalAppend, JournalOpError } from "./ops/journal.js";
+import { memoryGet, memoryPut, MemoryOpError } from "./ops/memory.js";
+import { meshPresence, MeshOpError } from "./ops/mesh.js";
+import { PolicyIndex, PolicyOpError, policyCheck } from "./ops/policy.js";
+class OpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function stringArg(args, name, required = true) {
+    const value = args[name];
+    if (typeof value === "string" && value.trim())
+        return value;
+    if (value === undefined && !required)
+        return undefined;
+    throw new OpError("bad_args", `${name} must be a non-empty string`);
+}
+/** Resolve cwd → company through the registry, cached until registry.json changes. */
+export function createResolver(registryPath) {
+    const cache = new Map();
+    let stamp = "";
+    return (cwd) => {
+        let current = "missing";
+        try {
+            const st = fs.statSync(registryPath);
+            current = `${st.mtimeMs}:${st.size}:${st.ino}`;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        if (current !== stamp) {
+            cache.clear();
+            stamp = current;
+        }
+        const key = canonicalDir(cwd);
+        const hit = cache.get(key);
+        if (hit)
+            return hit;
+        const result = resolveCompanyForDir(readRegistry(registryPath), key);
+        cache.set(key, result);
+        return result;
+    };
+}
+/** Is something answering on this socket? */
+function socketIsLive(socketPath) {
+    return new Promise((resolve) => {
+        const probe = net.createConnection(socketPath);
+        const done = (live) => {
+            probe.destroy();
+            resolve(live);
+        };
+        probe.once("connect", () => done(true));
+        probe.once("error", () => done(false));
+        setTimeout(() => done(false), 500).unref();
+    });
+}
+export async function startHqdServer(opts) {
+    const { socketPath } = opts;
+    const isPipe = process.platform === "win32";
+    const startedAtMs = (opts.now ?? (() => new Date()))().getTime();
+    const sessions = new SessionRegistry(opts.now);
+    const resolve = createResolver(opts.registryPath ?? registryFile());
+    const log = opts.log ?? (() => { });
+    const clock = opts.now ?? (() => new Date());
+    const env = opts.env ?? process.env;
+    const policyIndex = opts.hqRoot ? new PolicyIndex(opts.hqRoot, log) : null;
+    const requireRoot = () => {
+        if (!opts.hqRoot)
+            throw new OpError("no_hq_root", "hqd has no HQ root configured (set hqRoot in daemon config or HQ_ROOT)");
+        return opts.hqRoot;
+    };
+    /** Company for a call: explicit arg, else the open session's, else the registry's answer for cwd. */
+    const companyFor = (args) => {
+        const explicit = stringArg(args, "company", false);
+        if (explicit)
+            return explicit;
+        const runtime = stringArg(args, "runtime", false);
+        const sessionId = stringArg(args, "sessionId", false);
+        const session = runtime && sessionId ? sessions.get(runtime, sessionId) : null;
+        if (session?.company)
+            return session.company;
+        const cwd = stringArg(args, "cwd", false);
+        return cwd ? (resolve(cwd).company ?? undefined) : undefined;
+    };
+    if (!isPipe) {
+        fs.mkdirSync(path.dirname(socketPath), { recursive: true, mode: 0o700 });
+        if (fs.existsSync(socketPath)) {
+            if (await socketIsLive(socketPath))
+                throw new Error(`hqd is already listening on ${socketPath}`);
+            fs.unlinkSync(socketPath);
+        }
+    }
+    /** Synchronous ops answer in request order; only policy.check returns a promise. */
+    const handle = (req) => {
+        const args = req.args ?? {};
+        switch (req.op) {
+            case "ping":
+                return {
+                    version: opts.version ?? CLI_VERSION,
+                    hqRoot: opts.hqRoot ?? null,
+                    uptimeMs: clock().getTime() - startedAtMs,
+                    pid: process.pid,
+                    sessions: sessions.size,
+                };
+            case "resolve": {
+                const cwd = stringArg(args, "cwd");
+                return resolve(cwd);
+            }
+            case "session.open": {
+                const runtime = stringArg(args, "runtime");
+                const sessionId = stringArg(args, "sessionId");
+                const cwd = stringArg(args, "cwd");
+                const explicit = stringArg(args, "company", false);
+                const company = explicit ?? resolve(cwd).company;
+                return sessions.open({ runtime, sessionId, cwd: canonicalDir(cwd), company });
+            }
+            case "session.get": {
+                const runtime = stringArg(args, "runtime", false);
+                const sessionId = stringArg(args, "sessionId", false);
+                if (!sessionId) {
+                    const all = sessions.list();
+                    return { sessions: runtime ? all.filter((s) => s.runtime === runtime) : all };
+                }
+                if (!runtime)
+                    throw new OpError("bad_args", "runtime is required with sessionId");
+                return { session: sessions.get(runtime, sessionId) };
+            }
+            case "session.close": {
+                const runtime = stringArg(args, "runtime");
+                const sessionId = stringArg(args, "sessionId");
+                return { closed: sessions.close(runtime, sessionId) };
+            }
+            case "policy.check": {
+                const hqRoot = requireRoot();
+                const company = companyFor(args);
+                if (!company)
+                    throw new OpError("bad_args", "company is required (or a cwd linked to a company)");
+                const input = args.input;
+                if (input !== undefined && (input === null || typeof input !== "object" || Array.isArray(input))) {
+                    throw new OpError("bad_args", "input must be an object");
+                }
+                return policyCheck({
+                    company,
+                    event: stringArg(args, "event", false),
+                    tool: stringArg(args, "tool"),
+                    input: input,
+                    sessionId: stringArg(args, "sessionId", false),
+                    cwd: stringArg(args, "cwd", false),
+                }, { hqRoot, index: policyIndex, env, now: clock });
+            }
+            case "policy.index": {
+                requireRoot();
+                const company = stringArg(args, "company", false);
+                return { version: policyIndex.version, policies: policyIndex.list(company) };
+            }
+            case "journal.append": {
+                const company = companyFor(args);
+                if (!company)
+                    throw new OpError("bad_args", "company is required (or a cwd linked to a company)");
+                return journalAppend({ company, project: stringArg(args, "project"), section: stringArg(args, "section"), text: stringArg(args, "text") }, requireRoot(), clock());
+            }
+            case "memory.get":
+                return memoryGet(requireRoot(), stringArg(args, "sessionId"), stringArg(args, "key", false));
+            case "memory.put":
+                return memoryPut(requireRoot(), stringArg(args, "sessionId"), stringArg(args, "key"), args.value, clock());
+            case "mesh.presence": {
+                const harness = stringArg(args, "harness", false) ?? stringArg(args, "runtime");
+                return meshPresence({
+                    sessionId: stringArg(args, "sessionId"),
+                    harness,
+                    kind: stringArg(args, "kind"),
+                    cwd: stringArg(args, "cwd", false),
+                    company: companyFor(args),
+                    project: stringArg(args, "project", false),
+                    task: stringArg(args, "task", false),
+                    taskId: stringArg(args, "taskId", false),
+                    status: stringArg(args, "status", false),
+                    summary: stringArg(args, "summary", false),
+                    reason: stringArg(args, "reason", false),
+                }, { hqRoot: opts.hqRoot, workMeshRoot: opts.workMeshRoot, env, now: clock });
+            }
+            case "shutdown":
+                return { stopping: true };
+            default:
+                throw new OpError("unknown_op", `unknown op ${req.op}`);
+        }
+    };
+    const respond = (socket, msg) => {
+        if (!socket.destroyed)
+            socket.write(encodeMessage(msg));
+    };
+    const clients = new Set();
+    const server = net.createServer((socket) => {
+        clients.add(socket);
+        socket.on("close", () => clients.delete(socket));
+        socket.on("error", (err) => log("warn", `hqd client error: ${err.message}`));
+        const push = createLineSplitter((line) => {
+            const parsed = parseRequestLine(line);
+            if (!parsed.ok) {
+                respond(socket, { id: parsed.id, ok: false, error: parsed.error });
+                return;
+            }
+            const req = parsed.request;
+            const succeed = (result) => {
+                respond(socket, { id: req.id, ok: true, result });
+                if (req.op === "shutdown") {
+                    log("info", "hqd received a shutdown request");
+                    setImmediate(() => opts.onShutdown?.());
+                }
+            };
+            const fail = (err) => {
+                const error = err instanceof OpError ||
+                    err instanceof PolicyOpError ||
+                    err instanceof JournalOpError ||
+                    err instanceof MemoryOpError ||
+                    err instanceof MeshOpError
+                    ? { code: err.code, message: err.message }
+                    : { code: "internal", message: err instanceof Error ? err.message : String(err) };
+                if (error.code === "internal") {
+                    log("error", `hqd ${req.op} failed: ${error.message}`);
+                    try {
+                        opts.reportError?.(req.op, err);
+                    }
+                    catch (reportErr) {
+                        log("warn", `hqd could not report the ${req.op} failure: ${reportErr.message}`);
+                    }
+                }
+                respond(socket, { id: req.id, ok: false, error });
+            };
+            let result;
+            try {
+                result = handle(req);
+            }
+            catch (err) {
+                fail(err);
+                return;
+            }
+            if (result instanceof Promise)
+                result.then(succeed, fail);
+            else
+                succeed(result);
+        }, () => {
+            respond(socket, { id: null, ok: false, error: { code: "too_large", message: "request line too large" } });
+            socket.end();
+        });
+        socket.on("data", push);
+    });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        // Bind with a user-only umask so the socket is never briefly group/world accessible.
+        const prior = isPipe ? null : process.umask(0o177);
+        try {
+            server.listen(socketPath, () => {
+                server.off("error", rejectListen);
+                resolveListen();
+            });
+        }
+        finally {
+            if (prior !== null)
+                process.umask(prior);
+        }
+    });
+    if (!isPipe)
+        fs.chmodSync(socketPath, 0o600);
+    log("info", `hqd listening on ${socketPath}`);
+    let closing = null;
+    return {
+        socketPath,
+        sessions,
+        close: () => (closing ??= new Promise((done) => {
+            policyIndex?.close();
+            server.close(() => done());
+            // Answered-but-idle clients would otherwise hold close() open.
+            for (const client of clients)
+                client.destroy();
+            if (!isPipe) {
+                try {
+                    fs.unlinkSync(socketPath);
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        log("warn", `could not remove ${socketPath}: ${err.message}`);
+                }
+            }
+        })),
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/lib/daemon/session-registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-memory session registry hosted by hqd (hq-anywhere US-008). Keyed by
+ * runtime + session id; nothing is persisted, so a daemon restart starts empty
+ * and sessions re-open on their next hook.
+ */
+export interface HqdSession {
+    runtime: string;
+    sessionId: string;
+    cwd: string;
+    company: string | null;
+    startedAt: string;
+}
+export declare function sessionKey(runtime: string, sessionId: string): string;
+export declare class SessionRegistry {
+    private readonly now;
+    private readonly sessions;
+    constructor(now?: () => Date);
+    /** Open or refresh a session. Re-opening keeps the original startedAt. */
+    open(input: {
+        runtime: string;
+        sessionId: string;
+        cwd: string;
+        company: string | null;
+    }): HqdSession;
+    get(runtime: string, sessionId: string): HqdSession | null;
+    close(runtime: string, sessionId: string): boolean;
+    list(): HqdSession[];
+    get size(): number;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/lib/daemon/session-registry.js

@@ -0,0 +1,42 @@
+/**
+ * In-memory session registry hosted by hqd (hq-anywhere US-008). Keyed by
+ * runtime + session id; nothing is persisted, so a daemon restart starts empty
+ * and sessions re-open on their next hook.
+ */
+export function sessionKey(runtime, sessionId) {
+    return `${runtime}\u0000${sessionId}`;
+}
+export class SessionRegistry {
+    now;
+    sessions = new Map();
+    constructor(now = () => new Date()) {
+        this.now = now;
+    }
+    /** Open or refresh a session. Re-opening keeps the original startedAt. */
+    open(input) {
+        const key = sessionKey(input.runtime, input.sessionId);
+        const prior = this.sessions.get(key);
+        const session = {
+            runtime: input.runtime,
+            sessionId: input.sessionId,
+            cwd: input.cwd,
+            company: input.company,
+            startedAt: prior?.startedAt ?? this.now().toISOString(),
+        };
+        this.sessions.set(key, session);
+        return session;
+    }
+    get(runtime, sessionId) {
+        return this.sessions.get(sessionKey(runtime, sessionId)) ?? null;
+    }
+    close(runtime, sessionId) {
+        return this.sessions.delete(sessionKey(runtime, sessionId));
+    }
+    list() {
+        return [...this.sessions.values()];
+    }
+    get size() {
+        return this.sessions.size;
+    }
+}
+//# sourceMappingURL=session-registry.js.map

package/dist/lib/doctor/checks/anywhere.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `hq doctor` anywhere family (hq-anywhere US-012).
+ *
+ * Checks the pieces that let a session in any repo pick up HQ: the ~/.hq/root
+ * pointer, the repo registry, the hqd daemon service and socket, version
+ * convergence between hqd and the installed hq-cli, the heartbeat, the Claude
+ * and Codex MCP registrations, and the hq-* skill links. Every line is PASS,
+ * WARN or FAIL with a remediation command. When anywhere was never installed
+ * on this machine the family reports a single NA line.
+ */
+import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
+export declare const ANYWHERE_FAMILY_ID = "anywhere";
+export declare const REMEDIATION: {
+    readonly installClaude: "hq install --global --runtime claude";
+    readonly installCodex: "hq install --global --runtime codex";
+    readonly daemonInstall: "hq daemon install";
+    readonly daemonRestart: "hq daemon restart --daemon";
+    readonly link: "hq link <repo-dir> <company>";
+};
+export interface DaemonServiceState {
+    installed: boolean;
+    loaded: boolean;
+    detail: string;
+}
+export interface AnywhereDeps {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Version hqd reports; rejects when the socket is unreachable. */
+    ping?: () => Promise<string>;
+    /** The hq-cli version installed on this machine. Default: this CLI's version. */
+    cliVersion?: string;
+    serviceState?: () => DaemonServiceState;
+    now?: () => Date;
+}
+export declare function createAnywhereFamily(deps?: AnywhereDeps): CheckFamily;
+export declare const anywhereFamily: CheckFamily;
+export declare function runAnywhereChecks(_context: CheckContext, deps?: AnywhereDeps): Promise<CheckResult[]>;
+//# sourceMappingURL=anywhere.d.ts.map

package/dist/lib/doctor/checks/anywhere.js

@@ -0,0 +1,182 @@
+/**
+ * `hq doctor` anywhere family (hq-anywhere US-012).
+ *
+ * Checks the pieces that let a session in any repo pick up HQ: the ~/.hq/root
+ * pointer, the repo registry, the hqd daemon service and socket, version
+ * convergence between hqd and the installed hq-cli, the heartbeat, the Claude
+ * and Codex MCP registrations, and the hq-* skill links. Every line is PASS,
+ * WARN or FAIL with a remediation command. When anywhere was never installed
+ * on this machine the family reports a single NA line.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CLI_VERSION } from "../../../cli-version.js";
+import { computeMcpStatus } from "../../../commands/mcp-status.js";
+import { HQ_MCP_SERVER_NAME, SKILL_LINK_PREFIX, claudeTargets } from "../../install/claude-targets.js";
+import { codexTargets } from "../../install/codex-targets.js";
+import { pingHqdVersion } from "../../daemon/convergence.js";
+import { daemonPresenceLabel, heartbeatFile, readHeartbeat } from "../../daemon/heartbeat.js";
+import { DAEMON_LAUNCHD_LABEL, DAEMON_SYSTEMD_UNIT, DAEMON_WINDOWS_TASK } from "../../daemon/install.js";
+import { hqdSocketPath } from "../../daemon/protocol.js";
+import { readRegistry, registryDir, registryFile } from "../../registry/registry.js";
+export const ANYWHERE_FAMILY_ID = "anywhere";
+export const REMEDIATION = {
+    installClaude: "hq install --global --runtime claude",
+    installCodex: "hq install --global --runtime codex",
+    daemonInstall: "hq daemon install",
+    daemonRestart: "hq daemon restart --daemon",
+    link: "hq link <repo-dir> <company>",
+};
+export function createAnywhereFamily(deps = {}) {
+    return { id: ANYWHERE_FAMILY_ID, title: "HQ anywhere runtime", run: (context) => runAnywhereChecks(context, deps) };
+}
+export const anywhereFamily = createAnywhereFamily();
+function result(status, checkId, message, remediation, target) {
+    return { status, checkId: `anywhere.${checkId}`, message, ...(remediation ? { remediation } : {}), ...(target ? { target } : {}) };
+}
+export async function runAnywhereChecks(_context, deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const claude = claudeTargets(home);
+    const codex = codexTargets(home);
+    const installed = [claude.hqPointer, claude.stateFile, codex.stateFile].some((p) => fs.existsSync(p));
+    if (!installed) {
+        return [result("NA", "installed", "HQ anywhere is not installed on this machine", REMEDIATION.installClaude)];
+    }
+    const out = [];
+    out.push(checkPointer(claude.hqPointer));
+    out.push(checkRegistry(registryFile(registryDir(home, env))));
+    const service = (deps.serviceState ?? (() => defaultServiceState(home)))();
+    if (!service.installed)
+        out.push(result("FAIL", "daemon-installed", `daemon service is not installed (${service.detail})`, REMEDIATION.daemonInstall));
+    else if (!service.loaded)
+        out.push(result("FAIL", "daemon-installed", `daemon service is installed but not loaded (${service.detail})`, REMEDIATION.daemonRestart));
+    else
+        out.push(result("PASS", "daemon-installed", `daemon service is installed and loaded (${service.detail})`));
+    const socketPath = hqdSocketPath(home, env);
+    const ping = deps.ping ?? (() => pingHqdVersion(socketPath, 2_000));
+    let running = null;
+    try {
+        running = await ping();
+        out.push(result("PASS", "socket", `hqd answered on ${socketPath}`, undefined, socketPath));
+    }
+    catch (err) {
+        out.push(result("FAIL", "socket", `hqd is not reachable: ${err instanceof Error ? err.message : String(err)}`, REMEDIATION.daemonInstall, socketPath));
+    }
+    const cliVersion = deps.cliVersion ?? CLI_VERSION;
+    if (running === null)
+        out.push(result("FAIL", "version", `cannot compare versions: hqd did not answer (hq-cli is ${cliVersion})`, REMEDIATION.daemonInstall));
+    else if (running !== cliVersion)
+        out.push(result("FAIL", "version", `hqd runs ${running} but hq-cli ${cliVersion} is installed`, REMEDIATION.daemonRestart));
+    else
+        out.push(result("PASS", "version", `hqd and hq-cli both run ${cliVersion}`));
+    out.push(checkHeartbeat(heartbeatFile(home, env), (deps.now ?? (() => new Date()))()));
+    const mcp = computeMcpStatus({ home });
+    const server = mcp.servers.find((s) => s.server === HQ_MCP_SERVER_NAME);
+    out.push(checkRegistration("claude", server?.claude, mcp.runtimes.claude, REMEDIATION.installClaude));
+    out.push(checkRegistration("codex", server?.codex, mcp.runtimes.codex, REMEDIATION.installCodex));
+    out.push(checkSkillLinks("claude", claude.skillsDir, REMEDIATION.installClaude));
+    if (mcp.runtimes.codex.installed)
+        out.push(checkSkillLinks("codex", codex.skillsDir, REMEDIATION.installCodex));
+    return out;
+}
+function checkPointer(file) {
+    let root;
+    try {
+        root = fs.readFileSync(file, "utf8").trim();
+    }
+    catch {
+        return result("FAIL", "pointer", `${file} is missing`, REMEDIATION.installClaude, file);
+    }
+    const valid = root && path.isAbsolute(root) && [".claude", "core"].every((m) => fs.existsSync(path.join(root, m)));
+    if (!valid)
+        return result("FAIL", "pointer", `${file} points at ${root || "(empty)"}, which is not an HQ root`, REMEDIATION.installClaude, file);
+    return result("PASS", "pointer", `${file} points at ${root}`, undefined, file);
+}
+function checkRegistry(file) {
+    if (!fs.existsSync(file))
+        return result("WARN", "registry", `${file} does not exist yet; no repos are linked`, REMEDIATION.link, file);
+    try {
+        const registry = readRegistry(file);
+        const count = Object.keys(registry.entries).length;
+        return result("PASS", "registry", `${file} is readable (${count} entries)`, undefined, file);
+    }
+    catch (err) {
+        return result("FAIL", "registry", `${file} is unreadable: ${err.message}`, `mv ${file} ${file}.bad && ${REMEDIATION.installClaude}`, file);
+    }
+}
+function checkHeartbeat(file, now) {
+    let state;
+    try {
+        state = readHeartbeat(file);
+    }
+    catch (err) {
+        return result("FAIL", "heartbeat", `heartbeat record is unreadable: ${err.message}`, REMEDIATION.daemonRestart, file);
+    }
+    if (!state)
+        return result("WARN", "heartbeat", "no hqd heartbeat recorded yet", REMEDIATION.daemonRestart, file);
+    if (daemonPresenceLabel(state, now) !== "daemon live")
+        return result("WARN", "heartbeat", `daemon stale: last heartbeat at ${state.at}`, REMEDIATION.daemonRestart, file);
+    return result("PASS", "heartbeat", `last heartbeat at ${state.at} (hqd ${state.version}, ${state.sessions} sessions)`, undefined, file);
+}
+function checkRegistration(runtimeName, status, runtimeState, fix) {
+    const id = `${runtimeName}-registration`;
+    if (!runtimeState.installed)
+        return result("WARN", id, `${runtimeName} is not installed, so hq is not registered there`, fix);
+    if (!runtimeState.parses)
+        return result("FAIL", id, `${runtimeName} MCP config cannot be parsed`, fix);
+    if (!status || status.presence === "absent" || status.presence === "not-installed")
+        return result("WARN", id, `the hq MCP server is not registered in ${runtimeName}`, fix);
+    if (status.presence === "unparseable")
+        return result("FAIL", id, `${runtimeName} MCP config cannot be parsed`, fix);
+    if (!status.healthy)
+        return result("FAIL", id, `${runtimeName} hq MCP entry does not use absolute paths that exist (${status.target ?? ""})`, fix);
+    return result("PASS", id, `hq MCP server registered in ${runtimeName} with absolute paths`);
+}
+function checkSkillLinks(runtime, dir, fix) {
+    const id = `${runtime}-skills`;
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.startsWith(SKILL_LINK_PREFIX));
+    }
+    catch {
+        return result("WARN", id, `${dir} does not exist`, fix, dir);
+    }
+    const links = names.filter((n) => fs.lstatSync(path.join(dir, n)).isSymbolicLink());
+    if (links.length === 0)
+        return result("WARN", id, `no hq-* skill links in ${dir}`, fix, dir);
+    const broken = links.filter((n) => !fs.existsSync(path.join(dir, n)));
+    if (broken.length > 0)
+        return result("FAIL", id, `${broken.length} broken skill links in ${dir}: ${broken.slice(0, 5).join(", ")}`, fix, dir);
+    return result("PASS", id, `${links.length} hq-* skill links in ${dir} resolve`, undefined, dir);
+}
+function defaultServiceState(home) {
+    if (process.platform === "darwin") {
+        const plist = path.join(home, "Library", "LaunchAgents", `${DAEMON_LAUNCHD_LABEL}.plist`);
+        if (!fs.existsSync(plist))
+            return { installed: false, loaded: false, detail: `no ${plist}` };
+        const uid = process.getuid?.() ?? 0;
+        const probe = spawnSync("launchctl", ["print", `gui/${uid}/${DAEMON_LAUNCHD_LABEL}`], { encoding: "utf8", timeout: 5_000 });
+        return { installed: true, loaded: probe.status === 0, detail: `launchd ${DAEMON_LAUNCHD_LABEL}` };
+    }
+    if (process.platform === "linux") {
+        const unit = path.join(home, ".config", "systemd", "user", DAEMON_SYSTEMD_UNIT);
+        const systemUnit = path.join("/etc/systemd/system", DAEMON_SYSTEMD_UNIT);
+        if (!fs.existsSync(unit) && !fs.existsSync(systemUnit))
+            return { installed: false, loaded: false, detail: `no ${DAEMON_SYSTEMD_UNIT}` };
+        const systemScope = fs.existsSync(systemUnit);
+        const probe = spawnSync("systemctl", [...(systemScope ? [] : ["--user"]), "is-active", DAEMON_SYSTEMD_UNIT], { encoding: "utf8", timeout: 5_000 });
+        return { installed: true, loaded: probe.status === 0, detail: `systemd ${systemScope ? "system" : "user"} ${DAEMON_SYSTEMD_UNIT}` };
+    }
+    if (process.platform === "win32") {
+        const probe = spawnSync("schtasks.exe", ["/Query", "/TN", DAEMON_WINDOWS_TASK, "/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 5_000 });
+        if (probe.status !== 0)
+            return { installed: false, loaded: false, detail: `no Scheduled Task ${DAEMON_WINDOWS_TASK}` };
+        const loaded = /,\s*"?Running"?\s*$/i.test(probe.stdout.trim());
+        return { installed: true, loaded, detail: `Scheduled Task ${DAEMON_WINDOWS_TASK}${loaded ? " is running" : " is not running"}` };
+    }
+    return { installed: false, loaded: false, detail: `${process.platform}: service probe not available` };
+}
+//# sourceMappingURL=anywhere.js.map

package/dist/lib/doctor/registry.js

@@ -23,9 +23,11 @@ import { integrationsFamily } from "./checks/integrations.js";
 import { syncHealthFamily } from "./checks/sync-health.js";
 import { workContextFamily } from "./checks/work-context.js";
 import { botsFamily } from "./checks/bots.js";
+import { anywhereFamily } from "./checks/anywhere.js";
 import { scaffoldCliFloorFamily } from "./checks/scaffold-cli-floor.js";
 import { fixtureCoverageFamily } from "./fixtures/discover.js";
 import { checkClaudeWiring } from "./checks/claude-wiring.js";
+import { anywhereRuntimeEnabled } from "../../commands/anywhere-runtime-flag.js";
 /**
  * An ordered, id-keyed set of check families. Registration order is preserved
  * (Map iteration order), and re-registering an id replaces the family in place
@@ -262,6 +264,10 @@ export function createDefaultRegistry() {
     // Local bots: inbox/heartbeat reachability and a LaunchAgent whose hq
     // path survived an HQ toolchain move. Local-only reads.
     registry.register(botsFamily);
+    // HQ anywhere (US-012): pointer, registry, hqd service/socket/version,
+    // heartbeat, MCP registrations and skill links. NA when not installed.
+    if (anywhereRuntimeEnabled())
+        registry.register(anywhereFamily);
     return registry;
 }
 //# sourceMappingURL=registry.js.map