@indigoai-us/hq-cli 5.108.24 → 5.108.26

package/dist/lib/mesh/live/emit.js

@@ -0,0 +1,153 @@
+/**
+ * Direct-emit orchestration (owner decision 2026-09-08). One invocation:
+ *   1. drains the local retry file (prior failures),
+ *   2. appends the new event(s),
+ *   3. POSTs /v1/mesh/events in batches with a short bounded retry,
+ *   4. keeps only network/5xx/429-failed or unaccounted events for next time,
+ *   5. records lastPostAt + per-event status counts for `hq mesh doctor`.
+ *
+ * accepted / unassigned / rejected are all terminal (rejected is dropped with a
+ * count — never re-posted). No long-lived process, spool, or held queue.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { MESH_EVENTS_BATCH_MAX, parseEmitResults, } from "./emit-client.js";
+import { EMIT_RETRY_MAX, readEmitRetry, writeEmitRetry, } from "./emit-retry.js";
+import { defaultSleep, fullJitterDelayMs, } from "./backoff.js";
+export function emitStatePath(workMeshRoot) {
+    return path.join(workMeshRoot, "emit-state.json");
+}
+export function readEmitState(workMeshRoot) {
+    try {
+        const raw = fs.readFileSync(emitStatePath(workMeshRoot), "utf8");
+        const v = JSON.parse(raw);
+        if (v && typeof v === "object" && !Array.isArray(v))
+            return v;
+    }
+    catch {
+        /* absent / malformed */
+    }
+    return null;
+}
+function writeEmitState(workMeshRoot, state) {
+    const p = emitStatePath(workMeshRoot);
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+        const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
+        fs.renameSync(tmp, p);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function eventIdOf(e) {
+    return typeof e.eventId === "string" && e.eventId.trim() ? e.eventId.trim() : null;
+}
+/** Drain the retry file, post pending + new events, persist failures. */
+export async function emitEvents(deps) {
+    const now = deps.now ?? (() => new Date());
+    const sleep = deps.sleep ?? defaultSleep;
+    const random = deps.random ?? Math.random;
+    const maxAttempts = deps.maxAttempts ?? 3;
+    const retryMax = deps.retryMax ?? EMIT_RETRY_MAX;
+    // Combine pending retry + new events, deduped by eventId (first wins).
+    const pending = readEmitRetry(deps.workMeshRoot);
+    const combined = [];
+    const seen = new Set();
+    for (const e of [...pending, ...(deps.newEvents ?? [])]) {
+        const id = eventIdOf(e);
+        if (id) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+        }
+        combined.push(e);
+    }
+    const summary = {
+        attempted: combined.length,
+        accepted: 0,
+        unassigned: 0,
+        rejected: 0,
+        retained: 0,
+        droppedOverflow: 0,
+        retryDepth: 0,
+        batches: 0,
+        statuses: { accepted: 0, unassigned: 0, rejected: 0 },
+    };
+    const keep = [];
+    let anyPosted = false;
+    for (let i = 0; i < combined.length; i += MESH_EVENTS_BATCH_MAX) {
+        const chunk = combined.slice(i, i + MESH_EVENTS_BATCH_MAX);
+        summary.batches += 1;
+        let result = await deps.poster(chunk);
+        for (let attempt = 1; attempt < maxAttempts && !result.ok && result.retryable; attempt += 1) {
+            await sleep(fullJitterDelayMs(attempt - 1, { random }));
+            result = await deps.poster(chunk);
+        }
+        if (!result.ok) {
+            if (result.retryable) {
+                // Network/5xx/429 after retries → keep the whole chunk for next time.
+                keep.push(...chunk);
+                deps.log?.(`emit batch retained (${chunk.length}) status=${result.status}`);
+            }
+            else {
+                // Non-retryable 4xx (e.g. 401/400) → drop with a log (never user data).
+                summary.rejected += chunk.length;
+                summary.statuses.rejected += chunk.length;
+                deps.log?.(`emit batch dropped (${chunk.length}) non-retryable status=${result.status}`);
+            }
+            continue;
+        }
+        anyPosted = true;
+        const results = parseEmitResults(result.body);
+        if (!results) {
+            // Unparseable 2xx → retain rather than pretend posted.
+            keep.push(...chunk);
+            deps.log?.(`emit batch retained (${chunk.length}) unparseable 2xx`);
+            continue;
+        }
+        const byId = new Map(results.map((r) => [r.eventId, r]));
+        for (const e of chunk) {
+            const id = eventIdOf(e);
+            const r = id ? byId.get(id) : undefined;
+            if (!r) {
+                // Unaccounted event in a 2xx → retain (don't lose it).
+                keep.push(e);
+                continue;
+            }
+            summary.statuses[r.status] += 1;
+            if (r.status === "accepted")
+                summary.accepted += 1;
+            else if (r.status === "unassigned")
+                summary.unassigned += 1;
+            else
+                summary.rejected += 1;
+        }
+    }
+    const written = writeEmitRetry(deps.workMeshRoot, keep, retryMax);
+    summary.retained = written.written;
+    summary.droppedOverflow = written.dropped;
+    summary.retryDepth = written.written;
+    const nowIso = now().toISOString();
+    const prior = readEmitState(deps.workMeshRoot) ?? {};
+    const nextState = {
+        ...prior,
+        lastAttemptAt: nowIso,
+        lastAccepted: summary.accepted,
+        lastUnassigned: summary.unassigned,
+        lastRejected: summary.rejected,
+        lastRetryDepth: summary.retryDepth,
+    };
+    if (anyPosted) {
+        nextState.lastPostAt = nowIso;
+        summary.lastPostAt = nowIso;
+        delete nextState.lastError;
+    }
+    else if (combined.length > 0) {
+        nextState.lastError = "emit failed (network/server); retained for retry";
+    }
+    writeEmitState(deps.workMeshRoot, nextState);
+    return summary;
+}
+//# sourceMappingURL=emit.js.map

