@agentic-kit/run-log 0.2.0

package/esm/record.js

@@ -0,0 +1,83 @@
+/**
+ * The run log record: four platform-owned fields around a verbatim pi entry.
+ *
+ * The wrapper exists to give an entry identity (which run) and order (which
+ * position) across hosts — nothing else. It deliberately does not re-encode pi's
+ * semantics, because pi already versions and migrates its own session format;
+ * `piSessionVersion` records which version an entry was written under so a
+ * reader can hand old entries to pi's migrations instead of guessing.
+ */
+import { assertPiSessionEntry } from './pi-entry';
+/** Version of the wrapper itself — bumped only if these four fields change. */
+export const RUN_LOG_WRAPPER_VERSION = 1;
+/** The pi session format version this package projects without migration. */
+export const SUPPORTED_PI_SESSION_VERSION = 3;
+export function wrapEntry(options) {
+    if (!options.runId)
+        throw new TypeError('a run log record needs a runId');
+    if (!Number.isInteger(options.seq) || options.seq < 1) {
+        throw new TypeError(`run log seq must be a positive integer, received ${String(options.seq)}`);
+    }
+    return {
+        runId: options.runId,
+        seq: options.seq,
+        recordedAt: options.recordedAt ?? new Date().toISOString(),
+        piSessionVersion: options.piSessionVersion ?? SUPPORTED_PI_SESSION_VERSION,
+        entry: assertPiSessionEntry(options.entry)
+    };
+}
+/**
+ * Narrow an untrusted record (database row, HTTP body). Throws on anything
+ * unreadable — a log that cannot be parsed must fail loudly, never silently
+ * render as an empty conversation.
+ */
+export function assertRunEventRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError(`run log record must be an object, received ${typeof value}`);
+    }
+    const record = value;
+    if (typeof record.runId !== 'string' || record.runId.length === 0) {
+        throw new TypeError('run log record must carry a non-empty runId');
+    }
+    if (!Number.isInteger(record.seq) || record.seq < 1) {
+        throw new TypeError(`run log record ${record.runId} has an invalid seq: ${String(record.seq)}`);
+    }
+    if (typeof record.recordedAt !== 'string') {
+        throw new TypeError(`run log record ${record.runId}#${String(record.seq)} must carry recordedAt`);
+    }
+    if (!Number.isInteger(record.piSessionVersion)) {
+        throw new TypeError(`run log record ${record.runId}#${String(record.seq)} must carry an integer piSessionVersion`);
+    }
+    return {
+        runId: record.runId,
+        seq: record.seq,
+        recordedAt: record.recordedAt,
+        piSessionVersion: record.piSessionVersion,
+        entry: assertPiSessionEntry(record.entry)
+    };
+}
+/**
+ * The de-duplication key for an append. pi entry ids are unique within a
+ * session, so a retried append (a Job restart re-emitting its tail, a
+ * reconnecting writer) is recognised rather than duplicated.
+ */
+export function idempotencyKey(runId, entry) {
+    const id = typeof entry.id === 'string' ? entry.id : null;
+    if (id)
+        return `${runId}:${entry.type}:${id}`;
+    // Session headers carry no tree id; there is exactly one per session file.
+    return `${runId}:${entry.type}:${String(entry.id ?? 'header')}`;
+}
+/** Records must be contiguous and in order before anything projects them. */
+export function assertOrdered(records) {
+    for (let i = 1; i < records.length; i += 1) {
+        const previous = records[i - 1];
+        const current = records[i];
+        if (current.runId !== previous.runId) {
+            throw new Error(`run log records mix runs: ${previous.runId} then ${current.runId} at index ${String(i)}`);
+        }
+        if (current.seq <= previous.seq) {
+            throw new Error(`run log records out of order in ${current.runId}: seq ${String(previous.seq)} followed by ${String(current.seq)}`);
+        }
+    }
+}

