@indigoai-us/hq-cli 5.115.6 → 5.116.0

package/dist/lib/agent-kit/log.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Per-service log under ~/.hq-agent/logs/<service>.log, rotated at 5 MB.
+ * Lines are sanitized so a bearer token or secret reference can never land
+ * on disk even through an error message.
+ */
+import type { AgentKitPaths } from "./paths.js";
+export declare const KIT_LOG_MAX_BYTES: number;
+export type KitLogLevel = "info" | "warn" | "error";
+export type KitLogger = (level: KitLogLevel, message: string) => void;
+export declare function sanitizeLogLine(message: string): string;
+export declare function formatKitLogLine(level: KitLogLevel, message: string, now?: () => Date): string;
+export declare function createKitLogger(paths: Pick<AgentKitPaths, "logsDir">, service: string, opts?: {
+    now?: () => Date;
+    echo?: boolean;
+    maxBytes?: number;
+}): KitLogger;
+//# sourceMappingURL=log.d.ts.map

package/dist/lib/agent-kit/log.js

@@ -0,0 +1,46 @@
+/**
+ * Per-service log under ~/.hq-agent/logs/<service>.log, rotated at 5 MB.
+ * Lines are sanitized so a bearer token or secret reference can never land
+ * on disk even through an error message.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { serviceLogPath } from "./paths.js";
+export const KIT_LOG_MAX_BYTES = 5 * 1024 * 1024;
+export function sanitizeLogLine(message) {
+    return message
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]")
+        .replace(/eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, "[JWT REDACTED]")
+        .replace(/"secret"\s*:\s*"[^"]*"/g, '"secret":"[REDACTED]"')
+        .replace(/\r?\n/g, " ")
+        .slice(0, 1000);
+}
+export function formatKitLogLine(level, message, now = () => new Date()) {
+    return `${now().toISOString()} ${level} ${sanitizeLogLine(message)}`;
+}
+export function createKitLogger(paths, service, opts = {}) {
+    const file = serviceLogPath(paths, service);
+    const maxBytes = opts.maxBytes ?? KIT_LOG_MAX_BYTES;
+    return (level, message) => {
+        const line = formatKitLogLine(level, message, opts.now);
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+            try {
+                if (fs.statSync(file).size > maxBytes) {
+                    fs.renameSync(file, `${file}.1`);
+                }
+            }
+            catch {
+                /* no file yet */
+            }
+            fs.appendFileSync(file, `${line}\n`, { mode: 0o600 });
+        }
+        catch {
+            /* best-effort */
+        }
+        if (opts.echo) {
+            (level === "error" ? process.stderr : process.stdout).write(`${line}\n`);
+        }
+    };
+}
+//# sourceMappingURL=log.js.map

package/dist/lib/agent-kit/mcp/jsonrpc.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Minimal stdio MCP server core (JSON-RPC 2.0, newline-delimited).
+ *
+ * hq-cli carries no MCP SDK dependency and the full HQ MCP surface lives in
+ * the separate @indigoai-us/hq-mcp package (a bin, not a library). `hq agent
+ * mcp` needs only the tools subset of the protocol — initialize, ping,
+ * tools/list, tools/call — so this module implements exactly that over a
+ * transport-agnostic `dispatch()` (tests drive it directly) plus a stdio
+ * pump. Every request is answered; notifications are consumed silently;
+ * malformed input yields a JSON-RPC error rather than a crash.
+ */
+export declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-06-18", "2025-03-26", "2024-11-05"];
+export declare const MCP_LATEST_PROTOCOL_VERSION: "2025-06-18";
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare const JSONRPC_PARSE_ERROR = -32700;
+export declare const JSONRPC_INVALID_REQUEST = -32600;
+export declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+export declare const JSONRPC_INVALID_PARAMS = -32602;
+export declare const JSONRPC_INTERNAL_ERROR = -32603;
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpToolContent {
+    type: "text";
+    text: string;
+}
+export interface McpToolResult {
+    content: McpToolContent[];
+    isError?: boolean;
+}
+export type McpToolHandler = (args: Record<string, unknown>) => Promise<McpToolResult>;
+export interface McpTool extends McpToolDefinition {
+    handler: McpToolHandler;
+}
+export interface McpServerOptions {
+    name: string;
+    version: string;
+    instructions?: string;
+    tools: McpTool[];
+}
+export declare class McpToolInputError extends Error {
+    constructor(message: string);
+}
+export declare function textResult(text: string): McpToolResult;
+export declare function errorResult(text: string): McpToolResult;
+export declare class McpServer {
+    private readonly opts;
+    private readonly tools;
+    private initialized;
+    constructor(opts: McpServerOptions);
+    listTools(): McpToolDefinition[];
+    /**
+     * Handle one decoded message. Returns null for notifications (no reply)
+     * and for responses the client sends us (we issue no requests).
+     */
+    dispatch(message: unknown): Promise<JsonRpcResponse | null>;
+    /** Decode one line, dispatch, and encode the reply (or null). */
+    handleLine(line: string): Promise<string | null>;
+    isInitialized(): boolean;
+    /**
+     * Pump newline-delimited messages from `input` to `output` until EOF.
+     * Requests are processed strictly in order so tool side effects (a DM
+     * send, a secrets exec) never interleave.
+     */
+    serve(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): Promise<void>;
+}
+//# sourceMappingURL=jsonrpc.d.ts.map