package/dist/lib/narrow-hint-banner.d.ts

@@ -22,7 +22,6 @@
  *   - the env var `HQ_SYNC_NARROW_HINT=off` is set,
  *   - the per-hqRoot CLI config (`<hqRoot>/.hq/config.json`) has
  *     `syncNarrowHint: 'off'`,
- *   - the synced flag registry disables `sync.narrow-hint`,
  *   - or the same `{companyUid, level}` pair has already been shown this
  *     process (module-singleton dedupe; the runner imports the same module
  *     once per `hq` invocation so a single invocation prints at most one
@@ -47,7 +46,6 @@
  * `syncNarrowHintMinBytes` — see `resolveNarrowHintMinBytes`.
  */
 import * as fs from "node:fs";
-import { type FlagReader } from "./flag-registry.js";
 export type BannerLevel = "hint" | "warning" | "strict";
 /**
  * Default size gate for the narrow-mode nudge: 5 GiB. A local company folder
@@ -87,8 +85,6 @@ export interface ShouldShowBannerOpts {
     readFile?: (p: string) => string;
     /** Test seam: override `fs.existsSync`. */
     existsFile?: (p: string) => boolean;
-    /** Test seam: held registry snapshot reader. */
-    flagReader?: FlagReader;
 }
 /**
  * Decides whether a banner should be printed AT ALL — independent of
@@ -154,12 +150,12 @@ export declare function companyFolderExceedsThreshold(companyDir: string, thresh
  * `companyFolderExceedsThreshold`). A strict-level all-mode membership whose
  * folder is under the threshold is never refused.
  */
