@indigoai-us/hq-cli 5.108.0 → 5.108.2

package/dist/commands/search.d.ts

@@ -6,6 +6,29 @@ export type SearchOptions = {
     count?: number;
     json?: boolean;
 };
+/**
+ * Normalise a caller's query into the single argv token qmd is handed.
+ *
+ * A quoted multi-line query (a fleet agent forwards a whole Slack message as the
+ * query) reaches qmd with its newlines intact. qmd's `query` subcommand then
+ * reads it as a query DOCUMENT and, unless EVERY non-empty line carries a
+ * lex:/vec:/hyde:/intent:/expand: prefix, exits 1 with a syntax error — which
+ * hq surfaced as an unclassified crash (Sentry HQ-CLI-1B / indigo-d0 7705711476,
+ * 28 of 29 events).
+ *
+ * The rule is IMPLIED BY qmd's own acceptance rule, so it can never collapse a
+ * document qmd would have accepted: qmd requires a prefix on every line of a
+ * multi-line document, so a prefixed FIRST non-empty line is a NECESSARY
+ * condition of any document qmd accepts. When the caller opened such a document
+ * (two or more non-empty lines AND a prefixed first line) the query is returned
+ * VERBATIM so structured hybrid search keeps working; otherwise every run of
+ * whitespace — the newlines included — collapses to a single space, so plain
+ * multi-line free text becomes the single-line query qmd accepts. A half-prefixed
+ * document (a user typo whose first line lacks a prefix) is collapsed and still
+ * reaches qmd, which returns a real diagnostic rather than a silently-wrong
+ * free-text search.
+ */
+export declare function normalizeQueryForQmd(query: string): string;
 export declare function buildSearchArgs(query: string, options?: SearchOptions): string[];
 export declare function buildGetArgs(document: string, options?: Pick<SearchOptions, 'collection'>): string[];
 export declare function registerSearchCommand(program: Command): void;

package/dist/commands/search.js

@@ -1,7 +1,48 @@
 import { runQmd } from '../lib/search-index/index.js';