package/dist/lib/agent-kit/mcp/jsonrpc.js

@@ -0,0 +1,164 @@
+/**
+ * Minimal stdio MCP server core (JSON-RPC 2.0, newline-delimited).
+ *
+ * hq-cli carries no MCP SDK dependency and the full HQ MCP surface lives in
+ * the separate @indigoai-us/hq-mcp package (a bin, not a library). `hq agent
+ * mcp` needs only the tools subset of the protocol — initialize, ping,
+ * tools/list, tools/call — so this module implements exactly that over a
+ * transport-agnostic `dispatch()` (tests drive it directly) plus a stdio
+ * pump. Every request is answered; notifications are consumed silently;
+ * malformed input yields a JSON-RPC error rather than a crash.
+ */
+export const MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+export const MCP_LATEST_PROTOCOL_VERSION = MCP_PROTOCOL_VERSIONS[0];
+export const JSONRPC_PARSE_ERROR = -32700;
+export const JSONRPC_INVALID_REQUEST = -32600;
+export const JSONRPC_METHOD_NOT_FOUND = -32601;
+export const JSONRPC_INVALID_PARAMS = -32602;
+export const JSONRPC_INTERNAL_ERROR = -32603;
+export class McpToolInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "McpToolInputError";
+    }
+}
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function errorResult(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+function ok(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+function fail(id, code, message, data) {
+    return { jsonrpc: "2.0", id, error: { code, message, ...(data !== undefined ? { data } : {}) } };
+}
+export class McpServer {
+    opts;
+    tools = new Map();
+    initialized = false;
+    constructor(opts) {
+        this.opts = opts;
+        for (const tool of opts.tools) {
+            if (this.tools.has(tool.name))
+                throw new Error(`duplicate MCP tool ${tool.name}`);
+            this.tools.set(tool.name, tool);
+        }
+    }
+    listTools() {
+        return [...this.tools.values()].map(({ name, description, inputSchema }) => ({
+            name,
+            description,
+            inputSchema,
+        }));
+    }
+    /**
+     * Handle one decoded message. Returns null for notifications (no reply)
+     * and for responses the client sends us (we issue no requests).
+     */
+    async dispatch(message) {
+        if (!message || typeof message !== "object" || Array.isArray(message)) {
+            return fail(null, JSONRPC_INVALID_REQUEST, "expected a JSON-RPC object");
+        }
+        const msg = message;
+        if (typeof msg.method !== "string") {
+            // A response to a server-initiated request; we never send any.
+            if ("result" in msg || "error" in msg)
+                return null;
+            return fail(msg.id ?? null, JSONRPC_INVALID_REQUEST, "missing method");
+        }
+        const isNotification = msg.id === undefined;
+        const id = msg.id ?? null;
+        const params = (msg.params && typeof msg.params === "object" ? msg.params : {});
+        if (isNotification) {
+            if (msg.method === "notifications/initialized")
+                this.initialized = true;
+            return null;
+        }
+        switch (msg.method) {
+            case "initialize": {
+                const requested = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
+                const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested)
+                    ? requested
+                    : MCP_LATEST_PROTOCOL_VERSION;
+                return ok(id, {
+                    protocolVersion,
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: { name: this.opts.name, version: this.opts.version },
+                    ...(this.opts.instructions ? { instructions: this.opts.instructions } : {}),
+                });
+            }
+            case "ping":
+                return ok(id, {});
+            case "tools/list":
+                return ok(id, { tools: this.listTools() });
+            case "tools/call": {
+                const name = typeof params.name === "string" ? params.name : "";
+                const tool = this.tools.get(name);
+                if (!tool)
+                    return fail(id, JSONRPC_INVALID_PARAMS, `unknown tool: ${name || "(missing name)"}`);
+                const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments)
+                    ? params.arguments
+                    : {};
+                try {
+                    return ok(id, await tool.handler(args));
+                }
+                catch (err) {
+                    if (err instanceof McpToolInputError)
+                        return fail(id, JSONRPC_INVALID_PARAMS, err.message);
+                    // Tool execution failures are results, not protocol errors, so the
+                    // model can read and react to them.
+                    return ok(id, errorResult(err instanceof Error ? err.message : String(err)));
+                }
+            }
+            default:
+                return fail(id, JSONRPC_METHOD_NOT_FOUND, `method not found: ${msg.method}`);
+        }
+    }
+    /** Decode one line, dispatch, and encode the reply (or null). */
+    async handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return JSON.stringify(fail(null, JSONRPC_PARSE_ERROR, "invalid JSON"));
+        }
+        const reply = await this.dispatch(parsed);
+        return reply ? JSON.stringify(reply) : null;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Pump newline-delimited messages from `input` to `output` until EOF.
+     * Requests are processed strictly in order so tool side effects (a DM
+     * send, a secrets exec) never interleave.
+     */
+    async serve(input, output) {
+        let buffer = "";
+        const write = (s) => new Promise((resolve, reject) => output.write(`${s}\n`, (err) => (err ? reject(err) : resolve())));
+        input.setEncoding("utf8");
+        for await (const chunk of input) {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                const reply = await this.handleLine(line);
+                if (reply)
+                    await write(reply);
+            }
+        }
+        if (buffer.trim()) {
+            const reply = await this.handleLine(buffer);
+            if (reply)
+                await write(reply);
+        }
+    }
+}
+//# sourceMappingURL=jsonrpc.js.map