-export declare function isStrictRefusal(syncMode: BannerInput["syncMode"], level: BannerLevel, flagReader?: FlagReader): boolean;
+export declare function isStrictRefusal(syncMode: BannerInput["syncMode"], level: BannerLevel): boolean;
 /**
  * Keep the rendered banner honest about the decision that this invocation
  * actually made. Hint and warning remain local presentation choices. `strict`
- * is reserved for a real refusal, so a registry opt-out of an old strict level
- * degrades to the local warning presentation instead of claiming a block.
+ * is reserved for a real refusal, so a strict level that did NOT produce a
+ * refusal degrades to the local warning presentation instead of claiming a block.
  */
 export declare function resolveNarrowHintPresentationLevel(level: BannerLevel, strictRefusal: boolean): BannerLevel;
 /**

package/dist/lib/narrow-hint-banner.js

@@ -22,7 +22,6 @@
  *   - the env var `HQ_SYNC_NARROW_HINT=off` is set,
  *   - the per-hqRoot CLI config (`<hqRoot>/.hq/config.json`) has
  *     `syncNarrowHint: 'off'`,
- *   - the synced flag registry disables `sync.narrow-hint`,
  *   - or the same `{companyUid, level}` pair has already been shown this
  *     process (module-singleton dedupe; the runner imports the same module
  *     once per `hq` invocation so a single invocation prints at most one
@@ -49,7 +48,6 @@
 import chalk from "chalk";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveFlagGate, resolveProcessFlagGate, } from "./flag-registry.js";
 /**
  * Default size gate for the narrow-mode nudge: 5 GiB. A local company folder
  * smaller than this is cheap to keep in full, so all-mode is left alone and no
@@ -101,21 +99,11 @@ export function shouldShowBanner(opts = {}) {
             }
         }
     }
-    const lookup = {
-        globalEnvVar: "HQ_SYNC_NARROW_HINT",
-        globalValueSemantics: {
-            onValues: [],
-            offValues: ["off"],
-            unrecognizedValue: true,
-            unsetValue: true,
-            // Deliberately no `trim`: the legacy parser only case-folds.
-            caseInsensitive: true,
-        },
-        fallback: true,
-    };
-    return opts.flagReader
-        ? resolveFlagGate(opts.flagReader, "sync.narrow-hint", lookup, () => true)
-        : resolveProcessFlagGate("sync.narrow-hint", lookup, () => true);
+    // The env var (`HQ_SYNC_NARROW_HINT=off`, evaluated above) and the
+    // `.hq/config.json` off-switch are the ONLY ways to suppress the banner. This
+    // is a personal preference, not a rollout flag, so nothing else gates it:
+    // reaching here means neither off-switch fired, so the banner shows.
+    return true;
 }
 /**
  * Resolve the banner level from environment overrides. Defaults to
@@ -246,29 +234,20 @@ export function companyFolderExceedsThreshold(companyDir, thresholdBytes, deps =
  * `companyFolderExceedsThreshold`). A strict-level all-mode membership whose
  * folder is under the threshold is never refused.
  */
