@indigoai-us/hq-cli 5.312.0 → 5.312.1

package/dist/main.d.ts

@@ -12,6 +12,25 @@ import { upgradeToTeam } from "./utils/team-upgrade.js";
  * finalization; command execution itself does not consume this allowance.
  */
 export declare const FOREGROUND_NETWORK_BUDGET_MS = 1500;
+/**
+ * Shared accounting for awaited foreground network work. Each lifecycle phase
+ * debits only the bounded await it performs; ordinary command runtime leaves
+ * the allowance untouched. Earlier phases reserve the finalization floor, so
+ * error flushing cannot disappear after a long command.
+ */
+declare class ForegroundNetworkBudget {
+    private readonly budgetMs;
+    private readonly now;
+    private consumedMs;
+    constructor(budgetMs?: number, now?: () => number);
+    timeoutFor(phaseMaximumMs: number, reservedMs?: number): number;
+    waitFor<T>(phaseMaximumMs: number, reservedMs: number, work: (timeoutMs: number) => Promise<T>): Promise<T | undefined>;
+}
+/** Create a shared invocation budget; exported so the time accounting is directly testable. */
+export declare function createForegroundNetworkBudget(options?: {
+    budgetMs?: number;
+    now?: () => number;
+}): ForegroundNetworkBudget;
 export type StreamErrorDependencies = {
     stderr: Pick<typeof process.stderr, "write">;
     exit: (code: number) => void;
@@ -30,4 +49,5 @@ export type TopLevelErrorDependencies = {
 };
 /** Classify a top-level failure without making the CLI process boundary opaque to tests. */
 export declare function handleTopLevelError(err: unknown, deps?: TopLevelErrorDependencies): Promise<void>;
+export {};
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -108,6 +108,13 @@ class ForegroundNetworkBudget {
         }
     }
 }
+/** Create a shared invocation budget; exported so the time accounting is directly testable. */
+export function createForegroundNetworkBudget(options = {}) {
+    if (options.budgetMs === undefined && options.now === undefined) {
+        return new ForegroundNetworkBudget();
+    }
+    return new ForegroundNetworkBudget(options.budgetMs ?? FOREGROUND_NETWORK_BUDGET_MS, options.now ?? (() => performance.now()));
+}
 let activeForegroundNetworkBudget;
 /**
  * The RUNNING install's own entrypoint (`<pkg>/dist/index.js`), used as the
@@ -193,7 +200,7 @@ program.hook("preAction", async () => {
     });
 });
 export async function runCli() {
-    const foregroundNetworkBudget = new ForegroundNetworkBudget();
+    const foregroundNetworkBudget = createForegroundNetworkBudget();
     activeForegroundNetworkBudget = foregroundNetworkBudget;
     // Login must be usable before any identity or company is available, so do
     // not make a pre-auth feature-flag request on this path. Other commands

package/dist/run/discover-schemas.d.ts

@@ -1,4 +1,4 @@
-export interface SchemaConflict {
+interface SchemaConflict {
     paths: [string, string];
     slugs: [string, string];
 }
@@ -9,4 +9,5 @@ export interface DiscoverSchemasResult {
     conflict: SchemaConflict | null;
 }
 export declare function discoverSchemas(cwd: string): DiscoverSchemasResult;
+export {};
 //# sourceMappingURL=discover-schemas.d.ts.map

package/dist/utils/core-eval-trigger.d.ts

@@ -0,0 +1,4 @@
+/** Return shell-compatible 0/1/2: true, false, or malformed. */
+export declare function evaluateTrigger(expr: string, facts?: string): number;
+export declare function checkTriggerExpressions(stdin: string): string;
+//# sourceMappingURL=core-eval-trigger.d.ts.map

package/dist/utils/core-eval-trigger.js