package/dist/lib/agent-kit/mcp/tools.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The `hq agent mcp` tool surface. Each tool wraps an existing hq CLI
+ * capability so a bot framework (OpenClaw, grokbot, any MCP client)
+ * can act as the enrolled agent without a token ever crossing the MCP
+ * channel: the machine identity lives in machine-creds.json and every call
+ * mints through hq-cloud.
+ *
+ * Two seams keep this testable and honest:
+ *   - `runHq(args)` — spawn the SAME hq binary for capabilities that are
+ *     already complete CLI commands (search, files, secrets exec, work mesh).
+ *   - `api` — token + vault-API fetch for the notify surface (DM, inbox).
+ *
+ * `hq_secrets_exec` runs a command with secrets injected and returns ONLY
+ * the command's exit code and (bounded) output — never an environment dump,
+ * never a secret value. `hq_secrets_list` names secrets; values are never a
+ * tool result.
+ */
+import type { ExternalMachineCreds } from "../creds.js";
+import { type McpTool } from "./jsonrpc.js";
+export interface HqRunResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface McpToolClients {
+    creds: ExternalMachineCreds;
+    /** Run `hq <args…>` as the machine identity; never throws. */
+    runHq: (args: string[]) => Promise<HqRunResult>;
+    getToken: () => Promise<string>;
+    /** Authenticated JSON call against the control plane. */
+    apiJson: (token: string, path: string, init?: {
+        method?: string;
+        body?: Record<string, unknown>;
+        query?: Record<string, string>;
+    }) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}
+export declare const MAX_TOOL_OUTPUT_CHARS = 40000;
+export declare function clampOutput(text: string, max?: number): string;
+/** Vault paths are company-anchored and must not escape. */
+export declare function assertVaultPath(p: string): string;
+export declare function buildAgentMcpTools(clients: McpToolClients): McpTool[];
+//# sourceMappingURL=tools.d.ts.map

