@indigoai-us/hq-cli 5.59.0 → 5.61.0

package/dist/main.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * HQ CLI - Module management, package management, and cloud sync for HQ
+ */
+// MUST be first: guard the Node version before any dependency that needs a
+// Node 20+ API (e.g. util.styleText) or a newer native ABI is evaluated.
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a2c1badb-d418-557d-a0f4-0e3defd13913")}catch(e){}}();
+import "./node-preflight.js";
+import { Command } from "commander";
+import { initSentry, Sentry } from "./sentry.js";
+import { registerAddCommand } from "./commands/add.js";
+import { registerSyncCommand } from "./commands/sync.js";
+import { registerListCommand } from "./commands/list.js";
+import { registerUpdateCommand } from "./commands/update.js";
+import { registerCloudCommands } from "./commands/cloud.js";
+import { registerSyncModeCommand } from "./commands/sync-mode.js";
+import { registerSyncNarrowCommand } from "./commands/sync-narrow.js";
+import { registerCloudProvisionCommands } from "./commands/cloud-provision.js";
+import { registerCloudDemoteCommands } from "./commands/cloud-demote.js";
+import { registerLoginCommand } from "./commands/login.js";
+import { registerLogoutCommand } from "./commands/logout.js";
+import { registerWhoamiCommand } from "./commands/whoami.js";
+import { registerOnboardCommand } from "./commands/onboard.js";
+import { registerPackageInstallCommand } from "./commands/pkg-install.js";
+import { registerPackageRemoveCommand } from "./commands/pkg-remove.js";
+import { registerPackageUpdateCommand } from "./commands/pkg-update.js";
+import { registerPackageListCommand } from "./commands/pkg-list.js";
+import { registerPacksCommand } from "./commands/packs.js";
+import { registerPublishCommand } from "./commands/publish.js";
+import { registerCreatorsCommand } from "./commands/creators.js";
+import { registerTeamSyncCommand } from "./commands/team-sync.js";
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerApiKeysCommand } from "./commands/api-keys.js";
+import { registerSecretsCommand } from "./commands/secrets.js";
+import { registerRunCommand } from "./commands/run.js";
+import { registerGroupsCommand } from "./commands/groups.js";
+import { registerGroupGrantsCommand } from "./commands/group-grants.js";
+import { registerFilesCommand } from "./commands/files.js";
+import { registerFilesBrowseCommands } from "./commands/files-browse.js";
+import { registerMembersCommand } from "./commands/members.js";
+import { registerPeopleCommand } from "./commands/people.js";
+import { registerDmCommand } from "./commands/dm.js";
+import { registerChannelsCommand } from "./commands/channels.js";
+import { registerFeedbackCommand } from "./commands/feedback.js";
+import { registerMeetingsCommand } from "./commands/meetings.js";
+import { registerSourcesCommand } from "./commands/sources.js";
+import { registerSignalsCommand } from "./commands/signals.js";
+import { registerReindexCommand } from "./commands/reindex.js";
+import { registerRescueCommand } from "./commands/rescue.js";
+import { registerMcpCommand } from "./commands/mcp-status.js";
+import { registerCrmCommand } from "./commands/crm.js";
+import { registerCompanyCommand } from "./commands/company.js";
+import { sanitizeArgv } from "./utils/feedback-diagnostics.js";
+import { environmentalFsErrorMessage } from "./utils/environmental-error.js";
+import { isEpipe } from "./utils/epipe.js";
+import { isInterceptedProcessExit } from "./utils/intercepted-process-exit.js";
+import { maybeWarnNewVersion, refreshVersionCache, } from "./utils/version-check.js";
+import { enforceVersionGate, shouldSkipGate, } from "./utils/version-gate.js";
+import { CLI_VERSION } from "./cli-version.js";
+// Swallow EPIPE when a downstream reader (e.g. `source <(…)`, `| head`) closes
+// the pipe early. This covers the ASYNC path — an 'error' event emitted on the
+// stream. The SYNCHRONOUS path (a `write EPIPE` thrown straight out of
+// console.log inside a command) is handled in the top-level catch below; both
+// share `isEpipe` (HQ-6B).
+const onPipeError = (err) => {
+    if (isEpipe(err)) {
+        process.exit(0);
+    }
+    throw err;
+};
+process.stdout.on("error", onPipeError);
+process.stderr.on("error", onPipeError);
+initSentry();
+maybeWarnNewVersion();
+const program = new Command();
+program
+    .name("hq")
+    .description("HQ management CLI — modules, packages, and cloud sync")
+    .version(CLI_VERSION);
+// Module management subcommand group
+const modulesCmd = program
+    .command("modules")
+    .description("Module management commands");
+registerAddCommand(modulesCmd);
+registerSyncCommand(modulesCmd);
+registerListCommand(modulesCmd);
+registerUpdateCommand(modulesCmd);
+// Package management subcommand group
+const packagesCmd = program
+    .command("packages")
+    .description("Package management commands");
+registerPackageInstallCommand(packagesCmd);
+registerPackageRemoveCommand(packagesCmd);
+registerPackageUpdateCommand(packagesCmd);
+registerPackageListCommand(packagesCmd);
+// Content-pack lifecycle (core/packages/hq-pack-*). Distinct from the registry
+// `packages` system above. Available as both `hq packages packs …` (grouped)
+// and `hq packs …` (top-level convenience).
+registerPacksCommand(packagesCmd);
+registerPacksCommand(program);
+// Top-level shortcuts for package commands
+// "hq install <slug>" = "hq packages install <slug>"
+// "hq remove <slug>"  = "hq packages remove <slug>"
+registerPackageInstallCommand(program);
+registerPackageRemoveCommand(program);
+// Marketplace publish (top-level — packer + authenticated upload, US-004)
+// "hq publish <skill-or-worker-path>" packages and submits a pack to the
+// marketplace via POST /v1/listings.
+registerPublishCommand(program);
+// `hq creators apply` — request verified-creator access (required to publish).
+registerCreatorsCommand(program);
+// Cloud sync subcommand group
+const syncCmd = program
+    .command("sync")
+    .description("Cloud sync commands — sync HQ to S3 for mobile access");
+registerCloudCommands(syncCmd);
+registerSyncModeCommand(syncCmd);
+registerSyncNarrowCommand(syncCmd);
+// Cloud provisioning subcommand group (entity + bucket + initial sync)
+// Distinct from `hq sync` which assumes provisioning has already happened.
+const cloudCmd = program
+    .command("cloud")
+    .description("Cloud commands — provision entities and manage cloud-backed companies");
+registerCloudProvisionCommands(cloudCmd);
+registerCloudDemoteCommands(cloudCmd);
+// Team commands (top-level)
+registerTeamSyncCommand(program);
+// Auth commands (top-level — Cognito OAuth)
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerWhoamiCommand(program);
+registerAuthCommands(program);
+// Secrets management (subcommand group — hq secrets set|get|list|delete|exec|generate-link|cache)
+registerSecretsCommand(program);
+// API key management (subcommand group — hq api-keys create|list|revoke)
+registerApiKeysCommand(program);
+// Schema-driven dev runner — hq run [options] -- <cmd>
+registerRunCommand(program);
+// Groups management (subcommand group — hq groups create|delete|add|remove|list|members)
+registerGroupsCommand(program);
+// Cross-company group grants (subcommand group —
+// hq group-grants grant|revoke|outbound|inbound)
+registerGroupGrantsCommand(program);
+// Files ACL management (subcommand group — hq files share|unshare|acl)
+// `registerFilesCommand` returns the `files` group so we can attach the
+// browse-vs-sync subcommands (`hq files browse`/`cat`) onto the same group.
+const filesCmd = registerFilesCommand(program);
+registerFilesBrowseCommands(filesCmd);
+// Membership management (subcommand group — hq members invite|list|revoke)
+registerMembersCommand(program);
+// People directory (subcommand group — hq people list|search|resolve), reading
+// the local companies/<co>/people store scoped to one company.
+registerPeopleCommand(program);
+registerDmCommand(program);
+registerChannelsCommand(program);
+// Onboarding (top-level — Cognito + vault-service provisioning)
+registerOnboardCommand(program);
+// Feedback (subcommand group — hq feedback bug|feature)
+registerFeedbackCommand(program);
+// Meetings (subcommand group — hq meetings list|get|search|transcript|notes)
+registerMeetingsCommand(program);
+// Sources read surface (subcommand group — hq sources list|get|channels|entities)
+registerSourcesCommand(program);
+// Signals read surface (subcommand group — hq signals list|get|types|entities)
+registerSignalsCommand(program);
+// Skill/personal-overlay mirroring + workers-registry regen. Invoked by the
+// hq-core reindex hook shim (Stop / PostToolUse) and by sync()/rescue() after
+// they change on-disk sources. Keeps a `master-sync` alias for one release.
+// Implementation lives in @indigoai-us/hq-cloud.
+registerReindexCommand(program);
+// Drift-preserving HQ-core re-sync (top-level — `hq rescue`). CLI sibling of
+// the HQ Sync app's "Update / Restore" pill; drives the same replace-rescue.sh
+// shipped from @indigoai-us/hq-cloud.
+registerRescueCommand(program);
+// MCP pack observability (subcommand group — `hq mcp status`). Read-only
+// provenance-based status across BOTH Claude + Codex runtimes (reads `_hqPack`
+// off the configs, NOT linkStatus), with secret-redacted output + `--json`.
+registerMcpCommand(program);
+// Native CRM entity upsert (subcommand group — `hq crm entity upsert`). Wraps
+// POST /crm/entities (the ontology write gate) so an authenticated company
+// member can create/update canonical CRM entities in the company vault.
+registerCrmCommand(program);
+// Company settings (subcommand group — `hq company settings set`). Owner-only
+// toggles for crmEnabled / ontologyEnabled via PUT /company-settings.
+registerCompanyCommand(program);
+export async function runCli() {
+    try {
+        Sentry.addBreadcrumb({
+            category: "command",
+            message: sanitizeArgv(process.argv.slice(2)).join(" "),
+            level: "info",
+        });
+        // Hard version gate: ask hq-pro whether this CLI is below the floor and
+        // auto-update if so (exits the process on update). Skipped for inspection
+        // flags (`--version`, `--help`) so users debugging a broken install can
+        // still introspect what they have. Silent on any failure — never blocks
+        // the CLI on a flaky network or hq-pro hiccup. See `utils/version-gate.ts`.
+        if (!shouldSkipGate(process.argv)) {
+            await enforceVersionGate();
+        }
+        await program.parseAsync();
+    }
+    catch (err) {
+        // A broken pipe (EPIPE) means the reader of `hq`'s output closed it early
+        // (`hq … | head`, `source <(hq …)`, a parent that exited). That is normal
+        // Unix behavior with no user-facing degradation — exit cleanly (0) and
+        // skip Sentry capture instead of shipping a fatal (HQ-6B). A synchronous
+        // `write EPIPE` thrown out of console.log lands here rather than on the
+        // stream 'error' listener above.
+        if (isEpipe(err)) {
+            process.exitCode = 0;
+        }
+        else if (isInterceptedProcessExit(err)) {
+            // A security/audit FUZZ harness replaced `process.exit` with a throw so it
+            // can keep exercising the binary. Commander calling `process.exit` for
+            // normal CLI control flow (e.g. an unknown command → exit 1) then surfaces
+            // here as that synthetic marker. It is a test-harness artifact, NOT an
+            // hq-cli defect — a real user's `process.exit` just exits, so nothing is
+            // thrown or captured. Skip Sentry capture (no signal, no user-facing
+            // degradation) and preserve the intended non-zero exit (HQ-CLI-3).
+            process.exitCode = 1;
+        }
+        else {
+            // A full disk / exhausted quota / read-only filesystem is the user's
+            // machine, not an HQ code defect. Surface a clear, actionable message and
+            // skip Sentry capture so one full disk doesn't flood the tracker with
+            // identical, unfixable crash reports (HQ-CLI-2). Genuine errors still go
+            // to Sentry and still exit 1.
+            const envMsg = environmentalFsErrorMessage(err);
+            if (envMsg) {
+                process.stderr.write(`hq: ${envMsg}\n`);
+            }
+            else {
+                Sentry.captureException(err);
+            }
+            process.exitCode = 1;
+        }
+    }
+    finally {
+        // Release health: finalize the per-run session before the flush.
+        Sentry.endSession();
+        await Promise.allSettled([refreshVersionCache(), Sentry.flush(2000)]);
+    }
+}
+//# sourceMappingURL=main.js.map
+//# debugId=a2c1badb-d418-557d-a0f4-0e3defd13913