package/esm/store.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The storage contract. A run log is append-only and read by cursor, so the
+ * interfaces are deliberately two: a writer (the agent host) and a reader
+ * (every UI surface, the resume path, the usage rollup). Concrete stores live
+ * with their storage — Postgres in constructive-db, JSONL in `./file-store`,
+ * memory here for tests and for a run that has not been persisted yet.
+ */
+import type { PiSessionEntry } from './pi-entry';
+import { type RunEventRecord } from './record';
+/** Read position: `afterSeq` is exclusive, so `0` means "from the start". */
+export interface RunLogCursor {
+    afterSeq: number;
+}
+export declare const START: RunLogCursor;
+export declare const cursorAfter: (records: readonly RunEventRecord[], from?: RunLogCursor) => RunLogCursor;
+export interface RunLogPage {
+    records: RunEventRecord[];
+    cursor: RunLogCursor;
+}
+export interface AppendOptions {
+    /** pi session format version the entries were produced under. */
+    piSessionVersion?: number;
+    recordedAt?: string;
+}
+export interface RunLogAppendStore {
+    /**
+     * Append entries to a run, returning the records actually written. Entries
+     * already present (matched by pi entry id) are skipped, which makes an append
+     * safe to retry.
+     */
+    append(runId: string, entries: readonly PiSessionEntry[], options?: AppendOptions): Promise<RunEventRecord[]>;
+}
+export interface RunLogReadStore {
+    read(runId: string, cursor?: RunLogCursor, limit?: number): Promise<RunLogPage>;
+}
+export type RunLogStore = RunLogAppendStore & RunLogReadStore;
+/** In-memory store: the reference implementation and the test double. */
+export declare class MemoryRunLogStore implements RunLogStore {
+    private readonly runs;
+    private readonly seen;
+    append(runId: string, entries: readonly PiSessionEntry[], options?: AppendOptions): Promise<RunEventRecord[]>;
+    read(runId: string, cursor?: RunLogCursor, limit?: number): Promise<RunLogPage>;
+    /** Test/debug helper: every record of a run, ignoring cursors. */
+    snapshot(runId: string): RunEventRecord[];
+    runIds(): string[];
+}

package/esm/store.js

@@ -0,0 +1,51 @@
+/**
+ * The storage contract. A run log is append-only and read by cursor, so the
+ * interfaces are deliberately two: a writer (the agent host) and a reader
+ * (every UI surface, the resume path, the usage rollup). Concrete stores live
+ * with their storage — Postgres in constructive-db, JSONL in `./file-store`,
+ * memory here for tests and for a run that has not been persisted yet.
+ */
+import { assertOrdered, idempotencyKey, SUPPORTED_PI_SESSION_VERSION, wrapEntry } from './record';
+export const START = { afterSeq: 0 };
+export const cursorAfter = (records, from = START) => records.length === 0 ? from : { afterSeq: records[records.length - 1].seq };
+/** In-memory store: the reference implementation and the test double. */
+export class MemoryRunLogStore {
+    runs = new Map();
+    seen = new Map();
+    async append(runId, entries, options = {}) {
+        const records = this.runs.get(runId) ?? [];
+        const seen = this.seen.get(runId) ?? new Set();
+        const written = [];
+        for (const entry of entries) {
+            const key = idempotencyKey(runId, entry);
+            if (seen.has(key))
+                continue;
+            const record = wrapEntry({
+                runId,
+                seq: records.length + written.length + 1,
+                entry,
+                ...(options.recordedAt ? { recordedAt: options.recordedAt } : {}),
+                piSessionVersion: options.piSessionVersion ?? SUPPORTED_PI_SESSION_VERSION
+            });
+            written.push(record);
+            seen.add(key);
+        }
+        this.runs.set(runId, records.concat(written));
+        this.seen.set(runId, seen);
+        return written;
+    }
+    async read(runId, cursor = START, limit) {
+        const all = this.runs.get(runId) ?? [];
+        const after = all.filter((record) => record.seq > cursor.afterSeq);
+        const records = typeof limit === 'number' ? after.slice(0, limit) : after;
+        assertOrdered(records);
+        return { records, cursor: cursorAfter(records, cursor) };
+    }
+    /** Test/debug helper: every record of a run, ignoring cursors. */
+    snapshot(runId) {
+        return (this.runs.get(runId) ?? []).slice();
+    }
+    runIds() {
+        return Array.from(this.runs.keys());
+    }
+}

