@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/channels.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
-import { channelSlug } from "./dm.js";
+import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, } from "./dm.js";
 /**
  * Human label for a channel row. Named channels (personal/company) show their
  * name + a `hq dm <slug>` hint; unnamed group DMs are identified by their
@@ -42,6 +42,31 @@ export function formatChannelsList(channels) {
     }
     return lines.join("\n");
 }
+/**
+ * Remove the caller from a channel roster before it is used for mentions.
+ * Machine principals identify themselves with the JWT uid; human sessions can
+ * also match the roster's email when the uid claim is absent.
+ */
+function excludeCallerFromChannelMembers(members, caller) {
+    return members.filter((member) => {
+        if (caller.personUid && member.personUid === caller.personUid)
+            return false;
+        if (caller.email &&
+            member.email &&
+            member.email.trim().toLowerCase() === caller.email) {
+            return false;
+        }
+        return true;
+    });
+}
+/** Render the roster as either dm-bind's tab-separated format or JSON. */
+function formatChannelMembers(members, json) {
+    if (json)
+        return JSON.stringify(members);
+    return members
+        .map((member) => `${member.displayName ?? ""}\t${member.personUid}`)
+        .join("\n");
+}
 async function runChannelsList() {
     try {
         const token = await ensureCognitoToken();
@@ -64,6 +89,29 @@ async function runChannelsList() {
         process.exit(1);
     }
 }
+async function runChannelsMembers(channelName, opts) {
+    try {
+        const token = await ensureCognitoToken();
+        const channels = await fetchChannels(token);
+        const matches = matchChannelsByName(channels, channelName);
+        if (matches.length === 0) {
+            console.error(chalk.red(`No channel named '${channelName}' — run \`hq channels\` to see your channels.`));
+            process.exit(1);
+        }
+        if (matches.length > 1) {
+            const scopes = matches.map((match) => match.scope ?? "?").join(", ");
+            console.error(chalk.red(`'${channelName}' matches ${matches.length} channels (${scopes}) — this is ambiguous.`));
+            process.exit(1);
+        }
+        const members = await fetchChannelMembers(token, matches[0].channelId);
+        const visibleMembers = excludeCallerFromChannelMembers(members, callerFromToken(token));
+        console.log(formatChannelMembers(visibleMembers, opts.json === true));
+    }
+    catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 export function registerChannelsCommand(program) {
     const channels = program
         .command("channels")
@@ -74,5 +122,12 @@ export function registerChannelsCommand(program) {
         .action(async () => {
         await runChannelsList();
     });
+    channels
+        .command("members <channel>")
+        .description("Print the members of one of your DM channels.")
+        .option("--json", "Output the member array as JSON.")
+        .action(async (channelName, opts) => {
+        await runChannelsMembers(channelName, opts);
+    });
 }
 //# sourceMappingURL=channels.js.map

package/dist/commands/cloud-demote.js

@@ -160,8 +160,9 @@ export function registerCloudDemoteCommands(program) {
     demoteCmd
         .command("company")
         .description("Demote a cloud-backed company to local-only after the cloud entity " +
-        "has been soft-tombstoned in hq-console. Removes .hq/config.json, " +
-        "flips company.yaml `cloud: false`, and strips the manifest cloud refs.")
+        "has been soft-tombstoned (`hq cloud retire company` or hq-console). " +
+        "Removes .hq/config.json, flips company.yaml `cloud: false`, and " +
+        "strips the manifest cloud refs.")
         .argument("<slug>", "Company slug")
         .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
         .option("--vault-api-url <url>", `Vault API URL (default: ${DEFAULT_VAULT_API_URL})`, DEFAULT_VAULT_API_URL)

package/dist/commands/cloud-provision.d.ts

@@ -38,6 +38,8 @@ export interface VaultEntity {
     kmsKeyId?: string | null;
     status?: string;
     ownerUid?: string;
+    /** Set by hq-pro after a soft tombstone. Absent on live companies. */
+    deleted?: boolean;
 }
 /** Per-company `.hq/config.json` schema (matches AppBar `provision.rs::CompanyConfig`). */
 export interface CompanyConfig {
@@ -133,6 +135,8 @@ export interface VaultClient {
     checkSlugInMyNamespace(slug: string): Promise<{
         available: boolean;
         conflictingCompanyUid?: string;
+        /** Older hq-pro servers omit this field; absence means unsupported. */
+        skipStarterSeedSupported?: boolean;
     }>;
     /** Fetch a company entity by uid. Used to materialize the entity
      * after `checkSlugInMyNamespace` reports a same-namespace collision. */
@@ -141,7 +145,17 @@ export interface VaultClient {
         slug: string;
         name: string;
         ownerUid?: string;
+        skipStarterSeed?: boolean;
     }): Promise<VaultEntity>;
+    /**
+     * Soft-tombstone a company (`DELETE /entity/{uid}`). Owner-only. Leaves the
+     * row, S3 bucket, KMS key, and memberships intact. Idempotent on an already
+     * deleted company. Used by `hq cloud retire company`.
+     */
+    softDeleteCompany(uid: string): Promise<{
+        deleted: true;
+        uid: string;
+    }>;
 }
 /** Custom error class so the CLI runner can map to exit codes. */
 export declare class ProvisionError extends Error {

package/dist/commands/cloud-provision.js

@@ -32,8 +32,27 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as yaml from "js-yaml";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
-import { share } from "@indigoai-us/hq-cloud";
+import { createSyncProgressRecorder, share, } from "@indigoai-us/hq-cloud";
 import { DEFAULT_HQ_ROOT, DEFAULT_VAULT_API_URL, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
+const SHARED_COMPANY_STARTER_PATHS = [
+    "README.md",
+    "board.json",
+    "knowledge/README.md",
+    "knowledge/design-styles/packs/.gitkeep",
+    "people/.gitkeep",
+    "policies/.gitkeep",
+    "projects/.gitkeep",
+    "repos/.gitkeep",
+    "skills/.gitkeep",
+    "sources/meetings/source.yaml",
+    "workspace/.gitignore",
+    "workspace/index.jsonl",
+    "workspace/sessions/.gitkeep",
+];
+function hasLocalSharedStarterPath(hqRoot, slug) {
+    const companyDir = path.join(hqRoot, "companies", slug);
+    return SHARED_COMPANY_STARTER_PATHS.some((relativePath) => fs.existsSync(path.join(companyDir, relativePath)));
+}
 /** Custom error class so the CLI runner can map to exit codes. */
 export class ProvisionError extends Error {
     code;
@@ -266,6 +285,21 @@ export function writeCompanyConfig(hqRoot, slug, config) {
     return true;
 }
 // ── Vault HTTP client (real impl) ────────────────────────────────────────────
+const VAULT_REQUEST_TIMEOUT_MS = 15_000;
+/** Run a complete Vault HTTP operation under a finite deadline. */
+async function withVaultRequest(url, init, readResponse) {
+    const deadline = AbortSignal.timeout(VAULT_REQUEST_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, { ...init, signal: deadline });
+        return await readResponse(res);
+    }
+    catch (err) {
+        if (deadline.aborted) {
+            throw new ProvisionError(1, `Vault request timed out after ${VAULT_REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+}
 /**
  * Default vault HTTP client backed by global `fetch`. Uses the `/v1/entities`
  * route surface (matches AppBar `vault_client.rs` and hq-pro handler routes).
@@ -284,52 +318,60 @@ export function createDefaultVaultClient(apiUrl, accessToken) {
     return {
         async listMyPersonEntities() {
             const url = `${apiUrl.replace(/\/$/, "")}/entity/by-type/person`;
-            const res = await fetch(url, { method: "GET", headers });
-            if (res.status === 404)
-                return [];
-            if (!res.ok) {
-                const body = await safeBody(res);
-                throw new ProvisionError(1, `Vault GET /entity/by-type/person failed: ${res.status} ${res.statusText} — ${body}`);
-            }
-            const data = (await res.json());
-            return data.entities ?? [];
+            return withVaultRequest(url, { method: "GET", headers }, async (res) => {
+                if (res.status === 404)
+                    return [];
+                if (!res.ok) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(1, `Vault GET /entity/by-type/person failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                const data = (await res.json());
+                return data.entities ?? [];
+            });
         },
         async findCompanyBySlug(slug) {
             const url = `${apiUrl.replace(/\/$/, "")}/entity/by-slug/company/${encodeURIComponent(slug)}`;
-            const res = await fetch(url, { method: "GET", headers });
-            if (res.status === 404)
-                return null;
-            if (!res.ok) {
-                const body = await safeBody(res);
-                throw new ProvisionError(1, `Vault GET by-slug failed: ${res.status} ${res.statusText} — ${body}`);
-            }
-            const data = (await res.json());
-            if (!data.entity) {
-                throw new ProvisionError(1, `Vault GET by-slug returned 200 with no entity body`);
-            }
-            return data.entity;
+            return withVaultRequest(url, { method: "GET", headers }, async (res) => {
+                if (res.status === 404)
+                    return null;
+                if (!res.ok) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(1, `Vault GET by-slug failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                const data = (await res.json());
+                if (!data.entity) {
+                    throw new ProvisionError(1, `Vault GET by-slug returned 200 with no entity body`);
+                }
+                return data.entity;
+            });
         },
         async checkSlugInMyNamespace(slug) {
             const url = `${apiUrl.replace(/\/$/, "")}/entity/check-slug/me?type=company&slug=${encodeURIComponent(slug)}`;
-            const res = await fetch(url, { method: "GET", headers });
-            if (!res.ok) {
-                const body = await safeBody(res);
-                throw new ProvisionError(1, `Vault GET /entity/check-slug/me failed: ${res.status} ${res.statusText} — ${body}`);
-            }
-            return (await res.json());
+            return withVaultRequest(url, { method: "GET", headers }, async (res) => {
+                if (!res.ok) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(1, `Vault GET /entity/check-slug/me failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                const data = (await res.json());
+                return {
+                    ...data,
+                    skipStarterSeedSupported: data.skipStarterSeedSupported === true,
+                };
+            });
         },
         async getCompanyByUid(uid) {
             const url = `${apiUrl.replace(/\/$/, "")}/entity/${encodeURIComponent(uid)}`;
-            const res = await fetch(url, { method: "GET", headers });
-            if (!res.ok) {
-                const body = await safeBody(res);
-                throw new ProvisionError(1, `Vault GET /entity/${uid} failed: ${res.status} ${res.statusText} — ${body}`);
-            }
-            const data = (await res.json());
-            if (!data.entity) {
-                throw new ProvisionError(1, `Vault GET /entity/${uid} returned 200 with no entity body`);
-            }
-            return data.entity;
+            return withVaultRequest(url, { method: "GET", headers }, async (res) => {
+                if (!res.ok) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(1, `Vault GET /entity/${uid} failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                const data = (await res.json());
+                if (!data.entity) {
+                    throw new ProvisionError(1, `Vault GET /entity/${uid} returned 200 with no entity body`);
+                }
+                return data.entity;
+            });
         },
         async createCompanyEntity(input) {
             const url = `${apiUrl.replace(/\/$/, "")}/entity`;
@@ -340,29 +382,58 @@ export function createDefaultVaultClient(apiUrl, accessToken) {
             };
             if (input.ownerUid)
                 body.ownerUid = input.ownerUid;
-            const res = await fetch(url, {
+            if (input.skipStarterSeed)
+                body.skipStarterSeed = true;
+            return withVaultRequest(url, {
                 method: "POST",
                 headers,
                 body: JSON.stringify(body),
+            }, async (res) => {
+                if (!res.ok) {
+                    const text = await safeBody(res);
+                    // 409 SLUG_IN_USE_FOR_PERSON: the caller already has the slug
+                    // in their namespace (owned ∪ active-member-of). Under the
+                    // per-user-namespace model this is the new same-user-collision
+                    // signal — distinct from the legacy global EntityAlreadyExists.
+                    // The CLI normally reaches `createCompanyEntity` only after
+                    // `checkSlugInMyNamespace` reported `available: true`, so a
+                    // 409 here means a race between the pre-check and the POST.
+                    // Surface the response body verbatim so the caller can see the
+                    // `code` + `conflictingCompanyUid` and resolve / retry.
+                    throw new ProvisionError(1, `Vault POST /entity failed: ${res.status} ${res.statusText} — ${text}`);
+                }
+                const data = (await res.json());
+                if (!data.entity) {
+                    throw new ProvisionError(1, `Vault POST /entity returned ${res.status} with no entity body`);
+                }
+                return data.entity;
+            });
+        },
+        async softDeleteCompany(uid) {
+            const url = `${apiUrl.replace(/\/$/, "")}/entity/${encodeURIComponent(uid)}`;
+            return withVaultRequest(url, { method: "DELETE", headers }, async (res) => {
+                if (res.status === 403) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(2, `Refusing to retire '${uid}': only the company owner can soft-tombstone it. ${body}`);
+                }
+                if (res.status === 404) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(2, `Vault DELETE /entity/${uid} failed: not found — ${body}`);
+                }
+                if (res.status === 400) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(2, `Vault DELETE /entity/${uid} failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                if (!res.ok) {
+                    const body = await safeBody(res);
+                    throw new ProvisionError(1, `Vault DELETE /entity/${uid} failed: ${res.status} ${res.statusText} — ${body}`);
+                }
+                const data = (await res.json());
+                if (data.deleted !== true || typeof data.uid !== "string") {
+                    throw new ProvisionError(1, `Vault DELETE /entity/${uid} returned ${res.status} with no deleted confirmation`);
+                }
+                return { deleted: true, uid: data.uid };
             });
-            if (!res.ok) {
-                const text = await safeBody(res);
-                // 409 SLUG_IN_USE_FOR_PERSON: the caller already has the slug
-                // in their namespace (owned ∪ active-member-of). Under the
-                // per-user-namespace model this is the new same-user-collision
-                // signal — distinct from the legacy global EntityAlreadyExists.
-                // The CLI normally reaches `createCompanyEntity` only after
-                // `checkSlugInMyNamespace` reported `available: true`, so a
-                // 409 here means a race between the pre-check and the POST.
-                // Surface the response body verbatim so the caller can see the
-                // `code` + `conflictingCompanyUid` and resolve / retry.
-                throw new ProvisionError(1, `Vault POST /entity failed: ${res.status} ${res.statusText} — ${text}`);
-            }
-            const data = (await res.json());
-            if (!data.entity) {
-                throw new ProvisionError(1, `Vault POST /entity returned ${res.status} with no entity body`);
-            }
-            return data.entity;
         },
     };
 }
@@ -375,7 +446,32 @@ async function safeBody(res) {
     }
 }
 // ── Default initial-sync runner (wraps share()) ──────────────────────────────
+const INITIAL_SYNC_ERROR_FIELD_LIMIT = 240;
+function truncateInitialSyncErrorField(value) {
+    return value.length <= INITIAL_SYNC_ERROR_FIELD_LIMIT
+        ? value
+        : `${value.slice(0, INITIAL_SYNC_ERROR_FIELD_LIMIT - 1)}…`;
+}
+class InitialSyncUploadFailureError extends Error {
+    filesUploaded;
+    constructor(filesUploaded, failureCount, firstFailure) {
+        const detail = `${truncateInitialSyncErrorField(firstFailure.path)}: ` +
+            truncateInitialSyncErrorField(firstFailure.message);
+        const failureLabel = failureCount === 1
+            ? "upload failure"
+            : "upload failures";
+        super(`${failureCount} ${failureLabel}; first failure: ${detail}`);
+        this.filesUploaded = filesUploaded;
+        this.name = "InitialSyncUploadFailureError";
+    }
+}
 async function defaultRunInitialSync(args) {
+    let failureCount = 0;
+    let firstFailure;
+    const recordProgress = createSyncProgressRecorder({
+        company: args.slug,
+        phase: "push",
+    });
     const result = await share({
         paths: [companyDirPath(args.hqRoot, args.slug)],
         company: args.slug,
@@ -383,7 +479,25 @@ async function defaultRunInitialSync(args) {
         onConflict: "keep",
         vaultConfig: buildVaultConfig(args.accessToken),
         hqRoot: args.hqRoot,
+        progressRecorder: (event) => {
+            recordProgress(event);
+            if (event.type === "plan-limit") {
+                failureCount += Math.max(1, event.count ?? 0, event.paths?.length ?? 0);
+                firstFailure ??= {
+                    path: event.paths?.[0] ?? "plan limit",
+                    message: event.message ?? "plan limit refused upload",
+                };
+                return;
+            }
+            if (event.type !== "error" || event.diagnostic === true)
+                return;
+            failureCount++;
+            firstFailure ??= { path: event.path, message: event.message };
+        },
     });
+    if (failureCount > 0 && firstFailure) {
+        throw new InitialSyncUploadFailureError(result.filesUploaded, failureCount, firstFailure);
+    }
     return {
         filesUploaded: result.filesUploaded,
         bytesUploaded: result.bytesUploaded,
@@ -459,6 +573,7 @@ export async function provisionCompany(options) {
     // match the caller's own person UID(s) from `listMyPersonEntities`.
     const callerOwnedUids = new Set(persons.map((p) => p.uid));
     const callerIsOwner = !options.ownerUid || callerOwnedUids.has(options.ownerUid);
+    const hasLocalSharedStarterFiles = hasLocalSharedStarterPath(options.hqRoot, options.slug);
     let entity;
     let createdEntity = false;
     if (callerIsOwner) {
@@ -468,17 +583,24 @@ export async function provisionCompany(options) {
             entity = await vaultClient.getCompanyByUid(slugCheck.conflictingCompanyUid);
         }
         else {
+            if (hasLocalSharedStarterFiles && !slugCheck.skipStarterSeedSupported) {
+                throw new ProvisionError(1, "This hq-pro server does not support preserving local starter files during cloud provisioning; update hq-pro and retry");
+            }
             log(`slug available in caller's namespace — creating vault entity`);
             entity = await vaultClient.createCompanyEntity({
                 slug: options.slug,
                 name: options.name ?? options.slug,
                 ownerUid: options.ownerUid,
+                ...(hasLocalSharedStarterFiles ? { skipStarterSeed: true } : {}),
             });
             createdEntity = true;
             log(`created vault entity uid=${entity.uid}`);
         }
     }
     else {
+        if (hasLocalSharedStarterFiles) {
+            throw new ProvisionError(1, "Cannot preserve local starter files when provisioning for a different owner");
+        }
         log(`--owner ${options.ownerUid} differs from caller's person(s); skipping namespace pre-check (server authoritatively gates per-target-namespace)`);
         entity = await vaultClient.createCompanyEntity({
             slug: options.slug,
@@ -488,6 +610,52 @@ export async function provisionCompany(options) {
         createdEntity = true;
         log(`created vault entity uid=${entity.uid}`);
     }
+    // hq-pro auto-suffixes a company slug when another owner already holds the
+    // bare name (`<slug>-<ownerTag>`). `/entity/check-slug/me` only looks at the
+    // caller's namespace, so it reports "available" and we POST; the server then
+    // returns a different slug. Writing companies/<requested>/.hq/config.json
+    // with the requested slug (or syncing with --company <assigned>) leaves the
+    // local folder and the cloud slug pointing at two different paths — share()
+    // derives syncRoot from ctx.slug, so the company can never be pushed.
+    // Fail before any local write. Retire a just-created entity so we do not
+    // leave a suffixed orphan.
+    if (entity.slug !== options.slug) {
+        const assigned = entity.slug || "(missing)";
+        let retired = false;
+        if (createdEntity) {
+            try {
+                await vaultClient.softDeleteCompany(entity.uid);
+                retired = true;
+                log(`retired vault entity uid=${entity.uid} — assigned slug ${assigned} differs from requested ${options.slug}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`failed to retire mismatched vault entity uid=${entity.uid}: ${msg}`);
+            }
+        }
+        const retireNote = retired
+            ? `The just-created entity ${entity.uid} was retired.`
+            : createdEntity
+                ? `Retire entity ${entity.uid} with \`hq cloud retire company\`, then retry after the original slug is free.`
+                : `Existing entity ${entity.uid} was not modified.`;
+        throw new ProvisionError(1, `Cloud assigned slug "${assigned}" instead of requested "${options.slug}". ` +
+            `Local folder is companies/${options.slug}; sync derives the company folder from the cloud slug, so this company cannot be pushed. ` +
+            `${retireNote} Ask an admin to release the original slug, or rename the local folder to "${assigned}" and re-run.`, {
+            ok: false,
+            company_slug: options.slug,
+            cloud_uid: entity.uid,
+            bucket_name: entity.bucketName ?? "",
+            vault_api_url: options.vaultApiUrl,
+            kms_key_id: entity.kmsKeyId ?? null,
+            created_entity: createdEntity,
+            manifest_patched: false,
+            config_written: false,
+            initial_sync: {
+                ok: false,
+                error: `assigned slug "${assigned}" differs from requested "${options.slug}"`,
+            },
+        });
+    }
     if (!entity.bucketName) {
         // Vault returned an entity without a bucket — this would happen if the
         // provisioning Lambda asynchronously failed. We have a `cloud_uid` but
@@ -562,7 +730,13 @@ export async function provisionCompany(options) {
                 created_entity: createdEntity,
                 manifest_patched: true,
                 config_written: true,
-                initial_sync: { ok: false, error: msg },
+                initial_sync: {
+                    ok: false,
+                    error: msg,
+                    ...(err instanceof InitialSyncUploadFailureError
+                        ? { files_uploaded: err.filesUploaded }
+                        : {}),
+                },
             });
         }
     }

package/dist/commands/cloud-retire.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `hq cloud retire company <slug>` — soft-tombstone a cloud company so
+ * `hq cloud demote company` can run without `--propagate-deletes`.
+ *
+ * Console equivalent: Settings → Delete company (`DELETE /entity/{uid}`).
+ * Owner-only. The entity row, S3 bucket, KMS key, and memberships stay;
+ * `/membership/me` stops listing the company. Local files are not touched —
+ * demote is the follow-up that flips the local tree back to local-only.
+ *
+ * Confirm step is on by default (`[y/N]`). `--yes` skips it for scripts.
+ * A non-TTY stdin without `--yes` refuses rather than hanging.
+ *
+ * Exit codes (mirrors cloud-provision / cloud-demote):
+ *   0 — success, already tombstoned, or the operator cancelled.
+ *   1 — vault HTTP failure (auth/network/5xx).
+ *   2 — validation (bad slug, no entity, not owner, missing confirm).
+ */
+import { Command } from "commander";
+import { type VaultClient } from "./cloud-provision.js";
+/** Final stdout JSON shape. */
+export interface RetireResult {
+    ok: boolean;
+    company_slug: string;
+    cloud_uid: string | null;
+    /** True when hq-pro already had deleted=true (no DELETE sent). */
+    already_deleted: boolean;
+    cancelled?: boolean;
+}
+export interface RetireCompanyOptions {
+    slug: string;
+    hqRoot: string;
+    vaultApiUrl: string;
+    /** Skip the interactive confirmation prompt. */
+    yes?: boolean;
+    vaultClient?: VaultClient;
+    resolveAccessToken?: () => Promise<string>;
+    confirm?: (question: string) => Promise<boolean>;
+    stdinIsTTY?: boolean;
+}
+export declare function defaultConfirm(question: string): Promise<boolean>;
+/**
+ * Read `companyUid` from `companies/<slug>/.hq/config.json` when the by-slug
+ * lookup misses (a tombstoned company is filtered from that route).
+ */
+export declare function readLocalCompanyUid(hqRoot: string, slug: string): string | null;
+export declare function retireCompany(options: RetireCompanyOptions): Promise<RetireResult>;
+/**
+ * Register `retire company <slug>` under the `cloud` command group.
+ */
+export declare function registerCloudRetireCommands(program: Command): void;
+//# sourceMappingURL=cloud-retire.d.ts.map