@indigoai-us/hq-cli 5.108.1 → 5.108.2

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

@@ -0,0 +1,56 @@
+/**
+ * Flush spool + held session events (US-008).
+ *
+ * Claim-by-rename → group by sessionId → read work-context state →
+ * drop untracked / hold unverified / strip local-only → POST batches of ≤100
+ * with bounded full-jitter retries. Never touches sessions-bind.json.
+ *
+ * Orphan `*.claimed` files from a prior crash are recovered first.
+ * 2xx responses are accounted per eventId (accepted / duplicates / rejected).
+ */
+import { type RandomFn, type SleepFn } from "./backoff.js";
+import { type SessionEventsPoster } from "./session-events-client.js";
+export declare const HELD_TTL_MS: number;
+export type HeldReason = "STATE_ABSENT" | "NEEDS_COMPANY" | "COMPANY_CONFLICT" | "HELD_EXPIRED";
+export interface HeldLineRecord {
+    /** Original spool event fields. */
+    event: Record<string, unknown>;
+    heldReason: HeldReason;
+    heldAt: string;
+}
+export interface FlushDeps {
+    workMeshRoot: string;
+    workContextRoot: string;
+    poster: SessionEventsPoster;
+    now?: () => Date;
+    sleep?: SleepFn;
+    random?: RandomFn;
+    maxAttempts?: number;
+}
+export interface FlushSummary {
+    claimed: number;
+    posted: number;
+    held: number;
+    dropped: number;
+    deadLettered: number;
+    restored: number;
+    batches: number;
+}
+/**
+ * Flush spool + held. Safe to call concurrently with enqueue (claim-by-rename).
+ * Recovers orphan `*.claimed` files first; restores unprocessed lines on throw.
+ */
+export declare function flushSessionEvents(deps: FlushDeps): Promise<FlushSummary>;
+/**
+ * Assert flush never opens the machine-global bind cache.
+ * Used by tests; production flush has no reference to this path.
+ */
+export declare function sessionsBindPath(home: string): string;
+export declare function assertNoBindCacheAccess(root: string): void;
+/** Convenience: build FlushDeps from env/home with a poster. */
+export declare function defaultFlushRoots(env?: NodeJS.ProcessEnv): {
+    workMeshRoot: string;
+    workContextRoot: string;
+};
+export declare function bindCacheExists(meshRoot: string): boolean;
+//# sourceMappingURL=flush.d.ts.map

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

