@indigoai-us/hq-cli 5.108.25 → 5.108.26

package/dist/lib/mesh/live/emit-evidence.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Client-side attribution evidence for direct-emit (owner decision 2026-09-08:
+ * "sessions post directly; server attributes"). The hook gathers raw signals of
+ * the work — cwd, the files a tool touched, the enclosing repo, the session's
+ * bound company_slug, and any reported project/task — and the server decides the
+ * company. The client NEVER decides; it only reports evidence.
+ *
+ * Pure apart from reading the session meta (company_slug) and the enclosing git
+ * work-tree off disk. Never reads prompts/tokens; never hits the network.
+ */
+/** Evidence fields carried on each emitted event (contract direct-emit-v1). */
+export interface EmitEvidence {
+    cwd?: string;
+    hqRoot?: string;
+    /** The session's explicitly bound company (meta company_slug). */
+    companySlug?: string;
+    /** Distinct file paths the session's tool calls touched (absolute). */
+    touchedPaths?: string[];
+    /** Enclosing repo work-tree root of the cwd / touched files. */
+    repoPath?: string;
+    project?: string;
+    task?: string;
+}
+export interface BuildEmitEvidenceInput {
+    sessionId: string;
+    hqRoot?: string;
+    cwd?: string;
+    /** Raw touched paths from the tool payload (file_path, edits, notebook_path…). */
+    touchedPaths?: Array<string | undefined | null>;
+    /** Explicit repo path override (else derived from cwd / touched files). */
+    repoPath?: string;
+    /** Explicit bound company (else read from the session meta). */
+    companySlug?: string;
+    project?: string;
+    task?: string;
+    /** Injectable meta reader (tests). */
+    readMeta?: (sessionId: string, hqRoot: string | undefined) => string | undefined;
+    /** Injectable work-tree finder (tests). */
+    findRepo?: (startDir: string) => string | null;
+}
+/** Dedupe absolute-ish paths, preserving first-seen order. */
+export declare function normalizeTouchedPaths(paths: Array<string | undefined | null>): string[];
+/**
+ * Assemble the evidence bag for one event. companySlug falls back to the session
+ * meta; repoPath falls back to the enclosing git work-tree of the cwd (or the
+ * first touched file). All fields are omitted when empty.
+ */
+export declare function buildEmitEvidence(input: BuildEmitEvidenceInput): EmitEvidence;
+//# sourceMappingURL=emit-evidence.d.ts.map

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

@@ -0,0 +1,77 @@
+/**
+ * Client-side attribution evidence for direct-emit (owner decision 2026-09-08:
+ * "sessions post directly; server attributes"). The hook gathers raw signals of
+ * the work — cwd, the files a tool touched, the enclosing repo, the session's
+ * bound company_slug, and any reported project/task — and the server decides the
+ * company. The client NEVER decides; it only reports evidence.
+ *
+ * Pure apart from reading the session meta (company_slug) and the enclosing git
+ * work-tree off disk. Never reads prompts/tokens; never hits the network.
+ */
+import * as path from "node:path";
+import { readMetaCompanySlug } from "../../work-context/company.js";
+import { findWorkTreeRoot } from "../../work-context/repo-remote.js";
+function clean(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+/** Dedupe absolute-ish paths, preserving first-seen order. */
+export function normalizeTouchedPaths(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const p of paths) {
+        const c = clean(p);
+        if (!c)
+            continue;
+        const abs = path.isAbsolute(c) ? path.normalize(c) : c;
+        if (seen.has(abs))
+            continue;
+        seen.add(abs);
+        out.push(abs);
+    }
+    return out;
+}
+/**
+ * Assemble the evidence bag for one event. companySlug falls back to the session
+ * meta; repoPath falls back to the enclosing git work-tree of the cwd (or the
+ * first touched file). All fields are omitted when empty.
+ */
+export function buildEmitEvidence(input) {
+    const readMeta = input.readMeta ?? readMetaCompanySlug;
+    const findRepo = input.findRepo ?? findWorkTreeRoot;
+    const cwd = clean(input.cwd);
+    const hqRoot = clean(input.hqRoot);
+    const touchedPaths = normalizeTouchedPaths(input.touchedPaths ?? []);
+    const companySlug = clean(input.companySlug) ?? clean(readMeta(input.sessionId, hqRoot));
+    let repoPath = clean(input.repoPath);
+    if (!repoPath) {
+        // Search from the cwd (a directory) or the directory of the first touched
+        // file for the enclosing git work-tree.
+        const startDir = cwd ?? firstFileDir(touchedPaths);
+        if (startDir)
+            repoPath = clean(findRepo(startDir) ?? undefined);
+    }
+    const evidence = {};
+    if (cwd)
+        evidence.cwd = cwd;
+    if (hqRoot)
+        evidence.hqRoot = hqRoot;
+    if (companySlug)
+        evidence.companySlug = companySlug;
+    if (touchedPaths.length > 0)
+        evidence.touchedPaths = touchedPaths;
+    if (repoPath)
+        evidence.repoPath = repoPath;
+    const project = clean(input.project);
+    if (project)
+        evidence.project = project;
+    const task = clean(input.task);
+    if (task)
+        evidence.task = task;
+    return evidence;
+}
+/** Directory of the first absolute touched file, for work-tree discovery. */
+function firstFileDir(touchedPaths) {
+    const abs = touchedPaths.find((p) => path.isAbsolute(p));
+    return abs ? path.dirname(abs) : undefined;
+}
+//# sourceMappingURL=emit-evidence.js.map