package/file-store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `@agentic-kit/run-log/file-store` — the node-only JSONL store.
+ *
+ * A separate entry point because the package's main entry is imported by
+ * browsers, Electron renderers and Next client components; a `node:fs` import
+ * there breaks those bundles. Same split, same reason, as `12factor-env/dotenv`.
+ *
+ * The file holds one wrapped record per line, so a run is recoverable with
+ * `tail -f` and a partially-written last line is detectable rather than silently
+ * dropped. This is the store a local run uses before (or without) a database,
+ * and the one tests use when they want the log to survive a process restart.
+ */
+import type { PiSessionEntry } from './pi-entry';
+import { type SessionProjectionOptions } from './projectors/session';
+import { type RunEventRecord } from './record';
+import { type AppendOptions, type RunLogCursor, type RunLogPage, type RunLogStore } from './store';
+export interface FileRunLogStoreOptions {
+    /** Absolute path of the log file. Parent directories are created. */
+    path: string;
+}
+export declare class FileRunLogStore implements RunLogStore {
+    private readonly path;
+    constructor(options: FileRunLogStoreOptions);
+    private load;
+    append(runId: string, entries: readonly PiSessionEntry[], options?: AppendOptions): Promise<RunEventRecord[]>;
+    read(runId: string, cursor?: RunLogCursor, limit?: number): Promise<RunLogPage>;
+}
+/**
+ * Write the run's pi session file so `SessionManager.open` can resume it. This
+ * is the cloud→local (and local→local restart) resume path: project, write,
+ * hand the path to pi.
+ */
+export declare function writeSessionFile(path: string, records: readonly RunEventRecord[], options?: SessionProjectionOptions): string;

