@indigoai-us/hq-cli 5.108.25 → 5.108.26

package/dist/lib/mesh/live/daemon/doctor.js

@@ -10,6 +10,8 @@ import { workContextRoot } from "../../../work-context/paths.js";
 import { countJsonlLines, } from "../spool.js";
 import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../paths.js";
 import { daemonDir, daemonPidPath } from "./paths.js";
+import { readEmitState } from "../emit.js";
+import { emitRetryDepth } from "../emit-retry.js";
 import { pidLockStatus, readPidLock } from "./pid-lock.js";
 import { readDaemonState } from "./state.js";
 export const UNHEALTHY_SPOOL_AGE_MS = 60_000;
@@ -79,10 +81,13 @@ export function collectDaemonDoctor(deps = {}) {
     const outbox = outboxStats(ctxRoot);
     const mqttState = state?.mqttState ?? (running ? "unknown" : "closed");
     const companiesOnline = state?.companiesOnline ?? [];
+    const emitMode = state?.emitMode ?? "legacy";
+    const subscribed = mqttState === "connected";
     const oldestSpoolAgeMs = oldestJsonlAgeMs(spoolPath, now());
     const unhealthyReasons = [];
     const online = mqttState === "connected" && companiesOnline.length > 0;
-    if (online &&
+    if (emitMode === "legacy" &&
+        online &&
         spoolDepth > 0 &&
         oldestSpoolAgeMs !== undefined &&
         oldestSpoolAgeMs > UNHEALTHY_SPOOL_AGE_MS) {
@@ -96,6 +101,11 @@ export function collectDaemonDoctor(deps = {}) {
         unhealthyReasons.push(`presence credential refused (${presenceRefusal.code}); next retry ${presenceRefusal.nextRetryAt}`);
     }
     const auth = describeCognitoTokenSource({ home, env });
+    const emitState = readEmitState(meshRoot);
+    const emitRetry = emitRetryDepth(meshRoot);
+    if (emitRetry > 0) {
+        unhealthyReasons.push(`direct-emit retry depth=${emitRetry}`);
+    }
     return {
         running,
         pid: running ? record?.pid : undefined,
@@ -113,23 +123,44 @@ export function collectDaemonDoctor(deps = {}) {
         tokenSource: auth.tokenSource,
         actorKind: auth.actorKind,
         presenceRefusal,
+        emitMode,
+        subscribed,
+        emitRetryDepth: emitRetry,
+        lastPostAt: emitState?.lastPostAt,
+        lastEmit: emitState
+            ? {
+                accepted: emitState.lastAccepted,
+                unassigned: emitState.lastUnassigned,
+                rejected: emitState.lastRejected,
+                error: emitState.lastError,
+            }
+            : undefined,
     };
 }
 export function formatDaemonDoctor(report) {
     const lines = [
         `daemon: ${report.running ? `running pid=${report.pid}` : "not running"}`,
+        `mode: ${report.emitMode}`,
         `mqtt: ${report.mqttState}`,
+        `subscription: ${report.subscribed ? "connected" : "disconnected"}`,
         `companies online: ${report.companiesOnline.length ? report.companiesOnline.join(", ") : "(none)"}`,
-        `spool depth: ${report.spoolDepth}`,
-        `held: ${report.heldCount}`,
-        `dead-letter: ${report.deadLetterCount}`,
-        `outbox depth: ${report.outboxDepth}`,
-        `token source: ${report.tokenSource}`,
-        `actor kind: ${report.actorKind}`,
-        `last flush: ${report.lastFlushAt ?? "(never)"}${report.lastFlushResult
-            ? ` ok=${report.lastFlushResult.ok} posted=${report.lastFlushResult.posted}`
-            : ""}`,
     ];
+    if (report.emitMode === "legacy") {
+        // Legacy emit path only: the spool/held/outbox queues do not exist in
+        // receive-only (direct) mode.
+        lines.push(`spool depth: ${report.spoolDepth}`, `held: ${report.heldCount}`, `outbox depth: ${report.outboxDepth}`);
+    }
+    lines.push(`dead-letter: ${report.deadLetterCount}`, `token source: ${report.tokenSource}`, `actor kind: ${report.actorKind}`);
+    if (report.emitMode === "legacy") {
+        lines.push(`last flush: ${report.lastFlushAt ?? "(never)"}${report.lastFlushResult
+            ? ` ok=${report.lastFlushResult.ok} posted=${report.lastFlushResult.posted}`
+            : ""}`);
+    }
+    lines.push(`emit last post: ${report.lastPostAt ?? "(never)"}${report.lastEmit
+        ? ` accepted=${report.lastEmit.accepted ?? 0}` +
+            ` unassigned=${report.lastEmit.unassigned ?? 0}` +
+            ` rejected=${report.lastEmit.rejected ?? 0}`
+        : ""}`, `emit retry depth: ${report.emitRetryDepth}`);
     if (report.presenceRefusal) {
         lines.push(`presence refusal: ${report.presenceRefusal.code} (HTTP ${report.presenceRefusal.status}); next retry at ${report.presenceRefusal.nextRetryAt}`);
     }

package/dist/lib/mesh/live/daemon/mode.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Mesh daemon mode gate (owner decision 2026-09-08 "retire the client daemon";
+ * contract direct-emit-v1 §6.3 "deprecated, not deleted").
+ *
+ * Two modes coexist so this can merge before the server route ships and flip
+ * after:
+ *   - "legacy"  — the daemon runs the EMIT path (spool watch + flush + held +
+ *                 outbox replay + transcript-watch fallback) AND the receive
+ *                 subscriber. This is the default until the server route is live.
+ *   - "direct"  — sessions POST events directly (see `hq mesh session`/`emit`);
+ *                 the daemon runs RECEIVE-ONLY: the presence subscriber on
+ *                 hq/{personUid}/mesh keeps the cache the desktop app reads warm.
+ *                 No spool/held/outbox/flush/transcript-watch on this box.
+ *
+ * The flag is resolved from (highest first): env HQ_MESH_MODE, the work-mesh
+ * config file (~/.hq/work-mesh/config.json `emitMode`), else "legacy".
+ */
+export type MeshEmitMode = "legacy" | "direct";
+export declare const MESH_MODE_ENV = "HQ_MESH_MODE";
+export declare function meshConfigPath(meshRoot: string): string;
+/** Read `emitMode` from ~/.hq/work-mesh/config.json (best-effort). */
+export declare function readMeshConfigMode(meshRoot: string): MeshEmitMode | null;
+export interface ResolveModeDeps {
+    env?: NodeJS.ProcessEnv;
+    meshRoot?: string;
+    home?: string;
+}
+/**
+ * Resolve the daemon's emit mode. Env HQ_MESH_MODE wins, then the config file,
+ * else "legacy" (safe default until the server route returns 200).
+ */
+export declare function resolveMeshEmitMode(deps?: ResolveModeDeps): MeshEmitMode;
+/** Persist the emit mode to ~/.hq/work-mesh/config.json (`hq mesh mode set`). */
+export declare function writeMeshConfigMode(meshRoot: string, mode: MeshEmitMode): void;
+/** True when the daemon should run the legacy emit path (spool/flush/held). */
+export declare function runsEmitPath(mode: MeshEmitMode): boolean;
+//# sourceMappingURL=mode.d.ts.map

package/dist/lib/mesh/live/daemon/mode.js

@@ -0,0 +1,88 @@
+/**
+ * Mesh daemon mode gate (owner decision 2026-09-08 "retire the client daemon";
+ * contract direct-emit-v1 §6.3 "deprecated, not deleted").
+ *
+ * Two modes coexist so this can merge before the server route ships and flip
+ * after:
+ *   - "legacy"  — the daemon runs the EMIT path (spool watch + flush + held +
+ *                 outbox replay + transcript-watch fallback) AND the receive
+ *                 subscriber. This is the default until the server route is live.
+ *   - "direct"  — sessions POST events directly (see `hq mesh session`/`emit`);
+ *                 the daemon runs RECEIVE-ONLY: the presence subscriber on
+ *                 hq/{personUid}/mesh keeps the cache the desktop app reads warm.
+ *                 No spool/held/outbox/flush/transcript-watch on this box.
+ *
+ * The flag is resolved from (highest first): env HQ_MESH_MODE, the work-mesh
+ * config file (~/.hq/work-mesh/config.json `emitMode`), else "legacy".
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { workMeshRoot } from "../paths.js";
+export const MESH_MODE_ENV = "HQ_MESH_MODE";
+export function meshConfigPath(meshRoot) {
+    return path.join(meshRoot, "config.json");
+}
+function normalizeMode(value) {
+    if (typeof value !== "string")
+        return null;
+    const v = value.trim().toLowerCase();
+    if (v === "direct" || v === "direct-emit" || v === "receive-only")
+        return "direct";
+    if (v === "legacy" || v === "daemon")
+        return "legacy";
+    return null;
+}
+/** Read `emitMode` from ~/.hq/work-mesh/config.json (best-effort). */
+export function readMeshConfigMode(meshRoot) {
+    try {
+        const raw = fs.readFileSync(meshConfigPath(meshRoot), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return normalizeMode(parsed.emitMode);
+        }
+    }
+    catch {
+        /* absent / malformed → no override */
+    }
+    return null;
+}
+/**
+ * Resolve the daemon's emit mode. Env HQ_MESH_MODE wins, then the config file,
+ * else "legacy" (safe default until the server route returns 200).
+ */
+export function resolveMeshEmitMode(deps = {}) {
+    const env = deps.env ?? process.env;
+    const fromEnv = normalizeMode(env[MESH_MODE_ENV]);
+    if (fromEnv)
+        return fromEnv;
+    const meshRoot = deps.meshRoot ?? workMeshRoot(deps.home, env);
+    const fromConfig = readMeshConfigMode(meshRoot);
+    if (fromConfig)
+        return fromConfig;
+    return "legacy";
+}
+/** Persist the emit mode to ~/.hq/work-mesh/config.json (`hq mesh mode set`). */
+export function writeMeshConfigMode(meshRoot, mode) {
+    const p = meshConfigPath(meshRoot);
+    let existing = {};
+    try {
+        const raw = fs.readFileSync(p, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            existing = parsed;
+        }
+    }
+    catch {
+        /* new file */
+    }
+    existing.emitMode = mode;
+    fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+    const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(existing, null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, p);
+}
+/** True when the daemon should run the legacy emit path (spool/flush/held). */
+export function runsEmitPath(mode) {
+    return mode === "legacy";
+}
+//# sourceMappingURL=mode.js.map

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -13,6 +13,7 @@ import { type CredentialsFetcher, type TimerHost } from "./credentials.js";
 import { type PidLockDeps } from "./pid-lock.js";
 import { PresenceClient, type MqttConnectFn } from "./presence.js";
 import { TranscriptWatcher, type TranscriptFs } from "./transcript-watch.js";
+import { type MeshEmitMode } from "./mode.js";
 export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
 /**
@@ -53,6 +54,13 @@ export interface DaemonRunDeps {
     enablePresence?: boolean;
     /** When false, skip transcript-watch lane (tests). Default true. */
     enableTranscriptWatch?: boolean;
+    /**
+     * Emit mode. "legacy" runs the spool/flush/held/outbox/transcript-watch emit
+     * path; "direct" runs receive-only (subscriber + cache) because sessions POST
+     * events directly. Default resolves from HQ_MESH_MODE / work-mesh config, else
+     * "legacy" (contract direct-emit-v1 §6.3).
+     */
+    mode?: MeshEmitMode;
     /** Injectable transcript fs (tests). */
     transcriptFs?: TranscriptFs;
     /** HQ tree root for deterministic cwd→company/project mapping. */

package/dist/lib/mesh/live/daemon/run.js

@@ -28,6 +28,7 @@ import { PresenceClient, } from "./presence.js";
 import { defaultDaemonState, patchDaemonState, writeDaemonState, } from "./state.js";
 import { workMeshHeldPath } from "../paths.js";
 import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, } from "./transcript-watch.js";
+import { resolveMeshEmitMode, runsEmitPath, } from "./mode.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
 /**
@@ -64,6 +65,8 @@ export async function runMeshDaemon(deps = {}) {
     const ctxRoot = deps.workContextRoot ?? workContextRoot(home, env);
     const dir = daemonDir(meshRoot, home, env);
     const timers = deps.timers ?? realTimerHost;
+    const mode = deps.mode ?? resolveMeshEmitMode({ env, meshRoot, home });
+    const emitPath = runsEmitPath(mode);
     const now = deps.now ?? (() => new Date());
     const log = deps.log ??
         ((d, line) => appendDaemonLog(d, daemonLogLine("info", line, now)));
@@ -77,7 +80,8 @@ export async function runMeshDaemon(deps = {}) {
         throw new Error(`daemon already running (pid ${lock.owner.pid}); refuse second instance`);
     }
     writeDaemonState(dir, defaultDaemonState(lockDeps.pid, now));
-    log(dir, `daemon started pid=${lockDeps.pid}`);
+    log(dir, `daemon started pid=${lockDeps.pid} mode=${mode}`);
+    patchDaemonState(dir, { emitMode: mode }, now);
     // Opt into machine-credential minting when the box has creds (systemd exports
     // HQ_MACHINE_CREDS_FILE). On a person laptop with no machine creds this falls
     // through to the person login cache inside ensureCognitoToken.
@@ -199,7 +203,7 @@ export async function runMeshDaemon(deps = {}) {
     /** Shared with transcript watcher: sessionIds seen on the hook/spool path. */
     const lastHookEventAt = new Map();
     let transcriptWatcher = null;
-    if (deps.enableTranscriptWatch !== false) {
+    if (emitPath && deps.enableTranscriptWatch !== false) {
         const hqRoot = deps.hqRoot ?? env.HQ_ROOT?.trim() ?? undefined;
         const getToken = deps.getToken ?? defaultGetToken;
         transcriptWatcher = new TranscriptWatcher({
@@ -314,34 +318,36 @@ export async function runMeshDaemon(deps = {}) {
             void doFlushCycle("watch");
         }, SPOOL_DEBOUNCE_MS);
     };
-    // Watch spool directory (and file) for changes.
+    // Watch spool directory (and file) for changes — legacy emit path only.
     const spoolPath = workMeshSpoolPath(meshRoot);
-    try {
-        fs.mkdirSync(path.dirname(spoolPath), { recursive: true, mode: 0o700 });
-        if (!fs.existsSync(spoolPath)) {
-            fs.writeFileSync(spoolPath, "", { mode: 0o600 });
+    if (emitPath) {
+        try {
+            fs.mkdirSync(path.dirname(spoolPath), { recursive: true, mode: 0o700 });
+            if (!fs.existsSync(spoolPath)) {
+                fs.writeFileSync(spoolPath, "", { mode: 0o600 });
+            }
+            watcher = fs.watch(path.dirname(spoolPath), { persistent: true }, (_event, filename) => {
+                if (stopped)
+                    return;
+                if (shouldFlushOnSpoolDirEvent(filename)) {
+                    scheduleDebouncedFlush();
+                }
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(dir, `fs.watch failed (interval flush still active): ${msg.slice(0, 120)}`);
         }
-        watcher = fs.watch(path.dirname(spoolPath), { persistent: true }, (_event, filename) => {
+        flushIntervalHandle = timers.setTimeout(function tick() {
             if (stopped)
                 return;
-            if (shouldFlushOnSpoolDirEvent(filename)) {
-                scheduleDebouncedFlush();
-            }
-        });
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        log(dir, `fs.watch failed (interval flush still active): ${msg.slice(0, 120)}`);
+            void doFlushCycle("interval").finally(() => {
+                if (stopped)
+                    return;
+                flushIntervalHandle = timers.setTimeout(tick, FLUSH_INTERVAL_MS);
+            });
+        }, FLUSH_INTERVAL_MS);
     }
-    flushIntervalHandle = timers.setTimeout(function tick() {
-        if (stopped)
-            return;
-        void doFlushCycle("interval").finally(() => {
-            if (stopped)
-                return;
-            flushIntervalHandle = timers.setTimeout(tick, FLUSH_INTERVAL_MS);
-        });
-    }, FLUSH_INTERVAL_MS);
     boardIntervalHandle = timers.setTimeout(function boardTick() {
         if (stopped)
             return;
@@ -393,10 +399,15 @@ export async function runMeshDaemon(deps = {}) {
             });
         }, TRANSCRIPT_WATCH_INTERVAL_MS);
     }
-    // Initial flush + board pass + transcript scan.
-    void doFlushCycle("start");
+    // Initial pass. Board refresh runs in both modes; the flush + transcript
+    // scan are legacy emit-path only.
+    if (emitPath) {
+        void doFlushCycle("start");
+    }
     void refreshFn().catch(() => undefined);
-    void runTranscriptTick();
+    if (emitPath) {
+        void runTranscriptTick();
+    }
     const stop = async () => {
         if (stopped)
             return;

package/dist/lib/mesh/live/daemon/state.d.ts

@@ -22,6 +22,8 @@ export interface DaemonStateFile {
     lastErrorCode?: string;
     /** Set while credential vend is refused (FEATURE_DISABLED / unsupported / 403). */
     presenceRefusal?: PresenceRefusalState | null;
+    /** Daemon emit mode: "legacy" (spool/flush) or "direct" (receive-only). */
+    emitMode?: "legacy" | "direct";
     updatedAt: string;
 }
 export declare function defaultDaemonState(pid: number, now?: () => Date): DaemonStateFile;

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

@@ -0,0 +1,99 @@
+/**
+ * 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 type { SessionEventKind, SessionEventHarness, SessionEventSource } from "./format-spool-line.js";
+import type { EmitEvidence } from "./emit-evidence.js";
+export declare const MESH_EVENTS_PATH = "/v1/mesh/events";
+/** Max events per POST (server batches; keep parity with legacy 100). */
+export declare const MESH_EVENTS_BATCH_MAX = 100;
+/** Per-event server disposition. */
+export type EmitEventStatus = "accepted" | "unassigned" | "rejected";
+export interface EmitEventResult {
+    eventId: string;
+    status: EmitEventStatus;
+    /** Present when status != accepted (no_company_evidence | not_a_member | …). */
+    reason?: string;
+    /** Resolved company (accepted, or unassigned-into-single-company). */
+    companyUid?: string;
+}
+export interface EmitPostResult {
+    status: number;
+    body: unknown;
+    ok: boolean;
+    retryable: boolean;
+    networkError?: boolean;
+}
+export type EmitPoster = (events: Record<string, unknown>[]) => Promise<EmitPostResult>;
+export declare function classifyEmitResponse(status: number, networkError?: boolean): Pick<EmitPostResult, "ok" | "retryable" | "networkError">;
+/**
+ * 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 declare function parseEmitResults(body: unknown): EmitEventResult[] | null;
+/**
+ * Build a poster that uses vaultApiFetch + the caller's bearer token.
+ * `post` override is for tests (never hits the network).
+ */
+export declare function createEmitPoster(opts: {
+    token: string;
+    baseUrl?: string;
+    post?: (path: string, body: {
+        events: Record<string, unknown>[];
+    }) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}): EmitPoster;
+/** One event posted to /v1/mesh/events: core session-event fields + evidence. */
+export interface MeshEmitEvent {
+    v: 1;
+    eventId: string;
+    kind: SessionEventKind;
+    sessionId: string;
+    harness: SessionEventHarness;
+    adapterVersion: string;
+    at: string;
+    seq: number;
+    runtimeVersion?: string;
+    source?: SessionEventSource;
+    taskId?: string;
+    status?: "queued" | "in_progress" | "review" | "done";
+    reason?: string;
+    summary?: string;
+    evidence?: EmitEvidence;
+}
+export interface BuildMeshEmitEventInput {
+    eventId: string;
+    kind: SessionEventKind;
+    sessionId: string;
+    harness: SessionEventHarness;
+    adapterVersion: string;
+    at: string;
+    seq: number;
+    runtimeVersion?: string;
+    source?: SessionEventSource;
+    taskId?: string;
+    status?: "queued" | "in_progress" | "review" | "done";
+    reason?: string;
+    summary?: string;
+    evidence?: EmitEvidence;
+}
+/**
+ * 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 declare function buildMeshEmitEvent(input: BuildMeshEmitEventInput): MeshEmitEvent;
+//# sourceMappingURL=emit-client.d.ts.map

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