harnery 0.32.0 → 0.34.0

package/dist/core/agents/codex-replay.d.ts

@@ -1,29 +0,0 @@
-/**
- * Codex JSONL → canonical event replay.
- *
- * Production codex sessions emit canonical events from each `harn` invocation
- * via the in-process session-tee middleware (which calls `agent-coord
- * emit-event` for state.task_set / state.status_checked). But the codex
- * adapter itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
- * + tool.pre_use + turn.stop aren't emitted live.
- *
- * This module parses the Codex JSONL transcript at stop time and emits the
- * missing canonical events so the verdict has a complete turn-window view.
- *
- * Scope: just the events the stop-hook verdict reads: user_prompt.submit,
- * tool.pre_use (for exec_command function calls), state.status_checked
- * (when the cmd contains `<bin> agents status`), state.task_set (when the cmd
- * contains `<bin> agents set-task`), turn.stop (with status_box_present derived
- * from the last_assistant_message).
- */
-export interface CodexReplayOpts {
-    coordRoot: string;
-    sessionId: string;
-    instanceId: string;
-    jsonlPath: string;
-    lastAssistantMessage?: string;
-}
-export declare function replayCodexJsonl(opts: CodexReplayOpts): {
-    emitted: number;
-};
-//# sourceMappingURL=codex-replay.d.ts.map

package/dist/core/agents/codex-replay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codex-replay.d.ts","sourceRoot":"","sources":["../../../src/core/agents/codex-replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAkBH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAkH3E"}

package/dist/core/agents/codex-replay.js

@@ -1,138 +0,0 @@
-/**
- * Codex JSONL → canonical event replay.
- *
- * Production codex sessions emit canonical events from each `harn` invocation
- * via the in-process session-tee middleware (which calls `agent-coord
- * emit-event` for state.task_set / state.status_checked). But the codex
- * adapter itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
- * + tool.pre_use + turn.stop aren't emitted live.
- *
- * This module parses the Codex JSONL transcript at stop time and emits the
- * missing canonical events so the verdict has a complete turn-window view.
- *
- * Scope: just the events the stop-hook verdict reads: user_prompt.submit,
- * tool.pre_use (for exec_command function calls), state.status_checked
- * (when the cmd contains `<bin> agents status`), state.task_set (when the cmd
- * contains `<bin> agents set-task`), turn.stop (with status_box_present derived
- * from the last_assistant_message).
- */
-import { existsSync, readFileSync } from "node:fs";
-import { emit } from "./events/emit.js";
-const STATUS_BOX_PREFIX = "┌─ agent-";
-export function replayCodexJsonl(opts) {
-    const { coordRoot, sessionId, instanceId, jsonlPath, lastAssistantMessage } = opts;
-    if (!existsSync(jsonlPath))
-        return { emitted: 0 };
-    let raw;
-    try {
-        raw = readFileSync(jsonlPath, "utf8");
-    }
-    catch {
-        return { emitted: 0 };
-    }
-    let emitted = 0;
-    const lines = raw.split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const ts = entry.timestamp;
-        const t = entry.type;
-        if (t === "event_msg" && entry.payload?.type === "user_message") {
-            emit(coordRoot, {
-                event_type: "user_prompt.submit",
-                instance_id: instanceId,
-                session_id: sessionId,
-                adapter: "codex",
-                ts,
-                data: {
-                    prompt_text: clamp(entry.payload.message ?? "", 4000),
-                },
-            });
-            emitted += 1;
-            continue;
-        }
-        if (t === "response_item" && entry.payload?.type === "function_call") {
-            const name = entry.payload.name ?? "";
-            let cmd = "";
-            if (entry.payload.arguments) {
-                try {
-                    const parsed = JSON.parse(entry.payload.arguments);
-                    cmd = parsed.cmd ?? "";
-                }
-                catch {
-                    /* skip */
-                }
-            }
-            // Emit tool.pre_use for every function call.
-            emit(coordRoot, {
-                event_type: "tool.pre_use",
-                instance_id: instanceId,
-                session_id: sessionId,
-                adapter: "codex",
-                ts,
-                data: {
-                    tool_name: name === "exec_command" ? "Bash" : name,
-                    tool_input: JSON.stringify({ command: cmd }),
-                    intent: "",
-                    intent_source: "codex-replay",
-                },
-            });
-            emitted += 1;
-            // Match `<bin> agents status` / `<bin> agents set-task`, bin-agnostic, so
-            // it works for harn or any host CLI that composes harnery (a consumer's own
-            // binary). Wrapped invocations (cd && <bin> ...; PATH=... <bin> ...) pass
-            // because we scan the whole cmd string and anchor on the token before `agents`.
-            if (/(^|\s|;|&&)[\w./-]+\s+agents\s+status(\b|$)/.test(cmd)) {
-                emit(coordRoot, {
-                    event_type: "state.status_checked",
-                    instance_id: instanceId,
-                    session_id: sessionId,
-                    adapter: "codex",
-                    ts,
-                    data: { source: "codex-replay" },
-                });
-                emitted += 1;
-            }
-            if (/(^|\s|;|&&)[\w./-]+\s+agents\s+set-task(\b|$)/.test(cmd)) {
-                emit(coordRoot, {
-                    event_type: "state.task_set",
-                    instance_id: instanceId,
-                    session_id: sessionId,
-                    adapter: "codex",
-                    ts,
-                    data: { source: "codex-replay" },
-                });
-                emitted += 1;
-            }
-        }
-    }
-    // Finally, emit turn.stop with status_box_present derived from the last
-    // assistant message (codex's stop payload carries the assistant text
-    // directly, unlike CC which only has transcript_path).
-    const boxPresent = !!lastAssistantMessage && lastAssistantMessage.includes(STATUS_BOX_PREFIX);
-    emit(coordRoot, {
-        event_type: "turn.stop",
-        instance_id: instanceId,
-        session_id: sessionId,
-        adapter: "codex",
-        data: {
-            status_box_present: boxPresent,
-            tool_call_count: -1,
-            text_length: lastAssistantMessage?.length ?? 0,
-        },
-    });
-    emitted += 1;
-    return { emitted };
-}
-function clamp(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max);
-}