@@ -0,0 +1,88 @@
+/** Pure evaluator shared by the native command and migration helper. */
+function parseBooleanExpression(input) {
+    const expression = input;
+    if (/[^01&|!() \t]/.test(expression))
+        return { valid: false, value: false };
+    let position = 0;
+    let valid = true;
+    const skip = () => { while (expression[position] === " " || expression[position] === "\t")
+        position += 1; };
+    const atom = () => {
+        skip();
+        const char = expression[position];
+        if (char === "(") {
+            position += 1;
+            const value = parseOr();
+            skip();
+            if (expression[position] !== ")") {
+                valid = false;
+                return false;
+            }
+            position += 1;
+            return value;
+        }
+        if (char === "0" || char === "1") {
+            position += 1;
+            return char === "1";
+        }
+        valid = false;
+        return false;
+    };
+    const parseNot = () => {
+        skip();
+        if (expression[position] === "!") {
+            position += 1;
+            return !parseNot();
+        }
+        return atom();
+    };
+    const parseAnd = () => {
+        let value = parseNot();
+        skip();
+        while (valid && expression.slice(position, position + 2) === "&&") {
+            position += 2;
+            const rhs = parseNot();
+            value = value && rhs;
+            skip();
+        }
+        return value;
+    };
+    function parseOr() {
+        let value = parseAnd();
+        skip();
+        while (valid && expression.slice(position, position + 2) === "||") {
+            position += 2;
+            const rhs = parseAnd();
+            value = value || rhs;
+            skip();
+        }
+        return value;
+    }
+    const value = parseOr();
+    skip();
+    return { valid: valid && position === expression.length, value };
+}
+/** Return shell-compatible 0/1/2: true, false, or malformed. */
+export function evaluateTrigger(expr, facts = "") {
+    if (expr.replace(/[ \t]/g, "") === "")
+        return 2;
+    const have = new Set(facts.split(/[ ,]+/).filter(Boolean));
+    const substituted = expr.replace(/[A-Za-z0-9_./][A-Za-z0-9_./-]*/g, (token) => have.has(token.toLowerCase()) ? "1" : "0");
+    if (/[^01&|!() \t]/.test(substituted))
+        return 2;
+    const parsed = parseBooleanExpression(substituted);
+    if (!parsed.valid)
+        return 2;
+    return parsed.value ? 0 : 1;
+}
+export function checkTriggerExpressions(stdin) {
+    if (!stdin)
+        return "";
+    return stdin.split("\n").filter((line, index, all) => index < all.length - 1 || line !== "").map((line) => {
+        const tab = line.indexOf("\t");
+        const id = tab < 0 ? line : line.slice(0, tab);
+        const expr = tab < 0 ? "" : line.slice(tab + 1);
+        return `${id}\t${evaluateTrigger(expr, "") === 2 ? "malformed" : "ok"}\n`;
+    }).join("");
+}
+//# sourceMappingURL=core-eval-trigger.js.map

package/dist/utils/hq-roots.d.ts