package/dist/lib/mesh/live/emit-replay.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Replay the LEGACY local backlog (spool.jsonl + held.jsonl) through the new
+ * direct-emit endpoint (owner decision 2026-09-08 + contract direct-emit-v1 §6.3
+ * "deprecated, not deleted"). Each legacy line already carries the attribution
+ * evidence the daemon used to hold on (cwd / hqRoot / companySlug / project /
+ * task); we lift those into the `evidence` object the server now attributes
+ * from, and post with the event's original eventId so the server dedupes.
+ *
+ * Read-only over the legacy files — the caller (emitEvents) owns disposition and
+ * the retry file; this module never deletes spool/held (a follow-up removes the
+ * legacy queue once replay is confirmed).
+ */
+import { type MeshEmitEvent } from "./emit-client.js";
+/** Convert one legacy spool/held event object into a MeshEmitEvent, or null. */
+export declare function legacyEventToEmit(raw: Record<string, unknown>): MeshEmitEvent | null;
+export interface LegacyBacklog {
+    events: MeshEmitEvent[];
+    scanned: number;
+    skipped: number;
+}
+/**
+ * Read spool.jsonl + held.jsonl, convert to emit events, dedupe by eventId.
+ * The daemon's held retry may duplicate a spool line; first occurrence wins.
+ */
+export declare function readLegacyBacklog(workMeshRoot: string): LegacyBacklog;
+//# sourceMappingURL=emit-replay.d.ts.map

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