-export function isStrictRefusal(syncMode, level, flagReader) {
+export function isStrictRefusal(syncMode, level) {
     if (syncMode !== "all")
         return false;
-    const lookup = {
-        globalEnvVar: "HQ_SYNC_NARROW_HINT_LEVEL",
-        globalValueSemantics: {
-            onValues: ["strict"],
-            offValues: ["hint", "warning"],
-            unrecognizedValue: false,
-            unsetValue: false,
-            caseInsensitive: true,
-        },
-        fallback: level === "strict",
-    };
-    return flagReader
-        ? resolveFlagGate(flagReader, "sync.narrow-hint-strict", lookup, () => level === "strict")
-        : resolveProcessFlagGate("sync.narrow-hint-strict", lookup, () => level === "strict");
+    // The refusal is driven purely by the caller's `level`, which is itself
+    // resolved from the operator's own `HQ_SYNC_NARROW_HINT_LEVEL` (see
+    // `resolveBannerLevel`). This is a personal escalation choice, not a rollout
+    // flag, so no registry can independently force or clear the strict refusal.
+    return level === "strict";
 }
 /**
  * Keep the rendered banner honest about the decision that this invocation
  * actually made. Hint and warning remain local presentation choices. `strict`
- * is reserved for a real refusal, so a registry opt-out of an old strict level
- * degrades to the local warning presentation instead of claiming a block.
+ * is reserved for a real refusal, so a strict level that did NOT produce a
+ * refusal degrades to the local warning presentation instead of claiming a block.
  */
 export function resolveNarrowHintPresentationLevel(level, strictRefusal) {
     if (strictRefusal)

package/dist/lib/plan-limit-nag.d.ts

@@ -15,7 +15,6 @@
  * Additive only — never throws, never touches `process.exitCode`, never
  * writes to stdout. Env off-switch: `HQ_NO_PLAN_LIMIT_NAG=1`.
  */
-import { type FlagReader } from "./flag-registry.js";
 export declare const PLAN_LIMIT_UPGRADE_URL = "https://app.indigo-hq.com/billing/upgrade";
 export interface PlanLimitEntry {
     used: number;
@@ -40,8 +39,6 @@ export declare function emitPlanLimitNag(opts?: {
     write?: (s: string) => void;
     now?: () => Date;
     statePath?: string;
-    /** Test seam: held registry snapshot reader. */
-    flagReader?: FlagReader;
 }): void;
 /** Test-only helper — clears last-seen status and session dedupe flags. */
 export declare function _resetForTests(): void;

package/dist/lib/plan-limit-nag.js

@@ -19,7 +19,6 @@ import chalk from "chalk";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { resolveFlagGate, resolveProcessFlagGate, } from "./flag-registry.js";
 export const PLAN_LIMIT_UPGRADE_URL = "https://app.indigo-hq.com/billing/upgrade";
 const DAY_MS = 24 * 60 * 60 * 1000;
 /** Module-level last-seen cell — overwritten by each successful parse. */
@@ -31,24 +30,15 @@ let overShownThisSession = false;
 function defaultStatePath() {
     return path.join(os.homedir(), ".hq", "plan-limit-nag.json");
 }
-function isOptedOut() {
-    return process.env.HQ_NO_PLAN_LIMIT_NAG === "1";
-}
-function isPlanLimitNagEnabled(flagReader) {
-    const lookup = {
-        globalEnvVar: "HQ_NO_PLAN_LIMIT_NAG",
-        globalValueSemantics: {
-            onValues: [],
-            offValues: ["1"],
-            unrecognizedValue: true,
-            unsetValue: true,
-        },
-        fallback: true,
-    };
-    const legacyFallback = () => !isOptedOut();
-    return flagReader
-        ? resolveFlagGate(flagReader, "cli.plan-limit-nag", lookup, legacyFallback)
-        : resolveProcessFlagGate("cli.plan-limit-nag", lookup, legacyFallback);
+function isPlanLimitNagEnabled() {
+    // Personal opt-out only: `HQ_NO_PLAN_LIMIT_NAG=1` silences the nag on THIS
+    // machine. This is a user preference, not a rollout flag, so it is read
+    // straight from the environment — no registry lookup, so no future
+    // registration can revoke the opt-out. The value match is asymmetric on
+    // purpose: ONLY the exact value "1" turns the nag off; unset and every other
+    // value (including "0" and "false") keep it on. Do not "tidy" this into a
+    // boolean parse — that would silently silence anyone who wrote "false".
+    return process.env.HQ_NO_PLAN_LIMIT_NAG !== "1";
 }
 /**
  * Defensively parse a single planLimits entry. Returns null if the shape is
@@ -181,7 +171,7 @@ function buildOverBox(overEntries) {
  */
 export function emitPlanLimitNag(opts = {}) {
     try {
-        if (!isPlanLimitNagEnabled(opts.flagReader))
+        if (!isPlanLimitNagEnabled())
             return;
         if (lastSeen === null)
             return;

package/package.json

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