package/dist/lib/agent-kit/mcp/tools.js

@@ -0,0 +1,280 @@
+/**
+ * The `hq agent mcp` tool surface. Each tool wraps an existing hq CLI
+ * capability so a bot framework (OpenClaw, grokbot, any MCP client)
+ * can act as the enrolled agent without a token ever crossing the MCP
+ * channel: the machine identity lives in machine-creds.json and every call
+ * mints through hq-cloud.
+ *
+ * Two seams keep this testable and honest:
+ *   - `runHq(args)` — spawn the SAME hq binary for capabilities that are
+ *     already complete CLI commands (search, files, secrets exec, work mesh).
+ *   - `api` — token + vault-API fetch for the notify surface (DM, inbox).
+ *
+ * `hq_secrets_exec` runs a command with secrets injected and returns ONLY
+ * the command's exit code and (bounded) output — never an environment dump,
+ * never a secret value. `hq_secrets_list` names secrets; values are never a
+ * tool result.
+ */
+import { CLI_VERSION } from "../../../cli-version.js";
+import { peekIdToken } from "../../../utils/id-token.js";
+import { errorResult, McpToolInputError, textResult } from "./jsonrpc.js";
+export const MAX_TOOL_OUTPUT_CHARS = 40_000;
+function str(args, key, opts = {}) {
+    const v = args[key];
+    if (v === undefined || v === null) {
+        if (opts.required)
+            throw new McpToolInputError(`"${key}" is required`);
+        return undefined;
+    }
+    if (typeof v !== "string")
+        throw new McpToolInputError(`"${key}" must be a string`);
+    if (opts.required && v.trim().length === 0)
+        throw new McpToolInputError(`"${key}" must not be empty`);
+    if (opts.max !== undefined && v.length > opts.max)
+        throw new McpToolInputError(`"${key}" exceeds ${opts.max} characters`);
+    return v;
+}
+function int(args, key, opts) {
+    const v = args[key];
+    if (v === undefined || v === null)
+        return opts.fallback;
+    if (typeof v !== "number" || !Number.isInteger(v))
+        throw new McpToolInputError(`"${key}" must be an integer`);
+    return Math.min(opts.max, Math.max(opts.min, v));
+}
+function strList(args, key) {
+    const v = args[key];
+    if (!Array.isArray(v) || v.length === 0 || !v.every((x) => typeof x === "string" && x.length > 0)) {
+        throw new McpToolInputError(`"${key}" must be a non-empty array of strings`);
+    }
+    return v;
+}
+export function clampOutput(text, max = MAX_TOOL_OUTPUT_CHARS) {
+    return text.length > max ? `${text.slice(0, max)}\n… [truncated ${text.length - max} chars]` : text;
+}
+/** Vault paths are company-anchored and must not escape. */
+export function assertVaultPath(p) {
+    const clean = p.trim().replace(/^\/+/, "");
+    if (!/^companies\/[a-z0-9][a-z0-9-]*(\/[^\0]*)?$/i.test(clean) || clean.split("/").includes("..")) {
+        throw new McpToolInputError(`"path" must be vault-relative and start with companies/<slug>/ (got ${JSON.stringify(p)})`);
+    }
+    return clean;
+}
+const SECRET_NAME = /^[A-Z][A-Z0-9_]*(\/[A-Z][A-Z0-9_]+)*$/;
+function fromRun(r, label) {
+    const out = [r.stdout.trim(), r.stderr.trim()].filter(Boolean).join("\n");
+    if (r.code !== 0)
+        return errorResult(clampOutput(`${label} failed (exit ${r.code})\n${out}`));
+    return textResult(clampOutput(out || `${label}: (no output)`));
+}
+export function buildAgentMcpTools(clients) {
+    const { creds } = clients;
+    const company = creds.companySlug;
+    return [
+        {
+            name: "hq_whoami",
+            description: "Identity this MCP server acts as: the enrolled external agent, its company, and the control plane.",
+            inputSchema: { type: "object", properties: {}, additionalProperties: false },
+            handler: async () => {
+                let tokenOk;
+                let claimUid;
+                try {
+                    const claims = peekIdToken(await clients.getToken());
+                    claimUid = typeof claims["custom:entityUid"] === "string" ? claims["custom:entityUid"] : undefined;
+                    tokenOk = claimUid === creds.entityUid;
+                }
+                catch {
+                    tokenOk = false;
+                }
+                return textResult(JSON.stringify({
+                    agentUid: creds.entityUid,
+                    runtime: "external",
+                    companySlug: company,
+                    apiBaseUrl: creds.apiBaseUrl,
+                    cliVersion: CLI_VERSION,
+                    session: tokenOk ? "ok" : `unavailable${claimUid ? ` (token names ${claimUid})` : ""}`,
+                }, null, 2));
+            },
+        },
+        {
+            name: "hq_search",
+            description: "Search the synced company vault (local qmd index). Modes: keyword (default), semantic, hybrid.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search text" },
+                    mode: { type: "string", enum: ["keyword", "semantic", "hybrid"] },
+                    count: { type: "integer", minimum: 1, maximum: 50 },
+                },
+                required: ["query"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const query = str(args, "query", { required: true, max: 2000 });
+                const mode = str(args, "mode");
+                if (mode !== undefined && !["keyword", "semantic", "hybrid"].includes(mode)) {
+                    throw new McpToolInputError('"mode" must be keyword, semantic or hybrid');
+                }
+                const count = int(args, "count", { min: 1, max: 50, fallback: 10 });
+                const hqArgs = ["search", query, "--mode", mode ?? "keyword", "-n", String(count), "--json"];
+                return fromRun(await clients.runHq(hqArgs), "hq search");
+            },
+        },
+        {
+            name: "hq_files_list",
+            description: "List vault objects under a company path without syncing them (hq files browse).",
+            inputSchema: {
+                type: "object",
+                properties: { path: { type: "string", description: "companies/<slug>/<folder>" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const p = assertVaultPath(str(args, "path", { required: true, max: 1000 }));
+                return fromRun(await clients.runHq(["files", "browse", p]), "hq files browse");
+            },
+        },
+        {
+            name: "hq_files_read",
+            description: "Read one vault file's contents (hq files cat). Text files only; output is truncated at 40k chars.",
+            inputSchema: {
+                type: "object",
+                properties: { path: { type: "string", description: "companies/<slug>/<file>" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const p = assertVaultPath(str(args, "path", { required: true, max: 1000 }));
+                return fromRun(await clients.runHq(["files", "cat", p]), "hq files cat");
+            },
+        },
+        {
+            name: "hq_secrets_list",
+            description: "List the NAMES of company secrets this agent can use. Values are never returned.",
+            inputSchema: {
+                type: "object",
+                properties: { prefix: { type: "string", description: "Optional path prefix, e.g. DEV" } },
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const prefix = str(args, "prefix", { max: 200 });
+                const hqArgs = ["secrets", "--company", company, "list"];
+                if (prefix)
+                    hqArgs.push("--prefix", prefix);
+                return fromRun(await clients.runHq(hqArgs), "hq secrets list");
+            },
+        },
+        {
+            name: "hq_secrets_exec",
+            description: "Run a command with the named company secrets injected as environment variables. " +
+                "Returns the command's exit code and output only — never the secret values. " +
+                "Do not run commands that print their environment.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    secrets: { type: "array", items: { type: "string" }, description: "Secret names to inject (UPPER_SNAKE, optional / path)" },
+                    command: { type: "array", items: { type: "string" }, description: "argv of the command to run" },
+                },
+                required: ["secrets", "command"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const secrets = strList(args, "secrets");
+                for (const s of secrets) {
+                    if (!SECRET_NAME.test(s))
+                        throw new McpToolInputError(`invalid secret name ${JSON.stringify(s)}`);
+                }
+                const command = strList(args, "command");
+                if (/^(env|printenv|export|set)$/.test(command[0])) {
+                    throw new McpToolInputError("refusing to run an environment-dumping command under hq_secrets_exec");
+                }
+                const r = await clients.runHq(["secrets", "--company", company, "exec", "--only", secrets.join(","), "--", ...command]);
+                const out = [r.stdout.trim(), r.stderr.trim()].filter(Boolean).join("\n");
+                const text = clampOutput(`exit ${r.code}\n${out}`);
+                return r.code === 0 ? textResult(text) : errorResult(text);
+            },
+        },
+        {
+            name: "hq_dm_send",
+            description: "Send an HQ direct message as this agent to a person (email or prs_…) or agent (agt_…).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    to: { type: "string", description: "Email, prs_… or agt_… uid" },
+                    message: { type: "string" },
+                },
+                required: ["to", "message"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const to = str(args, "to", { required: true, max: 320 }).trim();
+                const message = str(args, "message", { required: true, max: 20_000 }).trim();
+                const body = /^[^\s]+@[^\s]+$/.test(to)
+                    ? { toEmail: to.toLowerCase(), body: message }
+                    : /^(prs|agt)_[A-Za-z0-9_-]+$/.test(to)
+                        ? { toPersonUid: to, body: message }
+                        : (() => {
+                            throw new McpToolInputError('"to" must be an email, prs_… or agt_… uid');
+                        })();
+                const token = await clients.getToken();
+                const res = await clients.apiJson(token, "/v1/notify/dm", { method: "POST", body });
+                if (res.status < 200 || res.status >= 300) {
+                    return errorResult(`DM send failed (${res.status}): ${describeError(res.body)}`);
+                }
+                return textResult(`sent to ${to}`);
+            },
+        },
+        {
+            name: "hq_inbox_read",
+            description: "Read this agent's recent incoming direct messages (newest first). Optionally only unread.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    limit: { type: "integer", minimum: 1, maximum: 100 },
+                    unread_only: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const limit = int(args, "limit", { min: 1, max: 100, fallback: 20 });
+                const unreadOnly = args.unread_only === true;
+                const token = await clients.getToken();
+                const res = await clients.apiJson(token, "/v1/notify/inbox", { query: { limit: String(limit) } });
+                if (res.status !== 200)
+                    return errorResult(`inbox read failed (${res.status}): ${describeError(res.body)}`);
+                const events = Array.isArray(res.body?.events)
+                    ? (res.body.events)
+                    : [];
+                const rows = events
+                    .filter((e) => !unreadOnly || !e.acknowledgedAt)
+                    .map((e) => ({
+                    eventId: e.eventId,
+                    from: e.fromDisplayName ?? e.fromEmail ?? e.fromPersonUid ?? "unknown",
+                    fromUid: e.fromPersonUid,
+                    at: e.createdAt,
+                    unread: !e.acknowledgedAt,
+                    body: e.body,
+                    ...(e.prompt ? { prompt: e.prompt } : {}),
+                }));
+                return textResult(clampOutput(JSON.stringify({ count: rows.length, messages: rows }, null, 2)));
+            },
+        },
+        {
+            name: "hq_work_mesh_status",
+            description: "Live read of what the team is working on right now (work-mesh session status for this agent's company).",
+            inputSchema: { type: "object", properties: {}, additionalProperties: false },
+            handler: async () => fromRun(await clients.runHq(["mesh", "session", "status", "--company", company, "--json"]), "hq mesh session status"),
+        },
+    ];
+}
+function describeError(body) {
+    if (body && typeof body === "object") {
+        const b = body;
+        const code = typeof b.code === "string" ? `${b.code}: ` : "";
+        const msg = typeof b.message === "string" ? b.message : typeof b.error === "string" ? b.error : "";
+        if (code || msg)
+            return `${code}${msg}`;
+    }
+    return "request failed";
+}
+//# sourceMappingURL=tools.js.map