@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/agent-kit/private-file.js

@@ -1,91 +0,0 @@
-/**
- * Writing owner-only files on filesystems that may not have owner-only files.
- *
- * The agent kit keeps credentials, wake config, and downloaded attachments in
- * the agent's home directory, and writes all of it 0600/0700. Not every
- * filesystem can honour that. A CIFS/SMB mount (Azure Files is the one that
- * found this) is mounted with a fixed `file_mode` and fails `chmod` outright
- * with EPERM; an NFS export or a Docker volume may accept the call and ignore
- * it. A bot whose only persistent storage is such a share must still be able
- * to run — so these helpers write the bytes, ask for the mode, and report
- * whether the mode actually took instead of dying on the request.
- *
- * Every helper here is atomic: bytes land in a temp file in the destination
- * directory and are renamed into place, so a reader never sees a half-written
- * file and a failed write never leaves a partial one behind.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-/**
- * chmod failures that mean "this filesystem does not do modes" rather than
- * "something is wrong". Anything else still throws: a refused chmod on a
- * local disk is a real fault and must not be swallowed.
- */
-export const MODE_UNSUPPORTED_CODES = new Set([
-    "EPERM",
-    "EACCES",
-    "EINVAL",
-    "ENOTSUP",
-    "EOPNOTSUPP",
-]);
-/** Apply a mode, tolerating filesystems that do not have modes. Returns the errno if refused. */
-export function chmodIfSupported(target, mode) {
-    try {
-        fs.chmodSync(target, mode);
-        return undefined;
-    }
-    catch (err) {
-        const code = err.code ?? "";
-        if (!MODE_UNSUPPORTED_CODES.has(code))
-            throw err;
-        return code;
-    }
-}
-/**
- * Make a directory and try to make it owner-only. The `mode` argument to
- * mkdir(2) is silently ignored on a share, and the follow-up chmod is refused
- * there, so neither is allowed to fail the call.
- */
-export function mkdirPrivate(dir, mode = 0o700) {
-    fs.mkdirSync(dir, { recursive: true, mode });
-    chmodIfSupported(dir, mode);
-}
-/** Write a file atomically with the given mode, replacing any existing one. */
-export function writePrivateFile(dest, contents, mode) {
-    mkdirPrivate(path.dirname(dest));
-    // Date.now() as well as the pid: two writes from one process must not
-    // collide on a temp name, and a leftover from a crashed run must not be
-    // adopted by the next one.
-    const tmp = `${dest}.tmp.${process.pid}.${Date.now()}`;
-    try {
-        fs.writeFileSync(tmp, contents, { mode });
-        const chmodError = chmodIfSupported(tmp, mode);
-        // Read the truth back rather than trusting either call: a mount can
-        // accept chmod and ignore it just as easily as it can refuse.
-        let observedMode;
-        try {
-            observedMode = fs.statSync(tmp).mode & 0o777;
-        }
-        catch {
-            /* stat is not worth failing a write over */
-        }
-        fs.renameSync(tmp, dest);
-        return {
-            enforced: observedMode === undefined ? !chmodError : (observedMode & 0o077) === 0,
-            ...(observedMode === undefined ? {} : { observedMode }),
-            ...(chmodError ? { chmodError } : {}),
-        };
-    }
-    catch (err) {
-        // Never leave the temp file behind — it may hold the same secret as the
-        // file that failed to land.
-        try {
-            fs.unlinkSync(tmp);
-        }
-        catch {
-            /* already gone */
-        }
-        throw err;
-    }
-}
-//# sourceMappingURL=private-file.js.map

package/dist/lib/agent-kit/run/heartbeat.d.ts