@@ -0,0 +1,157 @@
+/**
+ * Replay the LEGACY local backlog (spool.jsonl + held.jsonl) through the new
+ * direct-emit endpoint (owner decision 2026-09-08 + contract direct-emit-v1 §6.3
+ * "deprecated, not deleted"). Each legacy line already carries the attribution
+ * evidence the daemon used to hold on (cwd / hqRoot / companySlug / project /
+ * task); we lift those into the `evidence` object the server now attributes
+ * from, and post with the event's original eventId so the server dedupes.
+ *
+ * Read-only over the legacy files — the caller (emitEvents) owns disposition and
+ * the retry file; this module never deletes spool/held (a follow-up removes the
+ * legacy queue once replay is confirmed).
+ */
+import * as fs from "node:fs";
+import { workMeshSpoolPath, workMeshHeldPath } from "./paths.js";
+import { buildMeshEmitEvent } from "./emit-client.js";
+const KINDS = new Set([
+    "session_start",
+    "turn_start",
+    "turn_end",
+    "session_end",
+    "task_status",
+    "blocked",
+    "note",
+]);
+const HARNESSES = new Set([
+    "claude-code",
+    "claude-desktop",
+    "codex",
+    "grok",
+    "hq-sessions",
+    "agent-box",
+    "agents-v2",
+]);
+function str(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+/** Peel a held envelope { event, heldReason, heldAt } → the inner event. */
+function innerEvent(obj) {
+    if (obj.event &&
+        typeof obj.event === "object" &&
+        !Array.isArray(obj.event) &&
+        typeof obj.heldReason === "string") {
+        return obj.event;
+    }
+    return obj;
+}
+/** Convert one legacy spool/held event object into a MeshEmitEvent, or null. */
+export function legacyEventToEmit(raw) {
+    const event = innerEvent(raw);
+    const eventId = str(event.eventId);
+    const kind = str(event.kind);
+    const sessionId = str(event.sessionId);
+    const harness = str(event.harness);
+    const adapterVersion = str(event.adapterVersion);
+    const at = str(event.at);
+    const seq = typeof event.seq === "number" ? event.seq : Number(event.seq);
+    if (!eventId ||
+        !kind ||
+        !KINDS.has(kind) ||
+        !sessionId ||
+        !harness ||
+        !HARNESSES.has(harness) ||
+        !adapterVersion ||
+        !at ||
+        !Number.isInteger(seq) ||
+        seq < 1) {
+        return null;
+    }
+    const evidence = {};
+    const cwd = str(event.cwd);
+    if (cwd)
+        evidence.cwd = cwd;
+    const hqRoot = str(event.hqRoot);
+    if (hqRoot)
+        evidence.hqRoot = hqRoot;
+    const companySlug = str(event.companySlug);
+    if (companySlug)
+        evidence.companySlug = companySlug;
+    const project = str(event.project);
+    if (project)
+        evidence.project = project;
+    const task = str(event.task);
+    if (task)
+        evidence.task = task;
+    if (Array.isArray(event.touchedPaths)) {
+        const tp = event.touchedPaths.filter((p) => typeof p === "string" && p.trim().length > 0);
+        if (tp.length > 0)
+            evidence.touchedPaths = tp;
+    }
+    return buildMeshEmitEvent({
+        eventId,
+        kind,
+        sessionId,
+        harness,
+        adapterVersion,
+        at,
+        seq,
+        runtimeVersion: str(event.runtimeVersion),
+        source: event.source === "transcript" ? "transcript" : "hooks",
+        taskId: str(event.taskId),
+        status: str(event.status),
+        reason: str(event.reason),
+        summary: str(event.summary),
+        evidence,
+    });
+}
+function readJsonl(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const v = JSON.parse(t);
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+                out.push(v);
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return out;
+}
+/**
+ * Read spool.jsonl + held.jsonl, convert to emit events, dedupe by eventId.
+ * The daemon's held retry may duplicate a spool line; first occurrence wins.
+ */
+export function readLegacyBacklog(workMeshRoot) {
+    const rows = [
+        ...readJsonl(workMeshSpoolPath(workMeshRoot)),
+        ...readJsonl(workMeshHeldPath(workMeshRoot)),
+    ];
+    const events = [];
+    const seen = new Set();
+    let skipped = 0;
+    for (const row of rows) {
+        const ev = legacyEventToEmit(row);
+        if (!ev) {
+            skipped += 1;
+            continue;
+        }
+        if (seen.has(ev.eventId))
+            continue;
+        seen.add(ev.eventId);
+        events.push(ev);
+    }
+    return { events, scanned: rows.length, skipped };
+}
+//# sourceMappingURL=emit-replay.js.map

package/dist/lib/mesh/live/emit-retry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tiny local retry file for direct-emit (owner decision 2026-09-08). When a
+ * POST /v1/mesh/events fails (network / 5xx / 429), the batch is appended here
+ * and the NEXT `hq mesh emit` invocation drains it. No long-lived process; no
+ * spool/held queue. Bounded so a long offline stretch cannot grow unbounded —
+ * the oldest overflow is dropped with a log (events are best-effort telemetry,
+ * never user data).
+ */
+/** Default cap on retained retry events (oldest dropped past this). */
+export declare const EMIT_RETRY_MAX = 5000;
+export declare function emitRetryPath(workMeshRoot: string): string;
+/** Read pending retry events (parseable objects only). Missing file → []. */
+export declare function readEmitRetry(workMeshRoot: string): Record<string, unknown>[];
+/**
+ * Atomically replace the retry file with `events` (keeping the most recent
+ * EMIT_RETRY_MAX). Returns the number of oldest events dropped by the cap.
+ * Empty input removes the file.
+ */
+export declare function writeEmitRetry(workMeshRoot: string, events: Record<string, unknown>[], max?: number): {
+    written: number;
+    dropped: number;
+};
+/** Count of pending retry events (doctor retryDepth). */
+export declare function emitRetryDepth(workMeshRoot: string): number;
+//# sourceMappingURL=emit-retry.d.ts.map

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

@@ -0,0 +1,79 @@
+/**
+ * Tiny local retry file for direct-emit (owner decision 2026-09-08). When a
+ * POST /v1/mesh/events fails (network / 5xx / 429), the batch is appended here
+ * and the NEXT `hq mesh emit` invocation drains it. No long-lived process; no
+ * spool/held queue. Bounded so a long offline stretch cannot grow unbounded —
+ * the oldest overflow is dropped with a log (events are best-effort telemetry,
+ * never user data).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** Default cap on retained retry events (oldest dropped past this). */
+export const EMIT_RETRY_MAX = 5000;
+export function emitRetryPath(workMeshRoot) {
+    return path.join(workMeshRoot, "emit-retry.jsonl");
+}
+function ensureFileDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+}
+/** Read pending retry events (parseable objects only). Missing file → []. */
+export function readEmitRetry(workMeshRoot) {
+    const p = emitRetryPath(workMeshRoot);
+    let raw;
+    try {
+        raw = fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const v = JSON.parse(t);
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+                out.push(v);
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    return out;
+}
+/**
+ * Atomically replace the retry file with `events` (keeping the most recent
+ * EMIT_RETRY_MAX). Returns the number of oldest events dropped by the cap.
+ * Empty input removes the file.
+ */
+export function writeEmitRetry(workMeshRoot, events, max = EMIT_RETRY_MAX) {
+    const p = emitRetryPath(workMeshRoot);
+    let dropped = 0;
+    let keep = events;
+    if (max > 0 && events.length > max) {
+        dropped = events.length - max;
+        keep = events.slice(events.length - max);
+    }
+    if (keep.length === 0) {
+        try {
+            fs.rmSync(p, { force: true });
+        }
+        catch {
+            /* best-effort */
+        }
+        return { written: 0, dropped };
+    }
+    ensureFileDir(p);
+    const body = keep.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, body, { mode: 0o600 });
+    fs.renameSync(tmp, p);
+    return { written: keep.length, dropped };
+}
+/** Count of pending retry events (doctor retryDepth). */
+export function emitRetryDepth(workMeshRoot) {
+    return readEmitRetry(workMeshRoot).length;
+}
+//# sourceMappingURL=emit-retry.js.map