+/**
+ * qmd's query-DOCUMENT line prefixes (qmd 2.5.3, dist/cli/qmd.js:2165-2167 and
+ * :2210). qmd's `query` subcommand parses a multi-line positional as a query
+ * DOCUMENT: with two or more non-empty lines EVERY line must begin with one of
+ * these, or qmd throws and exits 1. Mirrored from the EXACT pinned version
+ * (package.json pins `@tobilu/qmd` to `2.5.3`, not a range), so the mirror cannot
+ * drift without a deliberate dependency bump.
+ */
+const QMD_DOCUMENT_PREFIX = /^(?:lex|vec|hyde|intent|expand):\s*/i;
+/**
+ * Normalise a caller's query into the single argv token qmd is handed.
+ *
+ * A quoted multi-line query (a fleet agent forwards a whole Slack message as the
+ * query) reaches qmd with its newlines intact. qmd's `query` subcommand then
+ * reads it as a query DOCUMENT and, unless EVERY non-empty line carries a
+ * lex:/vec:/hyde:/intent:/expand: prefix, exits 1 with a syntax error — which
+ * hq surfaced as an unclassified crash (Sentry HQ-CLI-1B / indigo-d0 7705711476,
+ * 28 of 29 events).
+ *
+ * The rule is IMPLIED BY qmd's own acceptance rule, so it can never collapse a
+ * document qmd would have accepted: qmd requires a prefix on every line of a
+ * multi-line document, so a prefixed FIRST non-empty line is a NECESSARY
+ * condition of any document qmd accepts. When the caller opened such a document
+ * (two or more non-empty lines AND a prefixed first line) the query is returned
+ * VERBATIM so structured hybrid search keeps working; otherwise every run of
+ * whitespace — the newlines included — collapses to a single space, so plain
+ * multi-line free text becomes the single-line query qmd accepts. A half-prefixed
+ * document (a user typo whose first line lacks a prefix) is collapsed and still
+ * reaches qmd, which returns a real diagnostic rather than a silently-wrong
+ * free-text search.
+ */
+export function normalizeQueryForQmd(query) {
+    const nonEmptyLines = query
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (nonEmptyLines.length >= 2 && QMD_DOCUMENT_PREFIX.test(nonEmptyLines[0])) {
+        return query;
+    }
+    return query.replace(/\s+/g, ' ').trim();
+}
 export function buildSearchArgs(query, options = {}) {
     const command = { keyword: 'search', semantic: 'vsearch', hybrid: 'query' }[options.mode ?? 'keyword'];
-    const args = [command, query];
+    const args = [command, normalizeQueryForQmd(query)];
     if (options.collection)
         args.push('-c', options.collection);
     if (options.count !== undefined)

package/dist/lib/doctor/checks/work-context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Work-context doctor family (US-007A + US-008): state-file health, outbox
+ * depth, quarantined count, default-company mode, and work-mesh spool /
+ * held / dead-letter visibility.
+ */
+import { type MigrationCapabilitySnapshot } from "../../work-context/config.js";
+import type { CheckContext, CheckFamily, CheckResult } from "../types.js";
+export declare const WORK_CONTEXT_FAMILY_ID = "work-context";
+export declare const WORK_CONTEXT_FAMILY_TITLE = "Work context";
+export interface WorkContextDoctorDeps {
+    root: (home?: string) => string;
+    home: () => string;
+    /** Work-mesh root (spool / held / dead-letter). Defaults to ~/.hq/work-mesh. */
+    meshRoot?: (home?: string) => string;
+    /**
+     * Optional override for the last migration-capability probe (US-017B).
+     * When omitted, doctor reads the snapshot from device config.
+     */
+    migrationCapability?: MigrationCapabilitySnapshot | null;
+}
+export declare const workContextFamily: CheckFamily;
+export declare function checkWorkContext(_context: CheckContext, deps?: WorkContextDoctorDeps): CheckResult[];
+//# sourceMappingURL=work-context.d.ts.map

package/dist/lib/doctor/checks/work-context.js

@@ -0,0 +1,195 @@
+/**
+ * Work-context doctor family (US-007A + US-008): state-file health, outbox
+ * depth, quarantined count, default-company mode, and work-mesh spool /
+ * held / dead-letter visibility.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { readDeviceConfig, getDefaultCompany, } from "../../work-context/config.js";
+import { outboxStats, listOutboxOperations } from "../../work-context/outbox.js";
+import { workContextRoot, workContextSessionsDir } from "../../work-context/paths.js";
+import { countJsonlLines, deadLetterNonEmpty, } from "../../mesh/live/spool.js";
+import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../../mesh/live/paths.js";
+import { collectDaemonDoctor, formatDaemonDoctor, } from "../../mesh/live/daemon/doctor.js";
+export const WORK_CONTEXT_FAMILY_ID = "work-context";
+export const WORK_CONTEXT_FAMILY_TITLE = "Work context";
+const DEFAULT_DEPS = {
+    root: (home) => workContextRoot(home ?? os.homedir()),
+    home: () => os.homedir(),
+    meshRoot: (home) => workMeshRoot(home ?? os.homedir()),
+};
+export const workContextFamily = {
+    id: WORK_CONTEXT_FAMILY_ID,
+    title: WORK_CONTEXT_FAMILY_TITLE,
+    run: (context) => Promise.resolve(checkWorkContext(context)),
+};
+export function checkWorkContext(_context, deps = DEFAULT_DEPS) {
+    try {
+        return runChecks(deps);
+    }
+    catch (error) {
+        return [
+            {
+                status: "UNKNOWN",
+                checkId: "work-context.error",
+                message: `work-context checks could not run: ${error.message}`,
+            },
+        ];
+    }
+}
+function runChecks(deps) {
+    const root = deps.root(deps.home());
+    const results = [];
+    // State-file health
+    const sessionsDir = workContextSessionsDir(root);
+    if (!fs.existsSync(sessionsDir)) {
+        results.push({
+            status: "NA",
+            checkId: "work-context.state-files",
+            target: sessionsDir,
+            message: "No work-context sessions directory yet.",
+        });
+    }
+    else {
+        const files = fs.readdirSync(sessionsDir).filter((n) => n.endsWith(".json"));
+        let corrupt = 0;
+        let healthy = 0;
+        for (const name of files) {
+            const p = path.join(sessionsDir, name);
+            try {
+                const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+                if (!raw.sessionId || !raw.contextStatus || raw.contractVersion !== 1) {
+                    corrupt += 1;
+                }
+                else {
+                    healthy += 1;
+                }
+            }
+            catch {
+                corrupt += 1;
+            }
+        }
+        results.push({
+            status: corrupt > 0 ? "WARN" : "PASS",
+            checkId: "work-context.state-files",
+            target: sessionsDir,
+            message: corrupt > 0
+                ? `${corrupt} corrupt / ${healthy} healthy session state file(s).`
+                : `${healthy} healthy session state file(s).`,
+        });
+    }
+    // Outbox depth + quarantined
+    const stats = outboxStats(root);
+    results.push({
+        status: stats.depth > 50 ? "WARN" : "PASS",
+        checkId: "work-context.outbox-depth",
+        target: path.join(root, "outbox"),
+        message: `Outbox queued depth=${stats.depth} (acked=${stats.acked}).`,
+    });
+    results.push({
+        status: stats.quarantined > 0 ? "WARN" : "PASS",
+        checkId: "work-context.outbox-quarantined",
+        target: path.join(root, "outbox"),
+        message: `Outbox quarantined count=${stats.quarantined}.`,
+    });
+    // Default-company mode + migration capability (US-017B)
+    try {
+        const cfg = readDeviceConfig({ root });
+        const def = getDefaultCompany({ root });
+        const mode = def?.enabled
+            ? `enabled slug=${def.slug}`
+            : "disabled (dark / unset)";
+        results.push({
+            status: "PASS",
+            checkId: "work-context.default-company",
+            target: path.join(root, "config.json"),
+            message: `Default-company mode: ${mode}; schemaVersion=${cfg.schemaVersion}.`,
+        });
+        const cap = deps.migrationCapability !== undefined
+            ? deps.migrationCapability
+            : (cfg.migrationCapability ?? null);
+        results.push(formatMigrationCapabilityCheck(cap, root));
+    }
+    catch (err) {
+        results.push({
+            status: "WARN",
+            checkId: "work-context.default-company",
+            target: path.join(root, "config.json"),
+            message: `Default-company config unreadable: ${err instanceof Error ? err.message : String(err)}`,
+        });
+        results.push({
+            status: "WARN",
+            checkId: "work-context.migration-capability",
+            target: path.join(root, "config.json"),
+            message: `Migration capability unknown: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+    // Touch listOutboxOperations so depth stays consistent with enumeration.
+    void listOutboxOperations(root);
+    // Work-mesh spool / held / dead-letter (US-008)
+    const meshRoot = (deps.meshRoot ?? DEFAULT_DEPS.meshRoot)(deps.home());
+    const spoolPath = workMeshSpoolPath(meshRoot);
+    const heldPath = workMeshHeldPath(meshRoot);
+    const deadLetterPath = workMeshDeadLetterPath(meshRoot);
+    const spoolDepth = countJsonlLines(spoolPath);
+    const heldDepth = countJsonlLines(heldPath);
+    results.push({
+        status: "PASS",
+        checkId: "work-context.spool-depth",
+        target: spoolPath,
+        message: `Work-mesh spool depth=${spoolDepth}; held depth=${heldDepth}.`,
+    });
+    const deadLetterFull = deadLetterNonEmpty(meshRoot);
+    results.push({
+        status: deadLetterFull ? "WARN" : "PASS",
+        checkId: "work-context.dead-letter",
+        target: deadLetterPath,
+        message: deadLetterFull
+            ? `Work-mesh dead-letter is non-empty (${countJsonlLines(deadLetterPath)} line(s)); inspect and clear after fixing the cause.`
+            : "Work-mesh dead-letter is empty.",
+    });
+    // Daemon doctor (US-009): running / MQTT / companies / flush / unhealthy age
+    const daemon = collectDaemonDoctor({
+        home: deps.home(),
+        meshRoot,
+        workContextRoot: root,
+    });
+    results.push({
+        status: daemon.unhealthy ? "WARN" : "PASS",
+        checkId: "work-context.daemon",
+        target: meshRoot,
+        message: formatDaemonDoctor(daemon).join(" "),
+    });
+    return results;
+}
+function formatMigrationCapabilityCheck(cap, root) {
+    const target = path.join(root, "config.json");
+    if (!cap) {
+        return {
+            status: "NA",
+            checkId: "work-context.migration-capability",
+            target,
+            message: "Migration capability: not probed yet (run hq mesh context default set or correct).",
+        };
+    }
+    if (cap.offline) {
+        return {
+            status: "WARN",
+            checkId: "work-context.migration-capability",
+            target,
+            message: `Migration capability: offline at ${cap.checkedAt}; default-company stays locked.`,
+        };
+    }
+    const falseCount = cap.companies.filter((c) => !c.migration).length;
+    const detail = cap.companies.length === 0
+        ? "no active memberships"
+        : `${cap.companies.filter((c) => c.migration).length}/${cap.companies.length} companies advertise migration`;
+    return {
+        status: cap.unlocked ? "PASS" : "WARN",
+        checkId: "work-context.migration-capability",
+        target,
+        message: `Migration capability: unlocked=${cap.unlocked} (${detail}; false=${falseCount}); checkedAt=${cap.checkedAt}.`,
+    };
+}
+//# sourceMappingURL=work-context.js.map

package/dist/lib/doctor/registry.js

@@ -21,6 +21,7 @@ import { checkRuntimeProbe } from "./checks/runtime-probe.js";
 import { runtimeHealthFamily } from "./checks/runtime-health.js";
 import { integrationsFamily } from "./checks/integrations.js";
 import { syncHealthFamily } from "./checks/sync-health.js";
+import { workContextFamily } from "./checks/work-context.js";
 import { fixtureCoverageFamily } from "./fixtures/discover.js";
 import { checkClaudeWiring } from "./checks/claude-wiring.js";
 /**
@@ -187,6 +188,9 @@ export function createDefaultRegistry() {
     // this registry's docblock always anticipated. Local-only reads, so the
     // doctor's offline contract is preserved.
     registry.register(syncHealthFamily);
+    // Work context (US-007A): session state files, outbox depth/quarantine,
+    // and default-company mode. Local-only reads under ~/.hq/work-context.
+    registry.register(workContextFamily);
     return registry;
 }
 //# sourceMappingURL=registry.js.map

package/dist/lib/mesh/api.d.ts

@@ -29,6 +29,24 @@ export declare function meshJson(token: string, path: string, init?: {
     query?: Record<string, string>;
 }): Promise<unknown>;
 export declare function resolveMeshCompany(token: string, company?: string): Promise<MeshCompany>;
+/**
+ * Active memberships for the caller via GET /membership/me.
+ * Does not honour HQ_COMPANY_UID / HQ_WORK_MESH_COMPANY_UID env overrides.
+ * Throws on transport / auth failures.
+ */
+export declare function listActiveMembershipCompanies(token: string): Promise<MeshCompany[]>;
+/**
+ * Memberships-backed company lookup for default-company set (US-007A).
+ *
+ * Lists the caller's active companies via GET /membership/me and matches the
+ * requested slug (case-insensitive). Does **not** honour HQ_COMPANY_UID /
+ * HQ_WORK_MESH_COMPANY_UID env overrides or treat a raw `cmp_`/`co_` ref as
+ * proof of membership without an active membership row.
+ *
+ * Returns null when the caller is not an active member. Throws on transport /
+ * auth failures so the caller can surface DEFAULT_COMPANY_UNAVAILABLE.
+ */
+export declare function resolveActiveMembershipCompany(token: string, slug: string): Promise<MeshCompany | null>;
 export declare function requireToken(): Promise<string>;
 export declare function listActiveThreads(token: string, companyUid: string, projectId?: string): Promise<MeshThread[]>;
 export declare function clamp(value: string, max: number): string;

package/dist/lib/mesh/api.js

@@ -58,6 +58,61 @@ export async function resolveMeshCompany(token, company) {
     const uid = await getCompanyUid(token, company);
     return { companyUid: uid, companySlug: company || uid };
 }
+/**
+ * Active memberships for the caller via GET /membership/me.
+ * Does not honour HQ_COMPANY_UID / HQ_WORK_MESH_COMPANY_UID env overrides.
+ * Throws on transport / auth failures.
+ */
+export async function listActiveMembershipCompanies(token) {
+    const data = asRecord(await meshJson(token, "/membership/me"));
+    const rows = Array.isArray(data?.memberships) ? data.memberships : [];
+    const out = [];
+    const seen = new Set();
+    for (const row of rows) {
+        const rec = asRecord(row);
+        if (!rec)
+            continue;
+        if (String(rec.status || "").toLowerCase() !== "active")
+            continue;
+        const companyUid = typeof rec.companyUid === "string" ? rec.companyUid : "";
+        if (!companyUid || seen.has(companyUid))
+            continue;
+        const companySlug = typeof rec.companySlug === "string"
+            ? rec.companySlug
+            : typeof rec.companyFolderSlug === "string"
+                ? rec.companyFolderSlug
+                : companyUid;
+        seen.add(companyUid);
+        out.push({ companyUid, companySlug: companySlug || companyUid });
+    }
+    return out;
+}
+/**
+ * Memberships-backed company lookup for default-company set (US-007A).
+ *
+ * Lists the caller's active companies via GET /membership/me and matches the
+ * requested slug (case-insensitive). Does **not** honour HQ_COMPANY_UID /
+ * HQ_WORK_MESH_COMPANY_UID env overrides or treat a raw `cmp_`/`co_` ref as
+ * proof of membership without an active membership row.
+ *
+ * Returns null when the caller is not an active member. Throws on transport /
+ * auth failures so the caller can surface DEFAULT_COMPANY_UNAVAILABLE.
+ */
+export async function resolveActiveMembershipCompany(token, slug) {
+    const trimmed = slug.trim();
+    if (!trimmed)
+        return null;
+    const rows = await listActiveMembershipCompanies(token);
+    const needle = trimmed.toLowerCase();
+    const matches = rows.filter((c) => c.companySlug.toLowerCase() === needle ||
+        c.companyUid.toLowerCase() === needle);
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length === 0)
+        return null;
+    // Ambiguous slug across memberships — refuse rather than guess.
+    return null;
+}
 export async function requireToken() {
     return ensureCognitoToken();
 }