@@ -59,8 +59,6 @@ export declare function createPackageRootResolver(options: PackageRootResolverOp
  * answer survives a change in output layout.
  */
 export declare function packageRoot(): string;
-/** Reset the memoized package root. Tests only. */
-export declare function __resetPackageRootCache(): void;
 /**
  * Derive this package's installed root from the running module's OWN path using
  * STRING operations only — no `readFileSync`, `realpathSync`, or `existsSync`.

package/dist/utils/hq-roots.js

@@ -170,7 +170,7 @@ export function createPackageRootResolver(options) {
     };
 }
 const currentModulePath = fileURLToPath(import.meta.url);
-let defaultPackageRootResolver = createPackageRootResolver({
+const defaultPackageRootResolver = createPackageRootResolver({
     moduleDir: path.dirname(currentModulePath),
     modulePath: currentModulePath,
 });
@@ -184,13 +184,6 @@ let defaultPackageRootResolver = createPackageRootResolver({
 export function packageRoot() {
     return defaultPackageRootResolver();
 }
-/** Reset the memoized package root. Tests only. */
-export function __resetPackageRootCache() {
-    defaultPackageRootResolver = createPackageRootResolver({
-        moduleDir: path.dirname(currentModulePath),
-        modulePath: currentModulePath,
-    });
-}
 /**
  * The trailing path segments that mark an installed copy of this package:
  * `node_modules` followed by the package name's own segments (for

package/dist/utils/incomplete-install-error.d.ts

@@ -11,7 +11,7 @@ export declare const INCOMPLETE_INSTALL_REMEDY: string;
 /** A resolver for the running install's root; returns null instead of throwing. */
 export type PackageRootResolver = () => string | null;
 /** Which strategy produced the running install's root, recorded in diagnostics. */
-export type PackageRootResolverSource = "manifest-walk" | "string-derivation" | "unresolved" | "injected";
+type PackageRootResolverSource = "manifest-walk" | "string-derivation" | "unresolved" | "injected";
 /**
  * If `err` is an in-process incomplete-install module-load failure — the CJS
  * relative-sibling shape (HQ-CLI-1N), the ESM vanished-at-read shape (HQ-CLI-1M),
@@ -30,7 +30,7 @@ export declare function incompleteInstallMessage(err: unknown, resolvePackageRoo
  * whose `path` did not survive delivery — the esm-loader open shape (HQ-CLI-1M) or
  * the resolve-time lstat shape (HQ-CLI-1S). The two frame booleans say which.
  */
-export type IncompleteInstallEsmDiagnostics = {
+type IncompleteInstallEsmDiagnostics = {
     /** The resolved install root, or the literal `<unresolved>` when none was found. */
     packageRoot: string;
     /** True only when a root was actually resolved (by any strategy). */
@@ -62,7 +62,7 @@ export type IncompleteInstallEsmDiagnostics = {
  * the closed error name and the bounded package name are recorded; never the
  * message, argv, or a full path.
  */
-export type IncompleteInstallEvalThrowDiagnostics = {
+type IncompleteInstallEvalThrowDiagnostics = {
     evalThrow: true;
     errorName: string;
     throwSitePackage: string;
@@ -77,13 +77,13 @@ export type IncompleteInstallEvalThrowDiagnostics = {
  * the requirer's own manifest did NOT declare it. Both names live inside
  * hq-cli's dependency graph, so grouping cardinality stays bounded.
  */
-export type IncompleteInstallBareDiagnostics = {
+type IncompleteInstallBareDiagnostics = {
     missingPackage: string;
     requiringPackage: string;
     requirerDeclaresMissing: false;
 };
 /** The four lexical scopes a NOT-suppressed CJS relative requirer can fall into. */
-export type RelativeRequirerScope = "dist" | "assets" | "outside-root" | "unresolved-root";
+type RelativeRequirerScope = "dist" | "assets" | "outside-root" | "unresolved-root";
 /**
  * Bounded, scrubber-safe diagnostics for a NOT-suppressed CJS RELATIVE-specifier
  * miss (HQ-CLI-1N): the CJS relative-sibling shape that reached the capture path
@@ -93,7 +93,7 @@ export type RelativeRequirerScope = "dist" | "assets" | "outside-root" | "unreso
  * against the root — never the requirer path and never the specifier — so
  * grouping cardinality cannot inflate. `code` is always `MODULE_NOT_FOUND`.
  */
-export type IncompleteInstallRelativeDiagnostics = {
+type IncompleteInstallRelativeDiagnostics = {
     code: string;
     relativeSpecifier: true;
     packageRoot: string;
@@ -136,4 +136,5 @@ export type IncompleteInstallDiagnostics = Partial<IncompleteInstallEsmDiagnosti
 export declare function incompleteInstallCaptureContext(err: unknown, resolvePackageRoot?: PackageRootResolver, fileSystem?: Pick<typeof fs, "existsSync"> & Partial<Pick<typeof fs, "readFileSync">>): {
     incomplete_install: IncompleteInstallDiagnostics;
 } | undefined;
+export {};
 //# sourceMappingURL=incomplete-install-error.d.ts.map

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/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/self-update.d.ts

@@ -64,7 +64,7 @@ import { type RestartDaemonResult } from "../lib/mesh/live/daemon/install.js";
  * One update + one re-exec per user invocation, ever.
  */
 export declare const REEXEC_GUARD_ENV = "HQ_RESCUE_SELF_UPDATED";
-export type SelfUpdateAction = 
+type SelfUpdateAction = 
 /** Opted out, guard set, lock held elsewhere, or latest unknown — nothing attempted. */
 "skipped"
 /** Already at (or ahead of) npm latest. */
@@ -200,4 +200,5 @@ export declare function selfUpdateAndReexec(argv: readonly string[], deps?: Self
  * outcome the daemon restarts itself onto the new version.
  */
 export declare function daemonSelfUpdate(deps?: SelfUpdateDeps): Promise<SelfUpdateOutcome>;
+export {};
 //# sourceMappingURL=self-update.d.ts.map

package/package.json

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