package/dist/lib/mesh/live/emit.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 { type EmitPoster, type EmitEventStatus } from "./emit-client.js";
+import { type RandomFn, type SleepFn } from "./backoff.js";
+export interface EmitStateFile {
+    lastPostAt?: string;
+    lastAttemptAt?: string;
+    lastAccepted?: number;
+    lastUnassigned?: number;
+    lastRejected?: number;
+    lastRetryDepth?: number;
+    lastError?: string;
+}
+export declare function emitStatePath(workMeshRoot: string): string;
+export declare function readEmitState(workMeshRoot: string): EmitStateFile | null;
+export interface EmitEventsDeps {
+    workMeshRoot: string;
+    poster: EmitPoster;
+    /** New events to emit this invocation (may be empty — just drain retry). */
+    newEvents?: Record<string, unknown>[];
+    /** Attempts per batch (short: default 3). */
+    maxAttempts?: number;
+    retryMax?: number;
+    now?: () => Date;
+    sleep?: SleepFn;
+    random?: RandomFn;
+    log?: (message: string) => void;
+}
+export interface EmitEventsSummary {
+    attempted: number;
+    accepted: number;
+    unassigned: number;
+    rejected: number;
+    /** Events kept in the retry file for a later invocation. */
+    retained: number;
+    /** Oldest events dropped by the retry cap. */
+    droppedOverflow: number;
+    retryDepth: number;
+    batches: number;
+    statuses: Record<EmitEventStatus, number>;
+    lastPostAt?: string;
+}
+/** Drain the retry file, post pending + new events, persist failures. */
+export declare function emitEvents(deps: EmitEventsDeps): Promise<EmitEventsSummary>;
+//# sourceMappingURL=emit.d.ts.map

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;
 /**