package/dist/core/agents/events/consume.d.ts

@@ -1,82 +0,0 @@
-/**
- * Incremental consumer for the canonical event stream at
- * `.harnery/events.ndjson`.
- *
- * A small `.harnery/.events-cursor` file persists the last-projected event_id;
- * subsequent runs skip everything up to and including that id and return only
- * the new tail.
- *
- * Read strategy: the global cursor is advanced on every agent's turn.stop, so
- * it almost always sits within the last few KB of the stream. We exploit that
- * with a bounded **tail read** (reading only the last `tailBytes` of the file
- * and locating the cursor there) which turns an O(file-size) read into
- * O(window). If the cursor is older than the window (a long-idle system, or a
- * cursor that's been rotated out) we fall back to a wider read that is itself
- * capped (`fallbackCapBytes`): the stream is an append-only ledger that grows
- * without bound, so a whole-file `readFileSync` throws V8's max-string-length
- * error ("Cannot create a string longer than 0x1fffffe8 characters") once it
- * passes ~512MB, which would abort the projection. Events older than the cap are
- * stale for coord-state purposes, so a bounded replay is the correct fallback.
- *
- * Idempotency: projectors are idempotent by `event_id`. The
- * cursor file makes this cheap (we never replay an already-projected event by
- * accident) and the projector tolerates the rare full-replay (cursor rotated
- * out) without double-applying.
- */
-export interface CanonicalEvent {
-    schema_version: number;
-    event_id: string;
-    event_type: string;
-    ts: string;
-    instance_id: string;
-    session_id: string;
-    parent_session_id?: string;
-    turn_id?: string;
-    parent_turn_id?: string;
-    adapter: string;
-    source: string;
-    data: Record<string, unknown>;
-}
-export interface ConsumeResult {
-    events: CanonicalEvent[];
-    /** event_id of the last event the caller successfully projected. */
-    lastEventId: string | null;
-    /** Total bytes in the stream file at read time (for diagnostics). */
-    streamBytes: number;
-}
-export interface ConsumeOpts {
-    /** Ignore the cursor and return everything, useful for backfill. */
-    replayAll?: boolean;
-    /**
-     * Tail-window size in bytes for the fast-path read. Defaults to
-     * `HARNERY_AGENT_COORD_TAIL_BYTES` env or 2 MiB. Mainly a test seam; production
-     * callers should leave it unset.
-     */
-    tailBytes?: number;
-    /**
-     * Cap in bytes for the fall-through read (cursor missed the tail window).
-     * Defaults to `HARNERY_AGENT_COORD_FALLBACK_CAP_BYTES` env or 64 MiB. Bounds
-     * the read so the unbounded ledger can never overflow V8's max string length.
-     * Mainly a test seam; production callers should leave it unset.
-     */
-    fallbackCapBytes?: number;
-}
-/**
- * Read all events after the persisted cursor, in chronological (file) order.
- */
-export declare function consumeSince(coordRoot: string, opts?: ConsumeOpts): ConsumeResult;
-/**
- * Read at most `capBytes` from the tail of the event stream as UTF-8, dropping
- * the (partial) leading line when the file is larger than the cap. Shared
- * bounded reader for CLI consumers (`agents trace` / `agents health`) that must
- * never `readFileSync` the whole unbounded ledger — a >512MB read throws V8's
- * max-string-length error. `truncated` is true when older bytes were skipped, so
- * callers can surface the cap rather than silently under-reporting.
- */
-export declare function readStreamTailBounded(streamPath: string, capBytes: number): {
-    text: string;
-    truncated: boolean;
-};
-export declare function readCursor(coordRoot: string): string | null;
-export declare function writeCursor(coordRoot: string, eventId: string): void;
-//# sourceMappingURL=consume.d.ts.map