@@ -1,72 +0,0 @@
-/**
- * Kit service: heartbeat reporter.
- *
- * Every 60 s POST /v1/agents/{uid}/heartbeat with the enabled component status
- * values (`sync` and `inbox`), plus cliVersion and hostInfo. The external-agent
- * body mirrors the hosted box's hq-agent-heartbeat.sh, which folds per-component
- * stamp files into one beat. A missing or stale enabled stamp reports `error`.
- *
- * The last successful beat is recorded at state/last-heartbeat.json so
- * `hq agent probe` can report its age.
- */
-import { type HeartbeatAgentUidSource, type HeartbeatCredsSource, type HeartbeatIdentityMismatchReporter } from "../../heartbeat-identity.js";
-import { type ComponentStatus } from "../creds.js";
-import type { KitLogger } from "../log.js";
-import { type AgentKitPaths, type KitComponent } from "../paths.js";
-/** A component stamp older than this reads as error. */
-export declare const COMPONENT_STALE_AFTER_MS: Record<KitComponent, number>;
-export interface HeartbeatBody {
-    /**
-     * Only the components this kit actually runs. A component that was never
-     * installed is OMITTED rather than reported `error`: with file sync off (the
-     * default — the bot reads vault files on demand through the MCP server)
-     * there is no sync loop to be unhealthy, and stamping it `error` would make
-     * every healthy bot look broken. hq-pro records the components it is sent
-     * and ignores absent names.
-     */
-    components: Partial<Record<KitComponent, ComponentStatus>>;
-    cliVersion: string;
-    hostInfo: {
-        os: string;
-        arch: string;
-        hostname: string;
-        cliVersion: string;
-    };
-}
-export declare function buildHeartbeatBody(paths: Pick<AgentKitPaths, "stateDir">, now?: () => Date, hostInfo?: HeartbeatBody["hostInfo"], components_?: readonly KitComponent[]): HeartbeatBody;
-export interface LastHeartbeat {
-    /** The most recent heartbeat attempt, successful or a terminal identity mismatch. */
-    at: string;
-    components: Partial<Record<KitComponent, ComponentStatus>>;
-    status: number;
-    reason?: "identity_mismatch";
-    configuredAgentUid?: string;
-    tokenAgentUid?: string;
-}
-export declare function writeLastHeartbeat(paths: Pick<AgentKitPaths, "stateDir" | "lastHeartbeatPath">, record: LastHeartbeat): void;
-export declare function readLastHeartbeat(paths: Pick<AgentKitPaths, "lastHeartbeatPath">): LastHeartbeat | null;
-export interface HeartbeatDeps {
-    paths: AgentKitPaths;
-    agentUid: string;
-    apiBaseUrl: string;
-    intervalMs: number;
-    getToken: () => Promise<string>;
-    log: KitLogger;
-    /** Components this kit runs; defaults to all of them. */
-    components?: readonly KitComponent[];
-    post?: (token: string, body: HeartbeatBody) => Promise<number | HeartbeatPostResult>;
-    now?: () => Date;
-    sleep?: (ms: number) => Promise<void>;
-    maxBeats?: number;
-    agentUidSource?: HeartbeatAgentUidSource;
-    credsSource?: HeartbeatCredsSource;
-    reportIdentityMismatch?: HeartbeatIdentityMismatchReporter;
-}
-export interface HeartbeatPostResult {
-    status: number;
-    bodyText?: string;
-}
-export declare function defaultHeartbeatPost(agentUid: string, apiBaseUrl: string): (token: string, body: HeartbeatBody) => Promise<HeartbeatPostResult>;
-export declare function beatOnce(deps: HeartbeatDeps): Promise<boolean>;
-export declare function runHeartbeatLoop(deps: HeartbeatDeps): Promise<void>;
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/lib/agent-kit/run/heartbeat.js

