@indigoai-us/hq-cli 5.345.156 → 5.345.160

package/dist/commands/billing-usage.js

@@ -12,27 +12,27 @@
  *
  * Tenant boundary: the company comes from the caller's own active memberships
  * (`/membership/me`); a slug outside them is refused before any read. The
- * usage-limits routes are member-gated on the server as well. With no cloud
+ * company statement is owner-gated on the server as well. With no cloud
  * company (or `--personal`) it reads the caller's personal scope.
  *
- * Usage numbers come through `readMonthUsage` (src/lib/billing/usage-cost.ts),
- * the single seam to switch to the US-005 daily rollup once it has a read route.
+ * Usage numbers come through `readMonthUsage` (src/lib/billing/usage-cost.ts)
+ * from the usage statement, `GET /v1/billing/usage` (hq-pro US-006). Only a
+ * server without that route (404) falls back to the usage-limits readings.
  *
  * Only an account on usage pricing gets costs. The plan comes from the
- * server: `pricingPlan` / `usageOnly` on the usage-limits body (hq-pro #5042,
- * computed with `isOnUsagePricing`). Only when that body does not say, the
- * billing summary the command already reads for the trial. A flat-plan account (for example a Workforce
- * company that subscribed before the 2026-10-16 cutover) and an account the
- * server says nothing about get readings only, with no rate, cost or
+ * server's shared plan status (`billingState`, hq-pro #5088) on the billing
+ * summary, with the legacy `pricingPlan` / `usageOnly` fields for a server
+ * that does not send it. An account on an earlier flat plan and an account
+ * the server says nothing about get readings only, with no rate, cost or
  * projected bill.
  */
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, vaultApiFetchPublic } from "../utils/vault-api.js";
-import { buildReadingsReport, buildReport, formatReport, readMonthUsage, } from "../lib/billing/usage-cost.js";
+import { buildReadingsReport, buildReport, formatReport, readMonthUsage, usageLimitsSource, usageStatementSource, } from "../lib/billing/usage-cost.js";
 import { ratesFromPricingStatement } from "../lib/billing/usage-rate-card.js";
 import { fetchUsageCard, formatUsageCardLines } from "../lib/billing/usage-card.js";
-import { fetchCompanyBillingSummary, pricingPlanFromBody, usageTrialActiveFromBody, } from "../lib/billing/usage-only.js";
+import { fetchCompanyBillingSummary, pricingPlanFromBody, hasBillingStateField, usageTrialActiveFromBody, } from "../lib/billing/usage-only.js";
 export class UsageScopeError extends Error {
 }
 /** Pick the scope. Never reaches outside the caller's own memberships. */
