@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/session/types.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Session state management types for babysitter orchestration.
+ * These types represent the state stored in markdown files with YAML frontmatter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionErrorCode = exports.SessionError = void 0;
+/**
+ * Error thrown when session operations fail.
+ */
+class SessionError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'SessionError';
+    }
+}
+exports.SessionError = SessionError;
+/**
+ * Session error codes.
+ */
+var SessionErrorCode;
+(function (SessionErrorCode) {
+    /** Session ID not provided */
+    SessionErrorCode["MISSING_SESSION_ID"] = "MISSING_SESSION_ID";
+    /** State file already exists */
+    SessionErrorCode["SESSION_EXISTS"] = "SESSION_EXISTS";
+    /** State file not found */
+    SessionErrorCode["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
+    /** Run already associated */
+    SessionErrorCode["RUN_ALREADY_ASSOCIATED"] = "RUN_ALREADY_ASSOCIATED";
+    /** Run not found */
+    SessionErrorCode["RUN_NOT_FOUND"] = "RUN_NOT_FOUND";
+    /** Run already completed */
+    SessionErrorCode["RUN_COMPLETED"] = "RUN_COMPLETED";
+    /** State file corrupted */
+    SessionErrorCode["CORRUPTED_STATE"] = "CORRUPTED_STATE";
+    /** Invalid state value */
+    SessionErrorCode["INVALID_STATE_VALUE"] = "INVALID_STATE_VALUE";
+    /** File system error */
+    SessionErrorCode["FS_ERROR"] = "FS_ERROR";
+})(SessionErrorCode || (exports.SessionErrorCode = SessionErrorCode = {}));

package/dist/session/write.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Session state file writing utilities.
+ * Provides atomic writes for session state files.
+ */
+import type { SessionState } from './types';
+/**
+ * Serialize session state to YAML frontmatter format.
+ */
+export declare function serializeSessionState(state: SessionState): string;
+/**
+ * Create full session file content with YAML frontmatter and prompt.
+ */
+export declare function createSessionFileContent(state: SessionState, prompt: string): string;
+/**
+ * Write session state file atomically.
+ * Uses temp file + rename pattern to ensure atomic writes.
+ */
+export declare function writeSessionFile(filePath: string, state: SessionState, prompt: string): Promise<void>;
+/**
+ * Update specific fields in an existing session state file.
+ * Reads, modifies, and atomically writes the file.
+ */
+export declare function updateSessionState(filePath: string, updates: Partial<SessionState>, existingContent?: {
+    state: SessionState;
+    prompt: string;
+}): Promise<SessionState>;
+/**
+ * Bind a new run to the session, retiring the previous active run to history.
+ *
+ * Invariant: only one run is active at a time (`runId`).
+ * The previous `runId` (if any) is pushed into `runIds` as audit history.
+ * Idempotent: re-binding the same runId is a no-op.
+ *
+ * Throws if the caller tries to bind a new run while `runId` is still set
+ * and `retirePrevious` is not explicitly true — this forces callers to
+ * acknowledge that the prior run is done.
+ */
+export declare function addRunToSession(state: SessionState, runId: string, options?: {
+    retirePrevious?: boolean;
+}): SessionState;
+/**
+ * Get the historical audit trail of all run IDs for this session (GAP-SESSION-001).
+ * Falls back to [runId] when runIds is empty for backward compatibility
+ * with sessions created before the runIds field existed.
+ */
+export declare function getSessionRuns(state: SessionState): string[];
+/**
+ * Get current ISO timestamp.
+ */
+export declare function getCurrentTimestamp(): string;
+/**
+ * Convert ISO timestamp to epoch seconds.
+ * Returns null if conversion fails.
+ */
+export declare function isoToEpochSeconds(isoTimestamp: string): number | null;
+/**
+ * Calculate iteration duration and update times array.
+ * Keeps only the last 10 durations for diagnostics.
+ */
+export declare function updateIterationTimes(existingTimes: number[], lastIterationAt: string, currentTime: string): number[];
+//# sourceMappingURL=write.d.ts.map

package/dist/session/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/session/write.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAgBjE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGpF;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,EAC9B,eAAe,CAAC,EAAE;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxD,OAAO,CAAC,YAAY,CAAC,CAyBvB;AAGD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACrC,YAAY,CAyBd;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,EAAE,CAG5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASrE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,MAAM,EAAE,CAgBV"}

package/dist/session/write.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Session state file writing utilities.
+ * Provides atomic writes for session state files.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSessionState = serializeSessionState;
+exports.createSessionFileContent = createSessionFileContent;
+exports.writeSessionFile = writeSessionFile;
+exports.updateSessionState = updateSessionState;
+exports.addRunToSession = addRunToSession;
+exports.getSessionRuns = getSessionRuns;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.isoToEpochSeconds = isoToEpochSeconds;
+exports.updateIterationTimes = updateIterationTimes;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+/**
+ * Serialize session state to YAML frontmatter format.
+ */
+function serializeSessionState(state) {
+    const lines = [];
+    lines.push(`active: ${state.active}`);
+    lines.push(`iteration: ${state.iteration}`);
+    lines.push(`max_iterations: ${state.maxIterations}`);
+    lines.push(`run_id: "${state.runId}"`);
+    lines.push(`run_ids: ${state.runIds.join(',')}`);
+    lines.push(`started_at: "${state.startedAt}"`);
+    lines.push(`last_iteration_at: "${state.lastIterationAt}"`);
+    lines.push(`iteration_times: ${state.iterationTimes.join(',')}`);
+    for (const [key, value] of Object.entries(state.metadata ?? {})) {
+        lines.push(`metadata_${key}: "${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Create full session file content with YAML frontmatter and prompt.
+ */
+function createSessionFileContent(state, prompt) {
+    const frontmatter = serializeSessionState(state);
+    return `---\n${frontmatter}\n---\n\n${prompt}\n`;
+}
+/**
+ * Write session state file atomically.
+ * Uses temp file + rename pattern to ensure atomic writes.
+ */
+async function writeSessionFile(filePath, state, prompt) {
+    const content = createSessionFileContent(state, prompt);
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    try {
+        // Ensure directory exists
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        // Write to temp file
+        await node_fs_1.promises.writeFile(tempPath, content, 'utf8');
+        // Atomic rename
+        await node_fs_1.promises.rename(tempPath, filePath);
+    }
+    catch (error) {
+        // Clean up temp file on error
+        try {
+            await node_fs_1.promises.unlink(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        const err = error;
+        throw new types_1.SessionError(`Failed to write session state file: ${err.message}`, types_1.SessionErrorCode.FS_ERROR, { filePath, originalError: err.message });
+    }
+}
+/**
+ * Update specific fields in an existing session state file.
+ * Reads, modifies, and atomically writes the file.
+ */
+async function updateSessionState(filePath, updates, existingContent) {
+    let state;
+    let prompt;
+    if (existingContent) {
+        state = existingContent.state;
+        prompt = existingContent.prompt;
+    }
+    else {
+        // Read existing file
+        const { readSessionFile } = await Promise.resolve().then(() => __importStar(require('./parse')));
+        const file = await readSessionFile(filePath);
+        state = file.state;
+        prompt = file.prompt;
+    }
+    // Apply updates
+    const updatedState = {
+        ...state,
+        ...updates,
+    };
+    // Write updated file
+    await writeSessionFile(filePath, updatedState, prompt);
+    return updatedState;
+}
+/**
+ * Bind a new run to the session, retiring the previous active run to history.
+ *
+ * Invariant: only one run is active at a time (`runId`).
+ * The previous `runId` (if any) is pushed into `runIds` as audit history.
+ * Idempotent: re-binding the same runId is a no-op.
+ *
+ * Throws if the caller tries to bind a new run while `runId` is still set
+ * and `retirePrevious` is not explicitly true — this forces callers to
+ * acknowledge that the prior run is done.
+ */
+function addRunToSession(state, runId, options) {
+    // Idempotent: already bound to this run
+    if (state.runId === runId)
+        return state;
+    // Guard: refuse to silently overwrite an active run
+    if (state.runId && !options?.retirePrevious) {
+        throw new types_1.SessionError(`Session already bound to run ${state.runId}. ` +
+            `Pass { retirePrevious: true } to retire it and bind ${runId}.`, types_1.SessionErrorCode.RUN_ALREADY_ASSOCIATED, { currentRunId: state.runId, requestedRunId: runId });
+    }
+    // Retire the old runId into history (if not already there)
+    const runIds = [...state.runIds];
+    if (state.runId && !runIds.includes(state.runId)) {
+        runIds.push(state.runId);
+    }
+    // Add the new one to the audit trail too
+    if (!runIds.includes(runId)) {
+        runIds.push(runId);
+    }
+    return { ...state, runId, runIds };
+}
+/**
+ * Get the historical audit trail of all run IDs for this session (GAP-SESSION-001).
+ * Falls back to [runId] when runIds is empty for backward compatibility
+ * with sessions created before the runIds field existed.
+ */
+function getSessionRuns(state) {
+    if (state.runIds.length > 0)
+        return state.runIds;
+    return state.runId ? [state.runId] : [];
+}
+/**
+ * Get current ISO timestamp.
+ */
+function getCurrentTimestamp() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+/**
+ * Convert ISO timestamp to epoch seconds.
+ * Returns null if conversion fails.
+ */
+function isoToEpochSeconds(isoTimestamp) {
+    if (!isoTimestamp)
+        return null;
+    try {
+        const date = new Date(isoTimestamp);
+        if (Number.isNaN(date.getTime()))
+            return null;
+        return Math.floor(date.getTime() / 1000);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate iteration duration and update times array.
+ * Keeps only the last 10 durations for diagnostics.
+ */
+function updateIterationTimes(existingTimes, lastIterationAt, currentTime) {
+    const lastEpoch = isoToEpochSeconds(lastIterationAt);
+    const currentEpoch = isoToEpochSeconds(currentTime);
+    if (lastEpoch === null || currentEpoch === null) {
+        return existingTimes;
+    }
+    const duration = currentEpoch - lastEpoch;
+    if (duration <= 0) {
+        return existingTimes;
+    }
+    const newTimes = [...existingTimes, duration];
+    // Keep only last 10
+    return newTimes.slice(-10);
+}

package/dist/storage/atomic.d.ts

@@ -0,0 +1,2 @@
+export declare function writeFileAtomic(targetPath: string, data: string | Buffer, retries?: number): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/storage/atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../../src/storage/atomic.ts"],"names":[],"mappings":"AAcA,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,SAAI,iBAiC3F"}

package/dist/storage/atomic.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomic = writeFileAtomic;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const RETRYABLE_ERRORS = new Set(["EBUSY", "ETXTBSY", "EPERM", "EACCES"]);
+async function fsyncPath(targetPath) {
+    const handle = await node_fs_1.promises.open(targetPath, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function writeFileAtomic(targetPath, data, retries = 3) {
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+    const handle = await node_fs_1.promises.open(tempPath, "w");
+    try {
+        if (typeof data === "string") {
+            await handle.writeFile(data, "utf8");
+        }
+        else {
+            await handle.writeFile(data);
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await node_fs_1.promises.rename(tempPath, targetPath);
+            await fsyncPath(node_path_1.default.dirname(targetPath));
+            return;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                await node_fs_1.promises.writeFile(targetPath, data);
+                return;
+            }
+            if (attempt === retries || !err.code || !RETRYABLE_ERRORS.has(err.code)) {
+                await node_fs_1.promises.rm(tempPath, { force: true });
+                throw err;
+            }
+            await new Promise((resolve) => setTimeout(resolve, (attempt + 1) * 25));
+        }
+    }
+}

package/dist/storage/clock.d.ts

@@ -0,0 +1,2 @@
+export declare function getClockIsoString(): string;
+//# sourceMappingURL=clock.d.ts.map

package/dist/storage/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/storage/clock.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/storage/clock.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClockIsoString = getClockIsoString;
+function getClockIsoString() {
+    return new Date().toISOString();
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,7 @@
+export { createJournalWatcher } from "./journalWatcher";
+export type { JournalWatcher, JournalWatcherOptions } from "./journalWatcher";
+export { snapshotState } from "./snapshotState";
+export { storeTaskArtifacts } from "./storeTaskArtifacts";
+export type { SnapshotStateOptions, StoreTaskArtifactsOptions } from "./types";
+export type { JournalEvent, JsonRecord } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAC/E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeTaskArtifacts = exports.snapshotState = exports.createJournalWatcher = void 0;
+var journalWatcher_1 = require("./journalWatcher");
+Object.defineProperty(exports, "createJournalWatcher", { enumerable: true, get: function () { return journalWatcher_1.createJournalWatcher; } });
+var snapshotState_1 = require("./snapshotState");
+Object.defineProperty(exports, "snapshotState", { enumerable: true, get: function () { return snapshotState_1.snapshotState; } });
+var storeTaskArtifacts_1 = require("./storeTaskArtifacts");
+Object.defineProperty(exports, "storeTaskArtifacts", { enumerable: true, get: function () { return storeTaskArtifacts_1.storeTaskArtifacts; } });

package/dist/storage/journalWatcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GAP-JSON-005: JournalWatcher — real-time event streaming from journal dir.
+ *
+ * Watches a run's journal/ directory for new .json files. Emits events
+ * incrementally (only seq > lastSeenSeq) in strict seq order. Supports
+ * fs.watch with automatic polling fallback.
+ */
+import type { JournalEvent } from "./types";
+export interface JournalWatcherOptions {
+    runDir: string;
+    afterSeq?: number;
+    pollIntervalMs?: number;
+    useFsWatch?: boolean;
+    onEvent: (event: JournalEvent) => void;
+    onError?: (error: Error) => void;
+    onDone?: () => void;
+}
+export interface JournalWatcher {
+    readonly lastSeenSeq: number;
+    onEvent: (event: JournalEvent) => void;
+    close(): void;
+}
+export declare function createJournalWatcher(options: JournalWatcherOptions): JournalWatcher;
+//# sourceMappingURL=journalWatcher.d.ts.map

package/dist/storage/journalWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journalWatcher.d.ts","sourceRoot":"","sources":["../../src/storage/journalWatcher.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,KAAK,IAAI,IAAI,CAAC;CACf;AAQD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CA0InF"}

package/dist/storage/journalWatcher.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * GAP-JSON-005: JournalWatcher — real-time event streaming from journal dir.
+ *
+ * Watches a run's journal/ directory for new .json files. Emits events
+ * incrementally (only seq > lastSeenSeq) in strict seq order. Supports
+ * fs.watch with automatic polling fallback.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJournalWatcher = createJournalWatcher;
+const fsSync = __importStar(require("node:fs"));
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+function parseJournalFilename(name) {
+    const match = name.match(/^(\d{6})\.([A-Z0-9]+)\.json$/);
+    if (!match)
+        return null;
+    return { seq: parseInt(match[1], 10), ulid: match[2] };
+}
+function createJournalWatcher(options) {
+    const { runDir, afterSeq = 0, pollIntervalMs = 1000, useFsWatch = true, onError, onDone, } = options;
+    const journalDir = path.join(runDir, "journal");
+    let lastSeenSeq = afterSeq;
+    let closed = false;
+    let pollTimer = null;
+    let fsWatcher = null;
+    let scanning = false;
+    let eventCallback = options.onEvent;
+    const watcher = {
+        get lastSeenSeq() {
+            return lastSeenSeq;
+        },
+        get onEvent() {
+            return eventCallback;
+        },
+        set onEvent(cb) {
+            eventCallback = cb;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
+            if (fsWatcher) {
+                fsWatcher.close();
+                fsWatcher = null;
+            }
+        },
+    };
+    async function scan() {
+        if (closed || scanning)
+            return;
+        scanning = true;
+        try {
+            let entries;
+            try {
+                entries = await node_fs_1.promises.readdir(journalDir);
+            }
+            catch {
+                return;
+            }
+            const parsed = entries
+                .map((name) => ({ name, parsed: parseJournalFilename(name) }))
+                .filter((entry) => entry.parsed !== null && entry.parsed.seq > lastSeenSeq)
+                .sort((a, b) => a.parsed.seq - b.parsed.seq);
+            for (const entry of parsed) {
+                if (closed)
+                    break;
+                const filePath = path.join(journalDir, entry.name);
+                let event;
+                let eventType;
+                try {
+                    const raw = await node_fs_1.promises.readFile(filePath, "utf-8");
+                    const data = JSON.parse(raw);
+                    eventType = data.type;
+                    event = {
+                        seq: entry.parsed.seq,
+                        ulid: entry.parsed.ulid,
+                        filename: entry.name,
+                        path: `journal/${entry.name}`,
+                        type: data.type,
+                        recordedAt: data.recordedAt,
+                        data: data.data,
+                        checksum: data.checksum,
+                    };
+                }
+                catch (error) {
+                    if (onError) {
+                        onError(error instanceof Error ? error : new Error(String(error)));
+                    }
+                    lastSeenSeq = entry.parsed.seq;
+                    continue;
+                }
+                try {
+                    eventCallback(event);
+                    lastSeenSeq = entry.parsed.seq;
+                }
+                catch (error) {
+                    if (onError) {
+                        onError(error instanceof Error ? error : new Error(String(error)));
+                    }
+                    lastSeenSeq = entry.parsed.seq;
+                }
+                if (eventType === "RUN_COMPLETED" || eventType === "RUN_FAILED") {
+                    if (onDone)
+                        onDone();
+                    watcher.close();
+                }
+            }
+        }
+        finally {
+            scanning = false;
+        }
+    }
+    pollTimer = setInterval(() => {
+        void scan();
+    }, pollIntervalMs);
+    if (useFsWatch) {
+        try {
+            fsWatcher = fsSync.watch(journalDir, () => {
+                void scan();
+            });
+            fsWatcher.on("error", () => {
+                if (fsWatcher) {
+                    fsWatcher.close();
+                    fsWatcher = null;
+                }
+            });
+        }
+        catch {
+            // Polling fallback remains active.
+        }
+    }
+    void scan();
+    return watcher;
+}

package/dist/storage/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function getTasksDir(runDir: string): string;
+export declare function getBlobsDir(runDir: string): string;
+export declare function getStateDir(runDir: string): string;
+export declare function getStateFile(runDir: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/storage/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/storage/paths.ts"],"names":[],"mappings":"AAOA,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/storage/paths.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTasksDir = getTasksDir;
+exports.getBlobsDir = getBlobsDir;
+exports.getStateDir = getStateDir;
+exports.getStateFile = getStateFile;
+const node_path_1 = __importDefault(require("node:path"));
+const TASKS_DIR = "tasks";
+const BLOBS_DIR = "blobs";
+const STATE_DIR = "state";
+const STATE_FILE = "state.json";
+function getTasksDir(runDir) {
+    return node_path_1.default.join(runDir, TASKS_DIR);
+}
+function getBlobsDir(runDir) {
+    return node_path_1.default.join(runDir, BLOBS_DIR);
+}
+function getStateDir(runDir) {
+    return node_path_1.default.join(runDir, STATE_DIR);
+}
+function getStateFile(runDir) {
+    return node_path_1.default.join(getStateDir(runDir), STATE_FILE);
+}

package/dist/storage/snapshotState.d.ts

@@ -0,0 +1,10 @@
+import type { SnapshotStateOptions } from "./types";
+export declare function snapshotState(options: SnapshotStateOptions): Promise<{
+    journalHead: {
+        seq: number;
+        ulid: string;
+    } | null;
+    savedAt: string;
+    state: import("@a5c-ai/babysitter-sdk/dist/storage/types").JsonRecord;
+}>;
+//# sourceMappingURL=snapshotState.d.ts.map