@indigoai-us/hq-cli 5.108.24 → 5.108.26

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

@@ -0,0 +1,193 @@
+/**
+ * Direct-emit client: POST /v1/mesh/events (owner decision 2026-09-08).
+ *
+ * Hooks post each Work Mesh event straight to the server over HTTPS with the
+ * caller's normal HQ bearer token (person login or fleet agent token). The
+ * server persists, attributes (server-side), and fans out over MQTT. There is
+ * no local spool, held queue, or per-person STS vend on the emit path.
+ *
+ * Field names for the endpoint + per-event status vocabulary follow
+ * companies/indigo/projects/work-mesh-live/contracts/direct-emit-v1.md; this
+ * client tolerates minor shape drift (unknown keys ignored) and treats an
+ * unparseable 2xx as "retain and retry" rather than pretend-posted.
+ */
+import { vaultApiFetch } from "../../../utils/vault-api.js";
+import { DEFAULT_VAULT_API_URL } from "../../../utils/cognito-session.js";
+export const MESH_EVENTS_PATH = "/v1/mesh/events";
+/** Max events per POST (server batches; keep parity with legacy 100). */
+export const MESH_EVENTS_BATCH_MAX = 100;
+export function classifyEmitResponse(status, networkError = false) {
+    if (networkError || status === 0) {
+        return { ok: false, retryable: true, networkError: true };
+    }
+    if (status >= 200 && status < 300)
+        return { ok: true, retryable: false };
+    // 404/408/425/429 + 5xx are transient (route not yet deployed, throttle,
+    // server fault) — RETAIN and retry, never drop. A 404 here matters: replaying
+    // the legacy backlog before the server route ships must not discard events.
+    if (status === 404 ||
+        status === 408 ||
+        status === 425 ||
+        status === 429 ||
+        status >= 500) {
+        return { ok: false, retryable: true };
+    }
+    // Real client/auth errors (400/401/403/413) → terminal (never retried).
+    return { ok: false, retryable: false };
+}
+/**
+ * Parse the batch response into per-event statuses. Returns null when the body
+ * is not an object (caller should retain events rather than treat as posted).
+ * Accepts either { results: [{eventId,status,code}] } or
+ * { accepted:[ids], unassigned:[ids], rejected:[{eventId,code}] }.
+ */
+export function parseEmitResults(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return null;
+    const rec = body;
+    if (Array.isArray(rec.results)) {
+        const out = [];
+        for (const row of rec.results) {
+            if (!row || typeof row !== "object" || Array.isArray(row))
+                continue;
+            const r = row;
+            const eventId = typeof r.eventId === "string" ? r.eventId.trim() : "";
+            if (!eventId)
+                continue;
+            const status = normalizeStatus(r.status);
+            if (!status)
+                continue;
+            const res = { eventId, status };
+            if (typeof r.reason === "string" && r.reason.trim())
+                res.reason = r.reason.trim();
+            else if (typeof r.code === "string" && r.code.trim())
+                res.reason = r.code.trim();
+            if (typeof r.companyUid === "string" && r.companyUid.trim()) {
+                res.companyUid = r.companyUid.trim();
+            }
+            out.push(res);
+        }
+        return out;
+    }
+    // Fallback shape: parallel arrays.
+    const out = [];
+    for (const id of asStringArray(rec.accepted))
+        out.push({ eventId: id, status: "accepted" });
+    for (const id of asStringArray(rec.unassigned))
+        out.push({ eventId: id, status: "unassigned" });
+    if (Array.isArray(rec.rejected)) {
+        for (const row of rec.rejected) {
+            if (typeof row === "string" && row.trim()) {
+                out.push({ eventId: row.trim(), status: "rejected" });
+            }
+            else if (row && typeof row === "object" && !Array.isArray(row)) {
+                const r = row;
+                const eventId = typeof r.eventId === "string" ? r.eventId.trim() : "";
+                if (!eventId)
+                    continue;
+                const res = { eventId, status: "rejected" };
+                if (typeof r.reason === "string" && r.reason.trim())
+                    res.reason = r.reason.trim();
+                else if (typeof r.code === "string" && r.code.trim())
+                    res.reason = r.code.trim();
+                out.push(res);
+            }
+        }
+    }
+    return out.length > 0 ? out : null;
+}
+function normalizeStatus(v) {
+    if (typeof v !== "string")
+        return null;
+    const s = v.trim().toLowerCase();
+    if (s === "accepted" || s === "unassigned" || s === "rejected")
+        return s;
+    return null;
+}
+function asStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === "string" && x.trim().length > 0).map((x) => x.trim());
+}
+/**
+ * Build a poster that uses vaultApiFetch + the caller's bearer token.
+ * `post` override is for tests (never hits the network).
+ */
+export function createEmitPoster(opts) {
+    return async (events) => {
+        const body = { events };
+        try {
+            if (opts.post) {
+                const res = await opts.post(MESH_EVENTS_PATH, body);
+                return { status: res.status, body: res.body, ...classifyEmitResponse(res.status) };
+            }
+            const res = await vaultApiFetch({
+                method: "POST",
+                path: MESH_EVENTS_PATH,
+                token: opts.token,
+                baseUrl: opts.baseUrl ?? DEFAULT_VAULT_API_URL,
+                body: body,
+            });
+            const text = await res.text();
+            let parsed = {};
+            if (text) {
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    parsed = { raw: text };
+                }
+            }
+            return { status: res.status, body: parsed, ...classifyEmitResponse(res.status) };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // Auth hard-fail: 401/403 is not retryable (bad token, not a blip).
+            if (/^401\b|^403\b|unauthorized|forbidden/i.test(message)) {
+                return { status: 401, body: { error: message }, ok: false, retryable: false };
+            }
+            return { status: 0, body: { error: message }, ...classifyEmitResponse(0, true) };
+        }
+    };
+}
+function keep(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+/**
+ * Build a MeshEmitEvent, omitting empty optionals and dropping the evidence
+ * object entirely when it carries nothing. Never includes server-owned fields
+ * (companyUid/actorUid/contextStatus) — those would draw a 403 (contract §2.1).
+ */
+export function buildMeshEmitEvent(input) {
+    const event = {
+        v: 1,
+        eventId: input.eventId,
+        kind: input.kind,
+        sessionId: input.sessionId,
+        harness: input.harness,
+        adapterVersion: input.adapterVersion,
+        at: input.at,
+        seq: input.seq,
+    };
+    const runtimeVersion = keep(input.runtimeVersion);
+    if (runtimeVersion)
+        event.runtimeVersion = runtimeVersion;
+    if (input.source)
+        event.source = input.source;
+    const taskId = keep(input.taskId);
+    if (taskId)
+        event.taskId = taskId;
+    if (input.status)
+        event.status = input.status;
+    const reason = keep(input.reason);
+    if (reason)
+        event.reason = reason;
+    const summary = keep(input.summary);
+    if (summary)
+        event.summary = summary;
+    if (input.evidence && Object.keys(input.evidence).length > 0) {
+        event.evidence = input.evidence;
+    }
+    return event;
+}
+//# sourceMappingURL=emit-client.js.map

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