@@ -67,7 +67,7 @@ function asRecord(value) {
 /** The plan on a usage-limits body: `pricingPlan`, else the `usageOnly` / `onUsagePricing` boolean. */
 export function pricingPlanFromUsageLimits(body) {
     const plan = pricingPlanFromBody(body);
-    if (plan)
+    if (plan || hasBillingStateField(body))
         return plan;
     const rec = asRecord(body);
     const flag = typeof rec?.onUsagePricing === "boolean" ? rec.onUsagePricing : rec?.usageOnly;
@@ -85,9 +85,12 @@ export function pricingPlanFromSummary(body) {
     const rec = asRecord(body);
     if (!rec)
         return null;
-    // `plan: "usage"` only means "no Workforce subscription", not usage pricing,
-    // so it never turns pricing on. Without pricingPlan, show no cost.
-    return pricingPlanFromBody(rec) ?? "current";
+    // `plan: "usage"` only means "no flat-plan subscription", not usage pricing,
+    // so it never turns pricing on. A server that sends billingState answers
+    // from it alone (unknown stays unknown); an older one without pricingPlan
+    // shows no cost.
+    const plan = pricingPlanFromBody(rec);
+    return hasBillingStateField(rec) ? plan : plan ?? "current";
 }
 /**
  * True: price the meters. False: flat plan. Null: unknown, show no cost.
@@ -101,20 +104,44 @@ export function resolveOnUsagePricing(limitsPlan, summaryPlan) {
         return null;
     return plan === "usage-only";
 }
+/** Thrown when the company statement is refused to a caller who is not its owner. */
+export class UsageStatementForbiddenError extends Error {
+}
+/**
+ * Read the statement, or say the caller should use the legacy readings: null
+ * means the server has no statement route (404) or no reader was given.
+ */
+async function readStatementBody(scope, deps) {
+    if (!deps.fetchUsageStatement)
+        return null;
+    const res = await deps.fetchUsageStatement(scope);
+    if (res.status === 404)
+        return null;
+    if (res.status === 403 && scope.kind === "company") {
+        throw new UsageStatementForbiddenError(`Only the owner of '${scope.companySlug}' can see its usage statement. ` +
+            "Run `hq billing usage --personal` for your own usage.");
+    }
+    return { body: res.status >= 200 && res.status < 300 ? res.body : null };
+}
 export async function runBillingUsage(opts, deps) {
     const memberships = await deps.listCompanies();
     const scope = resolveUsageScope(memberships, opts);
     const membership = scope.kind === "company" ? memberships.find((m) => m.uid === scope.companyUid) : undefined;
     let limitsBody = null;
+    const statement = await readStatementBody(scope, deps);
+    const usageDeps = {
+        fetchUsageLimits: async (s) => (limitsBody = await deps.fetchUsageLimits(s)),
+        now: deps.now,
+        ...(deps.readTrialActive ? { readTrialActive: deps.readTrialActive } : {}),
+        ...(opts.storageScan !== false && deps.readStorageSplit && membership
+            ? { readStorageSplit: () => deps.readStorageSplit(membership, { fresh: opts.fresh === true }) }
+            : {}),
+    };
+    const source = statement
+        ? usageStatementSource(async () => statement.body)
+        : usageLimitsSource(usageDeps);
     const [usage, pricing] = await Promise.all([
-        readMonthUsage(scope, {
-            fetchUsageLimits: async (s) => (limitsBody = await deps.fetchUsageLimits(s)),
-            now: deps.now,
-            ...(deps.readTrialActive ? { readTrialActive: deps.readTrialActive } : {}),
-            ...(opts.storageScan !== false && deps.readStorageSplit && membership
-                ? { readStorageSplit: () => deps.readStorageSplit(membership, { fresh: opts.fresh === true }) }
-                : {}),
-        }),
+        readMonthUsage(scope, usageDeps, source),
         deps.fetchPricing().catch(() => null),
     ]);
     const limitsPlan = pricingPlanFromUsageLimits(limitsBody);
@@ -142,6 +169,14 @@ function productionDeps() {
             const { companiesFromMemberships } = await import("./storage.js");
             return companiesFromMemberships(await res.json());
         },
+        async fetchUsageStatement(scope) {
+            const res = await vaultApiFetch(scope.kind === "company"
+                ? { token: await token(), path: "/v1/billing/usage", query: { companyUid: scope.companyUid } }
+                : { token: await token(), path: "/v1/billing/usage", query: { scope: "person" } });
+            if (!res.ok)
+                return { status: res.status, body: null };
+            return { status: res.status, body: await res.json().catch(() => null) };
+        },
         async fetchUsageLimits(scope) {
             const res = await vaultApiFetch(scope.kind === "company"
                 ? { token: await token(), path: "/v1/billing/usage-limits", query: { companyUid: scope.companyUid } }

package/dist/commands/billing.d.ts

@@ -13,16 +13,16 @@
  *   hq billing checkout [--company <slug>] [--personal] — mint a card-capture link
  *   hq billing usage    [--company <slug>] [--personal] — usage, projected bill,
  *                                                         drivers (read-only)
- *   hq billing upgrade  [--company <slug>]              — Workforce checkout
- *                                                         (legacy plans only)
+ *   hq billing upgrade  [--company <slug>]              — the switch to usage
+ *                                                         pricing (earlier plans)
  *   hq billing sponsor  …                               — ask a company to cover
- *                                                         your $50 plan, or
+ *                                                         your personal plan, or
  *                                                         answer such a request
  *
- * Usage pricing (US-012): a company whose billing summary says
- * `pricingPlan: "usage-only"` has no plan to upgrade to. `hq billing upgrade`
- * tells it so and points at `hq billing usage` instead of opening Workforce
- * checkout. Legacy companies keep the Workforce flow unchanged.
+ * Usage pricing (US-012, US-024): a company on usage pricing has no plan to
+ * upgrade to; `hq billing upgrade` tells it so and points at
+ * `hq billing usage`. Every other company is pointed at the switch to usage
+ * pricing: the flat-plan checkout is closed, so the CLI never opens it.
  */
 import { Command } from "commander";
 interface DatabaseBilling {

package/dist/commands/billing.js

@@ -13,22 +13,22 @@
  *   hq billing checkout [--company <slug>] [--personal] — mint a card-capture link
  *   hq billing usage    [--company <slug>] [--personal] — usage, projected bill,
  *                                                         drivers (read-only)
- *   hq billing upgrade  [--company <slug>]              — Workforce checkout
- *                                                         (legacy plans only)
+ *   hq billing upgrade  [--company <slug>]              — the switch to usage
+ *                                                         pricing (earlier plans)
  *   hq billing sponsor  …                               — ask a company to cover
- *                                                         your $50 plan, or
+ *                                                         your personal plan, or
  *                                                         answer such a request
  *
- * Usage pricing (US-012): a company whose billing summary says
- * `pricingPlan: "usage-only"` has no plan to upgrade to. `hq billing upgrade`
- * tells it so and points at `hq billing usage` instead of opening Workforce
- * checkout. Legacy companies keep the Workforce flow unchanged.
+ * Usage pricing (US-012, US-024): a company on usage pricing has no plan to
+ * upgrade to; `hq billing upgrade` tells it so and points at
+ * `hq billing usage`. Every other company is pointed at the switch to usage
+ * pricing: the flat-plan checkout is closed, so the CLI never opens it.
  */
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
 import { mintPaymentLink } from "../utils/billing-gate.js";
-import { upgradeToTeam } from "../utils/team-upgrade.js";
+import { openUsageSwitch } from "../utils/team-upgrade.js";
 import { registerBillingSponsorCommands } from "./billing-sponsor.js";
 import { fetchCompanyPricingPlan, isUsageOnly, usageOnlyUpgradeLines, } from "../lib/billing/usage-only.js";
 import { fetchUsageCard } from "../lib/billing/usage-card.js";
@@ -157,10 +157,10 @@ export function registerBillingCommand(program) {
     });
     billing
         .command("upgrade")
-        .description("Open Stripe Checkout to upgrade a company on an earlier plan (usage-pricing companies have no plan to upgrade)")
+        .description("Open the switch to usage pricing for a company on an earlier plan (usage-pricing companies have nothing to change)")
         .option("--company <slug>", "Company slug (resolves to companyUid)")
-        .option("--no-browser", "Print the Stripe Checkout URL instead of opening it")
-        .option("--json", "Emit the Checkout URL as JSON")
+        .option("--no-browser", "Print the URL instead of opening it")
+        .option("--json", "Emit the URL as JSON")
         .action(async function (opts) {
         try {
             const token = await ensureCognitoToken();
@@ -177,8 +177,8 @@ export function registerBillingCommand(program) {
                     console.log(line);
                 return;
             }
-            await upgradeToTeam({
-                companyUid,
+            await openUsageSwitch({
+                companySlug: companyOf(this),
                 noBrowser: opts.browser === false,
                 json: opts.json,
             });

package/dist/commands/bot.js

@@ -44,7 +44,7 @@ import { DEFAULT_COGNITO, ensureCognitoToken, resolveDefaultHqRoot, } from "../u
 import { peekHqApiKey } from "../utils/resolve-vault-credential.js";
 import { getCompanyUid, resolveCallerPersonUid } from "../utils/vault-api.js";
 import { resolveHqBinary } from "../lib/mesh/live/daemon/install.js";
-import { askDaemonToStart, askDaemonToStop, daemonOwnsProcess, daemonSupervises, daemonWillSupervise, handOffInstallHere, } from "../lib/daemon/handoff.js";
+import { askDaemonToStart, askDaemonToStop, daemonOwnsProcess, daemonHoldReason, daemonSupervises, daemonWillSupervise, handOffInstallHere, } from "../lib/daemon/handoff.js";
 import { daemonPaths } from "../lib/daemon/paths.js";
 import { launchdLabel } from "../lib/bot/paths.js";
 import { isAncestorProcess } from "../lib/bot/self-process.js";
@@ -286,9 +286,11 @@ async function startBot(name, dir, config, output, extra = {}) {
     const d = botDaemonStatus(paths, daemonDeps());
     const hqDaemon = daemonPaths();
     let how;
+    let supervised = false;
     // A bot created since the daemon last read its plan is the daemon's too,
     // unless its own LaunchAgent runs it.
     if (daemonSupervises(hqDaemon, `bots:${name}`) || (!d.installed && daemonWillSupervise(hqDaemon, `bots:${name}`))) {
+        supervised = true;
         // `hq daemon` runs this bot; starting a copy here would run it twice.
         const before = readBotStatus(dir);
         if (before && isPidAlive(before.pid) && before.state === "running") {
@@ -322,18 +324,19 @@ async function startBot(name, dir, config, output, extra = {}) {
         return !!s && s.state === "running" && isPidAlive(s.pid);
     }, 15_000);
     const status = readBotStatus(dir);
+    const lastError = (!running && supervised ? daemonHoldReason(hqDaemon, `bots:${name}`) : null) ?? status?.lastError ?? null;
     if (output === "silent")
         return { running, how };
     if (output === "json") {
-        console.log(JSON.stringify({ ok: running, name, ...extra, running, how, state: status?.state ?? "unknown", pid: status?.pid ?? null, lastError: status?.lastError ?? null }, null, 2));
+        console.log(JSON.stringify({ ok: running, name, ...extra, running, how, state: status?.state ?? "unknown", pid: status?.pid ?? null, lastError }, null, 2));
         return { running, how };
     }
     if (running)
         console.log(chalk.green(`${name} is running`) + chalk.dim(` (${how})`));
     else {
         console.log(chalk.yellow(`${name} did not report running within 15s`) + chalk.dim(` (${how})`));
-        if (status?.lastError)
-            console.log(chalk.dim(`  last error: ${status.lastError}`));
+        if (lastError)
+            console.log(chalk.dim(`  last error: ${lastError}`));
         console.log(chalk.dim(`  logs: hq bot logs ${name}`));
     }
     return { running, how };

package/dist/commands/channel-suggest.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Near-match suggestions for a channel name that resolved to nothing.
+ *
+ * `hq dm channel <name>`, `hq dm <channel> "msg"`, `hq channels members` and
+ * `hq files share --channel` all resolve a channel by exact slug or display
+ * name. When that misses, the user usually typed something close to a real
+ * channel (for example "desktop-agent-coordination" for the project channel
+ * "project-desktop-agent-creation-1331ed7f"). This module ranks the caller's
+ * channels against the typed name so the error can list the closest few.
+ *
+ * Pure: no I/O, so it is unit-testable.
+ */
+/** The fields the ranker reads. Structurally compatible with ChannelSummary. */
+export interface SuggestableChannel {
+    channelId: string;
+    name?: string;
+    slug?: string;
+    scope?: string;
+}
+export interface ChannelSuggestion {
+    id: string;
+    name: string;
+}
+/** Most suggestions an error ever lists. */
+export declare const MAX_CHANNEL_SUGGESTIONS = 3;
+/**
+ * Tokens used for comparison. Drops a leading "project" token and a trailing
+ * 8-hex id, which every project channel carries and which would otherwise
+ * dominate the comparison. Falls back to the raw tokens when stripping would
+ * leave nothing (a channel literally named "project").
+ */
+export declare function comparableTokens(value: string): string[];
+/** Levenshtein distance over code points (so astral characters count once). */
+export declare function editDistance(a: string, b: string): number;
+/**
+ * Rank the caller's channels against a name that matched nothing and return
+ * up to `max` close ones, best first. Group DMs are unnamed and cannot be
+ * addressed by name, so they are never suggested. Each channel is compared by
+ * both its slug and its display name; the better score wins.
+ */
+export declare function suggestChannels(channels: readonly SuggestableChannel[], query: string, max?: number): ChannelSuggestion[];
+/**
+ * Append a "Did you mean" block to a not-found message. Returns the message
+ * unchanged when there are no suggestions.
+ */
+export declare function withChannelSuggestions(message: string, suggestions: readonly ChannelSuggestion[]): string;
+/**
+ * Thrown by channel resolvers when a name or id matches nothing. Carries the
+ * near-match suggestions so a --json caller can emit them structurally.
+ */
+export declare class ChannelNotFoundError extends Error {
+    readonly baseMessage: string;
+    readonly suggestions: ChannelSuggestion[];
+    constructor(baseMessage: string, suggestions: ChannelSuggestion[]);
+}
+//# sourceMappingURL=channel-suggest.d.ts.map

package/dist/commands/channel-suggest.js

@@ -0,0 +1,170 @@
+/**
+ * Near-match suggestions for a channel name that resolved to nothing.
+ *
+ * `hq dm channel <name>`, `hq dm <channel> "msg"`, `hq channels members` and
+ * `hq files share --channel` all resolve a channel by exact slug or display
+ * name. When that misses, the user usually typed something close to a real
+ * channel (for example "desktop-agent-coordination" for the project channel
+ * "project-desktop-agent-creation-1331ed7f"). This module ranks the caller's
+ * channels against the typed name so the error can list the closest few.
+ *
+ * Pure: no I/O, so it is unit-testable.
+ */
+/** Most suggestions an error ever lists. */
+export const MAX_CHANNEL_SUGGESTIONS = 3;
+/**
+ * Comparison strings are capped so a very long name cannot make the edit
+ * distance (quadratic) expensive across a large channel list.
+ */
+const MAX_COMPARE_LENGTH = 64;
+/** Lowercase, Unicode-normalised tokens split on '-', '_' and whitespace. */
+function rawTokens(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .trim()
+        .replace(/^#/, "")
+        .split(/[\s_-]+/u)
+        .filter((token) => token.length > 0);
+}
+/**
+ * Tokens used for comparison. Drops a leading "project" token and a trailing
+ * 8-hex id, which every project channel carries and which would otherwise
+ * dominate the comparison. Falls back to the raw tokens when stripping would
+ * leave nothing (a channel literally named "project").
+ */
+export function comparableTokens(value) {
+    const tokens = rawTokens(value);
+    let stripped = tokens;
+    if (stripped[0] === "project")
+        stripped = stripped.slice(1);
+    const last = stripped[stripped.length - 1];
+    if (last !== undefined && /^[0-9a-f]{8}$/.test(last)) {
+        stripped = stripped.slice(0, -1);
+    }
+    return stripped.length > 0 ? stripped : tokens;
+}
+function sharedPrefixLength(a, b) {
+    const max = Math.min(a.length, b.length);
+    let i = 0;
+    while (i < max && a[i] === b[i])
+        i += 1;
+    return i;
+}
+/** Levenshtein distance over code points (so astral characters count once). */
+export function editDistance(a, b) {
+    const left = Array.from(a);
+    const right = Array.from(b);
+    if (left.length === 0)
+        return right.length;
+    if (right.length === 0)
+        return left.length;
+    let previous = Array.from({ length: right.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= left.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= right.length; j += 1) {
+            const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+        }
+        previous = current;
+    }
+    return previous[right.length];
+}
+function toComparable(value) {
+    const tokens = comparableTokens(value);
+    return {
+        tokens: new Set(tokens),
+        joined: Array.from(tokens.join("-")).slice(0, MAX_COMPARE_LENGTH).join(""),
+    };
+}
+/**
+ * Similarity in [0, 1], or 0 when the two are not close enough to suggest.
+ * A candidate qualifies when it shares a token, shares a prefix of at least
+ * three characters, or is within 40% edit distance of the query.
+ */
+function similarity(query, candidate) {
+    if (!query.joined || !candidate.joined)
+        return 0;
+    let shared = 0;
+    for (const token of query.tokens)
+        if (candidate.tokens.has(token))
+            shared += 1;
+    const union = query.tokens.size + candidate.tokens.size - shared;
+    const tokenScore = union > 0 ? shared / union : 0;
+    const prefix = sharedPrefixLength(query.joined, candidate.joined);
+    const longest = Math.max(Array.from(query.joined).length, Array.from(candidate.joined).length);
+    const prefixScore = longest > 0 ? prefix / longest : 0;
+    const editScore = longest > 0
+        ? 1 - editDistance(query.joined, candidate.joined) / longest
+        : 0;
+    const close = shared > 0 || prefix >= 3 || editScore >= 0.6;
+    if (!close)
+        return 0;
+    return 0.5 * tokenScore + 0.2 * prefixScore + 0.3 * editScore;
+}
+/**
+ * Rank the caller's channels against a name that matched nothing and return
+ * up to `max` close ones, best first. Group DMs are unnamed and cannot be
+ * addressed by name, so they are never suggested. Each channel is compared by
+ * both its slug and its display name; the better score wins.
+ */
+export function suggestChannels(channels, query, max = MAX_CHANNEL_SUGGESTIONS) {
+    if (max <= 0)
+        return [];
+    const target = toComparable(query);
+    if (!target.joined)
+        return [];
+    const scored = [];
+    for (const channel of channels) {
+        if (channel.scope === "group")
+            continue;
+        const slug = channel.slug?.trim() ?? "";
+        const name = channel.name?.trim() ?? "";
+        if (!slug && !name)
+            continue;
+        const score = Math.max(slug ? similarity(target, toComparable(slug)) : 0, name ? similarity(target, toComparable(name)) : 0);
+        if (score <= 0)
+            continue;
+        scored.push({
+            suggestion: { id: channel.channelId, name: slug || name },
+            score,
+        });
+    }
+    scored.sort((a, b) => b.score - a.score ||
+        a.suggestion.name.localeCompare(b.suggestion.name) ||
+        a.suggestion.id.localeCompare(b.suggestion.id));
+    return scored.slice(0, max).map((entry) => entry.suggestion);
+}
+/**
+ * Strip control and bidi-override characters so a server-supplied name cannot
+ * drive the terminal or visually reorder the line.
+ */
+function printable(value) {
+    // eslint-disable-next-line no-control-regex
+    return value.replace(/[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "");
+}
+/**
+ * Append a "Did you mean" block to a not-found message. Returns the message
+ * unchanged when there are no suggestions.
+ */
+export function withChannelSuggestions(message, suggestions) {
+    if (suggestions.length === 0)
+        return message;
+    const lines = suggestions.map((s) => `  ${printable(s.name)} (${printable(s.id)})`);
+    return `${message}\nDid you mean:\n${lines.join("\n")}`;
+}
+/**
+ * Thrown by channel resolvers when a name or id matches nothing. Carries the
+ * near-match suggestions so a --json caller can emit them structurally.
+ */
+export class ChannelNotFoundError extends Error {
+    baseMessage;
+    suggestions;
+    constructor(baseMessage, suggestions) {
+        super(withChannelSuggestions(baseMessage, suggestions));
+        this.name = "ChannelNotFoundError";
+        this.baseMessage = baseMessage;
+        this.suggestions = suggestions;
+    }
+}
+//# sourceMappingURL=channel-suggest.js.map

package/dist/commands/channels.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
+import { suggestChannels, withChannelSuggestions } from "./channel-suggest.js";
 import { callerFromToken, channelSlug, fetchChannelMembers, fetchChannels, matchChannelsByName, } from "./dm.js";
 /**
  * Human label for a channel row. Named channels (personal/company) show their
@@ -189,7 +190,12 @@ async function runChannelsMembers(channelName, opts) {
         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.`));
+            const message = `No channel named '${channelName}' — run \`hq channels\` to see your channels.`;
+            const suggestions = suggestChannels(channels, channelName);
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: message, suggestions }, null, 2));
+            }
+            console.error(chalk.red(withChannelSuggestions(message, suggestions)));
             process.exit(1);
         }
         if (matches.length > 1) {

package/dist/commands/cloud-provision.js

@@ -484,8 +484,8 @@ async function defaultRunInitialSync(args) {
             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",
+                    path: event.paths?.[0] ?? "new files",
+                    message: event.message ?? "new files are paused for this account",
                 };
                 return;
             }

package/dist/commands/cloud.d.ts

@@ -69,6 +69,32 @@ export declare function scopeExcludedExitCode(count: number): 0 | 1;
 export declare function scopeExcludedWarning(count: number): string | null;
 /** Actionable recovery for files refused because the vault baseline is stale. */
 export declare function staleUploadRefusalLines(count: number, paths?: readonly string[]): string[];
+/**
+ * Upload-failure fields newer hq-cloud ShareResult carries. Read through
+ * readUploadFailures so this CLI also builds against a release without them.
+ */
+export interface UploadFailureCounts {
+    filesUploadFailed?: number;
+    uploadFailedPaths?: string[];
+}
+export declare function readUploadFailures(result: object): {
+    count: number;
+    paths: string[];
+};
+/**
+ * Files the vault accepted in the plan but refused or failed at upload
+ * (feedback_943456f4). Without these lines a push that uploaded nothing
+ * printed "✓ Pushed 0" and exited 0.
+ */
+export declare function uploadFailedLines(count: number, paths?: readonly string[]): string[];
+/**
+ * share() option that turns a user-named path an ignore rule drops into an
+ * "unreachable path" error instead of a silent 0-file success
+ * (feedback_63bfc302, feedback_8c294805). Spread as a plain record so this
+ * builds against an hq-cloud release whose ShareOptions predates the field;
+ * older releases ignore it.
+ */
+export declare function namedPathShareOptions(userNamedPaths: boolean): Record<string, boolean>;
 /**
  * Optional detail line listing the effective write prefixes when a push
  * dropped files — helps debug ACL vs scope-excluded mismatches (feedback_7e9c535e).
@@ -241,6 +267,8 @@ export interface ShareCallResult {
     filesExcludedByScope: number;
     filesRefusedStale?: number;
     filesRefusedStalePaths?: string[];
+    filesUploadFailed?: number;
+    uploadFailedPaths?: string[];
     conflictPaths: string[];
     aborted: boolean;
     /** Files this leg's plan limit refused; absent or null when none were. */
@@ -286,6 +314,8 @@ export interface PushAllResult {
     filesExcludedByScope: number;
     filesRefusedStale?: number;
     filesRefusedStalePaths?: string[];
+    filesUploadFailed?: number;
+    uploadFailedPaths?: string[];
     errors: Array<{
         company: string;
         message: string;
@@ -418,4 +448,19 @@ export declare function printReadOnlyLocalOnly(hqRoot: string, journals: Readonl
         files?: Record<string, unknown>;
     };
 }>, log?: (line: string) => void): number;
+/**
+ * `hq sync status`: list local files under server-owned folders (sources/,
+ * signals/, ontology/ outside entities/) that are not in the sync journal.
+ * The server pipeline writes these folders; a client push refuses them and
+ * the recurring runner skips them quietly, so a file written locally there
+ * never reaches the vault and `pendingFiles: 0` still reports a clean tree
+ * (feedback_0414d71c). Uses only the journals already loaded, with no
+ * network calls. Prints nothing when nothing applies.
+ */
+export declare function printServerOwnedLocalOnly(hqRoot: string, journals: ReadonlyArray<{
+    slug: string;
+    journal: {
+        files?: Record<string, unknown>;
+    };
+}>, log?: (line: string) => void): number;
 //# sourceMappingURL=cloud.d.ts.map