package/dist/utils/sandbox-runner-client.d.ts

@@ -18,15 +18,28 @@ export interface SandboxRunnerJob {
 export interface SandboxRunnerClientOptions {
     baseUrl?: string;
     fetchImpl?: typeof fetch;
+    retry?: SandboxRunnerRetryOptions;
+    sleep?: (ms: number) => Promise<void>;
 }
 export interface SandboxRunnerPollOptions {
     intervalMs?: number;
     maxPolls?: number;
 }
+export interface SandboxRunnerRetryOptions {
+    maxAttempts?: number;
+    maxElapsedMs?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+}
 export declare class SandboxRunnerClient {
     private readonly baseUrl;
     private readonly fetchImpl;
+    private readonly retry;
+    private readonly sleep;
     constructor(options?: SandboxRunnerClientOptions);
+    private fetchWithRetry;
+    private shouldRetry;
+    private nextDelayMs;
     startJob(token: string, request: SandboxRunnerStartRequest): Promise<SandboxRunnerStartResponse>;
     getJob(token: string, jobId: string): Promise<SandboxRunnerJob>;
     pollJob(token: string, jobId: string, options?: SandboxRunnerPollOptions): Promise<SandboxRunnerJob>;

package/dist/utils/sandbox-runner-client.js

@@ -1,6 +1,13 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3cbec729-3b2b-5d53-9e90-5680dd725b7d")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e77a0f25-ac1a-574f-a1e4-985c6b3306d7")}catch(e){}}();
 const DEFAULT_SANDBOX_RUNNER_URL = "https://hqapi.getindigo.ai/sandbox";
