@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/commands/agent-probe.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `hq agent probe` — end-to-end check that this host is a working external
+ * team member, one line per check, non-zero exit on any failure:
+ *
+ *   whoami       mint as the machine identity; token names this agent
+ *   files        a vault listing answers on demand (or, with --sync-files, a
+ *                pull succeeds and the company folder exists)
+ *   presence     the agent-authorized inbox route answers 200 and this host's
+ *                own presence is live (a fresh last-heartbeat.json)
+ *   dm           send a DM to self via POST /v1/notify/dm (accepted) and read the agent inbox (200)
+ *                through GET /v1/agents/{uid}/inbox (the agent read surface;
+ *                /v1/notify/thread is intentionally closed to agents)
+ *   secrets      `GET /secrets/{companyUid}` answers 200
+ *
+ * Output is the exact shape the console recipes promise: one
+ * `PASS  <check>  <detail>` / `FAIL  <check>  <detail>` line per check, then
+ * `heartbeat  <age>`.
+ *
+ * The result is POSTed to /v1/agents/{uid}/probe-result (api-contract v1) so
+ * the console can flip the enrollment to "Enrolled". Also reports the age of
+ * the kit's last heartbeat.
+ */
+import { Command } from "commander";
+import { type InboxFetchResult } from "../lib/agent-kit/run/inbox.js";
+import { type AgentKitPaths } from "../lib/agent-kit/paths.js";
+import type { ExternalMachineCreds } from "../lib/agent-kit/creds.js";
+export interface ProbeCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface ProbeResult {
+    passed: boolean;
+    checks: ProbeCheck[];
+    at: string;
+    /** Seconds since the kit's last successful heartbeat, or null if never. */
+    heartbeatAgeSeconds: number | null;
+}
+/** A heartbeat older than this does not count as live presence (3 missed 60 s beats). */
+export declare const PRESENCE_FRESH_SECONDS = 180;
+export interface ProbeDeps {
+    paths: AgentKitPaths;
+    creds: ExternalMachineCreds;
+    hqRoot: string;
+    getToken: () => Promise<string>;
+    resolveCompanyUid: (token: string, slug: string) => Promise<string>;
+    /** Runs the `hq` CLI with these args as a child; resolves with its exit code. */
+    runHq: (args: string[]) => Promise<number>;
+    /** Mirror the vault to disk. Off by default: files are read through the API. */
+    syncFiles?: boolean;
+    /** GET /v1/agents/{self}/inbox — agent-authorized, self-scoped. */
+    readInbox: (token: string) => Promise<InboxFetchResult>;
+    sendDm: (token: string, toUid: string, body: string) => Promise<void>;
+    listSecrets: (token: string, companyUid: string) => Promise<number>;
+    postResult: (token: string, result: ProbeResult) => Promise<number>;
+    now?: () => Date;
+    /** Test seam; defaults to fs.existsSync. */
+    hostKeyExists?: (p: string) => boolean;
+    sleep?: (ms: number) => Promise<void>;
+    nonce?: () => string;
+    dmTimeoutMs?: number;
+}
+export declare function heartbeatAgeSeconds(paths: Pick<AgentKitPaths, "lastHeartbeatPath">, now?: () => Date): number | null;
+export declare function runProbe(deps: ProbeDeps): Promise<ProbeResult>;
+/** True when any inbox item (whatever its channel shape) carries the nonce. */
+export declare function inboxContainsNonce(body: unknown, nonce: string): boolean;
+export declare function formatHeartbeatAge(age: number | null): string;
+/**
+ * Recipe contract: `PASS  <check>  <detail>` / `FAIL  <check>  <detail>` per
+ * check, then `heartbeat  <age>`. Two-space separators; no trailing verdict
+ * line (the exit code carries it, and the console keys only on the POSTed
+ * probe-result).
+ */
+export declare function formatProbeReport(result: ProbeResult, color?: boolean): string[];
+export declare function defaultProbeDeps(paths: AgentKitPaths, creds: ExternalMachineCreds): ProbeDeps;
+export declare function registerAgentProbeCommand(agent: Command): void;
+//# sourceMappingURL=agent-probe.d.ts.map