package/dist/lib/mesh/cache.js

@@ -22,10 +22,41 @@ export function writeMeshCacheFile(segments, value, root = meshCacheRoot()) {
     if (segments.length === 0 || !segments.every(isSafeCacheSegment))
         return null;
     const dest = path.join(root, ...segments);
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    const tmp = `${dest}.tmp`;
-    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
-    fs.renameSync(tmp, dest);
+    fs.mkdirSync(path.dirname(dest), { recursive: true, mode: 0o700 });
+    const tmp = `${dest}.tmp.${process.pid}.${Date.now()}`;
+    let fd;
+    try {
+        fd = fs.openSync(tmp, "wx", 0o600);
+        const buf = Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+        fs.writeSync(fd, buf);
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tmp, dest);
+        try {
+            fs.chmodSync(dest, 0o600);
+        }
+        catch {
+            // ignore exotic FS
+        }
+    }
+    catch (err) {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* already closed */
+            }
+        }
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* temp may not exist */
+        }
+        throw err;
+    }
     return dest;
 }
 /** Drop leftover session.json once we know the real prs_/agt_ cache key. */

package/dist/lib/mesh/client.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Shared work-mesh transport client.
+ * Existing `hq mesh` verbs and work-context reconcile both use this for
+ * vault HTTP + receipt-shaped responses (US-007A / US-007B).
+ */
+import { listActiveMembershipCompanies, meshJson, requireToken, resolveMeshCompany, type MeshCompany } from "./api.js";
+import type { DeliverFn } from "../work-context/outbox.js";
+import type { CandidatesResponse, OrganizeReceipt, OrganizeSubmitDecision, FetchCandidatesFn, PostOrganizeFn } from "../work-context/organize.js";
+import type { MigrateReceipt, PostMigrateFn } from "../work-context/migrate.js";
+export { meshJson, requireToken, resolveMeshCompany, listActiveMembershipCompanies };
+export type { MeshCompany };
+/** Company-wide live read (US-004 / US-007B session status). */
+export interface CompanyLiveSession {
+    sessionId: string;
+    harness?: string;
+    contextStatus?: string;
+    projectId?: string;
+    taskId?: string;
+    status?: string;
+    startedAt?: string;
+    lastTurnAt?: string;
+    turnCount?: number;
+}
+export interface CompanyLiveParticipant {
+    actorUid: string;
+    actorType?: string;
+    displayName?: string;
+    presence?: string;
+    lastSeenAt?: string;
+    sessions?: CompanyLiveSession[];
+}
+export interface CompanyLiveReadResponse {
+    contractVersion: 1;
+    generatedAt: string;
+    participants: CompanyLiveParticipant[];
+    nextCursor?: string;
+}
+export interface MeshTransport {
+    token: string;
+    company: MeshCompany;
+}
+export declare function openMeshTransport(opts: {
+    company?: string;
+}): Promise<MeshTransport>;
+/**
+ * POST work-session registration for a queued outbox operation.
+ * Maps HTTP status to retryable vs quarantine.
+ */
+export declare function createWorkSessionDeliverer(opts: {
+    token: string;
+    /** Override fetch for tests. */
+    post?: (path: string, body: Record<string, unknown>) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}): DeliverFn;
+/**
+ * Probe whether the server advertises migration capability (US-017A).
+ * Failures return false (default-company stays locked).
+ */
+export declare function fetchMigrationCapability(token: string, companyUid: string): Promise<boolean>;
+export interface MigrationCapabilityCompanyResult {
+    companyUid: string;
+    companySlug: string;
+    migration: boolean;
+}
+export interface MigrationCapabilityProbe {
+    /** True only when every active membership reports migration: true. */
+    unlocked: boolean;
+    /** True when memberships could not be listed (no session / network). */
+    offline: boolean;
+    checkedAt: string;
+    companies: MigrationCapabilityCompanyResult[];
+}
+/**
+ * Unlock rule for default-company mode (US-017B): migration must be true for
+ * EVERY company the caller belongs to. Offline / empty memberships → locked.
+ */
+export declare function probeMigrationCapabilityForMemberships(token: string, opts?: {
+    listCompanies?: (token: string) => Promise<MeshCompany[]>;
+    fetchOne?: (token: string, companyUid: string) => Promise<boolean>;
+    now?: () => Date;
+}): Promise<MigrationCapabilityProbe>;
+/**
+ * POST /v1/work-mesh/sessions/{sessionId}/migrate
+ */
+export declare function createMigratePoster(opts: {
+    token: string;
+    post?: (path: string, body: Record<string, unknown>) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}): PostMigrateFn;
+/**
+ * GET /v1/work-mesh/sessions/{sessionId}/candidates?companyUid=...
+ */
+export declare function createCandidatesFetcher(opts: {
+    token: string;
+    get?: (path: string, query: Record<string, string>) => Promise<unknown>;
+}): FetchCandidatesFn;
+/**
+ * POST /v1/work-mesh/sessions/{sessionId}/organize
+ */
+export declare function createOrganizePoster(opts: {
+    token: string;
+    post?: (path: string, body: Record<string, unknown>) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}): PostOrganizeFn;
+/** GET /v1/work-mesh/live?companyUid=... */
+export declare function fetchCompanyLive(token: string, companyUid: string, opts?: {
+    cursor?: string;
+    get?: (path: string, query: Record<string, string>) => Promise<unknown>;
+}): Promise<CompanyLiveReadResponse>;
+export declare function formatCompanyLiveTable(live: CompanyLiveReadResponse, companyLabel: string): string[];
+export type { OrganizeSubmitDecision, OrganizeReceipt, CandidatesResponse, MigrateReceipt, PostMigrateFn, };
+//# sourceMappingURL=client.d.ts.map