+const RETRYABLE_STATUS_CODES = new Set([408, 425, 429, 500, 502, 503, 504]);
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 8,
+    maxElapsedMs: 90_000,
+    baseDelayMs: 500,
+    maxDelayMs: 5_000,
+};
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.replace(/\/+$/, "");
 }
@@ -40,15 +47,85 @@ function delay(ms) {
         return Promise.resolve();
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+function parseRetryAfterMs(value) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const dateMs = Date.parse(value);
+    if (!Number.isNaN(dateMs)) {
+        return Math.max(0, dateMs - Date.now());
+    }
+    return undefined;
+}
 export class SandboxRunnerClient {
     baseUrl;
     fetchImpl;
+    retry;
+    sleep;
     constructor(options = {}) {
         this.baseUrl = normalizeBaseUrl(options.baseUrl ?? getSandboxRunnerBaseUrl());
         this.fetchImpl = options.fetchImpl ?? fetch;
+        this.retry = { ...DEFAULT_RETRY_OPTIONS, ...options.retry };
+        this.sleep = options.sleep ?? delay;
+    }
+    async fetchWithRetry(url, init) {
+        const startedAt = Date.now();
+        let lastError = "unknown error";
+        let attempts = 0;
+        for (let attempt = 1; attempt <= this.retry.maxAttempts; attempt += 1) {
+            attempts = attempt;
+            try {
+                const res = await this.fetchImpl(url, init);
+                if (!RETRYABLE_STATUS_CODES.has(res.status)) {
+                    return res;
+                }
+                lastError = `HTTP ${res.status} ${res.statusText}`.trim();
+                if (!this.shouldRetry(attempt, startedAt)) {
+                    break;
+                }
+                await this.sleep(this.nextDelayMs(attempt, res));
+            }
+            catch (error) {
+                lastError = getErrorMessage(error);
+                if (!this.shouldRetry(attempt, startedAt)) {
+                    break;
+                }
+                await this.sleep(this.nextDelayMs(attempt));
+            }
+        }
+        throw new Error(`Sandbox Runner did not respond after ${attempts} attempts ` +
+            `(cold start or transient network); last error: ${lastError}`);
+    }
+    shouldRetry(attempt, startedAt) {
+        if (attempt >= this.retry.maxAttempts) {
+            return false;
+        }
+        return Date.now() - startedAt < this.retry.maxElapsedMs;
+    }
+    nextDelayMs(attempt, res) {
+        const retryAfterMs = parseRetryAfterMs(res?.headers.get("Retry-After") ?? null);
+        if (retryAfterMs !== undefined) {
+            return Math.min(retryAfterMs, this.retry.maxDelayMs);
+        }
+        const exponential = this.retry.baseDelayMs * 2 ** (attempt - 1);
+        const capped = Math.min(exponential, this.retry.maxDelayMs);
+        const jitter = Math.floor(Math.random() * Math.max(1, capped * 0.25));
+        return Math.min(capped + jitter, this.retry.maxDelayMs);
     }
     async startJob(token, request) {
-        const res = await this.fetchImpl(`${this.baseUrl}/jobs`, {
+        const res = await this.fetchWithRetry(`${this.baseUrl}/jobs`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${token}`,
@@ -75,7 +152,7 @@ export class SandboxRunnerClient {
         };
     }
     async getJob(token, jobId) {
-        const res = await this.fetchImpl(`${this.baseUrl}/jobs/${encodeURIComponent(jobId)}`, {
+        const res = await this.fetchWithRetry(`${this.baseUrl}/jobs/${encodeURIComponent(jobId)}`, {
             headers: { Authorization: `Bearer ${token}` },
         });
         const body = await parseJsonResponse(res);
@@ -97,10 +174,10 @@ export class SandboxRunnerClient {
             if (job.status === "succeeded" || job.status === "failed") {
                 return job;
             }
-            await delay(intervalMs);
+            await this.sleep(intervalMs);
         }
         throw new Error(`Sandbox Runner job '${jobId}' did not finish before the poll limit.`);
     }
 }
 //# sourceMappingURL=sandbox-runner-client.js.map
-//# debugId=3cbec729-3b2b-5d53-9e90-5680dd725b7d
+//# debugId=e77a0f25-ac1a-574f-a1e4-985c6b3306d7

package/dist/utils/version-check.d.ts

@@ -1,3 +1,9 @@
+declare function isKnownNoninteractiveStatusProbe(argv?: readonly string[]): boolean;
 export declare function maybeWarnNewVersion(): void;
 export declare function refreshVersionCache(): Promise<void>;
+export declare const __test__: {
+    CACHE_TTL_MS: number;
+    isKnownNoninteractiveStatusProbe: typeof isKnownNoninteractiveStatusProbe;
+};
+export {};
 //# sourceMappingURL=version-check.d.ts.map

package/dist/utils/version-check.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="99545a82-414c-5fed-a478-ea8e63009643")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f7058fc6-251e-5e11-af6c-de15f6e256f3")}catch(e){}}();
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
@@ -9,10 +9,15 @@ import { CLI_VERSION } from "../cli-version.js";
 const PACKAGE_NAME = "@indigoai-us/hq-cli";
 const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_TTL_JITTER_MS = 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 3_000;
+const REFRESH_LOCK_STALE_MS = 10 * 60 * 1000;
 function cachePath() {
     return path.join(os.homedir(), ".hq", "version-check.json");
 }
+function lockPath() {
+    return path.join(os.homedir(), ".hq", "version-check.lock");
+}
 function isOptedOut() {
     return process.env.HQ_NO_UPDATE_CHECK === "1";
 }
@@ -40,6 +45,59 @@ function writeCache(entry) {
         // best-effort; never break the CLI on cache write failure
     }
 }
+function freshEnough(entry, now = Date.now()) {
+    const jitter = Math.floor(Math.random() * CACHE_TTL_JITTER_MS);
+    return now - entry.fetchedAt <= CACHE_TTL_MS - jitter;
+}
+function isKnownNoninteractiveStatusProbe(argv = process.argv) {
+    const args = argv.slice(2);
+    const positional = args.filter((arg) => !arg.startsWith("-"));
+    const json = args.includes("--json") || !process.stdout.isTTY;
+    if (!json)
+        return false;
+    if (positional[0] === "mcp" && positional[1] === "status")
+        return true;
+    if (positional[0] === "packs" && (positional[1] === "list" || positional[1] === "ls"))
+        return true;
+    if (positional[0] === "packages" &&
+        positional[1] === "packs" &&
+        (positional[2] === "list" || positional[2] === "ls")) {
+        return true;
+    }
+    if ((positional[0] === "sources" || positional[0] === "signals") && positional[1] === "list") {
+        return true;
+    }
+    return false;
+}
+function acquireRefreshLock(now = Date.now()) {
+    const dir = lockPath();
+    try {
+        fs.mkdirSync(path.dirname(dir), { recursive: true });
+        fs.mkdirSync(dir);
+        fs.writeFileSync(path.join(dir, "owner"), `${process.pid}\n${now}\n`);
+        return () => {
+            try {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort lock cleanup
+            }
+        };
+    }
+    catch {
+        try {
+            const stat = fs.statSync(dir);
+            if (now - stat.mtimeMs > REFRESH_LOCK_STALE_MS) {
+                fs.rmSync(dir, { recursive: true, force: true });
+                return acquireRefreshLock(now);
+            }
+        }
+        catch {
+            // ignore lock inspection failures
+        }
+        return null;
+    }
+}
 export function maybeWarnNewVersion() {
     if (isOptedOut())
         return;
@@ -60,7 +118,18 @@ export function maybeWarnNewVersion() {
 export async function refreshVersionCache() {
     if (isOptedOut())
         return;
+    if (isKnownNoninteractiveStatusProbe())
+        return;
+    const existing = readCache();
+    if (existing && freshEnough(existing))
+        return;
+    const releaseLock = acquireRefreshLock();
+    if (!releaseLock)
+        return;
     try {
+        const lockedExisting = readCache();
+        if (lockedExisting && freshEnough(lockedExisting))
+            return;
         const res = await fetch(REGISTRY_URL, {
             headers: { Accept: "application/json" },
             signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
@@ -75,6 +144,13 @@ export async function refreshVersionCache() {
     catch {
         // best-effort; offline / registry down / timeout — silent
     }
+    finally {
+        releaseLock();
+    }
 }
+export const __test__ = {
+    CACHE_TTL_MS,
+    isKnownNoninteractiveStatusProbe,
+};
 //# sourceMappingURL=version-check.js.map
-//# debugId=99545a82-414c-5fed-a478-ea8e63009643
+//# debugId=f7058fc6-251e-5e11-af6c-de15f6e256f3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.59.0",
+  "version": "5.61.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {

package/src/commands/meetings.test.ts

@@ -45,6 +45,7 @@ beforeEach(() => {
 
 afterEach(() => {
   vi.restoreAllMocks();
+  vi.unstubAllGlobals();
 });
 
 function buildProgram(): Command {
@@ -298,7 +299,7 @@ describe("meetings set-company", () => {
       "acme",
     ]);
 
-    const output = logSpy.mock.calls.map(([line]) => String(line)).join("\n");
+    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
     expect(output).not.toContain("Applied to 1 meetings");
     expect(output).not.toContain("Refiled 0 transcripts");
     expect(output).not.toContain("Future occurrences of this recurring series will inherit this attribution.");
@@ -345,8 +346,121 @@ describe("meetings list — null-safe rendering", () => {
       program.parseAsync(["node", "hq", "meetings", "list", "--company", "indigo"]),
     ).resolves.toBeDefined();
 
-    const printed = logSpy.mock.calls.map(([line]) => String(line)).join("\n");
+    const printed = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
     expect(printed).toContain("Meetings (2)");
     expect(printed).toContain("(untitled)");
   });
 });
+
+describe("meetings — markdown shape rendering", () => {
+  const markdownMeetingId = "589bfd78-aaaa-bbbb-cccc-1234567890ab";
+  const markdownUrl = "https://example.test/meeting.md";
+
+  function markdownDetail(signals: Record<string, unknown> = {}) {
+    return {
+      meetingId: markdownMeetingId,
+      sourceShape: "markdown",
+      source: {
+        path: "meetings/meeting.md",
+        presigned_url: markdownUrl,
+        frontmatter: {
+          title: "Markdown Standup",
+          channel: "eng",
+          origin: "recall",
+          company_id: "cmp_indigo",
+          meeting_url: "https://meet.example.test/standup",
+          meeting_platform: "google_meet",
+          calendar_event_id: null,
+          scheduled_start_time: "2026-02-03T15:30:00Z",
+          created_at: "2026-02-03T15:00:00Z",
+          updated_at: "2026-02-03T16:00:00Z",
+          ingested_at: "2026-02-03T16:05:00Z",
+          recall_bot_id: null,
+          bot_status: "done",
+          auto_scheduled: true,
+        },
+      },
+      signals,
+    };
+  }
+
+  it("lists markdown meetings without invalid legacy field output", async () => {
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(
+      jsonRes({
+        meetings: [
+          {
+            meetingId: markdownMeetingId,
+            sourceShape: "markdown",
+            title: "Markdown Standup",
+            startTime: "2026-02-03T15:30:00Z",
+            channel: "eng",
+            ingested_at: "2026-02-03T16:05:00Z",
+            hasSignals: true,
+            companyId: "cmp_indigo",
+            attributed: true,
+          },
+        ],
+      }),
+    );
+
+    const program = buildProgram();
+    await program.parseAsync(["node", "hq", "meetings", "list"]);
+
+    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
+    expect(output).toContain("Markdown Standup");
+    expect(output).toContain(" S ");
+    expect(output).not.toContain("NaN");
+    expect(output).not.toContain("undefined");
+    expect(output).not.toContain("Invalid Date");
+  });
+
+  it("gets markdown details from frontmatter without reading participants", async () => {
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail({ action_items: ["Ship fix"] })));
+
+    const program = buildProgram();
+    await expect(
+      program.parseAsync(["node", "hq", "meetings", "get", markdownMeetingId]),
+    ).resolves.toBeDefined();
+
+    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
+    expect(output).toContain("Markdown Standup");
+    expect(output).toContain("Status:      done");
+    expect(output).toContain("Platform:    google_meet");
+    expect(output).toContain("Origin:      recall");
+    expect(output).toContain("Company:     cmp_indigo");
+    expect(output).toContain("Meeting URL: https://meet.example.test/standup");
+    expect(output).toContain("Signals:     1");
+    expect(output).toContain("stored as a markdown document");
+  });
+
+  it("prints markdown transcript text from the presigned source URL", async () => {
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail()));
+    const fetchMock = vi.fn(async () => new Response("# Markdown transcript\n\nHello team."));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const program = buildProgram();
+    await program.parseAsync(["node", "hq", "meetings", "transcript", markdownMeetingId]);
+
+    expect(fetchMock).toHaveBeenCalledWith(markdownUrl);
+    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
+    expect(output).toContain("Transcript: Markdown Standup");
+    expect(output).toContain("# Markdown transcript");
+    expect(output).toContain("Hello team.");
+  });
+
+  it("falls back to the markdown document for notes when markdown signals are empty", async () => {
+    vi.mocked(vaultApiFetch).mockResolvedValueOnce(jsonRes(markdownDetail({})));
+    vi.stubGlobal("fetch", vi.fn(async () => new Response("# Notes\n\nFollow up next week.")));
+
+    const program = buildProgram();
+    await program.parseAsync(["node", "hq", "meetings", "notes", markdownMeetingId]);
+
+    const output = logSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
+    const errors = errSpy.mock.calls.map(([line]) => (line === undefined ? "" : String(line))).join("\n");
+    expect(output).toContain("Meeting Notes: Markdown Standup");
+    expect(output).toContain("# Notes");
+    expect(output).toContain("Follow up next week.");
+    expect(output).not.toContain("No document URL available");
+    expect(errors).not.toContain("No document URL available");
+  });
+});