package/dist/commands/agent-probe.js

@@ -0,0 +1,335 @@
+/**
+ * `hq agent probe` — end-to-end check that this host is a working external
+ * team member, one line per check, non-zero exit on any failure:
+ *
+ *   whoami       mint as the machine identity; token names this agent
+ *   files        a vault listing answers on demand (or, with --sync-files, a
+ *                pull succeeds and the company folder exists)
+ *   presence     the agent-authorized inbox route answers 200 and this host's
+ *                own presence is live (a fresh last-heartbeat.json)
+ *   dm           send a DM to self via POST /v1/notify/dm (accepted) and read the agent inbox (200)
+ *                through GET /v1/agents/{uid}/inbox (the agent read surface;
+ *                /v1/notify/thread is intentionally closed to agents)
+ *   secrets      `GET /secrets/{companyUid}` answers 200
+ *
+ * Output is the exact shape the console recipes promise: one
+ * `PASS  <check>  <detail>` / `FAIL  <check>  <detail>` line per check, then
+ * `heartbeat  <age>`.
+ *
+ * The result is POSTed to /v1/agents/{uid}/probe-result (api-contract v1) so
+ * the console can flip the enrollment to "Enrolled". Also reports the age of
+ * the kit's last heartbeat.
+ */
+import chalk from "chalk";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomBytes } from "node:crypto";
+import { CLI_VERSION } from "../cli-version.js";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { peekIdToken } from "../utils/id-token.js";
+import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
+import { sendAgentDm } from "./agents.js";
+import { defaultFetchInbox } from "../lib/agent-kit/run/inbox.js";
+import { agentKitPaths } from "../lib/agent-kit/paths.js";
+import { readKitConfig } from "../lib/agent-kit/kit-config.js";
+import { readLastHeartbeat } from "../lib/agent-kit/run/heartbeat.js";
+import { defaultRunPull, syncPullArgs } from "../lib/agent-kit/run/sync.js";
+import { requireExternalCreds } from "./agent-kit.js";
+/** A heartbeat older than this does not count as live presence (3 missed 60 s beats). */
+export const PRESENCE_FRESH_SECONDS = 180;
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function heartbeatAgeSeconds(paths, now = () => new Date()) {
+    const last = readLastHeartbeat(paths);
+    if (!last)
+        return null;
+    const at = new Date(last.at).getTime();
+    if (Number.isNaN(at))
+        return null;
+    return Math.max(0, Math.round((now().getTime() - at) / 1000));
+}
+export async function runProbe(deps) {
+    const now = deps.now ?? (() => new Date());
+    const nonce = (deps.nonce ?? (() => randomBytes(6).toString("hex")))();
+    const self = deps.creds.entityUid;
+    const checks = [];
+    let token = null;
+    let companyUid = null;
+    // 1. whoami
+    try {
+        token = await deps.getToken();
+        const claims = peekIdToken(token);
+        const uid = claims["custom:entityUid"];
+        const type = claims["custom:entityType"];
+        if (type === "agent" && uid === self && !(deps.hostKeyExists ?? fs.existsSync)(deps.creds.hostKeyPath)) {
+            // A cached token hides a missing host key for up to an hour: the probe
+            // used to pass and the agent then went silent at its next refresh.
+            checks.push({
+                name: "whoami",
+                ok: false,
+                detail: `token minted from cache, but there is no host key at ${deps.creds.hostKeyPath}, so the next refresh will fail. Keep host-key beside machine-creds.json, or re-enroll`,
+            });
+            token = null;
+        }
+        else if (type === "agent" && uid === self) {
+            checks.push({ name: "whoami", ok: true, detail: `${self} (external, ${deps.creds.companySlug})` });
+        }
+        else {
+            checks.push({
+                name: "whoami",
+                ok: false,
+                detail: `token names ${String(type)}:${String(uid)}, expected agent:${self}`,
+            });
+            token = null;
+        }
+    }
+    catch (err) {
+        checks.push({ name: "whoami", ok: false, detail: `mint failed: ${errText(err)}` });
+    }
+    if (token) {
+        try {
+            companyUid = await deps.resolveCompanyUid(token, deps.creds.companySlug);
+        }
+        catch (err) {
+            checks.push({ name: "company", ok: false, detail: `cannot resolve ${deps.creds.companySlug}: ${errText(err)}` });
+        }
+    }
+    // 2. files
+    //
+    // Two shapes, because the kit has two. With file sync off (the default) the
+    // bot reads and writes vault files on demand, so what has to be proven is
+    // that a vault listing answers — not that a full local copy exists. Pulling
+    // the whole vault here would also make the probe fail for a reason that does
+    // not affect the bot: a team with a large asset library is hundreds of
+    // megabytes, and a sandboxed bot host whose egress truncates large responses
+    // can never finish it.
+    if (token) {
+        if (deps.syncFiles) {
+            try {
+                const code = await deps.runHq(syncPullArgs(deps.hqRoot));
+                const companyDir = path.join(deps.hqRoot, "companies", deps.creds.companySlug);
+                const present = fs.existsSync(companyDir);
+                const ok = code === 0 && present;
+                checks.push({
+                    name: "files",
+                    ok,
+                    detail: ok
+                        ? `synced into ${companyDir}`
+                        : code !== 0
+                            ? `hq sync pull exited ${code}`
+                            : `sync exited 0 but ${companyDir} is missing`,
+                });
+            }
+            catch (err) {
+                checks.push({ name: "files", ok: false, detail: errText(err) });
+            }
+        }
+        else {
+            const target = `companies/${deps.creds.companySlug}`;
+            try {
+                const code = await deps.runHq(["files", "browse", target]);
+                checks.push({
+                    name: "files",
+                    ok: code === 0,
+                    detail: code === 0
+                        ? `${target} is readable on demand (no local copy)`
+                        : `hq files browse ${target} exited ${code}`,
+                });
+            }
+            catch (err) {
+                checks.push({ name: "files", ok: false, detail: errText(err) });
+            }
+        }
+    }
+    else {
+        checks.push({ name: "files", ok: false, detail: "skipped: no token" });
+    }
+    // 3. presence: HQ can see this agent, and the agent can read its own inbox.
+    //
+    // This replaces a work-mesh check that also required the realtime doorbell
+    // to be connected. The doorbell was never what made an agent reachable —
+    // messages arrive over the inbox either way — and on a host whose egress
+    // intercepts that connection it could never pass, so a perfectly healthy
+    // bot reported a failure it could do nothing about.
+    if (token) {
+        try {
+            const inbox = await deps.readInbox(token);
+            const age = heartbeatAgeSeconds(deps.paths, now);
+            const reachable = inbox.status === 200;
+            const fresh = age !== null && age <= PRESENCE_FRESH_SECONDS;
+            const ok = reachable && fresh;
+            checks.push({
+                name: "presence",
+                ok,
+                detail: `inbox GET → ${inbox.status}; heartbeat ${age === null ? "never" : `${age}s ago`}` +
+                    (ok ? "" : " — is `hq agent kit` installed and running? see ~/.hq-agent/logs/"),
+            });
+        }
+        catch (err) {
+            checks.push({ name: "presence", ok: false, detail: errText(err) });
+        }
+    }
+    else {
+        checks.push({ name: "presence", ok: false, detail: "skipped: no token" });
+    }
+    // 4. dm: the send is accepted and the agent inbox is readable.
+    // The server never delivers a self-DM into the sender's own inbox
+    // (hq-pro-core notify-dm skips inbox delivery when recipient === sender),
+    // so a self round-trip can never succeed. Inbound delivery is proven by a
+    // teammate's DM, which the kit's inbox poller mirrors to inbox.jsonl.
+    if (token) {
+        try {
+            const body = `hq agent probe ${nonce}`;
+            await deps.sendDm(token, self, body);
+            const res = await deps.readInbox(token);
+            checks.push({
+                name: "dm",
+                ok: res.status === 200,
+                detail: res.status === 200
+                    ? "send accepted by /v1/notify/dm; /v1/agents/{uid}/inbox → 200 (self-DMs are not delivered to the inbox; a DM from a teammate confirms inbound)"
+                    : `send accepted but /v1/agents/{uid}/inbox answered ${res.status}`,
+            });
+        }
+        catch (err) {
+            checks.push({ name: "dm", ok: false, detail: errText(err) });
+        }
+    }
+    else {
+        checks.push({ name: "dm", ok: false, detail: "skipped: no token" });
+    }
+    // 5. secrets-list
+    if (token && companyUid) {
+        try {
+            const status = await deps.listSecrets(token, companyUid);
+            checks.push({
+                name: "secrets",
+                ok: status === 200,
+                detail: status === 200 ? `GET /secrets/${companyUid} → 200` : `GET /secrets/${companyUid} → ${status}`,
+            });
+        }
+        catch (err) {
+            checks.push({ name: "secrets", ok: false, detail: errText(err) });
+        }
+    }
+    else {
+        checks.push({ name: "secrets", ok: false, detail: "skipped: no token/company" });
+    }
+    const result = {
+        passed: checks.every((c) => c.ok),
+        checks,
+        at: now().toISOString(),
+        heartbeatAgeSeconds: heartbeatAgeSeconds(deps.paths, now),
+    };
+    if (token) {
+        try {
+            const status = await deps.postResult(token, result);
+            if (status < 200 || status >= 300) {
+                result.checks.push({ name: "report", ok: false, detail: `probe-result POST → ${status}` });
+                result.passed = false;
+            }
+        }
+        catch (err) {
+            result.checks.push({ name: "report", ok: false, detail: `probe-result POST failed: ${errText(err)}` });
+            result.passed = false;
+        }
+    }
+    return result;
+}
+/** True when any inbox item (whatever its channel shape) carries the nonce. */
+export function inboxContainsNonce(body, nonce) {
+    const rec = body && typeof body === "object" ? body : {};
+    const messages = Array.isArray(rec.messages) ? rec.messages : [];
+    return messages.some((m) => {
+        try {
+            return JSON.stringify(m).includes(nonce);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export function formatHeartbeatAge(age) {
+    if (age === null)
+        return "never (kit heartbeat has not posted yet)";
+    if (age < 90)
+        return `${age}s ago`;
+    if (age < 3600)
+        return `${Math.round(age / 60)}m ago`;
+    return `${(age / 3600).toFixed(1)}h ago`;
+}
+/**
+ * Recipe contract: `PASS  <check>  <detail>` / `FAIL  <check>  <detail>` per
+ * check, then `heartbeat  <age>`. Two-space separators; no trailing verdict
+ * line (the exit code carries it, and the console keys only on the POSTed
+ * probe-result).
+ */
+export function formatProbeReport(result, color = true) {
+    const pass = color ? chalk.green("PASS") : "PASS";
+    const failTag = color ? chalk.red("FAIL") : "FAIL";
+    const lines = result.checks.map((c) => `${c.ok ? pass : failTag}  ${c.name}  ${c.detail}`);
+    lines.push(`heartbeat  ${formatHeartbeatAge(result.heartbeatAgeSeconds)}`);
+    return lines;
+}
+export function defaultProbeDeps(paths, creds) {
+    process.env.HQ_MACHINE_CREDS_FILE = paths.machineCredsPath;
+    process.env.HQ_REQUIRE_MACHINE_IDENTITY = "1";
+    process.env.HQ_VAULT_API_URL = creds.apiBaseUrl;
+    const config = readKitConfig(paths, CLI_VERSION);
+    const base = creds.apiBaseUrl;
+    return {
+        paths,
+        creds,
+        hqRoot: config.hqRoot,
+        syncFiles: config.syncFiles,
+        getToken: () => ensureCognitoToken({ tokenSource: "machine", interactive: false }),
+        resolveCompanyUid: (token, slug) => getCompanyUid(token, slug),
+        runHq: defaultRunPull(process.execPath, process.argv[1], process.env),
+        readInbox: (token) => defaultFetchInbox(creds.entityUid, base)(token),
+        sendDm: (token, to, body) => sendAgentDm(token, to, body),
+        listSecrets: async (token, companyUid) => {
+            const res = await vaultApiFetch({
+                token,
+                baseUrl: base,
+                path: `/secrets/${encodeURIComponent(companyUid)}`,
+            });
+            return res.status;
+        },
+        postResult: async (token, result) => {
+            const res = await vaultApiFetch({
+                token,
+                baseUrl: base,
+                path: `/v1/agents/${encodeURIComponent(creds.entityUid)}/probe-result`,
+                method: "POST",
+                body: { passed: result.passed, checks: result.checks, at: result.at },
+            });
+            return res.status;
+        },
+    };
+}
+export function registerAgentProbeCommand(agent) {
+    agent
+        .command("probe")
+        .description("Verify identity, vault access, presence, DMs and secrets; report to the console")
+        .option("--json", "Print machine-readable JSON")
+        .action(async (opts) => {
+        try {
+            const paths = agentKitPaths(os.homedir(), process.env);
+            const creds = requireExternalCreds(paths);
+            const result = await runProbe(defaultProbeDeps(paths, creds));
+            if (opts.json)
+                console.log(JSON.stringify(result, null, 2));
+            else
+                for (const line of formatProbeReport(result))
+                    console.log(line);
+            if (!result.passed)
+                process.exit(1);
+        }
+        catch (err) {
+            console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=agent-probe.js.map

package/dist/commands/agent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `hq agent …` — commands a host runs to BE an external HQ agent (as opposed
+ * to `hq agents …`, which an admin runs to manage a company's agents):
+ *
+ *   hq agent enroll <code>        redeem a one-time enrollment code
+ *   hq agent kit install|status|uninstall|run <service>
+ *   hq agent probe                end-to-end membership check
+ *   hq agent mcp                  stdio MCP server for the bot framework
+ *   hq agent inbox [done <id…>]   pending HQ messages / mark handled
+ */
+import { Command } from "commander";
+export declare function registerAgentCommand(program: Command): void;
+//# sourceMappingURL=agent.d.ts.map

package/dist/commands/agent.js

@@ -0,0 +1,40 @@
+/**
+ * `hq agent …` — commands a host runs to BE an external HQ agent (as opposed
+ * to `hq agents …`, which an admin runs to manage a company's agents):
+ *
+ *   hq agent enroll <code>        redeem a one-time enrollment code
+ *   hq agent kit install|status|uninstall|run <service>
+ *   hq agent probe                end-to-end membership check
+ *   hq agent mcp                  stdio MCP server for the bot framework
+ *   hq agent inbox [done <id…>]   pending HQ messages / mark handled
+ */
+import * as os from "node:os";
+import { adoptAgentIdentityEnv } from "../lib/agent-kit/adopt-identity.js";
+import { agentKitPaths } from "../lib/agent-kit/paths.js";
+import { registerAgentEnrollCommand } from "./agent-enroll.js";
+import { registerAgentInboxCommand } from "./agent-inbox.js";
+import { registerAgentKitCommand } from "./agent-kit.js";
+import { registerAgentMcpCommand } from "./agent-mcp.js";
+import { registerAgentProbeCommand } from "./agent-probe.js";
+export function registerAgentCommand(program) {
+    const agent = program
+        .command("agent")
+        .description("Enroll and run this host as an external HQ agent")
+        // A bot that shares a computer with its owner keeps its identity in its
+        // own directory. Publish that tree to the environment before any
+        // subcommand runs, so the CLI and hq-cloud both mint as the AGENT rather
+        // than falling back to the one fixed path — and, on a person's computer,
+        // to the person. Enroll is exempt: it is the command that decides where
+        // the tree goes.
+        .hook("preAction", (_thisCommand, actionCommand) => {
+        if (actionCommand.name() === "enroll")
+            return;
+        adoptAgentIdentityEnv(agentKitPaths(os.homedir(), process.env), process.env);
+    });
+    registerAgentEnrollCommand(agent);
+    registerAgentKitCommand(agent);
+    registerAgentProbeCommand(agent);
+    registerAgentMcpCommand(agent);
+    registerAgentInboxCommand(agent);
+}
+//# sourceMappingURL=agent.js.map

package/dist/commands/agents.d.ts

@@ -15,8 +15,11 @@
  *   hq agents start|stop <uid>     — EC2 start/stop
  *   hq agents retry <uid>          — resume setup from first non-done step
  *   hq agents rm <uid> --yes       — deprovision (destructive; flag-guarded)
+ *   hq agents rotate <uid>         — new enrollment code for an external agent
+ *   hq agents revoke <uid> --yes   — revoke an external agent (--remove deletes it)
  *   hq agents jobs list <uid>      — off-box job roster (schedule + rate)
  *   hq agents jobs pause <uid> <jobId>  — flip schedule State=DISABLED
+ *   hq agents jobs resume <uid> <jobId> — flip schedule State=ENABLED
  *   hq agents jobs cancel <uid> <jobId> — delete schedule + drop the job
  *
  * Agents are company-scoped. `--company <slug>` may sit on the group
@@ -26,6 +29,7 @@
  */
 import { Command } from "commander";
 import { type TerminalSessionPayload } from "@indigoai-us/hq-cloud/outposts/node";
+import { type AgentModelProvider, type AgentModelCatalog } from "../lib/agents/model-catalog.js";
 import { type BillingErrorPayload } from "../utils/billing-gate.js";
 /** Reasoning-effort values hq-pro accepts on `runtime-config`. */
 export declare const VALID_EFFORTS: Set<string>;
@@ -37,6 +41,29 @@ export declare const VALID_PROVIDERS: Set<string>;
 export declare const VALID_AUTH_MODES: Set<string>;
 /** Customer-facing agent size keys served by hq-pro's authoritative catalog. */
 export declare const VALID_AGENT_SIZE_KEYS: Set<string>;
+/**
+ * `hq agents create` exits with this distinct status when payment is required.
+ * Scripts can distinguish the expected upgrade state from an ordinary command
+ * failure without parsing human output.
+ */
+export declare const AGENT_CREATE_PAYMENT_REQUIRED_EXIT_CODE = 3;
+export type AgentCreatePlanLimit = Readonly<{
+    requiredPlan: "agents-500";
+    amountMinor: number;
+    currency: string;
+    checkoutUrl?: string;
+}>;
+/**
+ * Decode only the priced response defined by the agent-create contract. A
+ * lookalike 403 must stay an ordinary API error rather than opening a browser
+ * or guessing at a price.
+ */
+export declare function agentCreatePlanLimitFromPayload(status: number, body: unknown): AgentCreatePlanLimit | null;
+/** Print a server-priced plan block without minting or rewriting its URL. */
+export declare function surfaceAgentCreatePlanLimit(planLimit: AgentCreatePlanLimit, opts?: {
+    json?: boolean;
+    companyUid?: string;
+}): Promise<void>;
 /**
  * Resolve a closed-set option value, or exit(1) with a message naming the
  * offending input and the legal set.
@@ -82,7 +109,9 @@ export declare class AgentsHttpError extends Error {
     code?: string;
     /** hq-pro's billing envelope on a `402 billing_required` provision block. */
     billing?: BillingErrorPayload;
-    constructor(status: number, message: string, code?: string, billing?: BillingErrorPayload);
+    /** Strictly decoded priced `403 AGENT_PLAN_LIMIT` create response. */
+    agentCreatePlanLimit?: AgentCreatePlanLimit;
+    constructor(status: number, message: string, code?: string, billing?: BillingErrorPayload, agentCreatePlanLimit?: AgentCreatePlanLimit);
 }
 /** Roster row from `GET /v1/agents` — a superset is returned; we keep what we render. */
 export interface CompanyAgentView {
@@ -104,6 +133,18 @@ export interface CompanyAgentView {
     };
     [key: string]: unknown;
 }
+/**
+ * STATUS column for `hq agents list`.
+ *
+ * `agentStatus` is the agent's own stored runtime status and is NOT rewritten
+ * when a teardown starts — an agent that never finished provisioning and is
+ * now being removed keeps reading `provisioning` until the teardown completes
+ * and archives it. Observed live on liverecover/sean 2026-09-21: a removal that
+ * stalled on an object-locked vault bucket sat in the roster as `provisioning`,
+ * so the operator believed the removal had never been accepted. The roster
+ * already carries `setupPhase`, so prefer it whenever a teardown is in flight.
+ */
+export declare function rosterStatusLabel(agent: CompanyAgentView): string;
 export interface ProfilePatch {
     displayName?: string;
     title?: string;
@@ -145,7 +186,11 @@ export interface ProvisionAgentInput {
     slug: string;
     codexAuthMode: "subscription" | "apiKey";
     provider?: "codex" | "grok" | "claude" | "agents-v2";
+    codexModel?: string;
     codexApiKey?: string;
+    /** Write-only Slack credentials, validated by hq-pro before creation. */
+    slackBotToken?: string;
+    slackAppToken?: string;
     idempotencyKey: string;
     title?: string;
     description?: string;
@@ -157,6 +202,21 @@ export interface ProvisionAgentInput {
     /** Funnel attribution: which client surface made the attempt. */
     surface?: AgentCreateSurface;
 }
+export interface ProvisionSlackTokenOptions {
+    slackBotToken?: string;
+    slackAppToken?: string;
+    slackTokensStdin?: boolean;
+}
+export interface ProvisionSlackTokens {
+    botToken: string;
+    appToken?: string;
+}
+/**
+ * Resolve write-only Slack credentials without printing them. Flags are useful
+ * for automation; HQ_SLACK_BOT_TOKEN/HQ_SLACK_APP_TOKEN and stdin avoid shell
+ * history. Multiple sources are rejected so the selected credential is clear.
+ */
+export declare function resolveProvisionSlackTokens(options: ProvisionSlackTokenOptions, environment?: Record<string, string | undefined>, readStdin?: () => Promise<string>): Promise<ProvisionSlackTokens | undefined>;
 /** Closed set shared with hq-pro's agent_create_* funnel contract. */
 export declare const CLI_AGENT_CREATE_SURFACE: "cli_agents_create";
 export type AgentCreateSurface = typeof CLI_AGENT_CREATE_SURFACE;
@@ -194,7 +254,7 @@ export declare function formatAgentCreateSize(option: AgentCreateSizeOption): st
 /** Ask a TTY user to choose one of hq-pro's currently selectable quotes. */
 export declare function promptForAgentCreateSize(view: AgentCreateOptionsView): Promise<QuotedAgentCreateSizeOption>;
 /** Confirm creation using the server quote, preserving $0 as a real answer. */
-export declare function confirmAgentCreateQuoteOrExit(option: QuotedAgentCreateSizeOption, yes?: boolean): void;
+export declare function confirmAgentCreateQuoteOrExit(option: QuotedAgentCreateSizeOption, yes?: boolean, quiet?: boolean): void;
 export declare function provisionAgent(token: string, input: ProvisionAgentInput): Promise<{
     uid?: string;
     slug?: string;
@@ -218,6 +278,11 @@ export declare function startStopAgent(token: string, agentUid: string, action:
     uid: string;
     runtime?: Record<string, unknown>;
 }>;
+/** Submit a human-provided Claude subscription code through hq-pro's route. */
+export declare function submitAgentLoginCode(token: string, agentUid: string, code: string): Promise<{
+    uid: string;
+    ok: boolean;
+}>;
 /** `POST /v1/agents/{uid}/terminal` wire shape: vended session or 202 starting. */
 export type AgentTerminalResponse = ({
     ok: true;
@@ -232,7 +297,7 @@ export type AgentTerminalResponse = ({
 };
 export declare function openAgentTerminal(token: string, agentUid: string, body: Record<string, unknown>): Promise<AgentTerminalResponse>;
 export declare function retryAgent(token: string, agentUid: string): Promise<Record<string, unknown>>;
-export declare function deprovisionAgent(token: string, agentUid: string): Promise<{
+export declare function deprovisionAgent(token: string, agentUid: string, confirmDestroyAgentsV2?: string): Promise<{
     uid: string;
     setupState?: string;
     terminal?: boolean;
@@ -257,12 +322,20 @@ export interface PauseJobResult {
     changed: boolean;
     previousState?: string;
 }
+export interface ResumeJobResult {
+    ok: true;
+    jobId: string;
+    scheduleState: "ENABLED" | string;
+    changed: boolean;
+    previousState?: string;
+}
 export interface CancelJobResult {
     ok: true;
     jobId: string;
 }
 export declare function listAgentJobs(token: string, agentUid: string): Promise<AgentJobView[]>;
 export declare function pauseAgentJob(token: string, agentUid: string, jobId: string): Promise<PauseJobResult>;
+export declare function resumeAgentJob(token: string, agentUid: string, jobId: string): Promise<ResumeJobResult>;
 export declare function cancelAgentJob(token: string, agentUid: string, jobId: string): Promise<CancelJobResult>;
 /**
  * Map a jobs-control HTTP error to a single operator-facing line. Pure so the
@@ -273,12 +346,16 @@ export declare function cancelAgentJob(token: string, agentUid: string, jobId: s
  * the agent is cross-company) must print a clear message and exit non-zero,
  * never throw a stack trace.
  */
-export declare function formatJobsHttpError(err: AgentsHttpError, jobId?: string): string;
+export declare function formatJobsHttpError(err: AgentsHttpError, jobId?: string, action?: "resume"): string;
 /** Stable padEnd table: jobId, scheduleState, rate, lastRunOutcome, status. */
 export declare function formatJobsTable(jobs: AgentJobView[]): string;
 export declare function formatPauseResult(result: PauseJobResult): string;
+export declare function formatResumeResult(result: ResumeJobResult): string;
 /** Human-readable "hot-applied to the running box" vs "saved for next launch". */
 export declare function appliedHint(applied: boolean): string;
+/** Stable human table shared by the all-provider and provider-filtered forms. */
+export declare function formatAgentModelsTable(catalog: AgentModelCatalog, selectedProvider?: AgentModelProvider): string;
+/** Agent uid shape (`agt_…`). */
 /** One message in a DM thread, as returned by `GET /v1/notify/thread`. */
 export interface DmThreadMessage {
     eventId: string;
@@ -326,5 +403,30 @@ export declare function sendAgentDm(token: string, agentUid: string, message: st
 export declare function readAgentThread(token: string, agentUid: string, limit?: number): Promise<DmThreadMessage[]>;
 /** Render one thread message as a labeled line for the terminal. */
 export declare function formatThreadMessage(m: DmThreadMessage, agentLabel: string): string;
+export interface EnrollmentIssue {
+    code: string;
+    expiresAt: string;
+    enrollmentId: string;
+}
+export interface RotateAgentResult {
+    agentUid: string;
+    enrollment: EnrollmentIssue;
+}
+/**
+ * POST /v1/agents/{uid}/rotate — invalidate the current secret and host key
+ * and issue a fresh one-time enrollment code (returned exactly once).
+ */
+export declare function rotateAgent(token: string, agentUid: string): Promise<RotateAgentResult>;
+/** Display form of a 24-char code: six groups of four. */
+export declare function groupEnrollmentCode(code: string): string;
+/**
+ * POST /v1/agents/{uid}/revoke — disable the Cognito user, drop membership,
+ * mark the enrollment revoked; `remove` also deletes the entity.
+ */
+export declare function revokeAgent(token: string, agentUid: string, remove: boolean): Promise<{
+    removed: boolean;
+}>;
+/** Lines printed after a rotate: the code is shown once and never stored. */
+export declare function formatRotateOutput(result: RotateAgentResult): string[];
 export declare function registerAgentsCommand(program: Command): void;
 //# sourceMappingURL=agents.d.ts.map