@@ -0,0 +1,360 @@
+/**
+ * Flush spool + held session events (US-008).
+ *
+ * Claim-by-rename → group by sessionId → read work-context state →
+ * drop untracked / hold unverified / strip local-only → POST batches of ≤100
+ * with bounded full-jitter retries. Never touches sessions-bind.json.
+ *
+ * Orphan `*.claimed` files from a prior crash are recovered first.
+ * 2xx responses are accounted per eventId (accepted / duplicates / rejected).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readSessionState } from "../../work-context/state.js";
+import { workContextRoot } from "../../work-context/paths.js";
+import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
+import { LOCAL_ONLY_FIELDS, stripLocalOnlyFields } from "./format-spool-line.js";
+import { SESSION_EVENTS_BATCH_MAX, WRITABLE_CONTEXT_STATUSES, parseSessionEventsBatchAck, } from "./session-events-client.js";
+import { appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendSpoolLine, claimHeld, claimSpool, recoverOrphanClaims, removeClaimFile, } from "./spool.js";
+import { workMeshRoot } from "./paths.js";
+export const HELD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function parseLine(line) {
+    try {
+        const v = JSON.parse(line);
+        if (!v || typeof v !== "object" || Array.isArray(v))
+            return null;
+        return v;
+    }
+    catch {
+        return null;
+    }
+}
+function sessionIdOf(obj) {
+    return typeof obj.sessionId === "string" && obj.sessionId.trim()
+        ? obj.sessionId.trim()
+        : null;
+}
+function eventIdOf(obj) {
+    return typeof obj.eventId === "string" && obj.eventId.trim()
+        ? obj.eventId.trim()
+        : null;
+}
+/** Peel held envelope if present; return event + prior heldAt. */
+function unwrapHeld(obj) {
+    if (obj.event &&
+        typeof obj.event === "object" &&
+        !Array.isArray(obj.event) &&
+        typeof obj.heldReason === "string") {
+        return {
+            event: obj.event,
+            heldAt: typeof obj.heldAt === "string" ? obj.heldAt : undefined,
+            heldReason: obj.heldReason,
+        };
+    }
+    return { event: obj };
+}
+function heldEnvelope(event, heldReason, heldAt) {
+    return JSON.stringify({ event, heldReason, heldAt });
+}
+function deadLetterEnvelope(event, reason, responseCode, at) {
+    return JSON.stringify({ event, reason, responseCode, at });
+}
+function groupBySession(events) {
+    const map = new Map();
+    for (const item of events) {
+        const sid = sessionIdOf(item.event);
+        if (!sid) {
+            // Malformed: dead-letter immediately by caller — skip grouping key.
+            continue;
+        }
+        const list = map.get(sid) ?? [];
+        list.push(item);
+        map.set(sid, list);
+    }
+    return map;
+}
+async function postBatchWithRetries(poster, body, deps) {
+    let lastStatus = 0;
+    let lastBody = {};
+    for (let attempt = 0; attempt < deps.maxAttempts; attempt += 1) {
+        const res = await poster(body);
+        lastStatus = res.status;
+        lastBody = res.body;
+        if (res.ok)
+            return { ok: true, body: res.body };
+        if (!res.retryable) {
+            return { ok: false, retryable: false, status: res.status, body: res.body };
+        }
+        if (attempt + 1 >= deps.maxAttempts)
+            break;
+        const delay = fullJitterDelayMs(attempt, { random: deps.random });
+        await deps.sleep(delay);
+    }
+    return { ok: false, retryable: true, status: lastStatus, body: lastBody };
+}
+/**
+ * Flush spool + held. Safe to call concurrently with enqueue (claim-by-rename).
+ * Recovers orphan `*.claimed` files first; restores unprocessed lines on throw.
+ */
+export async function flushSessionEvents(deps) {
+    const now = deps.now ?? (() => new Date());
+    const sleep = deps.sleep ?? defaultSleep;
+    const random = deps.random ?? Math.random;
+    const maxAttempts = deps.maxAttempts ?? FLUSH_MAX_ATTEMPTS;
+    const ts = `${now().getTime()}`;
+    const orphans = recoverOrphanClaims(deps.workMeshRoot);
+    const spoolClaim = claimSpool(deps.workMeshRoot, ts);
+    const heldClaim = claimHeld(deps.workMeshRoot, `${ts}.held`);
+    const claimPaths = [
+        ...orphans.claimPaths,
+        spoolClaim.claimPath,
+        heldClaim.claimPath,
+    ].filter((p) => Boolean(p));
+    const summary = {
+        claimed: 0,
+        posted: 0,
+        held: 0,
+        dropped: 0,
+        deadLettered: 0,
+        restored: 0,
+        batches: 0,
+    };
+    /** Original events still awaiting disposition (restored on throw). */
+    const pendingRestore = [];
+    const collected = [];
+    try {
+        for (const line of [...orphans.lines, ...spoolClaim.lines, ...heldClaim.lines]) {
+            summary.claimed += 1;
+            const parsed = parseLine(line);
+            if (!parsed) {
+                appendDeadLetterLine(deadLetterEnvelope({ raw: line.slice(0, 200) }, "SCHEMA_REJECTED", "parse_error", now().toISOString()), deps.workMeshRoot);
+                summary.deadLettered += 1;
+                continue;
+            }
+            const { event, heldAt } = unwrapHeld(parsed);
+            if (!sessionIdOf(event)) {
+                appendDeadLetterLine(deadLetterEnvelope(event, "SCHEMA_REJECTED", "missing_sessionId", now().toISOString()), deps.workMeshRoot);
+                summary.deadLettered += 1;
+                continue;
+            }
+            // Expire held lines older than 7 days.
+            if (heldAt) {
+                const age = now().getTime() - Date.parse(heldAt);
+                if (Number.isFinite(age) && age > HELD_TTL_MS) {
+                    appendDeadLetterLine(deadLetterEnvelope(event, "HELD_EXPIRED", "held_ttl", now().toISOString()), deps.workMeshRoot);
+                    summary.deadLettered += 1;
+                    continue;
+                }
+            }
+            pendingRestore.push(event);
+            collected.push({ event, heldAt });
+        }
+        const bySession = groupBySession(collected);
+        const markDisposed = (event) => {
+            const idx = pendingRestore.indexOf(event);
+            if (idx >= 0)
+                pendingRestore.splice(idx, 1);
+        };
+        for (const [sessionId, items] of bySession) {
+            const state = readSessionState(sessionId, deps.workContextRoot);
+            const decision = classifySession(state);
+            if (decision.action === "drop") {
+                appendDroppedReceipt({
+                    v: 1,
+                    sessionId,
+                    dropped: items.length,
+                    reason: "untracked",
+                    at: now().toISOString(),
+                }, deps.workMeshRoot);
+                summary.dropped += items.length;
+                for (const item of items)
+                    markDisposed(item.event);
+                continue;
+            }
+            if (decision.action === "hold") {
+                const heldAt = now().toISOString();
+                for (const item of items) {
+                    appendHeldLine(heldEnvelope(item.event, decision.heldReason, item.heldAt ?? heldAt), deps.workMeshRoot);
+                    summary.held += 1;
+                    markDisposed(item.event);
+                }
+                continue;
+            }
+            // Post path: strip local-only, batch ≤100, retry.
+            const stripped = items.map((item) => stripLocalOnlyFields(item.event));
+            for (let i = 0; i < stripped.length; i += SESSION_EVENTS_BATCH_MAX) {
+                const chunk = stripped.slice(i, i + SESSION_EVENTS_BATCH_MAX);
+                const originalChunk = items.slice(i, i + SESSION_EVENTS_BATCH_MAX);
+                const body = {
+                    contractVersion: 1,
+                    companyUid: decision.companyUid,
+                    sessionId,
+                    contextStatus: decision.contextStatus,
+                    events: chunk,
+                };
+                if (decision.bindingEpisodeId)
+                    body.bindingEpisodeId = decision.bindingEpisodeId;
+                if (decision.projectId)
+                    body.projectId = decision.projectId;
+                if (decision.taskId)
+                    body.taskId = decision.taskId;
+                summary.batches += 1;
+                const result = await postBatchWithRetries(deps.poster, body, {
+                    maxAttempts,
+                    sleep,
+                    random,
+                });
+                if (result.ok) {
+                    accountBatchSuccess(result.body, originalChunk, deps.workMeshRoot, now, summary, markDisposed);
+                    continue;
+                }
+                if (!result.retryable) {
+                    const at = now().toISOString();
+                    for (const item of originalChunk) {
+                        appendDeadLetterLine(deadLetterEnvelope(item.event, `HTTP_${result.status}`, result.status, at), deps.workMeshRoot);
+                        summary.deadLettered += 1;
+                        markDisposed(item.event);
+                    }
+                    continue;
+                }
+                // Retry exhaustion (5xx / network): restore to spool intact.
+                for (const item of originalChunk) {
+                    const line = JSON.stringify(canonicalizeForRestore(item.event));
+                    appendSpoolLine(line, deps.workMeshRoot);
+                    summary.restored += 1;
+                    markDisposed(item.event);
+                }
+            }
+        }
+    }
+    finally {
+        // Crash / throw mid-flush: put unprocessed events back on the spool.
+        for (const event of pendingRestore) {
+            try {
+                appendSpoolLine(JSON.stringify(canonicalizeForRestore(event)), deps.workMeshRoot);
+                summary.restored += 1;
+            }
+            catch {
+                /* best-effort; orphan claim scan will retry next flush */
+            }
+        }
+        pendingRestore.length = 0;
+        for (const p of claimPaths) {
+            removeClaimFile(p);
+        }
+    }
+    return summary;
+}
+/**
+ * Account a 2xx batch: dead-letter rejected eventIds with their codes;
+ * count accepted+duplicates as posted; restore any eventId not accounted for.
+ */
+function accountBatchSuccess(body, originalChunk, meshRoot, now, summary, markDisposed) {
+    const ack = parseSessionEventsBatchAck(body);
+    if (!ack) {
+        // Unparseable 2xx: retain everything rather than pretend posted.
+        for (const item of originalChunk) {
+            appendSpoolLine(JSON.stringify(canonicalizeForRestore(item.event)), meshRoot);
+            summary.restored += 1;
+            markDisposed(item.event);
+        }
+        return;
+    }
+    const byId = new Map();
+    for (const item of originalChunk) {
+        const id = eventIdOf(item.event);
+        if (id)
+            byId.set(id, item);
+    }
+    const rejectedIds = new Set();
+    const at = now().toISOString();
+    for (const row of ack.rejected) {
+        const item = byId.get(row.eventId);
+        if (!item)
+            continue;
+        appendDeadLetterLine(deadLetterEnvelope(item.event, row.code, row.code, at), meshRoot);
+        summary.deadLettered += 1;
+        rejectedIds.add(row.eventId);
+        markDisposed(item.event);
+    }
+    const remaining = originalChunk.filter((item) => {
+        const id = eventIdOf(item.event);
+        return !id || !rejectedIds.has(id);
+    });
+    const accounted = ack.accepted + ack.duplicates;
+    if (accounted === remaining.length) {
+        for (const item of remaining) {
+            summary.posted += 1;
+            markDisposed(item.event);
+        }
+        return;
+    }
+    // Under-accounted (or over): retain every remaining event rather than delete.
+    for (const item of remaining) {
+        appendSpoolLine(JSON.stringify(canonicalizeForRestore(item.event)), meshRoot);
+        summary.restored += 1;
+        markDisposed(item.event);
+    }
+}
+function canonicalizeForRestore(event) {
+    // Preserve known fields; drop held envelope keys if any leaked.
+    const out = {};
+    for (const [k, v] of Object.entries(event)) {
+        if (k === "heldReason" || k === "heldAt" || k === "event")
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+function classifySession(state) {
+    if (!state) {
+        return { action: "hold", heldReason: "STATE_ABSENT" };
+    }
+    if (state.contextStatus === "untracked") {
+        return { action: "drop" };
+    }
+    if (state.contextStatus === "needs_company") {
+        return { action: "hold", heldReason: "NEEDS_COMPANY" };
+    }
+    if (state.contextStatus === "company_conflict") {
+        return { action: "hold", heldReason: "COMPANY_CONFLICT" };
+    }
+    if (!WRITABLE_CONTEXT_STATUSES.has(state.contextStatus)) {
+        return { action: "hold", heldReason: "STATE_ABSENT" };
+    }
+    if (!state.companyUid) {
+        return { action: "hold", heldReason: "NEEDS_COMPANY" };
+    }
+    return {
+        action: "post",
+        companyUid: state.companyUid,
+        contextStatus: state.contextStatus,
+        bindingEpisodeId: state.bindingEpisodeId,
+        projectId: state.projectId,
+        taskId: state.taskId,
+    };
+}
+/**
+ * Assert flush never opens the machine-global bind cache.
+ * Used by tests; production flush has no reference to this path.
+ */
+export function sessionsBindPath(home) {
+    return path.join(home, ".hq", "work-mesh", "cache", "sessions-bind.json");
+}
+export function assertNoBindCacheAccess(root) {
+    const bind = path.join(root, "cache", "sessions-bind.json");
+    // Touch-detection helper for tests: we simply ensure we never create it.
+    void bind;
+    void LOCAL_ONLY_FIELDS;
+}
+/** Convenience: build FlushDeps from env/home with a poster. */
+export function defaultFlushRoots(env = process.env) {
+    return {
+        workMeshRoot: workMeshRoot(undefined, env),
+        workContextRoot: workContextRoot(undefined, env),
+    };
+}
+export function bindCacheExists(meshRoot) {
+    return fs.existsSync(path.join(meshRoot, "cache", "sessions-bind.json"));
+}
+//# sourceMappingURL=flush.js.map

package/dist/lib/mesh/live/format-spool-line.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Canonical spool-line JSON. Node and the POSIX shell writer must emit
+ * byte-identical lines for the same inputs (fixed key order, compact JSON).
+ */
+export declare const LOCAL_ONLY_FIELDS: readonly ["cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
+export type LocalOnlyField = (typeof LOCAL_ONLY_FIELDS)[number];
+/** Network + local key order matching work-mesh-enqueue.sh. */
+export declare const SPOOL_KEY_ORDER: readonly ["v", "eventId", "kind", "sessionId", "harness", "adapterVersion", "runtimeVersion", "source", "at", "seq", "taskId", "status", "reason", "summary", "cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
+export type SessionEventKind = "session_start" | "turn_start" | "turn_end" | "session_end" | "task_status" | "blocked" | "note";
+export type SessionEventHarness = "claude-code" | "claude-desktop" | "codex" | "grok" | "hq-sessions" | "agent-box";
+export type SessionEventSource = "hooks" | "transcript";
+export interface SpoolEventInput {
+    v?: 1;
+    eventId: string;
+    kind: SessionEventKind;
+    sessionId: string;
+    harness: SessionEventHarness;
+    adapterVersion: string;
+    runtimeVersion?: string;
+    source?: SessionEventSource;
+    at: string;
+    seq: number;
+    taskId?: string;
+    status?: "queued" | "in_progress" | "review" | "done";
+    reason?: string;
+    summary?: string;
+    cwd?: string;
+    hqRoot?: string;
+    companySlug?: string;
+    project?: string;
+    task?: string;
+    toolWrites?: number;
+}
+/**
+ * Build a compact JSON object in SPOOL_KEY_ORDER, omitting absent optional
+ * strings. `toolWrites` is included when it is a finite number >= 0 (including 0).
+ */
+export declare function buildOrderedSpoolObject(input: SpoolEventInput): Record<string, string | number>;
+/** Compact JSON line body (no trailing newline). */
+export declare function formatSpoolLine(input: SpoolEventInput): string;
+export declare function stripLocalOnlyFields(event: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=format-spool-line.d.ts.map

package/dist/lib/mesh/live/format-spool-line.js

@@ -0,0 +1,106 @@
+/**
+ * Canonical spool-line JSON. Node and the POSIX shell writer must emit
+ * byte-identical lines for the same inputs (fixed key order, compact JSON).
+ */
+export const LOCAL_ONLY_FIELDS = [
+    "cwd",
+    "hqRoot",
+    "companySlug",
+    "project",
+    "task",
+    "toolWrites",
+];
+/** Network + local key order matching work-mesh-enqueue.sh. */
+export const SPOOL_KEY_ORDER = [
+    "v",
+    "eventId",
+    "kind",
+    "sessionId",
+    "harness",
+    "adapterVersion",
+    "runtimeVersion",
+    "source",
+    "at",
+    "seq",
+    "taskId",
+    "status",
+    "reason",
+    "summary",
+    "cwd",
+    "hqRoot",
+    "companySlug",
+    "project",
+    "task",
+    "toolWrites",
+];
+function includeString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+/**
+ * Build a compact JSON object in SPOOL_KEY_ORDER, omitting absent optional
+ * strings. `toolWrites` is included when it is a finite number >= 0 (including 0).
+ */
+export function buildOrderedSpoolObject(input) {
+    const out = {
+        v: 1,
+        eventId: input.eventId,
+        kind: input.kind,
+        sessionId: input.sessionId,
+        harness: input.harness,
+        adapterVersion: input.adapterVersion,
+    };
+    if (includeString(input.runtimeVersion))
+        out.runtimeVersion = input.runtimeVersion;
+    if (includeString(input.source))
+        out.source = input.source;
+    out.at = input.at;
+    out.seq = input.seq;
+    if (includeString(input.taskId))
+        out.taskId = input.taskId;
+    if (includeString(input.status))
+        out.status = input.status;
+    if (includeString(input.reason))
+        out.reason = input.reason;
+    if (includeString(input.summary))
+        out.summary = input.summary;
+    if (includeString(input.cwd))
+        out.cwd = input.cwd;
+    if (includeString(input.hqRoot))
+        out.hqRoot = input.hqRoot;
+    if (includeString(input.companySlug))
+        out.companySlug = input.companySlug;
+    if (includeString(input.project))
+        out.project = input.project;
+    if (includeString(input.task))
+        out.task = input.task;
+    if (typeof input.toolWrites === "number" &&
+        Number.isFinite(input.toolWrites) &&
+        input.toolWrites >= 0) {
+        out.toolWrites = Math.floor(input.toolWrites);
+    }
+    return out;
+}
+/** Compact JSON line body (no trailing newline). */
+export function formatSpoolLine(input) {
+    const ordered = buildOrderedSpoolObject(input);
+    // Re-insert in canonical order so JSON.stringify key order is stable.
+    const canonical = {};
+    for (const key of SPOOL_KEY_ORDER) {
+        if (Object.prototype.hasOwnProperty.call(ordered, key)) {
+            canonical[key] = ordered[key];
+        }
+    }
+    return JSON.stringify(canonical);
+}
+export function stripLocalOnlyFields(event) {
+    const out = {};
+    for (const key of SPOOL_KEY_ORDER) {
+        if (LOCAL_ONLY_FIELDS.includes(key))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(event, key) && event[key] !== undefined) {
+            out[key] = event[key];
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=format-spool-line.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * Work Mesh Live client-side contract package (hq-cli).
+ * Schema is a verbatim copy of hq-pro's session-event.schema.json.
+ */
+export { getSessionEventValidator, PROHIBITED_CONTENT_CLASSES, PROHIBITED_FIELD_BY_CLASS, redactValidationMessage, resolveHqProSchemaPath, SESSION_EVENT_SCHEMA_PATH, SESSION_EVENT_SCHEMA_SHA256, sha256File, sha256SessionEventSchema, validateSessionEvent, } from "./validate-session-event.js";
+export type { ProhibitedContentClass, SessionEventValidationResult, } from "./validate-session-event.js";
+export { InvalidSessionIdentityError, SESSION_ID_ENV_KEYS, isValidSessionId, normalizeSessionIdentity, sessionIdFromEnv, } from "./session-identity.js";
+export type { NormalizeSessionIdentityInput, NormalizedSessionIdentity, } from "./session-identity.js";
+export { LOCAL_ONLY_FIELDS, SPOOL_KEY_ORDER, buildOrderedSpoolObject, formatSpoolLine, stripLocalOnlyFields, } from "./format-spool-line.js";
+export type { LocalOnlyField, SessionEventHarness, SessionEventKind, SessionEventSource, SpoolEventInput, } from "./format-spool-line.js";
+export { encodeCrockford, generateUlid, isUlid } from "./ulid.js";
+export { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "./paths.js";
+export { SPOOL_LINE_MAX_BYTES, SpoolWriteError, appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendJsonlLine, appendSpoolLine, claimHeld, claimJsonlByRename, claimSpool, countJsonlLines, deadLetterNonEmpty, ensureSpoolFile, removeClaimFile, } from "./spool.js";
+export { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent, resolveEnqueueSessionId, } from "./enqueue.js";
+export type { EnqueueOptions, EnqueueResult } from "./enqueue.js";
+export { HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
+export type { FlushDeps, FlushSummary, HeldReason } from "./flush.js";
+export { BACKOFF_BASE_MS, BACKOFF_CAP_MS, FLUSH_MAX_ATTEMPTS, defaultSleep, fullJitterDelayMs, } from "./backoff.js";
+export { SESSION_EVENTS_BATCH_MAX, SESSION_EVENTS_PATH, WRITABLE_CONTEXT_STATUSES, classifySessionEventsResponse, createSessionEventsPoster, resolveVaultApiBase, } from "./session-events-client.js";
+export type { SessionEventsBatchBody, SessionEventsPostResult, SessionEventsPoster, } from "./session-events-client.js";
+export * from "./daemon/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * Work Mesh Live client-side contract package (hq-cli).
+ * Schema is a verbatim copy of hq-pro's session-event.schema.json.
+ */
+export { getSessionEventValidator, PROHIBITED_CONTENT_CLASSES, PROHIBITED_FIELD_BY_CLASS, redactValidationMessage, resolveHqProSchemaPath, SESSION_EVENT_SCHEMA_PATH, SESSION_EVENT_SCHEMA_SHA256, sha256File, sha256SessionEventSchema, validateSessionEvent, } from "./validate-session-event.js";
+export { InvalidSessionIdentityError, SESSION_ID_ENV_KEYS, isValidSessionId, normalizeSessionIdentity, sessionIdFromEnv, } from "./session-identity.js";
+export { LOCAL_ONLY_FIELDS, SPOOL_KEY_ORDER, buildOrderedSpoolObject, formatSpoolLine, stripLocalOnlyFields, } from "./format-spool-line.js";
+export { encodeCrockford, generateUlid, isUlid } from "./ulid.js";
+export { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "./paths.js";
+export { SPOOL_LINE_MAX_BYTES, SpoolWriteError, appendDeadLetterLine, appendDroppedReceipt, appendHeldLine, appendJsonlLine, appendSpoolLine, claimHeld, claimJsonlByRename, claimSpool, countJsonlLines, deadLetterNonEmpty, ensureSpoolFile, removeClaimFile, } from "./spool.js";
+export { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent, resolveEnqueueSessionId, } from "./enqueue.js";
+export { HELD_TTL_MS, assertNoBindCacheAccess, bindCacheExists, defaultFlushRoots, flushSessionEvents, sessionsBindPath, } from "./flush.js";
+export { BACKOFF_BASE_MS, BACKOFF_CAP_MS, FLUSH_MAX_ATTEMPTS, defaultSleep, fullJitterDelayMs, } from "./backoff.js";
+export { SESSION_EVENTS_BATCH_MAX, SESSION_EVENTS_PATH, WRITABLE_CONTEXT_STATUSES, classifySessionEventsResponse, createSessionEventsPoster, resolveVaultApiBase, } from "./session-events-client.js";
+export * from "./daemon/index.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Local Work Mesh Live paths under ~/.hq/work-mesh/.
+ * Injectable root for tests (never touch the real HOME in unit tests).
+ */
+export declare const WORK_MESH_DIRNAME = "work-mesh";
+export declare function workMeshRoot(home?: string, env?: NodeJS.ProcessEnv): string;
+export declare function workMeshSpoolPath(root?: string): string;
+export declare function workMeshHeldPath(root?: string): string;
+export declare function workMeshDeadLetterPath(root?: string): string;
+export declare function workMeshDroppedReceiptPath(root?: string): string;
+/** Claim path: spool.<ts>.claimed (never reuse spool.jsonl for claim). */
+export declare function workMeshClaimPath(kind: "spool" | "held", ts: string, root?: string): string;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Local Work Mesh Live paths under ~/.hq/work-mesh/.
+ * Injectable root for tests (never touch the real HOME in unit tests).
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+export const WORK_MESH_DIRNAME = "work-mesh";
+export function workMeshRoot(home = os.homedir(), env = process.env) {
+    const override = env.HQ_WORK_MESH_ROOT?.trim();
+    if (override)
+        return override;
+    return path.join(home, ".hq", WORK_MESH_DIRNAME);
+}
+export function workMeshSpoolPath(root) {
+    return path.join(root ?? workMeshRoot(), "spool.jsonl");
+}
+export function workMeshHeldPath(root) {
+    return path.join(root ?? workMeshRoot(), "held.jsonl");
+}
+export function workMeshDeadLetterPath(root) {
+    return path.join(root ?? workMeshRoot(), "dead-letter.jsonl");
+}
+export function workMeshDroppedReceiptPath(root) {
+    return path.join(root ?? workMeshRoot(), "dropped-receipts.jsonl");
+}
+/** Claim path: spool.<ts>.claimed (never reuse spool.jsonl for claim). */
+export function workMeshClaimPath(kind, ts, root) {
+    return path.join(root ?? workMeshRoot(), `${kind}.${ts}.claimed`);
+}
+//# sourceMappingURL=paths.js.map