package/dist/core/agents/events/consume.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consume.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/events/consume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAwBH,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,oEAAoE;IACpE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,oEAAoE;IACpE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,aAAa,CAuDrF;AAgBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAWtC;AAiDD,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS3D;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAQpE"}

package/dist/core/agents/events/consume.js

@@ -1,195 +0,0 @@
-/**
- * Incremental consumer for the canonical event stream at
- * `.harnery/events.ndjson`.
- *
- * A small `.harnery/.events-cursor` file persists the last-projected event_id;
- * subsequent runs skip everything up to and including that id and return only
- * the new tail.
- *
- * Read strategy: the global cursor is advanced on every agent's turn.stop, so
- * it almost always sits within the last few KB of the stream. We exploit that
- * with a bounded **tail read** (reading only the last `tailBytes` of the file
- * and locating the cursor there) which turns an O(file-size) read into
- * O(window). If the cursor is older than the window (a long-idle system, or a
- * cursor that's been rotated out) we fall back to a wider read that is itself
- * capped (`fallbackCapBytes`): the stream is an append-only ledger that grows
- * without bound, so a whole-file `readFileSync` throws V8's max-string-length
- * error ("Cannot create a string longer than 0x1fffffe8 characters") once it
- * passes ~512MB, which would abort the projection. Events older than the cap are
- * stale for coord-state purposes, so a bounded replay is the correct fallback.
- *
- * Idempotency: projectors are idempotent by `event_id`. The
- * cursor file makes this cheap (we never replay an already-projected event by
- * accident) and the projector tolerates the rare full-replay (cursor rotated
- * out) without double-applying.
- */
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { coordEnv } from "../../../lib/env.js";
-const STREAM_REL = ".harnery/events.ndjson";
-const CURSOR_REL = ".harnery/.events-cursor";
-const DEFAULT_TAIL_BYTES = 2 * 1024 * 1024; // 2 MiB, thousands of events of headroom
-/** Cap for the fall-through read when the cursor misses the tail window. Well
- * under V8's ~512MB max string length so it never throws on the unbounded
- * ledger; comfortably larger than any realistic cursor drift (the global cursor
- * advances on every agent's turn.stop, so it sits near EOF in practice). */
-const DEFAULT_FALLBACK_CAP_BYTES = 64 * 1024 * 1024; // 64 MiB
-/**
- * Read all events after the persisted cursor, in chronological (file) order.
- */
-export function consumeSince(coordRoot, opts = {}) {
-    const streamPath = join(coordRoot, STREAM_REL);
-    if (!existsSync(streamPath)) {
-        return { events: [], lastEventId: null, streamBytes: 0 };
-    }
-    const cursor = opts.replayAll ? null : readCursor(coordRoot);
-    const fileSize = statSync(streamPath).size;
-    const windowBytes = resolveTailBytes(opts.tailBytes);
-    // Tail fast-path: a cursor exists and the file is larger than the window.
-    // Read only the trailing window, drop the (likely partial) first line, and
-    // look for the cursor. A hit returns just the new events without ever
-    // touching the bulk of the file.
-    if (cursor !== null && fileSize > windowBytes) {
-        const tail = readTailUtf8(streamPath, fileSize, windowBytes);
-        const firstNl = tail.indexOf("\n");
-        const usable = firstNl >= 0 ? tail.slice(firstNl + 1) : "";
-        const parsed = eventsAfterCursor(parseLines(usable), cursor);
-        if (parsed.foundCursor) {
-            return {
-                events: parsed.events,
-                lastEventId: parsed.events.at(-1)?.event_id ?? cursor,
-                streamBytes: fileSize,
-            };
-        }
-        // Cursor older than the tail window → fall through to a full read.
-    }
-    // Bounded fall-through: first run, replayAll, small file, or cursor not found
-    // in the tail. This must NEVER read the whole file: the stream grows without
-    // bound and a >512MB readFileSync throws V8's max-string-length error, which
-    // would abort the projection. Read at most `cap` bytes from the tail; when we
-    // start mid-file, drop the (likely partial) first line.
-    const cap = resolveFallbackCap(opts.fallbackCapBytes);
-    const readBytes = Math.min(fileSize, cap);
-    let text = readTailUtf8(streamPath, fileSize, readBytes);
-    if (readBytes < fileSize) {
-        const firstNl = text.indexOf("\n");
-        text = firstNl >= 0 ? text.slice(firstNl + 1) : "";
-    }
-    const all = parseLines(text);
-    const parsed = eventsAfterCursor(all, cursor);
-    if (parsed.foundCursor) {
-        return {
-            events: parsed.events,
-            lastEventId: parsed.events.at(-1)?.event_id ?? cursor,
-            streamBytes: fileSize,
-        };
-    }
-    // The cursor names an event older than the capped window (or rotated out), so
-    // replay what the window holds (safer than silent state drift; the projector
-    // is idempotent by event_id). lastEventId null keeps the cursor put.
-    return { events: all, lastEventId: null, streamBytes: fileSize };
-}
-function resolveFallbackCap(override) {
-    if (override !== undefined && override > 0)
-        return override;
-    const env = coordEnv("AGENT_COORD_FALLBACK_CAP_BYTES");
-    const n = env ? Number(env) : Number.NaN;
-    return Number.isFinite(n) && n > 0 ? n : DEFAULT_FALLBACK_CAP_BYTES;
-}
-function resolveTailBytes(override) {
-    if (override !== undefined && override > 0)
-        return override;
-    const env = coordEnv("AGENT_COORD_TAIL_BYTES");
-    const n = env ? Number(env) : Number.NaN;
-    return Number.isFinite(n) && n > 0 ? n : DEFAULT_TAIL_BYTES;
-}
-/**
- * Read at most `capBytes` from the tail of the event stream as UTF-8, dropping
- * the (partial) leading line when the file is larger than the cap. Shared
- * bounded reader for CLI consumers (`agents trace` / `agents health`) that must
- * never `readFileSync` the whole unbounded ledger — a >512MB read throws V8's
- * max-string-length error. `truncated` is true when older bytes were skipped, so
- * callers can surface the cap rather than silently under-reporting.
- */
-export function readStreamTailBounded(streamPath, capBytes) {
-    if (!existsSync(streamPath))
-        return { text: "", truncated: false };
-    const fileSize = statSync(streamPath).size;
-    const readBytes = Math.min(fileSize, capBytes);
-    let text = readTailUtf8(streamPath, fileSize, readBytes);
-    const truncated = readBytes < fileSize;
-    if (truncated) {
-        const nl = text.indexOf("\n");
-        text = nl >= 0 ? text.slice(nl + 1) : "";
-    }
-    return { text, truncated };
-}
-/** Read the trailing `windowBytes` of a file as UTF-8 without loading the rest. */
-function readTailUtf8(streamPath, fileSize, windowBytes) {
-    const start = Math.max(0, fileSize - windowBytes);
-    const len = fileSize - start;
-    const buf = Buffer.allocUnsafe(len);
-    const fd = openSync(streamPath, "r");
-    try {
-        let read = 0;
-        while (read < len) {
-            const n = readSync(fd, buf, read, len - read, start + read);
-            if (n === 0)
-                break;
-            read += n;
-        }
-        return buf.toString("utf8", 0, read);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function parseLines(raw) {
-    const out = [];
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        try {
-            out.push(JSON.parse(line));
-        }
-        catch {
-            /* skip malformed line */
-        }
-    }
-    return out;
-}
-/**
- * Events strictly after `cursor` (or all events when `cursor` is null). When a
- * non-null cursor isn't present in `all`, returns `foundCursor: false` so the
- * caller can decide between a wider read and a full replay.
- */
-function eventsAfterCursor(all, cursor) {
-    if (cursor === null)
-        return { events: all, foundCursor: true };
-    const idx = all.findIndex((e) => e.event_id === cursor);
-    if (idx < 0)
-        return { events: [], foundCursor: false };
-    return { events: all.slice(idx + 1), foundCursor: true };
-}
-export function readCursor(coordRoot) {
-    const path = join(coordRoot, CURSOR_REL);
-    if (!existsSync(path))
-        return null;
-    try {
-        const v = readFileSync(path, "utf8").trim();
-        return v.length > 0 ? v : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function writeCursor(coordRoot, eventId) {
-    const path = join(coordRoot, CURSOR_REL);
-    try {
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, eventId, "utf8");
-    }
-    catch {
-        /* swallow; next run replays */
-    }
-}

package/dist/core/agents/events/emit.d.ts

@@ -1,42 +0,0 @@
-/**
- * Canonical-event writer for agent-coord. Mirrors the agent-hooks emitter:
- * both modules write the same envelope shape to the same
- * `.harnery/events.ndjson` file but stay independent (shared code limited to
- * event/schema types).
- *
- * Phase 4: agent-coord uses this from CLI handlers (state.task_set,
- * state.status_checked, state.journal_append, council.*, decision.*,
- * presence.*).
- */
-declare const SCHEMA_VERSION: 1;
-export type { Adapter, Source } from "../../hooks/events/schema.js";
-import type { Adapter, Source } from "../../hooks/events/schema.js";
-export interface Envelope {
-    schema_version: typeof SCHEMA_VERSION;
-    event_id: string;
-    event_type: string;
-    ts: string;
-    instance_id: string;
-    session_id: string;
-    parent_session_id?: string;
-    turn_id?: string;
-    parent_turn_id?: string;
-    adapter: Adapter;
-    source: Source;
-    data: Record<string, unknown>;
-}
-export interface EmitInput {
-    event_type: string;
-    instance_id: string;
-    session_id: string;
-    adapter: Adapter;
-    source?: Source;
-    parent_session_id?: string;
-    turn_id?: string;
-    parent_turn_id?: string;
-    ts?: string;
-    data: Record<string, unknown>;
-}
-export declare function buildEnvelope(input: EmitInput): Envelope;
-export declare function emit(coordRoot: string, input: EmitInput): Envelope;
-//# sourceMappingURL=emit.d.ts.map

package/dist/core/agents/events/emit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/events/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,QAAA,MAAM,cAAc,EAAG,CAAU,CAAC;AAKlC,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAexD;AAED,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,CA4BlE"}

package/dist/core/agents/events/emit.js

@@ -1,75 +0,0 @@
-/**
- * Canonical-event writer for agent-coord. Mirrors the agent-hooks emitter:
- * both modules write the same envelope shape to the same
- * `.harnery/events.ndjson` file but stay independent (shared code limited to
- * event/schema types).
- *
- * Phase 4: agent-coord uses this from CLI handlers (state.task_set,
- * state.status_checked, state.journal_append, council.*, decision.*,
- * presence.*).
- */
-import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { maybeRotateEventStream } from "../../hooks/events/rotate.js";
-import { ulid } from "./ulid.js";
-const SCHEMA_VERSION = 1;
-const STREAM_FILE = ".harnery/events.ndjson";
-const LOCK_FILE = ".harnery/events.ndjson.lock";
-const MAX_LINE_BYTES = 64 * 1024;
-export function buildEnvelope(input) {
-    return {
-        schema_version: SCHEMA_VERSION,
-        event_id: ulid(),
-        event_type: input.event_type,
-        ts: input.ts ?? new Date().toISOString(),
-        instance_id: input.instance_id,
-        session_id: input.session_id,
-        parent_session_id: input.parent_session_id,
-        turn_id: input.turn_id,
-        parent_turn_id: input.parent_turn_id,
-        adapter: input.adapter,
-        source: input.source ?? "agent-coord",
-        data: input.data,
-    };
-}
-export function emit(coordRoot, input) {
-    const envelope = buildEnvelope(input);
-    const streamPath = join(coordRoot, STREAM_FILE);
-    const lockPath = join(coordRoot, LOCK_FILE);
-    // Size-triggered rotation (shared with the agent-hooks emitter): roll the
-    // active file to a dated archive when it crosses the cap. Fail-soft.
-    maybeRotateEventStream(coordRoot);
-    ensureDir(dirname(streamPath));
-    ensureFile(lockPath);
-    let line = `${JSON.stringify(envelope)}\n`;
-    if (Buffer.byteLength(line, "utf8") > MAX_LINE_BYTES) {
-        line = `${JSON.stringify({
-            ...envelope,
-            data: { __over_size_limit: true, original_bytes: Buffer.byteLength(line, "utf8") },
-        })}\n`;
-    }
-    const lockFd = openSync(lockPath, "r+");
-    try {
-        appendFileSync(streamPath, line, { encoding: "utf8", flag: "a" });
-    }
-    finally {
-        closeSync(lockFd);
-    }
-    return envelope;
-}
-function ensureDir(path) {
-    try {
-        mkdirSync(path, { recursive: true });
-    }
-    catch {
-        /* swallow */
-    }
-}
-function ensureFile(path) {
-    try {
-        closeSync(openSync(path, "a"));
-    }
-    catch {
-        /* swallow */
-    }
-}

package/dist/core/agents/events/ulid.d.ts

@@ -1,11 +0,0 @@
-/**
- * Tiny ULID generator. Crockford-base32, 10-char timestamp (48-bit ms epoch)
- * + 16-char random (80-bit). 26 chars total, monotonically-sortable.
- *
- * Intentionally duplicated from the agent-hooks ULID generator: agent-hooks
- * and agent-coord stay strictly-separated packages, sharing only event/schema
- * types. The writer side reimplements per-module so neither depends on the
- * other's runtime code.
- */
-export declare function ulid(): string;
-//# sourceMappingURL=ulid.d.ts.map

package/dist/core/agents/events/ulid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ulid.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/events/ulid.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,wBAAgB,IAAI,IAAI,MAAM,CAI7B"}

package/dist/core/agents/events/ulid.js

@@ -1,47 +0,0 @@
-/**
- * Tiny ULID generator. Crockford-base32, 10-char timestamp (48-bit ms epoch)
- * + 16-char random (80-bit). 26 chars total, monotonically-sortable.
- *
- * Intentionally duplicated from the agent-hooks ULID generator: agent-hooks
- * and agent-coord stay strictly-separated packages, sharing only event/schema
- * types. The writer side reimplements per-module so neither depends on the
- * other's runtime code.
- */
-const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export function ulid() {
-    const ts = encodeTime(Date.now());
-    const rnd = encodeRandom();
-    return ts + rnd;
-}
-function encodeTime(ms) {
-    let out = "";
-    let n = BigInt(ms);
-    const base = BigInt(32);
-    for (let i = 0; i < 10; i++) {
-        const mod = Number(n % base);
-        out = ALPHABET[mod] + out;
-        n = n / base;
-    }
-    return out;
-}
-function encodeRandom() {
-    const bytes = new Uint8Array(10);
-    crypto.getRandomValues(bytes);
-    let out = "";
-    let buf = 0n;
-    let bits = 0;
-    for (const b of bytes) {
-        buf = (buf << 8n) | BigInt(b);
-        bits += 8;
-        while (bits >= 5) {
-            bits -= 5;
-            const idx = Number((buf >> BigInt(bits)) & 0x1fn);
-            out += ALPHABET[idx];
-        }
-    }
-    if (bits > 0) {
-        const idx = Number((buf << BigInt(5 - bits)) & 0x1fn);
-        out += ALPHABET[idx];
-    }
-    return out.slice(0, 16);
-}