@@ -1,128 +0,0 @@
-/**
- * Kit service: heartbeat reporter.
- *
- * Every 60 s POST /v1/agents/{uid}/heartbeat with the enabled component status
- * values (`sync` and `inbox`), plus cliVersion and hostInfo. The external-agent
- * body mirrors the hosted box's hq-agent-heartbeat.sh, which folds per-component
- * stamp files into one beat. A missing or stale enabled stamp reports `error`.
- *
- * The last successful beat is recorded at state/last-heartbeat.json so
- * `hq agent probe` can report its age.
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import { CLI_VERSION } from "../../../cli-version.js";
-import { captureHeartbeatIdentityMismatch, identityMismatchMessage, isHeartbeatIdentityMismatch, parseHeartbeatFailureBody, tokenAgentUid, } from "../../heartbeat-identity.js";
-import { vaultApiFetch } from "../../../utils/vault-api.js";
-import { readComponentStatus } from "../creds.js";
-import { KIT_COMPONENTS } from "../paths.js";
-import { writePrivateFile } from "./../private-file.js";
-/** A component stamp older than this reads as error. */
-export const COMPONENT_STALE_AFTER_MS = {
-    sync: 3 * 60 * 60_000, // sync passes every 5 min; three hours of silence is real trouble
-    inbox: 3 * 60_000,
-};
-export function buildHeartbeatBody(paths, now = () => new Date(), hostInfo, components_ = KIT_COMPONENTS) {
-    const components = {};
-    for (const c of components_) {
-        components[c] = readComponentStatus(paths, c, COMPONENT_STALE_AFTER_MS[c], now).status;
-    }
-    return {
-        components,
-        cliVersion: CLI_VERSION,
-        hostInfo: hostInfo ?? {
-            os: `${os.platform()} ${os.release()}`,
-            arch: os.arch(),
-            hostname: os.hostname(),
-            cliVersion: CLI_VERSION,
-        },
-    };
-}
-export function writeLastHeartbeat(paths, record) {
-    writePrivateFile(paths.lastHeartbeatPath, `${JSON.stringify(record)}\n`, 0o600);
-}
-export function readLastHeartbeat(paths) {
-    try {
-        const raw = JSON.parse(fs.readFileSync(paths.lastHeartbeatPath, "utf8"));
-        return typeof raw.at === "string" ? raw : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function defaultHeartbeatPost(agentUid, apiBaseUrl) {
-    return async (token, body) => {
-        const res = await vaultApiFetch({
-            token,
-            baseUrl: apiBaseUrl,
-            path: `/v1/agents/${encodeURIComponent(agentUid)}/heartbeat`,
-            method: "POST",
-            body: body,
-        });
-        return { status: res.status, bodyText: await res.text().catch(() => "") };
-    };
-}
-async function beatOnceResult(deps) {
-    const now = deps.now ?? (() => new Date());
-    const post = deps.post ?? defaultHeartbeatPost(deps.agentUid, deps.apiBaseUrl);
-    const body = buildHeartbeatBody(deps.paths, now, undefined, deps.components ?? KIT_COMPONENTS);
-    try {
-        const token = await deps.getToken();
-        const response = await post(token, body);
-        const result = typeof response === "number" ? { status: response } : response;
-        const status = result.status;
-        const ok = status >= 200 && status < 300;
-        if (ok) {
-            writeLastHeartbeat(deps.paths, { at: now().toISOString(), components: body.components, status });
-        }
-        else {
-            const failure = parseHeartbeatFailureBody(result.bodyText);
-            if (isHeartbeatIdentityMismatch({ status, code: failure.code, message: failure.message })) {
-                const tokenUid = tokenAgentUid(token);
-                writeLastHeartbeat(deps.paths, {
-                    at: now().toISOString(),
-                    components: body.components,
-                    status,
-                    reason: "identity_mismatch",
-                    configuredAgentUid: deps.agentUid,
-                    ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
-                });
-                const tokenLabel = tokenUid ?? "unknown";
-                deps.log("warn", identityMismatchMessage("heartbeat", deps.agentUid, tokenLabel));
-                (deps.reportIdentityMismatch ?? captureHeartbeatIdentityMismatch)({
-                    runner: "agent-kit",
-                    configuredAgentUid: deps.agentUid,
-                    ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
-                    agentUidSource: deps.agentUidSource ?? "config_file",
-                    credsSource: deps.credsSource ?? "default",
-                });
-                return { ok: false, stop: true };
-            }
-        }
-        deps.log(ok ? "info" : "warn", `heartbeat ${status} ${Object.entries(body.components)
-            .map(([name, health]) => `${name}=${health}`)
-            .join(" ")}`);
-        return { ok, stop: false };
-    }
-    catch (err) {
-        deps.log("error", `heartbeat failed: ${err instanceof Error ? err.message : String(err)}`);
-        return { ok: false, stop: false };
-    }
-}
-export async function beatOnce(deps) {
-    return (await beatOnceResult(deps)).ok;
-}
-export async function runHeartbeatLoop(deps) {
-    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-    let beats = 0;
-    for (;;) {
-        const result = await beatOnceResult(deps);
-        beats += 1;
-        if (result.stop)
-            return;
-        if (deps.maxBeats !== undefined && beats >= deps.maxBeats)
-            return;
-        await sleep(deps.intervalMs);
-    }
-}
-//# sourceMappingURL=heartbeat.js.map

package/dist/lib/agent-kit/run/inbox.d.ts

@@ -1,76 +0,0 @@
-/**
- * Kit service: inbox poller.
- *
- * Mirrors the poll half of the hosted box's hq-agent-inbox.sh: every
- * `inboxPollMs` GET /v1/agents/{uid}/inbox, take `.messages[]`, and stamp
- * `component-inbox` ok on a 200 (any other status → error, token re-minted
- * on the next pass). The hosted watcher then dispatches each item to a
- * provider and acks it; an external bot brings its own brain, so this
- * service only MIRRORS: each new item is written once to
- * ~/.hq-agent/inbox/<id>.json and appended to inbox.jsonl for the bot to
- * consume, and the work-mesh conversation cache is refreshed so `hq dm`
- * and the skills see the same state.
- *
- * Acking is opt-in (kit.json `inboxAck`): with it off the server keeps the
- * item until the bot acks (`POST /v1/agents/{uid}/inbox/{id}/ack`), and the
- * poller dedupes by id so the same item is never mirrored twice.
- */
-import type { KitLogger } from "../log.js";
-import type { AgentKitPaths } from "../paths.js";
-import { type WakeConfig, type WakeDeps, type WakeNotice, type WakeResult } from "../wake.js";
-export declare const SEEN_IDS_NAME = "seen-ids.json";
-export declare const INBOX_JSONL_NAME = "inbox.jsonl";
-export declare const MAX_SEEN_IDS = 5000;
-export interface InboxItem {
-    id: string;
-    raw: Record<string, unknown>;
-}
-/** Pull `{id}` out of each server item; items without a string id are dropped. */
-export declare function extractInboxItems(body: unknown): InboxItem[];
-export declare function readSeenIds(paths: Pick<AgentKitPaths, "inboxDir">): Set<string>;
-export declare function writeSeenIds(paths: Pick<AgentKitPaths, "inboxDir">, seen: Set<string>): void;
-export declare function mirrorInboxItem(paths: Pick<AgentKitPaths, "inboxDir">, item: InboxItem): string;
-export interface InboxDeps {
-    paths: AgentKitPaths;
-    agentUid: string;
-    apiBaseUrl: string;
-    pollMs: number;
-    ack: boolean;
-    getToken: () => Promise<string>;
-    log: KitLogger;
-    fetchInbox?: (token: string) => Promise<InboxFetchResult>;
-    ackItem?: (token: string, id: string) => Promise<number>;
-    warmCache?: (token: string, agentUid: string) => Promise<unknown>;
-    sleep?: (ms: number) => Promise<void>;
-    maxPolls?: number;
-    /** Override wake config lookup (tests). `null` disables the wake. */
-    wakeConfig?: WakeConfig | null;
-    fireWake?: (config: WakeConfig, notice: WakeNotice, deps: WakeDeps) => Promise<WakeResult>;
-    now?: () => Date;
-}
-export declare const INBOX_ERROR_BODY_MAX = 300;
-export interface InboxFetchResult {
-    status: number;
-    body: unknown;
-    /** Full request URL (never carries credentials). */
-    url?: string;
-    /** Raw response text, truncated to INBOX_ERROR_BODY_MAX chars. */
-    bodyText?: string;
-}
-/**
- * Join apiBaseUrl (from machine-creds.json) with the agent inbox route.
- * `new URL("/v1/…", base)` would silently drop a base path such as an API
- * Gateway stage (`…/prod`), and a base that already ends in `/v1` must not
- * become `/v1/v1`. Trailing slashes are tolerated.
- */
-export declare function agentApiUrl(apiBaseUrl: string, route: string): string;
-export declare function agentInboxUrl(apiBaseUrl: string, agentUid: string): string;
-export declare function truncateBody(text: string, max?: number): string;
-export declare function defaultFetchInbox(agentUid: string, apiBaseUrl: string): (token: string) => Promise<InboxFetchResult>;
-export declare function defaultAckItem(agentUid: string, apiBaseUrl: string): (token: string, id: string) => Promise<number>;
-export declare function pollInboxOnce(deps: InboxDeps): Promise<{
-    ok: boolean;
-    mirrored: number;
-}>;
-export declare function runInboxLoop(deps: InboxDeps): Promise<void>;
-//# sourceMappingURL=inbox.d.ts.map

package/dist/lib/agent-kit/run/inbox.js

@@ -1,205 +0,0 @@
-/**
- * Kit service: inbox poller.
- *
- * Mirrors the poll half of the hosted box's hq-agent-inbox.sh: every
- * `inboxPollMs` GET /v1/agents/{uid}/inbox, take `.messages[]`, and stamp
- * `component-inbox` ok on a 200 (any other status → error, token re-minted
- * on the next pass). The hosted watcher then dispatches each item to a
- * provider and acks it; an external bot brings its own brain, so this
- * service only MIRRORS: each new item is written once to
- * ~/.hq-agent/inbox/<id>.json and appended to inbox.jsonl for the bot to
- * consume, and the work-mesh conversation cache is refreshed so `hq dm`
- * and the skills see the same state.
- *
- * Acking is opt-in (kit.json `inboxAck`): with it off the server keeps the
- * item until the bot acks (`POST /v1/agents/{uid}/inbox/{id}/ack`), and the
- * poller dedupes by id so the same item is never mirrored twice.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { vaultApiFetch } from "../../../utils/vault-api.js";
-import { writeComponentStatus } from "../creds.js";
-import { pendingInbox } from "../inbox-state.js";
-import { writePrivateFile } from "./../private-file.js";
-import { buildWakeNotice, currentWakeState, fireWake, readWakeConfig, shouldWake, } from "../wake.js";
-export const SEEN_IDS_NAME = "seen-ids.json";
-export const INBOX_JSONL_NAME = "inbox.jsonl";
-export const MAX_SEEN_IDS = 5000;
-/** Pull `{id}` out of each server item; items without a string id are dropped. */
-export function extractInboxItems(body) {
-    const rec = body && typeof body === "object" ? body : {};
-    const messages = Array.isArray(rec.messages) ? rec.messages : [];
-    const items = [];
-    for (const m of messages) {
-        if (!m || typeof m !== "object")
-            continue;
-        const raw = m;
-        const id = typeof raw.id === "string" ? raw.id : typeof raw.messageId === "string" ? raw.messageId : null;
-        if (!id || !/^[A-Za-z0-9._:-]{1,200}$/.test(id))
-            continue;
-        items.push({ id, raw });
-    }
-    return items;
-}
-export function readSeenIds(paths) {
-    try {
-        const raw = JSON.parse(fs.readFileSync(path.join(paths.inboxDir, SEEN_IDS_NAME), "utf8"));
-        return new Set(Array.isArray(raw) ? raw.filter((x) => typeof x === "string") : []);
-    }
-    catch {
-        return new Set();
-    }
-}
-export function writeSeenIds(paths, seen) {
-    const list = [...seen].slice(-MAX_SEEN_IDS);
-    writePrivateFile(path.join(paths.inboxDir, SEEN_IDS_NAME), JSON.stringify(list), 0o600);
-}
-export function mirrorInboxItem(paths, item) {
-    const dest = path.join(paths.inboxDir, `${item.id}.json`);
-    writePrivateFile(dest, `${JSON.stringify(item.raw, null, 2)}\n`, 0o600);
-    fs.appendFileSync(path.join(paths.inboxDir, INBOX_JSONL_NAME), `${JSON.stringify({ id: item.id, mirroredAt: new Date().toISOString(), ...item.raw })}\n`, { mode: 0o600 });
-    return dest;
-}
-export const INBOX_ERROR_BODY_MAX = 300;
-/**
- * Join apiBaseUrl (from machine-creds.json) with the agent inbox route.
- * `new URL("/v1/…", base)` would silently drop a base path such as an API
- * Gateway stage (`…/prod`), and a base that already ends in `/v1` must not
- * become `/v1/v1`. Trailing slashes are tolerated.
- */
-export function agentApiUrl(apiBaseUrl, route) {
-    const base = new URL(apiBaseUrl);
-    let prefix = base.pathname.replace(/\/+$/, "");
-    const suffix = route.startsWith("/") ? route : `/${route}`;
-    if (prefix.endsWith("/v1") && suffix.startsWith("/v1/"))
-        prefix = prefix.slice(0, -3);
-    return `${base.origin}${prefix}${suffix}`;
-}
-export function agentInboxUrl(apiBaseUrl, agentUid) {
-    return agentApiUrl(apiBaseUrl, `/v1/agents/${encodeURIComponent(agentUid)}/inbox`);
-}
-export function truncateBody(text, max = INBOX_ERROR_BODY_MAX) {
-    const flat = text.replace(/\s+/g, " ").trim();
-    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
-}
-export function defaultFetchInbox(agentUid, apiBaseUrl) {
-    return async (token) => {
-        const url = new URL(agentInboxUrl(apiBaseUrl, agentUid));
-        const res = await vaultApiFetch({
-            token,
-            baseUrl: url.origin,
-            path: url.pathname,
-        });
-        const text = await res.text().catch(() => "");
-        let body;
-        try {
-            body = text ? JSON.parse(text) : {};
-        }
-        catch {
-            body = {};
-        }
-        return { status: res.status, body, url: url.toString(), bodyText: truncateBody(text) };
-    };
-}
-export function defaultAckItem(agentUid, apiBaseUrl) {
-    return async (token, id) => {
-        const res = await vaultApiFetch({
-            token,
-            baseUrl: apiBaseUrl,
-            path: `/v1/agents/${encodeURIComponent(agentUid)}/inbox/${encodeURIComponent(id)}/ack`,
-            method: "POST",
-        });
-        return res.status;
-    };
-}
-export async function pollInboxOnce(deps) {
-    const fetchInbox = deps.fetchInbox ?? defaultFetchInbox(deps.agentUid, deps.apiBaseUrl);
-    const ackItem = deps.ackItem ?? defaultAckItem(deps.agentUid, deps.apiBaseUrl);
-    // No default cache warm: the human conversation routes 403 for agent callers.
-    const warmCache = deps.warmCache ?? (async () => { });
-    let token;
-    try {
-        token = await deps.getToken();
-    }
-    catch (err) {
-        writeComponentStatus(deps.paths, "inbox", "error");
-        deps.log("error", `inbox token mint failed: ${err instanceof Error ? err.message : String(err)}`);
-        return { ok: false, mirrored: 0 };
-    }
-    let res;
-    try {
-        res = await fetchInbox(token);
-    }
-    catch (err) {
-        writeComponentStatus(deps.paths, "inbox", "error");
-        deps.log("error", `inbox fetch failed: GET ${agentInboxUrl(deps.apiBaseUrl, deps.agentUid)}: ${err instanceof Error ? err.message : String(err)}`);
-        return { ok: false, mirrored: 0 };
-    }
-    if (res.status !== 200) {
-        writeComponentStatus(deps.paths, "inbox", "error");
-        const url = res.url ?? agentInboxUrl(deps.apiBaseUrl, deps.agentUid);
-        // Non-OK bodies are not constrained to an error envelope and could carry
-        // inbox items. Keep the status and route, but do not copy the body to logs.
-        deps.log("warn", `inbox poll GET ${url} → ${res.status}`);
-        return { ok: false, mirrored: 0 };
-    }
-    writeComponentStatus(deps.paths, "inbox", "ok");
-    const seen = readSeenIds(deps.paths);
-    const fresh = extractInboxItems(res.body).filter((i) => !seen.has(i.id));
-    for (const item of fresh) {
-        mirrorInboxItem(deps.paths, item);
-        seen.add(item.id);
-        if (deps.ack) {
-            try {
-                const status = await ackItem(token, item.id);
-                if (status < 200 || status >= 300)
-                    deps.log("warn", `ack ${item.id} → ${status}`);
-            }
-            catch (err) {
-                deps.log("warn", `ack ${item.id} failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-    if (fresh.length > 0) {
-        writeSeenIds(deps.paths, seen);
-        deps.log("info", `inbox mirrored ${fresh.length} item(s)`);
-        try {
-            await warmCache(token, deps.agentUid);
-        }
-        catch (err) {
-            deps.log("warn", `cache refresh failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    await maybeWake(deps, fresh.length);
-    return { ok: true, mirrored: fresh.length };
-}
-/** Poke the bot's framework when mail is new, or still pending past the retry window. */
-async function maybeWake(deps, freshCount) {
-    const config = deps.wakeConfig !== undefined ? deps.wakeConfig : readWakeConfig(deps.paths);
-    if (!config)
-        return;
-    const now = (deps.now ?? (() => new Date()))();
-    const pending = pendingInbox(deps.paths);
-    const reason = shouldWake(config, currentWakeState(deps.paths), freshCount, pending.length, now);
-    if (!reason)
-        return;
-    const notice = buildWakeNotice(deps.agentUid, reason, pending.map((e) => e.id), now);
-    try {
-        await (deps.fireWake ?? fireWake)(config, notice, { paths: deps.paths, agentUid: deps.agentUid, log: deps.log, now: deps.now });
-    }
-    catch (err) {
-        deps.log("warn", `wake failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-export async function runInboxLoop(deps) {
-    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-    let polls = 0;
-    for (;;) {
-        await pollInboxOnce(deps);
-        polls += 1;
-        if (deps.maxPolls !== undefined && polls >= deps.maxPolls)
-            return;
-        await sleep(deps.pollMs);
-    }
-}
-//# sourceMappingURL=inbox.js.map

package/dist/lib/agent-kit/run/supervisor.d.ts

@@ -1,35 +0,0 @@
-/**
- * `hq agent kit run all` — supervise the four kit services in ONE process.
- *
- * The fallback for hosts with no usable service manager (a Linux box with no
- * systemd user session bus, a container, launchd unavailable): each service
- * runs as a child `node hq agent kit run <service>` whose output is appended
- * to its own ~/.hq-agent/logs/<service>.log, and a child that exits is
- * restarted with per-service exponential backoff (1 s doubling to 60 s,
- * reset once a child has stayed up for a minute).
- */
-import type { KitService } from "../services.js";
-export declare const SUPERVISOR_BACKOFF_BASE_MS = 1000;
-export declare const SUPERVISOR_BACKOFF_MAX_MS = 60000;
-/** A child that ran at least this long resets its backoff. */
-export declare const SUPERVISOR_HEALTHY_RUN_MS = 60000;
-export interface SupervisedChild {
-    on(event: "exit", handler: (code: number | null, signal: string | null) => void): unknown;
-    kill(signal?: NodeJS.Signals | number): boolean;
-}
-export interface SupervisorDeps {
-    services: readonly KitService[];
-    spawnService: (service: KitService) => SupervisedChild;
-    log: (level: "info" | "warn" | "error", msg: string) => void;
-    now?: () => number;
-    setTimeout?: (fn: () => void, ms: number) => unknown;
-    clearTimeout?: (handle: unknown) => void;
-}
-export interface SupervisorHandle {
-    stop: (signal?: NodeJS.Signals) => void;
-    restarts: () => Record<string, number>;
-    running: () => KitService[];
-}
-export declare function supervisorBackoffMs(attempt: number): number;
-export declare function superviseKitServices(deps: SupervisorDeps): SupervisorHandle;
-//# sourceMappingURL=supervisor.d.ts.map