@indigoai-us/hq-cli 5.345.159 → 5.345.161

package/dist/commands/integrations-manage.js

@@ -76,6 +76,8 @@ export function parsePrincipal(raw) {
     }
     throw new IntegrationsCliError(`Could not tell what '${raw}' refers to. Use an email address, a uid (prs_… / agt_… / grp_…), \`everyone\`, or an explicit \`person:<id>\` / \`group:<id>\` form.`, { expected: true });
 }
+/** `--with` / `--to` / `--from` help. Groups resolve membership at call time. */
+export const PRINCIPAL_HELP = "Email, uid, vault group (grp_…), or `everyone`";
 /** How a principal reads back in output, without leaking a raw uid as a name. */
 function describePrincipal(entry) {
     if (entry.granteeType === "company-wide")
@@ -379,7 +381,7 @@ export function registerManageCommands(integrations) {
         .option("--provider <slug>", "Connected app (e.g. linear)")
         .option("--connection <id>", "Connection id (acct_…)")
         .requiredOption("--tool <name>", "The tool to authorize")
-        .requiredOption("--to <principal>", "Email, uid, or `everyone`")
+        .requiredOption("--to <principal>", PRINCIPAL_HELP)
         .option("--permission <level>", "read, write, or admin", "write")
         .option("--json", "Machine-readable output")
         .action(async (app, opts) => {
@@ -418,7 +420,7 @@ export function registerManageCommands(integrations) {
         .option("--provider <slug>", "Connected app (e.g. linear)")
         .option("--connection <id>", "Connection id (acct_…)")
         .requiredOption("--tool <name>", "The tool to stop authorizing")
-        .requiredOption("--from <principal>", "Email, uid, or `everyone`")
+        .requiredOption("--from <principal>", PRINCIPAL_HELP)
         .option("--json", "Machine-readable output")
         .action(async (app, opts) => {
         const principal = parsePrincipal(opts.from);
@@ -465,7 +467,7 @@ export function registerManageCommands(integrations) {
         .option("--company <slug>", "Company slug, e.g. indigo")
         .option("--provider <slug>", "Connected app (e.g. linear)")
         .option("--connection <id>", "Connection id (acct_…)")
-        .requiredOption("--with <principal>", "Email, uid, or `everyone`")
+        .requiredOption("--with <principal>", PRINCIPAL_HELP)
         .option("--permission <level>", "read, write, or admin", "write")
         .option("--json", "Machine-readable output")
         .action(async (app, opts) => {
@@ -495,7 +497,7 @@ export function registerManageCommands(integrations) {
         .option("--company <slug>", "Company slug, e.g. indigo")
         .option("--provider <slug>", "Connected app (e.g. linear)")
         .option("--connection <id>", "Connection id (acct_…)")
-        .requiredOption("--from <principal>", "Email, uid, or `everyone`")
+        .requiredOption("--from <principal>", PRINCIPAL_HELP)
         .option("--json", "Machine-readable output")
         .action(async (app, opts) => {
         const principal = parsePrincipal(opts.from);

package/dist/commands/lanes-link.js

@@ -14,6 +14,7 @@ function addLinkOptions(command) {
         .option("--engine <engine>", "Session engine")
         .option("--title <title>", "Session title")
         .option("--host-session <id>", "Host session id")
+        .option("--claims <ids>", "Exact comma-separated recipient receipt IDs")
         .option("--text <message>", "Message text")
         .option("--text-file <path>", "Read message text from a file")
         .option("--state <state>", "Child state")
@@ -35,7 +36,7 @@ function commandError(error) {
 }
 export function registerLanesLinkCommand(lanes) {
     const link = lanes.command("link").description("Link live sessions to a conductor through session inboxes");
-    const commands = ["open", "join", "send", "report", "status", "inbox", "read", "wait", "list", "leave", "close"];
+    const commands = ["open", "join", "send", "ack", "capabilities", "report", "status", "inbox", "read", "wait", "list", "leave", "close"];
     for (const subcommand of commands) {
         addLinkOptions(link.command(subcommand)).action(async (options) => {
             try {
@@ -56,7 +57,8 @@ export function registerLanesLinkCommand(lanes) {
     }
     const deliver = link.command("_deliver", { hidden: true })
         .description("Internal linked-session hook delivery")
-        .requiredOption("--event <event>", "Hook event");
+        .requiredOption("--event <event>", "Hook event")
+        .option("--ack-mode <mode>", "Internal explicit recipient acknowledgement");
     deliver.action(async (options) => {
         // Hook commands must not update/re-exec the CLI inside the provider's time budget.
         process.env.HQ_NO_UPDATE_CHECK = "1";
@@ -70,7 +72,7 @@ export function registerLanesLinkCommand(lanes) {
                 env: process.env,
                 defaultValue: true,
             });
-            const result = await runLaneLinkWithFlag("_deliver", { hqRoot: root, env: process.env, event: options.event, input }, enabled);
+            const result = await runLaneLinkWithFlag("_deliver", { hqRoot: root, env: process.env, event: options.event, ackMode: options.ackMode, input }, enabled);
             if (result.output)
                 writeJson(result.output);
         }

package/dist/commands/lanes-session-start.d.ts

@@ -8,9 +8,21 @@ export interface SessionStartOptions {
     stderr?: Pick<NodeJS.WriteStream, "write">;
     resolveRoot?: (env: NodeJS.ProcessEnv, cwd?: string) => string;
     startSweep?: (root: string, env: NodeJS.ProcessEnv) => void;
+    /** Starts the off-hot-path registry read when an offline flag value is missing or old. */
+    refreshFlags?: (env: NodeJS.ProcessEnv) => void;
 }
+/** Offline flag values older than this trigger one background registry read. */
+export declare const SESSION_START_FLAG_REFRESH_AFTER_MS: number;
 /** Starts the CL-4 read-only orphan report once per host, without holding SessionStart open. */
 export declare function startSessionStartOrphanSweep(root: string, env?: NodeJS.ProcessEnv, spawnDetached?: typeof spawn, rootScoped?: boolean): void;
+/**
+ * Start a detached `hq lanes session-start --refresh-flags` so the registry
+ * read never runs inside the SessionStart hook. A short lease keeps a burst of
+ * session starts to one refresh. An env without a state dir never spawns.
+ */
+export declare function startSessionStartFlagRefresh(env: NodeJS.ProcessEnv, spawnDetached?: typeof spawn, now?: number): boolean;
+/** Read the session-start flags from the registry, refreshing the offline cache. */
+export declare function refreshSessionStartFlags(env?: NodeJS.ProcessEnv): Promise<void>;
 /** SessionStart-compatible, fail-open conduct bootstrap. */
 export declare function runLaneSessionStart(options?: SessionStartOptions): Promise<void>;
 export declare function registerLaneSessionStartCommand(lanes: Command): void;

package/dist/commands/lanes-session-start.js

@@ -4,8 +4,17 @@ import os from "node:os";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
-import { readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { readLanesRegistryFlagOffline, readLanesRegistryFlagResult } from "../lib/lanes/registry-flag.js";
 import { LANE_CONDUCT_SESSION_START_FLAG, LANE_ORPHAN_SWEEP_CONTEXT_FLAG, LANE_ORPHAN_SWEEP_ROOT_KEYING_FLAG } from "../lib/lanes/flag-keys.js";
+const SESSION_START_FLAGS = [
+    LANE_CONDUCT_SESSION_START_FLAG,
+    LANE_ORPHAN_SWEEP_ROOT_KEYING_FLAG,
+    LANE_ORPHAN_SWEEP_CONTEXT_FLAG,
+];
+/** Offline flag values older than this trigger one background registry read. */
+export const SESSION_START_FLAG_REFRESH_AFTER_MS = 10 * 60 * 1000;
+const SESSION_START_FLAG_REFRESH_LEASE_MS = 60 * 1000;
+const SESSION_START_FLAG_REFRESH_LEASE = "lanes-session-start-flag-refresh.lock";
 const CODEX_DEFAULT_KEYS = ["conduct_engine", "conduct_child_model", "conduct_child_effort", "conduct_default_source"];
 function readSessionMetaValue(text, key) {
     const line = text.split(/\r?\n/).find((entry) => new RegExp(`^\\s*${key}:`).test(entry));
@@ -247,6 +256,58 @@ export function startSessionStartOrphanSweep(root, env = process.env, spawnDetac
         // SessionStart's orphan report is advisory and must never block startup.
     }
 }
+function flagRefreshLeaseDir(env) {
+    const stateDir = env.HQ_STATE_DIR?.trim();
+    if (stateDir)
+        return stateDir;
+    const home = env.HOME?.trim() || env.USERPROFILE?.trim();
+    return home ? path.join(home, ".hq") : null;
+}
+/**
+ * Start a detached `hq lanes session-start --refresh-flags` so the registry
+ * read never runs inside the SessionStart hook. A short lease keeps a burst of
+ * session starts to one refresh. An env without a state dir never spawns.
+ */
+export function startSessionStartFlagRefresh(env, spawnDetached = spawn, now = Date.now()) {
+    const dir = flagRefreshLeaseDir(env);
+    const cli = process.argv[1];
+    if (!dir || !cli)
+        return false;
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const lease = path.join(dir, SESSION_START_FLAG_REFRESH_LEASE);
+        try {
+            if (now - fs.statSync(lease).mtimeMs < SESSION_START_FLAG_REFRESH_LEASE_MS)
+                return false;
+            fs.rmSync(lease, { force: true });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return false;
+        }
+        try {
+            fs.closeSync(fs.openSync(lease, "wx", 0o600));
+        }
+        catch {
+            return false;
+        }
+        const child = spawnDetached(process.execPath, [cli, "lanes", "session-start", "--refresh-flags"], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...env, HQ_NO_UPDATE_CHECK: "1" },
+        });
+        child.on("error", () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Read the session-start flags from the registry, refreshing the offline cache. */
+export async function refreshSessionStartFlags(env = process.env) {
+    await Promise.all(SESSION_START_FLAGS.map((flag) => readLanesRegistryFlagResult(flag, { env, defaultValue: true, reportFailure: () => undefined }).catch(() => undefined)));
+}
 /** SessionStart-compatible, fail-open conduct bootstrap. */
 export async function runLaneSessionStart(options = {}) {
     const env = options.env ?? process.env;
@@ -278,19 +339,33 @@ export async function runLaneSessionStart(options = {}) {
         if (/(^|,)auto-conduct(,|$)/.test(disabledHooks))
             return;
         const root = (options.resolveRoot ?? ((e, cwd) => resolveLanesHqRoot({ env: e, cwd })))(env, options.cwd);
-        const flagEnabled = await readLanesRegistryFlagFailOpen(LANE_CONDUCT_SESSION_START_FLAG, {
-            env,
-            defaultValue: true,
-            reportFailure: (error) => {
-                const kind = error instanceof Error ? error.name : "Error";
-                debug(`hq lanes session-start: flag read failed (${kind})`);
-            },
-        });
+        // Flags come from offline state only. A missing or old value fails open and
+        // schedules one background registry read for the next session start.
+        let refreshNeeded = false;
+        const readFlag = (flag) => {
+            let read = null;
+            try {
+                read = readLanesRegistryFlagOffline(flag, { env, defaultValue: true });
+            }
+            catch {
+                read = null;
+            }
+            if (!read || (read.source !== "local-override" && read.ageMs > SESSION_START_FLAG_REFRESH_AFTER_MS))
+                refreshNeeded = true;
+            return read?.value ?? true;
+        };
+        const flagEnabled = readFlag(LANE_CONDUCT_SESSION_START_FLAG);
+        const rootScoped = readFlag(LANE_ORPHAN_SWEEP_ROOT_KEYING_FLAG);
+        const contextEnabled = readFlag(LANE_ORPHAN_SWEEP_CONTEXT_FLAG);
+        if (refreshNeeded) {
+            try {
+                (options.refreshFlags ?? ((e) => { startSessionStartFlagRefresh(e); }))(env);
+            }
+            catch { /* advisory */ }
+        }
         if (!flagEnabled)
             return;
-        const rootScoped = await readLanesRegistryFlagFailOpen(LANE_ORPHAN_SWEEP_ROOT_KEYING_FLAG, { env, defaultValue: true });
         (options.startSweep ?? ((r, e) => startSessionStartOrphanSweep(r, e, spawn, rootScoped)))(root, env);
-        const contextEnabled = await readLanesRegistryFlagFailOpen(LANE_ORPHAN_SWEEP_CONTEXT_FLAG, { env, defaultValue: true });
         if (contextEnabled) {
             const count = readOrphanCount(root, env, rootScoped, (error) => debug(`hq lanes session-start: orphan report read failed (${error instanceof Error ? error.name : "Error"})`));
             if (count > 0)
@@ -324,6 +399,12 @@ export async function runLaneSessionStart(options = {}) {
 export function registerLaneSessionStartCommand(lanes) {
     lanes.command("session-start", { hidden: true })
         .description("Internal SessionStart bootstrap")
-        .action(async () => runLaneSessionStart());
+        .option("--refresh-flags", "Refresh the offline session-start flag values from the registry")
+        .action(async (opts) => {
+        if (opts.refreshFlags)
+            await refreshSessionStartFlags();
+        else
+            await runLaneSessionStart();
+    });
 }
 //# sourceMappingURL=lanes-session-start.js.map

package/dist/commands/meetings.d.ts

@@ -3,11 +3,22 @@ import { type PricingPlan } from "../lib/billing/usage-only.js";
 /** Upper bound on list pages one short-id lookup reads (per cursor chain). */
 export declare const SHORT_ID_MAX_PAGES = 50;
 /**
- * The 402 copy for meeting bots. A usage-only company (US-012: the body or the
- * company's billing summary says `pricingPlan: "usage-only"`) has no Workforce
- * plan to buy, so it is told to add a card. Every other company keeps the
- * Workforce copy.
+ * The 402 copy for meeting bots. A usage pause (US-024) prints the server's
+ * message and Billing link. A usage-only company (US-012) is told to add a
+ * card. Every other company gets the server's sentence under a line that
+ * names no plan: the flat plans are closed.
  */
 export declare function meetingPaymentRequiredLines(body: Record<string, unknown>, resolvePlan?: () => Promise<PricingPlan | null>): Promise<string[]>;
+/**
+ * The company a `hq meetings` call is about: the explicit `--company` value,
+ * otherwise the company an explicitly named HQ session is bound to (the session's company
+ * lock, from `scope-capability.json` or `meta.yaml`). A session bound to
+ * Personal, an unbound session, or an unreadable lock gives undefined so the
+ * server's own default applies. Before this, every subcommand sent no
+ * company at all without `--company`, so the list, get, transcript and
+ * search views silently showed only the caller's personal recordings.
+ * Feedback 04771691-fcbc-4847-899a-6c966c561b52.
+ */
+export declare function sessionCompanySlug(env?: NodeJS.ProcessEnv): string | undefined;
 export declare function registerMeetingsCommand(program: Command): void;
 //# sourceMappingURL=meetings.d.ts.map

package/dist/commands/meetings.js

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import { readFile } from "node:fs/promises";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { readSessionCompanyLock } from "../lib/session-company-lock.js";
+import { sessionIdFromEnv } from "../lib/core-utils/session-id.js";
 import { vaultApiFetch, getCompanyUid, resolveCallerPersonUid, } from "../utils/vault-api.js";
 import { isPlanGateError, planGateErrorFromPayload, } from "../utils/plan-gate-error.js";
 import { mapWithConcurrency } from "./sync-manifest.js";
-import { isUsageOnly, pricingPlanFromBody, resolveCompanyPricingPlan, usageOnlyCardRequiredLines, } from "../lib/billing/usage-only.js";
+import { isUsageOnly, pricingPlanFromBody, resolveCompanyPricingPlan, usageOnlyCardRequiredLines, usagePauseFromBody, } from "../lib/billing/usage-only.js";
 const LIVE_SNAPSHOT_STATUSES = new Set([
     "joining",
     "recording",
@@ -318,23 +320,32 @@ async function resolveShortId(token, prefix, query) {
     process.exit(1);
 }
 /**
- * The 402 copy for meeting bots. A usage-only company (US-012: the body or the
- * company's billing summary says `pricingPlan: "usage-only"`) has no Workforce
- * plan to buy, so it is told to add a card. Every other company keeps the
- * Workforce copy.
+ * The 402 copy for meeting bots. A usage pause (US-024) prints the server's
+ * message and Billing link. A usage-only company (US-012) is told to add a
+ * card. Every other company gets the server's sentence under a line that
+ * names no plan: the flat plans are closed.
  */
 export async function meetingPaymentRequiredLines(body, resolvePlan = () => resolveCompanyPricingPlan()) {
     const plan = pricingPlanFromBody(body) ?? (await resolvePlan().catch(() => null));
     if (isUsageOnly(plan)) {
         return usageOnlyCardRequiredLines("A meeting notetaker bot").map((line, i) => i === 0 ? chalk.red(line) : chalk.dim(line));
     }
+    // US-024: a usage pause is the server's own answer: its message and link.
+    const pause = usagePauseFromBody(body);
+    if (pause) {
+        return [
+            chalk.red(pause.message),
+            ...(pause.actionUrl ? [chalk.dim(`Billing: ${pause.actionUrl}`)] : []),
+        ];
+    }
+    // The server's sentence when it sent one; otherwise copy that names no plan.
     const detail = typeof body.message === "string"
         ? body.message
         : typeof body.error === "string"
             ? body.error
-            : "Upgrade your company to HQ Workforce to record meetings.";
+            : "Run `hq billing status` or open the company's Billing page to check it.";
     return [
-        chalk.red("Meeting notetaker bots require the $500/mo HQ Workforce plan."),
+        chalk.red("Meeting notetaker bots are not available on this company's current billing."),
         chalk.dim(detail),
     ];
 }
@@ -425,11 +436,39 @@ function printMeetingTable(meetings) {
         ].join("  "));
     }
 }
+/**
+ * The company a `hq meetings` call is about: the explicit `--company` value,
+ * otherwise the company an explicitly named HQ session is bound to (the session's company
+ * lock, from `scope-capability.json` or `meta.yaml`). A session bound to
+ * Personal, an unbound session, or an unreadable lock gives undefined so the
+ * server's own default applies. Before this, every subcommand sent no
+ * company at all without `--company`, so the list, get, transcript and
+ * search views silently showed only the caller's personal recordings.
+ * Feedback 04771691-fcbc-4847-899a-6c966c561b52.
+ */
+export function sessionCompanySlug(env = process.env) {
+    // The shared reader also supports the last-writer-wins .current pointer.
+    // It cannot identify a plain terminal or cron caller's session.
+    if (!sessionIdFromEnv(env))
+        return undefined;
+    let lock;
+    try {
+        lock = readSessionCompanyLock(env);
+    }
+    catch (err) {
+        // Fall through to the server default, but say why so an unbound call is
+        // never mistaken for a working company scope.
+        console.error(chalk.dim(`  (session company not applied: ${err instanceof Error ? err.message : String(err)})`));
+        return undefined;
+    }
+    const primary = lock?.companies[0];
+    return primary && primary !== "personal" ? primary : undefined;
+}
 export function registerMeetingsCommand(program) {
     const meetings = program
         .command("meetings")
         .description("View and search meeting recordings, transcripts, and notes")
-        .option("--company <slug>", "Company slug (for multi-company users)")
+        .option("--company <slug>", "Company slug (defaults to the company this HQ session is bound to)")
         .option("--json", "Output raw JSON instead of formatted text");
     // ── hq meetings list ──────────────────────────────────────────────
     meetings
@@ -441,7 +480,7 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const query = {};
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (opts.limit)
                 query.limit = opts.limit;
             if (opts.next)
@@ -479,9 +518,9 @@ export function registerMeetingsCommand(program) {
         .action(async (recallBotId, opts) => {
         try {
             const token = await ensureCognitoToken();
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (!companySlug)
-                throw new Error("--company <slug|uid> is required for live transcripts");
+                throw new Error("--company <slug|uid> is required for live transcripts (this session is not bound to a company)");
             const companyId = companySlug.startsWith("cmp_") ? companySlug : await getCompanyUid(token, companySlug);
             if (!recallBotId) {
                 if (opts.follow || opts.since)
@@ -601,9 +640,9 @@ export function registerMeetingsCommand(program) {
         .description("Import a normalized historical transcript JSON file")
         .action(async (file) => {
         try {
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (!companySlug) {
-                throw new Error("--company <slug> is required for historical imports");
+                throw new Error("--company <slug> is required for historical imports (this session is not bound to a company)");
             }
             const bytes = await readFile(file);
             if (bytes.byteLength > 5 * 1024 * 1024) {
@@ -657,10 +696,10 @@ export function registerMeetingsCommand(program) {
         .action(async (meetingUrl) => {
         try {
             const token = await ensureCognitoToken();
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             // Always name a company. With no companyId the backend files the bot
             // under Personal, which can never record, so an entitled user would
-            // get the HQ Workforce upgrade prompt. Without --company this uses the
+            // get the payment-required refusal. Without --company this uses the
             // caller's only active company, or asks them to pick one.
             const query = {
                 companyId: await getCompanyUid(token, companySlug),
@@ -698,7 +737,7 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const query = {};
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (companySlug)
                 query.companyId = await getCompanyUid(token, companySlug);
             const meetingId = await resolveShortId(token, rawId, query);
@@ -823,7 +862,7 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const params = { q: query };
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (companySlug)
                 params.companyId = await getCompanyUid(token, companySlug);
             const res = await vaultApiFetch({
@@ -854,7 +893,7 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const query = {};
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (companySlug)
                 query.companyId = await getCompanyUid(token, companySlug);
             const meetingId = await resolveShortId(token, rawId, query);
@@ -923,7 +962,7 @@ export function registerMeetingsCommand(program) {
         try {
             const token = await ensureCognitoToken();
             const query = {};
-            const companySlug = meetings.opts().company;
+            const companySlug = meetings.opts().company ?? sessionCompanySlug();
             if (companySlug)
                 query.companyId = await getCompanyUid(token, companySlug);
             const meetingId = await resolveShortId(token, rawId, query);

package/dist/commands/skill.js

@@ -28,7 +28,7 @@ import { AuthError } from "../utils/auth-error.js";
 import { redactErrorText } from "../utils/redact-error-text.js";
 import { stampVaultAccessDenied, vaultAccessDeniedDiagnostics, } from "../utils/vault-access-denied-error.js";
 import { PlanGateError } from "../utils/plan-gate-error.js";
-import { createPlanLimitRefusalTracker, trackingProgressRecorder, } from "../lib/billing/plan-limit-refusals.js";
+import { createPlanLimitRefusalTracker, REFUSAL_FALLBACK_SENTENCE, trackingProgressRecorder, } from "../lib/billing/plan-limit-refusals.js";
 export const SKILL_UID_PATTERN = /^skl_[A-Za-z0-9]+$/;
 export const SKILL_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 const COMPANY_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
@@ -54,16 +54,16 @@ async function defaultSyncFile(input) {
     };
 }
 /**
- * The upload of a stamped skill file was refused by a plan limit. Registration
+ * The upload of a stamped skill file was refused (new files paused). Registration
  * and the local stamp already succeeded, so say that on stderr, then return a
- * typed plan gate for main.ts to render (reason and upgrade link) and exit
+ * typed plan gate for main.ts to render (reason and billing link) and exit
  * non-zero. Never "Skill ready … Sync: complete".
  */
 function skillUploadRefused(skillUid, filePath, companySlug, refused) {
-    console.warn(chalk.yellow(`⚠ Skill ${skillUid} is stamped locally at '${filePath}', but the upload was refused by your plan limit.`));
+    console.warn(chalk.yellow(`⚠ Skill ${skillUid} is stamped locally at '${filePath}', but the upload was refused: new files are paused for this account.`));
     return new PlanGateError("PLAN_LIMIT_EXCEEDED", {
-        reason: `${refused.message ?? "New files are paused by your plan limit."} ` +
-            "The skill file was not uploaded. Once the limit is sorted, upload it with: " +
+        reason: `${refused.message ?? REFUSAL_FALLBACK_SENTENCE} ` +
+            "The skill file was not uploaded. Once uploads resume, upload it with: " +
             `hq sync push --company ${companySlug} '${filePath}'`,
         ...(refused.upgradeUrl ? { upgradeUrl: refused.upgradeUrl } : {}),
     });

package/dist/commands/whoami.js

@@ -123,7 +123,7 @@ export function registerWhoamiCommand(program) {
         .command('whoami')
         .description('Show the currently authenticated user')
         .option('--json', 'Output identity metadata as JSON (never tokens)')
-        .option('--company <slug>', 'Also report this company\'s workspace plan state (Starter nag)')
+        .option('--company <slug>', 'Also report this company\'s billing and usage notice')
         .action(async (opts) => {
         try {
             // Effective source (same as auth status / ensureCognitoToken): env

package/dist/hook-engine-path.js

@@ -18,7 +18,7 @@ export async function runHookEnginePath(args) {
             console.log('Usage: hq core hook-engine-path [--repair] [--for-registration]\nResolve and pin the installed native hook engine offline.\n--for-registration prints a path only when the launcher flag is enabled.');
             return;
         }
-        const { installHookEngine, hookEngineRequired, HOOK_ENGINE_REPAIR } = await import('./lib/hook-engine/resolve.js');
+        const { installHookEngine, hookEngineRequired, removeHookEnginePointer, verifyHookEngine, HOOK_ENGINE_REPAIR } = await import('./lib/hook-engine/resolve.js');
         if (args.includes('--for-registration')) {
             const { launcherEnabled } = await import('./lib/hook-engine/registration.js');
             if (!launcherEnabled()) {
@@ -27,8 +27,19 @@ export async function runHookEnginePath(args) {
             }
         }
         const binary = installHookEngine({ repair: args.includes('--repair') });
-        if (binary)
+        if (binary) {
+            // The printed path is one that runs and reports as an hq-hook engine.
+            // A binary that cannot answer its self-check must not be bridged, so the
+            // shell pointer is removed and the command exits non-zero.
+            const problem = verifyHookEngine(binary);
+            if (problem) {
+                removeHookEnginePointer();
+                console.error(`${problem}. Existing bash hooks remain active. Repair: ${HOOK_ENGINE_REPAIR}`);
+                process.exitCode = 1;
+                return;
+            }
             console.log(binary);
+        }
         else {
             console.error(`Native hook engine missing; ${hookEngineRequired() ? 'repair before running hooks' : 'existing bash hooks remain active'}. Repair: ${HOOK_ENGINE_REPAIR}`);
             process.exitCode = 1;