@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/utils/large-file-guard.d.ts

@@ -18,16 +18,6 @@ export interface LargeFileGuardOptions {
     /** Bypass the throttle. */
     force?: boolean;
 }
-/**
- * Render a repo-relative path as a literal `.gitignore` pattern.
- *
- * The leading slash anchors it to the repo root — without it a bare filename
- * would also ignore same-named files in every subdirectory. Glob and
- * character-class metacharacters are escaped so the rule matches the one real
- * path and nothing else, and a trailing space is escaped because git strips
- * unescaped ones.
- */
-export declare function toGitignorePattern(relPath: string): string;
 /**
  * Scan `hqRoot` for files above the size limit, ignore them, and drop any that
  * are already in the index.

package/dist/utils/large-file-guard.js

@@ -177,7 +177,7 @@ function oversizedInWorktree(hqRoot, threshold) {
  * path and nothing else, and a trailing space is escaped because git strips
  * unescaped ones.
  */
-export function toGitignorePattern(relPath) {
+function toGitignorePattern(relPath) {
     const escaped = relPath.replace(/([\\*?[\]!#])/g, "\\$1");
     const anchored = `/${escaped}`;
     return anchored.endsWith(" ") ? `${anchored.slice(0, -1)}\\ ` : anchored;

package/dist/utils/local-files-overview.d.ts

@@ -11,10 +11,11 @@
  * cross the wire; there is no string field on it for anything sensitive to
  * hide inside.
  *
- * Sources (metadata only, via `fs.stat` — full content is read only for the
+ * Sources (metadata only, via `fs.lstat` — full content is read only for the
  * bounded error-line count below, and even then only a capped tail window,
  * and even then only an integer count is ever returned):
- *   - the hq-sync desktop app's log file, `~/.hq/logs/hq-sync.log`
+ *   - the newest available desktop or daemon sync-log family and its rotations
+ *     under `~/.hq/logs/` or `~/.hq/daemon/logs/`
  *   - the CLI's own per-company sync journals, enumerated via `listJournals()`
  *     (never a hand-reconstructed path — see client-health.ts's note on the
  *     single-path-reconstruction regression this mirrors).
@@ -25,12 +26,6 @@
  * must never break a heartbeat, let alone a CLI command.
  */
 import { type ClientHealthLocalFilesOverview } from "./client-health-contract.js";
-/**
- * Only the last N bytes of the sync log are read for error-line counting —
- * this bounds memory/CPU regardless of how large the on-disk log has grown.
- * Metadata (size/age) still reflects the FULL file via `fs.stat`.
- */
-export declare const LOCAL_FILES_OVERVIEW_TAIL_READ_BYTES: number;
 /**
  * Count lines that look like an error marker in the last
  * {@link LOCAL_FILES_OVERVIEW_TAIL_READ_BYTES} of `filePath`, capped at
@@ -42,6 +37,7 @@ export declare function countRecentErrorLines(filePath: string, maxBytes?: numbe
 export interface CollectLocalFilesOverviewDeps {
     now?: () => Date;
     homeDir?: () => string;
+    env?: NodeJS.ProcessEnv;
     journals?: () => readonly {
         path: string;
     }[];

package/dist/utils/local-files-overview.js

@@ -11,10 +11,11 @@
  * cross the wire; there is no string field on it for anything sensitive to
  * hide inside.
  *
- * Sources (metadata only, via `fs.stat` — full content is read only for the
+ * Sources (metadata only, via `fs.lstat` — full content is read only for the
  * bounded error-line count below, and even then only a capped tail window,
  * and even then only an integer count is ever returned):
- *   - the hq-sync desktop app's log file, `~/.hq/logs/hq-sync.log`
+ *   - the newest available desktop or daemon sync-log family and its rotations
+ *     under `~/.hq/logs/` or `~/.hq/daemon/logs/`
  *   - the CLI's own per-company sync journals, enumerated via `listJournals()`
  *     (never a hand-reconstructed path — see client-health.ts's note on the
  *     single-path-reconstruction regression this mirrors).
@@ -28,16 +29,18 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { listJournals } from "@indigoai-us/hq-cloud";
+import { currentSyncLogFamily, SYNC_LOG_GENERATIONS, syncLogBasePaths, syncLogGenerationPath, } from "./sync-log-sources.js";
 import { CLIENT_HEALTH_MAX_ERROR_LINE_COUNT, CLIENT_HEALTH_MAX_FILE_AGE_SECONDS, CLIENT_HEALTH_MAX_FILE_SIZE_BYTES, } from "./client-health-contract.js";
 /**
  * Only the last N bytes of the sync log are read for error-line counting —
  * this bounds memory/CPU regardless of how large the on-disk log has grown.
  * Metadata (size/age) still reflects the FULL file via `fs.stat`.
  */
-export const LOCAL_FILES_OVERVIEW_TAIL_READ_BYTES = 2 * 1024 * 1024; // 2 MiB
+const LOCAL_FILES_OVERVIEW_TAIL_READ_BYTES = 2 * 1024 * 1024; // 2 MiB
 /** Case-insensitive marker matched against each line (or JSON-lines `level`). */
 const ERROR_MARKER = /error/i;
-const JSON_LEVEL_ERROR = /"level"\s*:\s*"error"/i;
+const JSON_LEVEL_ERROR = /"level"\s*:\s*"error"\s*(?=[,}])/i;
+const JSON_NUMERIC_LEVEL = /"level"\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}])/;
 const ABSENT = { exists: false, sizeBytes: 0, ageSeconds: 0 };
 function clampInt(value, max) {
     if (!Number.isFinite(value) || value < 0)
@@ -102,6 +105,12 @@ export function countRecentErrorLines(filePath, maxBytes = LOCAL_FILES_OVERVIEW_
         for (const line of text.split("\n")) {
             if (count >= cap)
                 break;
+            const numericLevel = JSON_NUMERIC_LEVEL.exec(line)?.[1];
+            if (numericLevel !== undefined) {
+                if (Number(numericLevel) >= 50)
+                    count += 1;
+                continue;
+            }
             if (ERROR_MARKER.test(line) || JSON_LEVEL_ERROR.test(line))
                 count += 1;
         }
@@ -133,9 +142,41 @@ export function collectLocalFilesOverview(deps = {}) {
     const nowMs = now.getTime();
     const homeDir = (deps.homeDir ?? os.homedir)();
     const countErrorLines = deps.countErrorLines ?? countRecentErrorLines;
-    const syncLogPath = path.join(homeDir, ".hq", "logs", "hq-sync.log");
-    const syncLogFacts = statFacts(syncLogPath, nowMs);
-    const recentErrorLineCount = syncLogFacts.exists ? countErrorLines(syncLogPath) : 0;
+    const hqDir = path.join(homeDir, ".hq");
+    const syncLogPaths = syncLogBasePaths(hqDir, deps.env);
+    const generations = {
+        desktop: [],
+        daemon: [],
+    };
+    const familyModifiedMs = (family) => {
+        let newest = null;
+        for (let generation = 0; generation < SYNC_LOG_GENERATIONS; generation += 1) {
+            const file = syncLogGenerationPath(syncLogPaths[family], generation);
+            try {
+                const stat = fs.lstatSync(file);
+                if (!stat.isFile())
+                    continue;
+                generations[family].push({ file, modifiedMs: stat.mtimeMs });
+                newest = newest === null ? stat.mtimeMs : Math.max(newest, stat.mtimeMs);
+            }
+            catch {
+                // Missing, denied, or raced generations are absent from this overview.
+            }
+        }
+        return newest;
+    };
+    const family = currentSyncLogFamily(familyModifiedMs("desktop"), familyModifiedMs("daemon"));
+    const selectedFamily = family ?? "desktop";
+    const selectedFiles = generations[selectedFamily];
+    const activePath = syncLogPaths[selectedFamily];
+    const activeFacts = statFacts(activePath, nowMs);
+    const freshestGeneration = [...selectedFiles].sort((a, b) => b.modifiedMs - a.modifiedMs)[0];
+    const syncLogPath = activeFacts.exists ? activePath : freshestGeneration?.file;
+    const syncLogFacts = syncLogPath ? statFacts(syncLogPath, nowMs) : ABSENT;
+    let recentErrorLineCount = 0;
+    for (const generation of selectedFiles) {
+        recentErrorLineCount = Math.min(CLIENT_HEALTH_MAX_ERROR_LINE_COUNT, recentErrorLineCount + countErrorLines(generation.file));
+    }
     let journalEntries;
     try {
         journalEntries = (deps.journals ?? listJournals)();

package/dist/utils/login-provider.d.ts

@@ -5,7 +5,14 @@ declare const PROVIDER_TO_COGNITO_IDP: {
     readonly picker: undefined;
 };
 export type LoginProvider = keyof typeof PROVIDER_TO_COGNITO_IDP;
+export type RememberedLoginProvider = Exclude<LoginProvider, "picker">;
+export interface LoginProviderSelection {
+    config: CognitoAuthConfig;
+    providerToRemember?: RememberedLoginProvider;
+}
 export declare function parseLoginProvider(value: string | undefined): LoginProvider | undefined;
 export declare function cognitoConfigForLoginProvider(value: string | undefined): CognitoAuthConfig;
+/** Resolve CLI, environment, remembered, then first-login choice-page precedence. */
+export declare function resolveLoginProviderSelection(explicitProvider: string | undefined, env: NodeJS.ProcessEnv, rememberedProvider?: RememberedLoginProvider): LoginProviderSelection;
 export {};
 //# sourceMappingURL=login-provider.d.ts.map

package/dist/utils/login-provider.js

@@ -22,4 +22,38 @@ export function cognitoConfigForLoginProvider(value) {
         identityProvider: PROVIDER_TO_COGNITO_IDP[provider],
     };
 }
+function rememberedProviderForCognitoProvider(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "google")
+        return "google";
+    if (normalized === "microsoft" || normalized === "microsoftpersonal")
+        return "microsoft";
+    return undefined;
+}
+/** Resolve CLI, environment, remembered, then first-login choice-page precedence. */
+export function resolveLoginProviderSelection(explicitProvider, env, rememberedProvider) {
+    if (explicitProvider !== undefined) {
+        const provider = parseLoginProvider(explicitProvider);
+        return {
+            config: cognitoConfigForLoginProvider(explicitProvider),
+            ...(provider && provider !== "picker" ? { providerToRemember: provider } : {}),
+        };
+    }
+    if (env.HQ_COGNITO_IDENTITY_PROVIDER !== undefined) {
+        const identityProvider = env.HQ_COGNITO_IDENTITY_PROVIDER.trim() || undefined;
+        return {
+            config: { ...DEFAULT_COGNITO, identityProvider },
+            ...(rememberedProviderForCognitoProvider(identityProvider)
+                ? { providerToRemember: rememberedProviderForCognitoProvider(identityProvider) }
+                : {}),
+        };
+    }
+    if (rememberedProvider) {
+        return {
+            config: cognitoConfigForLoginProvider(rememberedProvider),
+            providerToRemember: rememberedProvider,
+        };
+    }
+    return { config: cognitoConfigForLoginProvider("picker") };
+}
 //# sourceMappingURL=login-provider.js.map

package/dist/utils/pack-contributions.d.ts

@@ -39,6 +39,8 @@
 import type { PackManifest, PackContributeKey } from '../types.js';
 import { CONTRIBUTION_TABLE, type WireMode } from './contribution-table.js';
 import { type UnregisterServerResult, type SafeWriteEnv, type AcquireLockOptions } from '../commands/mcp-registration.js';
+export { readHqVersion, readRecommendedPackages } from './hq-core-yaml.js';
+export type { CatalogEntry } from './hq-core-yaml.js';
 export { CONTRIBUTION_TABLE };
 export type { WireMode };
 /**
@@ -75,11 +77,6 @@ export type LinkStatus = 'live' | 'broken' | 'missing' | 'foreign';
  * effect (a config merge) is handled separately (US-004/US-005).
  */
 export declare function contributionLinks(hqRoot: string, packDir: string, contributes: Partial<Record<PackContributeKey, string[]>>): WiredLink[];
-/**
- * Canonical absolute path — resolves symlinks and platform aliases such as
- * macOS `/var` ↔ `/private/var` so equivalent paths compare equal.
- */
-export declare function canonicalPath(p: string): string;
 /** Classify a host path against the link that should own it. */
 export declare function linkStatus(link: WiredLink, packDir?: string): LinkStatus;
 /** A content pack's manifest plus the install-time stamped source. */
@@ -163,13 +160,4 @@ export interface UnwirePackMcpOptions {
  * @param contributes the pack's `contributes` block (its `mcp` list drives removal)
  */
 export declare function unwirePackMcp(packName: string, contributes: Partial<Record<PackContributeKey, string[]>>, options?: UnwirePackMcpOptions): UnwireMcpResult;
-export declare function readHqVersion(hqRoot: string): string | null;
-export interface CatalogEntry {
-    source: string;
-    description?: string;
-    conditional?: string;
-    auto_install?: boolean;
-}
-/** Read `recommended_packages` from core.yaml (the curated content-pack catalog). */
-export declare function readRecommendedPackages(hqRoot: string): CatalogEntry[];
 //# sourceMappingURL=pack-contributions.d.ts.map

package/dist/utils/pack-contributions.js

@@ -41,6 +41,7 @@ import * as path from 'path';
 import * as yaml from 'js-yaml';
 import { CONTRIBUTION_TABLE, payloadFor } from './contribution-table.js';
 import { unregisterMcpServers, } from '../commands/mcp-registration.js';
+export { readHqVersion, readRecommendedPackages } from './hq-core-yaml.js';
 // NOTE on dependency direction: this module imports from ../commands/mcp-registration.js
 // to un-register `wire:merge` (mcp) servers on uninstall. mcp-registration.ts imports
 // ONLY fs/os/path/smol-toml (it does NOT import from pack-contributions.ts), so there
@@ -136,7 +137,7 @@ export function contributionLinks(hqRoot, packDir, contributes) {
  * Canonical absolute path — resolves symlinks and platform aliases such as
  * macOS `/var` ↔ `/private/var` so equivalent paths compare equal.
  */
-export function canonicalPath(p) {
+function canonicalPath(p) {
     try {
         return fs.realpathSync.native(p);
     }
@@ -199,10 +200,11 @@ export function linkStatus(link, packDir) {
     catch {
         return 'foreign';
     }
-    // scan-packages.sh writes the symlink target as the absolute `src` path.
-    // Canonicalize both sides so `/var` vs `/private/var` (macOS) and symlink
-    // aliases classify as ours; optionally accept stale targets that still resolve
-    // inside this pack's directory.
+    // scan-packages writes the symlink target as a path relative to the host
+    // directory (`path.relative(dirname(dst), src)`). Older trees still carry
+    // absolute `src` strings; canonicalize both so those, `/var` vs `/private/var`
+    // (macOS), and symlink aliases classify as ours; optionally accept stale
+    // targets that still resolve inside this pack's directory.
     const resolvedTarget = path.resolve(path.dirname(link.dst), target);
     if (pointsAtDeclaredPayload(link, resolvedTarget)) {
         return fs.existsSync(link.src) ? 'live' : 'broken';
@@ -342,43 +344,4 @@ export function unwirePackMcp(packName, contributes, options) {
     }
     return { servers };
 }
-// ---------------------------------------------------------------------------
-// Host introspection: hqVersion + recommended_packages catalog
-// ---------------------------------------------------------------------------
-/** Locate core.yaml -- v14+ nests it under `core/`, older layouts at the root. */
-function coreYamlPath(hqRoot) {
-    const nested = path.join(hqRoot, 'core', 'core.yaml');
-    if (fs.existsSync(nested))
-        return nested;
-    const flat = path.join(hqRoot, 'core.yaml');
-    if (fs.existsSync(flat))
-        return flat;
-    return null;
-}
-export function readHqVersion(hqRoot) {
-    const p = coreYamlPath(hqRoot);
-    if (!p)
-        return null;
-    try {
-        const c = yaml.load(fs.readFileSync(p, 'utf-8'));
-        return c?.hqVersion ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Read `recommended_packages` from core.yaml (the curated content-pack catalog). */
-export function readRecommendedPackages(hqRoot) {
-    const p = coreYamlPath(hqRoot);
-    if (!p)
-        return [];
-    try {
-        const c = yaml.load(fs.readFileSync(p, 'utf-8'));
-        const list = c?.recommended_packages;
-        return Array.isArray(list) ? list : [];
-    }
-    catch {
-        return [];
-    }
-}
 //# sourceMappingURL=pack-contributions.js.map

package/dist/utils/package-root-diagnostics.d.ts

@@ -6,7 +6,7 @@
  * so a malformed install cannot turn an error report into an unbounded or
  * multi-line payload.
  */
-export type PackageRootVisitOutcome = "no-manifest" | "eacces" | "eisdir" | "parse-error" | "name-mismatch" | "read-error" | "omitted";
+type PackageRootVisitOutcome = "no-manifest" | "eacces" | "eisdir" | "parse-error" | "name-mismatch" | "read-error" | "omitted";
 export type PackageRootVisit = {
     directory: string;
     outcome: PackageRootVisitOutcome;

package/dist/utils/people.d.ts

@@ -22,6 +22,9 @@ export interface PersonRecord {
     name: string;
     /** Contact email, when recorded. */
     email?: string;
+    /** Canonical identity from authoritative company membership, never local YAML. */
+    personUid?: string;
+    companyUid?: string;
     /** "internal" (team member) | "external" (client, vendor, …). */
     type?: string;
     /** Role/title inside (or relative to) the company. */
@@ -83,17 +86,10 @@ export type ResolveResult = {
 /**
  * Resolve a person NAME to their email, built on top of {@link searchPeople}.
  *
- * Match precedence (narrowest first) so a precise query isn't drowned out by
- * looser substring hits:
- *   1. exact name match (case-insensitive, trimmed)
- *   2. exact folder-slug match
- *   3. substring search over name/email/slug
- *
- * The first tier that yields any match decides the result:
- *   - exactly one match with an email  → `found`
- *   - exactly one match, no email      → `no_email`
- *   - more than one match              → `ambiguous` (caller disambiguates)
- *   - no match in any tier             → `not_found`
+ * Resolution is deliberately stricter than a convenience ranking. Every
+ * case-insensitive name, email, or slug substring match is a candidate; an
+ * exact name never silently selects one person when the query also names
+ * other people. The caller must disambiguate any multi-person result.
  */
 export declare function resolveNameToEmail(people: PersonRecord[], name: string): ResolveResult;
 //# sourceMappingURL=people.d.ts.map

package/dist/utils/people.js

@@ -122,31 +122,16 @@ export function searchPeople(people, keyword) {
 /**
  * Resolve a person NAME to their email, built on top of {@link searchPeople}.
  *
- * Match precedence (narrowest first) so a precise query isn't drowned out by
- * looser substring hits:
- *   1. exact name match (case-insensitive, trimmed)
- *   2. exact folder-slug match
- *   3. substring search over name/email/slug
- *
- * The first tier that yields any match decides the result:
- *   - exactly one match with an email  → `found`
- *   - exactly one match, no email      → `no_email`
- *   - more than one match              → `ambiguous` (caller disambiguates)
- *   - no match in any tier             → `not_found`
+ * Resolution is deliberately stricter than a convenience ranking. Every
+ * case-insensitive name, email, or slug substring match is a candidate; an
+ * exact name never silently selects one person when the query also names
+ * other people. The caller must disambiguate any multi-person result.
  */
 export function resolveNameToEmail(people, name) {
     const query = name.trim();
     if (!query)
         return { status: "not_found" };
-    const lowered = query.toLowerCase();
-    const exactName = people.filter((p) => p.name.toLowerCase() === lowered);
-    const exactSlug = people.filter((p) => p.slug.toLowerCase() === lowered);
-    const substring = searchPeople(people, query);
-    const matches = exactName.length > 0
-        ? exactName
-        : exactSlug.length > 0
-            ? exactSlug
-            : substring;
+    const matches = searchPeople(people, query);
     if (matches.length === 0)
         return { status: "not_found" };
     if (matches.length > 1)

package/dist/utils/plan-gate-error.d.ts

@@ -1,26 +1,59 @@
-/**
- * A deliberate subscription denial returned by hq-pro. Keeping its structured
- * fields on a typed error lets the CLI boundary render one safe, consistent
- * message instead of every command parsing and printing a server response.
- */
-export type PlanGateCode = "PLAN_LIMIT_EXCEEDED" | "PLAN_REQUIRED";
+import { type PlanLimitFreeMonth } from "../lib/billing/free-month.js";
+export type PlanGateCode = "PLAN_LIMIT_EXCEEDED" | "PLAN_REQUIRED" | "MEETING_PLAN_REQUIRED"
+/** A PERSONAL scope asked for a feature the paid Individual plan includes. */
+ | "PERSONAL_PLAN_REQUIRED"
+/** External agent enrollment was denied by the company plan. */
+ | "BILLING_REQUIRED";
+/** One over-limit dimension, as hq-pro's hard-stop 402 body names it. */
+export interface PlanGateResourceUsage {
+    resource: string;
+    used: number;
+    limit: number;
+}
 export interface PlanGateDetails {
     resource?: string;
+    feature?: string;
     used?: number;
     limit?: number;
     upgradeUrl?: string;
-    /** Best-effort target captured by the shared HTTP client for interactive checkout. */
+    reason?: string;
+    /** Company target from request context or the server's UID-keyed billing URL. */
     companyUid?: string;
+    /** Hard-stop 402: the create action the server refused, e.g. `secrets.create`. */
+    blocked?: string;
+    /** Hard-stop 402: every over-limit dimension, in server order. */
+    resources?: PlanGateResourceUsage[];
+    /** Hard-stop 402: how far back each over resource must come, keyed by resource. */
+    fixOptions?: Record<string, number>;
+    /** Hard-stop 402: the free-month offer, present only when it stands. */
+    freeMonth?: PlanLimitFreeMonth;
 }
+/** One renderer for server-selected upgrade links across CLI plan refusals. */
+export declare function formatUpgradeRefusal(reason: string, upgradeUrl: string | undefined, options?: {
+    urlOnly?: boolean;
+}): string;
+/** Recover a company UID only from the server's UID-keyed billing callback. */
+export declare function companyUidFromPlanUpgradeUrl(value: unknown): string | undefined;
 export declare class PlanGateError extends Error {
     readonly code: PlanGateCode;
     readonly details: PlanGateDetails;
     constructor(code: PlanGateCode, details: PlanGateDetails);
 }
 export declare function isPlanGateError(err: unknown): err is PlanGateError;
-export declare function formatPlanGateError(err: PlanGateError): string;
+/** Plain, stable CLI copy for plan-gated resource creation. */
+export declare function formatPlanGateError(err: PlanGateError, options?: {
+    urlOnly?: boolean;
+}): string;
 export declare function canOfferTeamUpgrade(argv?: readonly string[]): boolean;
-/** Ask once, only on a real interactive terminal. */
+export interface UpgradeLinkOfferDependencies {
+    ask?: (question: string) => Promise<string>;
+    openUrl?: (url: string) => Promise<void>;
+    argv?: readonly string[];
+    interactive?: boolean;
+}
+/** Ask before opening the exact URL returned by the server. */
+export declare function offerUpgradeLink(url: string, deps?: UpgradeLinkOfferDependencies): Promise<boolean>;
+/** Legacy checkout callback retained for callers outside the shared refusal paths. */
 export declare function offerTeamUpgrade(onConfirm: () => Promise<void>, deps?: {
     ask?: (question: string) => Promise<string>;
     argv?: readonly string[];
@@ -29,7 +62,16 @@ export declare function offerTeamUpgrade(onConfirm: () => Promise<void>, deps?:
 /** Decode an already-read JSON envelope from either shared HTTP client. */
 export declare function planGateErrorFromPayload(status: number, body: unknown, companyUid?: string): PlanGateError | null;
 /**
- * Decode only the two deliberate plan-gate envelopes. Malformed, unrelated,
+ * Recognise a plan-limit refusal carried by an `@indigoai-us/hq-cloud`
+ * `VaultClientError` (sync, share, skill upload). Duck-typed so hq-cli keeps
+ * working across hq-cloud releases: the error exposes `statusCode`, `code`,
+ * `upgradeUrl` and the raw response `body`. The raw body is decoded first so
+ * the server's message, fix options and free month survive; a bare code (a
+ * personal presign row has no body) still becomes a refusal with its link.
+ */
+export declare function planGateErrorFromVaultError(err: unknown): PlanGateError | null;
+/**
+ * Decode the supported plan-gate envelopes. Malformed, unrelated,
  * or non-402 responses retain their existing command-specific handling.
  */
 export declare function planGateErrorFromResponse(response: Response, companyUid?: string): Promise<{