package/file-store.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * `@agentic-kit/run-log/file-store` — the node-only JSONL store.
+ *
+ * A separate entry point because the package's main entry is imported by
+ * browsers, Electron renderers and Next client components; a `node:fs` import
+ * there breaks those bundles. Same split, same reason, as `12factor-env/dotenv`.
+ *
+ * The file holds one wrapped record per line, so a run is recoverable with
+ * `tail -f` and a partially-written last line is detectable rather than silently
+ * dropped. This is the store a local run uses before (or without) a database,
+ * and the one tests use when they want the log to survive a process restart.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRunLogStore = void 0;
+exports.writeSessionFile = writeSessionFile;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const session_1 = require("./projectors/session");
+const record_1 = require("./record");
+const store_1 = require("./store");
+class FileRunLogStore {
+    path;
+    constructor(options) {
+        this.path = options.path;
+    }
+    load() {
+        if (!(0, node_fs_1.existsSync)(this.path))
+            return [];
+        const contents = (0, node_fs_1.readFileSync)(this.path, 'utf8');
+        const records = [];
+        const lines = contents.split('\n');
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i].trim();
+            if (line.length === 0)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (error) {
+                throw new Error(`run log ${this.path} line ${String(i + 1)} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            records.push((0, record_1.assertRunEventRecord)(parsed));
+        }
+        return records;
+    }
+    async append(runId, entries, options = {}) {
+        const existing = this.load().filter((record) => record.runId === runId);
+        const seen = new Set(existing.map((record) => (0, record_1.idempotencyKey)(runId, record.entry)));
+        const written = [];
+        for (const entry of entries) {
+            const key = (0, record_1.idempotencyKey)(runId, entry);
+            if (seen.has(key))
+                continue;
+            written.push((0, record_1.wrapEntry)({
+                runId,
+                seq: existing.length + written.length + 1,
+                entry,
+                ...(options.recordedAt ? { recordedAt: options.recordedAt } : {}),
+                piSessionVersion: options.piSessionVersion ?? record_1.SUPPORTED_PI_SESSION_VERSION
+            }));
+            seen.add(key);
+        }
+        if (written.length === 0)
+            return written;
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.path), { recursive: true });
+        if (!(0, node_fs_1.existsSync)(this.path))
+            (0, node_fs_1.writeFileSync)(this.path, '', { mode: 0o600 });
+        (0, node_fs_1.appendFileSync)(this.path, written.map((record) => JSON.stringify(record)).join('\n') + '\n');
+        return written;
+    }
+    async read(runId, cursor = store_1.START, limit) {
+        const after = this.load().filter((record) => record.runId === runId && record.seq > cursor.afterSeq);
+        const records = typeof limit === 'number' ? after.slice(0, limit) : after;
+        return { records, cursor: (0, store_1.cursorAfter)(records, cursor) };
+    }
+}
+exports.FileRunLogStore = FileRunLogStore;
+/**
+ * Write the run's pi session file so `SessionManager.open` can resume it. This
+ * is the cloud→local (and local→local restart) resume path: project, write,
+ * hand the path to pi.
+ */
+function writeSessionFile(path, records, options = {}) {
+    const projection = (0, session_1.projectSession)(records, options);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, projection.jsonl, { mode: 0o600 });
+    return path;
+}

package/follow.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Following a run log.
+ *
+ * Every surface — a desktop chat pane, a web execution view, a CLI tail, the
+ * resume path — is the same reader: hold a cursor, ask for what came after it.
+ * That is what makes local and cloud runs indistinguishable to a UI, so this is
+ * the only reader loop in the system.
+ *
+ * A push wakeup (LISTEN/NOTIFY, IPC, websocket) is an optimisation, not a
+ * requirement: `waitForChange` short-circuits the delay when it resolves, and
+ * without one the loop degrades to polling at `pollIntervalMs`.
+ */
+import type { RunEventRecord } from './record';
+import { type RunLogCursor, type RunLogReadStore } from './store';
+export interface FollowOptions {
+    cursor?: RunLogCursor;
+    /** Polling delay when no wakeup arrives. */
+    pollIntervalMs?: number;
+    /** Records per read. */
+    limit?: number;
+    /** Resolves when the run may have new records; races the poll delay. */
+    waitForChange?: (signal?: AbortSignal) => Promise<void>;
+    /** Stop following once this returns true for the batch just yielded. */
+    isTerminal?: (records: readonly RunEventRecord[]) => boolean;
+    signal?: AbortSignal;
+    /** Injectable for tests; defaults to `setTimeout`. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Yield every batch of new records until the run reaches a terminal state or
+ * the caller aborts. Batches are yielded as read, so a caller can project
+ * incrementally rather than re-projecting the whole run per frame.
+ */
+export declare function follow(store: RunLogReadStore, runId: string, options?: FollowOptions): AsyncGenerator<RunEventRecord[], void, void>;
+/** Read a run to its current end in one pass. */
+export declare function readAll(store: RunLogReadStore, runId: string, cursor?: RunLogCursor, pageLimit?: number): Promise<RunEventRecord[]>;

package/follow.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Following a run log.
+ *
+ * Every surface — a desktop chat pane, a web execution view, a CLI tail, the
+ * resume path — is the same reader: hold a cursor, ask for what came after it.
+ * That is what makes local and cloud runs indistinguishable to a UI, so this is
+ * the only reader loop in the system.
+ *
+ * A push wakeup (LISTEN/NOTIFY, IPC, websocket) is an optimisation, not a
+ * requirement: `waitForChange` short-circuits the delay when it resolves, and
+ * without one the loop degrades to polling at `pollIntervalMs`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.follow = follow;
+exports.readAll = readAll;
+const store_1 = require("./store");
+const defaultSleep = (ms, signal) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(timer);
+        resolve();
+    }, { once: true });
+});
+/**
+ * Yield every batch of new records until the run reaches a terminal state or
+ * the caller aborts. Batches are yielded as read, so a caller can project
+ * incrementally rather than re-projecting the whole run per frame.
+ */
+async function* follow(store, runId, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 500;
+    const sleep = options.sleep ?? defaultSleep;
+    let cursor = options.cursor ?? store_1.START;
+    while (!options.signal?.aborted) {
+        const page = await store.read(runId, cursor, options.limit);
+        if (page.records.length > 0) {
+            cursor = (0, store_1.cursorAfter)(page.records, cursor);
+            yield page.records;
+            if (options.isTerminal?.(page.records))
+                return;
+            // Drain before waiting: a burst of tool output should not be paced by the
+            // poll interval.
+            continue;
+        }
+        if (options.waitForChange) {
+            await Promise.race([
+                options.waitForChange(options.signal),
+                sleep(pollIntervalMs, options.signal)
+            ]);
+        }
+        else {
+            await sleep(pollIntervalMs, options.signal);
+        }
+    }
+}
+/** Read a run to its current end in one pass. */
+async function readAll(store, runId, cursor = store_1.START, pageLimit = 500) {
+    const records = [];
+    let position = cursor;
+    for (;;) {
+        const page = await store.read(runId, position, pageLimit);
+        if (page.records.length === 0)
+            return records;
+        records.push(...page.records);
+        position = (0, store_1.cursorAfter)(page.records, position);
+        if (page.records.length < pageLimit)
+            return records;
+    }
+}

package/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@agentic-kit/run-log` — the append-only run log: one ordered record of what
+ * an agent run did, wherever it ran.
+ *
+ * Browser-safe on purpose: renderers import the projectors, so nothing here may
+ * reach for a node builtin. The filesystem store lives behind
+ * `@agentic-kit/run-log/file-store`.
+ */
+export { follow, type FollowOptions, readAll } from './follow';
+export { assertPiSessionEntry, contentText, isAssistantMessage, isPiBranchSummaryEntry, isPiCompactionEntry, isPiMessageEntry, isPiSessionHeader, isToolResultMessage, type PiAssistantMessage, type PiBashExecutionMessage, type PiBranchSummaryEntry, type PiCompactionEntry, type PiContent, type PiCustomMessage, type PiEntryBase, type PiImageContent, type PiMessage, type PiMessageEntry, type PiOtherEntry, type PiSessionEntry, type PiSessionHeader, type PiSummaryMessage, type PiTextContent, type PiThinkingContent, type PiToolCallContent, type PiToolResultMessage, type PiUsage, type PiUsageCost, type PiUserMessage, toolCalls } from './pi-entry';
+export { type BashPart, type Conversation, type ConversationPart, type CustomPart, projectParts, type SummaryPart, type TextPart, type ThinkingPart, type ToolPart, type ToolStatus, type UnknownPart } from './projectors/parts';
+export { parseSessionJsonl, projectSession, type SessionProjection, type SessionProjectionOptions } from './projectors/session';
+export { APPROVAL_REQUEST_TYPE, APPROVAL_RESOLUTION_TYPE, type ApprovalRequestInput, approvalRequestMessage, type ApprovalResolutionInput, approvalResolutionMessage, type ApprovalState, projectToolState, type ToolCallState, type ToolCallStatus, type ToolStateProjection } from './projectors/tool-state';
+export { modelKey, type ModelUsage, projectUsage, type RunUsage, type UsageTotals } from './projectors/usage';
+export { assertOrdered, assertRunEventRecord, idempotencyKey, RUN_LOG_WRAPPER_VERSION, type RunEventRecord, SUPPORTED_PI_SESSION_VERSION, wrapEntry, type WrapEntryOptions } from './record';
+export { type AppendOptions, cursorAfter, MemoryRunLogStore, type RunLogAppendStore, type RunLogCursor, type RunLogPage, type RunLogReadStore, type RunLogStore, START } from './store';

package/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * `@agentic-kit/run-log` — the append-only run log: one ordered record of what
+ * an agent run did, wherever it ran.
+ *
+ * Browser-safe on purpose: renderers import the projectors, so nothing here may
+ * reach for a node builtin. The filesystem store lives behind
+ * `@agentic-kit/run-log/file-store`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.START = exports.MemoryRunLogStore = exports.cursorAfter = exports.wrapEntry = exports.SUPPORTED_PI_SESSION_VERSION = exports.RUN_LOG_WRAPPER_VERSION = exports.idempotencyKey = exports.assertRunEventRecord = exports.assertOrdered = exports.projectUsage = exports.modelKey = exports.projectToolState = exports.approvalResolutionMessage = exports.approvalRequestMessage = exports.APPROVAL_RESOLUTION_TYPE = exports.APPROVAL_REQUEST_TYPE = exports.projectSession = exports.parseSessionJsonl = exports.projectParts = exports.toolCalls = exports.isToolResultMessage = exports.isPiSessionHeader = exports.isPiMessageEntry = exports.isPiCompactionEntry = exports.isPiBranchSummaryEntry = exports.isAssistantMessage = exports.contentText = exports.assertPiSessionEntry = exports.readAll = exports.follow = void 0;
+var follow_1 = require("./follow");
+Object.defineProperty(exports, "follow", { enumerable: true, get: function () { return follow_1.follow; } });
+Object.defineProperty(exports, "readAll", { enumerable: true, get: function () { return follow_1.readAll; } });
+var pi_entry_1 = require("./pi-entry");
+Object.defineProperty(exports, "assertPiSessionEntry", { enumerable: true, get: function () { return pi_entry_1.assertPiSessionEntry; } });
+Object.defineProperty(exports, "contentText", { enumerable: true, get: function () { return pi_entry_1.contentText; } });
+Object.defineProperty(exports, "isAssistantMessage", { enumerable: true, get: function () { return pi_entry_1.isAssistantMessage; } });
+Object.defineProperty(exports, "isPiBranchSummaryEntry", { enumerable: true, get: function () { return pi_entry_1.isPiBranchSummaryEntry; } });
+Object.defineProperty(exports, "isPiCompactionEntry", { enumerable: true, get: function () { return pi_entry_1.isPiCompactionEntry; } });
+Object.defineProperty(exports, "isPiMessageEntry", { enumerable: true, get: function () { return pi_entry_1.isPiMessageEntry; } });
+Object.defineProperty(exports, "isPiSessionHeader", { enumerable: true, get: function () { return pi_entry_1.isPiSessionHeader; } });
+Object.defineProperty(exports, "isToolResultMessage", { enumerable: true, get: function () { return pi_entry_1.isToolResultMessage; } });
+Object.defineProperty(exports, "toolCalls", { enumerable: true, get: function () { return pi_entry_1.toolCalls; } });
+var parts_1 = require("./projectors/parts");
+Object.defineProperty(exports, "projectParts", { enumerable: true, get: function () { return parts_1.projectParts; } });
+var session_1 = require("./projectors/session");
+Object.defineProperty(exports, "parseSessionJsonl", { enumerable: true, get: function () { return session_1.parseSessionJsonl; } });
+Object.defineProperty(exports, "projectSession", { enumerable: true, get: function () { return session_1.projectSession; } });
+var tool_state_1 = require("./projectors/tool-state");
+Object.defineProperty(exports, "APPROVAL_REQUEST_TYPE", { enumerable: true, get: function () { return tool_state_1.APPROVAL_REQUEST_TYPE; } });
+Object.defineProperty(exports, "APPROVAL_RESOLUTION_TYPE", { enumerable: true, get: function () { return tool_state_1.APPROVAL_RESOLUTION_TYPE; } });
+Object.defineProperty(exports, "approvalRequestMessage", { enumerable: true, get: function () { return tool_state_1.approvalRequestMessage; } });
+Object.defineProperty(exports, "approvalResolutionMessage", { enumerable: true, get: function () { return tool_state_1.approvalResolutionMessage; } });
+Object.defineProperty(exports, "projectToolState", { enumerable: true, get: function () { return tool_state_1.projectToolState; } });
+var usage_1 = require("./projectors/usage");
+Object.defineProperty(exports, "modelKey", { enumerable: true, get: function () { return usage_1.modelKey; } });
+Object.defineProperty(exports, "projectUsage", { enumerable: true, get: function () { return usage_1.projectUsage; } });
+var record_1 = require("./record");
+Object.defineProperty(exports, "assertOrdered", { enumerable: true, get: function () { return record_1.assertOrdered; } });
+Object.defineProperty(exports, "assertRunEventRecord", { enumerable: true, get: function () { return record_1.assertRunEventRecord; } });
+Object.defineProperty(exports, "idempotencyKey", { enumerable: true, get: function () { return record_1.idempotencyKey; } });
+Object.defineProperty(exports, "RUN_LOG_WRAPPER_VERSION", { enumerable: true, get: function () { return record_1.RUN_LOG_WRAPPER_VERSION; } });
+Object.defineProperty(exports, "SUPPORTED_PI_SESSION_VERSION", { enumerable: true, get: function () { return record_1.SUPPORTED_PI_SESSION_VERSION; } });
+Object.defineProperty(exports, "wrapEntry", { enumerable: true, get: function () { return record_1.wrapEntry; } });
+var store_1 = require("./store");
+Object.defineProperty(exports, "cursorAfter", { enumerable: true, get: function () { return store_1.cursorAfter; } });
+Object.defineProperty(exports, "MemoryRunLogStore", { enumerable: true, get: function () { return store_1.MemoryRunLogStore; } });
+Object.defineProperty(exports, "START", { enumerable: true, get: function () { return store_1.START; } });

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@agentic-kit/run-log",
+  "version": "0.2.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "The append-only agent run log — pi session entries stored verbatim under a run/seq wrapper, with projections for transcript, usage, tool state and resumable sessions",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [
+    "agentic-kit",
+    "pi",
+    "coding-agent",
+    "run-log",
+    "constructive"
+  ],
+  "gitHead": "d4bf3a37545daad7246505a96ae8a4b87f44d53c"
+}