@felan-ai/felan 0.12.7 → 0.12.9

package/dist/memory/lease.js

@@ -0,0 +1,188 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, readdir, rename, rm, utimes, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { acquireLocalFileLock } from '../lock.js';
+const DEFAULT_STALE_MS = 30_000;
+const DEFAULT_UPDATE_MS = 10_000;
+export async function acquireLocalMemoryLease(projectDirectory, options = {}) {
+    const target = join(projectDirectory, 'writer');
+    const gateTarget = join(projectDirectory, 'writer.gate');
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, '', { flag: 'a', mode: 0o600 });
+    await writeFile(gateTarget, '', { flag: 'a', mode: 0o600 });
+    const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+    let gateLock;
+    try {
+        gateLock = await acquireLocalFileLock(gateTarget, {
+            realpath: false,
+            stale: staleMs,
+            update: options.updateMs ?? DEFAULT_UPDATE_MS,
+            retries: 0,
+            preservePathOnRelease: true,
+        });
+    }
+    catch (error) {
+        if (isLocked(error))
+            return undefined;
+        throw error;
+    }
+    let fileLock;
+    try {
+        await recoverStaleLegacyLock(target, staleMs);
+        fileLock = await acquireLocalFileLock(target, {
+            realpath: false,
+            stale: staleMs,
+            update: options.updateMs ?? DEFAULT_UPDATE_MS,
+            retries: 0,
+            preservePathOnRelease: true,
+        });
+    }
+    catch (error) {
+        await gateLock.release().catch(() => { });
+        await gateLock.retire(staleMs);
+        if (isLocked(error))
+            return undefined;
+        throw error;
+    }
+    const token = randomUUID();
+    const acquiredAt = new Date().toISOString();
+    const ownerPath = `${target}.owner.${token}.json`;
+    const temporaryOwnerPath = `${ownerPath}.${token}.tmp`;
+    const compromiseController = new AbortController();
+    const onCompromise = () => {
+        compromiseController.abort(new Error('Memory writer lease was lost'));
+    };
+    gateLock.compromised.addEventListener('abort', onCompromise, { once: true });
+    fileLock.compromised.addEventListener('abort', onCompromise, { once: true });
+    try {
+        await writeFile(temporaryOwnerPath, `${JSON.stringify({ token, acquiredAt, pid: process.pid })}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+            flag: 'wx',
+        });
+        await rename(temporaryOwnerPath, ownerPath);
+        gateLock.throwIfCompromised('Memory writer lease was lost during acquisition');
+        fileLock.throwIfCompromised('Memory writer lease was lost during acquisition');
+        if (!(await gateLock.isCurrent()) || !(await fileLock.isCurrent())) {
+            throw new Error('Memory writer lease was lost during acquisition');
+        }
+        await garbageCollectOwnerFiles(target, ownerPath);
+    }
+    catch (error) {
+        await rm(temporaryOwnerPath, { force: true }).catch(() => { });
+        await removeOwnerIfToken(ownerPath, token);
+        await fileLock.release().catch(() => { });
+        await fileLock.retire(staleMs);
+        gateLock.compromised.removeEventListener('abort', onCompromise);
+        fileLock.compromised.removeEventListener('abort', onCompromise);
+        await gateLock.release().catch(() => { });
+        await gateLock.retire(staleMs);
+        throw error;
+    }
+    let released = false;
+    return {
+        token,
+        acquiredAt,
+        compromised: compromiseController.signal,
+        async verify() {
+            if (released || fileLock.isCompromised())
+                return false;
+            if (gateLock.isCompromised())
+                return false;
+            if (!(await gateLock.isCurrent()) || !(await fileLock.isCurrent()))
+                return false;
+            try {
+                const owner = JSON.parse(await readFile(ownerPath, 'utf8'));
+                return owner.token === token;
+            }
+            catch {
+                return false;
+            }
+        },
+        async release() {
+            if (released)
+                return;
+            released = true;
+            let ownsOwnerRecord = false;
+            try {
+                const owner = JSON.parse(await readFile(ownerPath, 'utf8'));
+                ownsOwnerRecord = owner.token === token;
+            }
+            catch {
+                // A missing owner record is fenced and must not release a possible successor lock.
+            }
+            if (ownsOwnerRecord)
+                await rm(ownerPath, { force: true }).catch(() => { });
+            // LocalFileLock guards the underlying directory identity before rmdir, so
+            // releasing a fenced handle stops its heartbeat without removing a successor.
+            await fileLock.release().catch(() => { });
+            await fileLock.retire(staleMs);
+            gateLock.compromised.removeEventListener('abort', onCompromise);
+            fileLock.compromised.removeEventListener('abort', onCompromise);
+            await gateLock.release().catch(() => { });
+            await gateLock.retire(staleMs);
+        },
+    };
+}
+async function garbageCollectOwnerFiles(target, currentOwnerPath) {
+    const directory = dirname(target);
+    const prefix = `${basename(target)}.owner.`;
+    let entries;
+    try {
+        entries = await readdir(directory);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return;
+        throw error;
+    }
+    await Promise.all(entries
+        .filter((entry) => entry.startsWith(prefix) && join(directory, entry) !== currentOwnerPath)
+        .map((entry) => rm(join(directory, entry), { force: true })));
+}
+async function recoverStaleLegacyLock(target, staleMs) {
+    const lockPath = `${target}.lock`;
+    const ownerPath = join(lockPath, 'owner.json');
+    const effectiveStaleMs = Math.max(staleMs, 2_000);
+    const initial = await safeLstat(lockPath);
+    if (!initial?.isDirectory() || initial.mtimeMs >= Date.now() - effectiveStaleMs)
+        return;
+    const owner = await safeLstat(ownerPath);
+    if (!owner?.isFile())
+        return;
+    const confirmed = await safeLstat(lockPath);
+    if (!confirmed?.isDirectory()
+        || confirmed.mtimeMs !== initial.mtimeMs
+        || confirmed.mtimeMs >= Date.now() - effectiveStaleMs)
+        return;
+    await rm(ownerPath, { force: true });
+    const retiredAt = new Date(Date.now() - effectiveStaleMs - 1_000);
+    await utimes(lockPath, retiredAt, retiredAt).catch(() => { });
+}
+async function removeOwnerIfToken(ownerPath, token) {
+    try {
+        const owner = JSON.parse(await readFile(ownerPath, 'utf8'));
+        if (owner.token === token)
+            await rm(ownerPath, { force: true });
+    }
+    catch { }
+}
+async function safeLstat(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+function isLocked(error) {
+    return typeof error === 'object'
+        && error !== null
+        && Reflect.get(error, 'code') === 'ELOCKED';
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && Reflect.get(error, 'code') === 'ENOENT';
+}
+//# sourceMappingURL=lease.js.map

package/dist/memory/lease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lease.js","sourceRoot":"","sources":["../../src/memory/lease.ts"],"names":[],"mappings":"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"}

package/dist/memory/project.d.ts

@@ -0,0 +1,7 @@
+export interface LocalMemoryProject {
+    readonly canonicalRoot: string;
+    readonly key: string;
+}
+export declare function resolveLocalMemoryProject(cwd: string): Promise<LocalMemoryProject>;
+export declare function localMemoryProjectDirectory(agentDir: string, project: LocalMemoryProject): string;
+//# sourceMappingURL=project.d.ts.map

package/dist/memory/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/memory/project.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAQxF;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAEjG"}

package/dist/memory/project.js

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { realpath } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { resolve } from 'node:path';
+const execFileAsync = promisify(execFile);
+export async function resolveLocalMemoryProject(cwd) {
+    const canonicalCwd = await canonicalPath(cwd);
+    const gitRoot = await discoverGitRoot(canonicalCwd);
+    const canonicalRoot = await canonicalPath(gitRoot ?? canonicalCwd);
+    return {
+        canonicalRoot,
+        key: createHash('sha256').update(canonicalRoot, 'utf8').digest('hex'),
+    };
+}
+export function localMemoryProjectDirectory(agentDir, project) {
+    return resolve(agentDir, 'memory', 'v1', 'projects', project.key);
+}
+async function discoverGitRoot(cwd) {
+    try {
+        const result = await execFileAsync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
+            encoding: 'utf8',
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        const root = result.stdout.trim();
+        return root.length > 0 ? root : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function canonicalPath(path) {
+    try {
+        return await realpath(resolve(path));
+    }
+    catch {
+        return resolve(path);
+    }
+}
+//# sourceMappingURL=project.js.map

package/dist/memory/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/memory/project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,aAAa,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;AAO1C,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,GAAW;IACzD,MAAM,YAAY,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,YAAY,CAAC,CAAC;IACpD,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,OAAO,IAAI,YAAY,CAAC,CAAC;IACnE,OAAO;QACL,aAAa;QACb,GAAG,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KACtE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,QAAgB,EAAE,OAA2B;IACvF,OAAO,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;AACpE,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,GAAW;IACxC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE;YACrF,QAAQ,EAAE,MAAM;YAChB,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,IAAY;IACvC,IAAI,CAAC;QACH,OAAO,MAAM,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACvC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;AACH,CAAC"}

package/dist/memory/store.d.ts

@@ -0,0 +1,52 @@
+import { type MemoryArtifact, type MemorySnapshot, type SessionCheckpoint } from '@felan-ai/ext-memory';
+import type { LocalMemoryProject } from './project.js';
+import { type LocalMemoryLease } from './lease.js';
+declare const STATE_VERSION: 1;
+export interface StoredCheckpoint {
+    readonly checkpoint: SessionCheckpoint;
+    readonly recordedAt: string;
+}
+export interface ProcessedCheckpoint extends StoredCheckpoint {
+    readonly processedAt: string;
+    readonly memoryFingerprint: string;
+}
+export interface LocalMemoryState {
+    readonly version: typeof STATE_VERSION;
+    readonly memoryFingerprint: string;
+    readonly pending: Readonly<Record<string, StoredCheckpoint>>;
+    readonly processed: Readonly<Record<string, ProcessedCheckpoint>>;
+    readonly updatedAt: string;
+}
+export interface LocalMemoryProcessingSnapshot {
+    readonly artifact: MemoryArtifact;
+    readonly fingerprint: string;
+    readonly checkpoints: readonly StoredCheckpoint[];
+    readonly state: LocalMemoryState;
+}
+export interface LocalMemoryStoreOptions {
+    readonly memoryPath?: string;
+}
+export declare class LocalMemoryStore {
+    #private;
+    readonly agentDir: string;
+    readonly project: LocalMemoryProject;
+    readonly projectDirectory: string;
+    readonly currentDirectory: string;
+    readonly stagingDirectory: string;
+    readonly statePath: string;
+    readonly projectionName = ".memory";
+    constructor(agentDir: string, project: LocalMemoryProject, options?: LocalMemoryStoreOptions);
+    initialize(): Promise<void>;
+    readCurrent(): Promise<MemorySnapshot>;
+    projectTo(sessionStorageRoot: string, snapshot?: MemorySnapshot): Promise<MemorySnapshot>;
+    recordCheckpoint(checkpoint: SessionCheckpoint): Promise<boolean>;
+    status(): Promise<LocalMemoryState>;
+    processingSnapshot(maxSessions?: number): Promise<LocalMemoryProcessingSnapshot>;
+    createStagingDirectory(): Promise<string>;
+    commit(lease: LocalMemoryLease, baseFingerprint: string, artifact: MemoryArtifact, processed: readonly StoredCheckpoint[]): Promise<string>;
+    clearStaging(): Promise<void>;
+    get memoryPath(): string;
+    private readState;
+}
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/memory/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/memory/store.ts"],"names":[],"mappings":"AAGA,OAAO,EAOL,KAAK,cAAc,EAEnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAA2B,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG5E,QAAA,MAAM,aAAa,EAAG,CAAU,CAAC;AAEjC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,aAAa,CAAC;IACvC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAClE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,gBAAgB;;IASzB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,OAAO,EAAE,kBAAkB;IATtC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,aAAa;gBAIzB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,EACpC,OAAO,GAAE,uBAA4B;IASjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B3B,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC;IAOtC,SAAS,CACb,kBAAkB,EAAE,MAAM,EAC1B,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,cAAc,CAAC;IAQpB,gBAAgB,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBjE,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAInC,kBAAkB,CAAC,WAAW,SAAI,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAY3E,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAOzC,MAAM,CACV,KAAK,EAAE,gBAAgB,EACvB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,SAAS,gBAAgB,EAAE,GACrC,OAAO,CAAC,MAAM,CAAC;IAiEZ,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAKnC,IAAI,UAAU,IAAI,MAAM,CAEvB;YAEa,SAAS;CAKxB"}

package/dist/memory/store.js

@@ -0,0 +1,344 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile, lstat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { createEmptyMemoryArtifact, createMemoryProjectionSnapshot, createMemorySnapshot, hydrateMemoryDirectory, memoryArtifactFingerprint, readMemoryDirectory, } from '@felan-ai/ext-memory';
+import { localMemoryProjectDirectory } from './project.js';
+import { acquireLocalMemoryLease } from './lease.js';
+import { withLocalFileLock } from '../lock.js';
+const STATE_VERSION = 1;
+export class LocalMemoryStore {
+    agentDir;
+    project;
+    projectDirectory;
+    currentDirectory;
+    stagingDirectory;
+    statePath;
+    projectionName = '.memory';
+    #memoryPath;
+    constructor(agentDir, project, options = {}) {
+        this.agentDir = agentDir;
+        this.project = project;
+        this.projectDirectory = localMemoryProjectDirectory(agentDir, project);
+        this.currentDirectory = join(this.projectDirectory, 'current');
+        this.stagingDirectory = join(this.projectDirectory, 'staging');
+        this.statePath = join(this.projectDirectory, 'state.json');
+        this.#memoryPath = options.memoryPath ?? '.memory';
+    }
+    async initialize() {
+        await mkdir(this.projectDirectory, { recursive: true, mode: 0o700 });
+        await mkdir(this.stagingDirectory, { recursive: true, mode: 0o700 });
+        const recoveryLease = await acquireLocalMemoryLease(this.projectDirectory);
+        try {
+            await withStateLock(this, async () => {
+                if (recoveryLease)
+                    await recoverTransaction(this);
+                const current = await safeLstat(this.currentDirectory);
+                if (current?.isSymbolicLink())
+                    throw new Error('Canonical memory current directory cannot be a symlink');
+                if (!current) {
+                    await hydrateMemoryDirectory(createEmptyMemoryArtifact(this.#memoryPath), this.currentDirectory);
+                }
+                const artifact = await readMemoryDirectory(this.currentDirectory, { memoryPath: this.#memoryPath });
+                const fingerprint = memoryArtifactFingerprint(artifact);
+                const existing = await readState(this.statePath);
+                if (!existing || existing.memoryFingerprint !== fingerprint) {
+                    await writeState(this.statePath, {
+                        version: STATE_VERSION,
+                        memoryFingerprint: fingerprint,
+                        pending: existing?.pending ?? {},
+                        processed: existing?.processed ?? {},
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+            });
+        }
+        finally {
+            await recoveryLease?.release();
+        }
+    }
+    async readCurrent() {
+        return withStateLock(this, async () => {
+            const artifact = await readMemoryDirectory(this.currentDirectory, { memoryPath: this.#memoryPath });
+            return createMemorySnapshot(artifact, this.#memoryPath);
+        });
+    }
+    async projectTo(sessionStorageRoot, snapshot) {
+        const current = snapshot ?? await this.readCurrent();
+        const target = join(sessionStorageRoot, this.projectionName);
+        const projection = createMemoryProjectionSnapshot(current, target);
+        await hydrateMemoryDirectory(projection, target, { replace: true, memoryPath: target });
+        return projection;
+    }
+    async recordCheckpoint(checkpoint) {
+        return withStateLock(this, async () => {
+            const state = await this.readState();
+            const previousPending = state.pending[checkpoint.sessionId];
+            const previousProcessed = state.processed[checkpoint.sessionId];
+            if (sameCursor(previousPending?.checkpoint, checkpoint) || sameCursor(previousProcessed?.checkpoint, checkpoint)) {
+                return false;
+            }
+            const pending = {
+                ...state.pending,
+                [checkpoint.sessionId]: {
+                    checkpoint,
+                    recordedAt: new Date().toISOString(),
+                },
+            };
+            await writeState(this.statePath, { ...state, pending, updatedAt: new Date().toISOString() });
+            return true;
+        });
+    }
+    async status() {
+        return this.readState();
+    }
+    async processingSnapshot(maxSessions = 8) {
+        return withStateLock(this, async () => {
+            const state = await this.readState();
+            const artifact = await readMemoryDirectory(this.currentDirectory, { memoryPath: this.#memoryPath });
+            const fingerprint = memoryArtifactFingerprint(artifact);
+            const checkpoints = Object.values(state.pending)
+                .sort((left, right) => left.recordedAt.localeCompare(right.recordedAt))
+                .slice(0, maxSessions);
+            return { artifact, fingerprint, checkpoints, state };
+        });
+    }
+    async createStagingDirectory() {
+        await mkdir(this.stagingDirectory, { recursive: true, mode: 0o700 });
+        const path = join(this.stagingDirectory, `run-${randomUUID()}`);
+        await mkdir(path, { recursive: true, mode: 0o700 });
+        return path;
+    }
+    async commit(lease, baseFingerprint, artifact, processed) {
+        if (!(await lease.verify()))
+            throw new Error('Memory writer lease was lost before commit');
+        const fingerprint = memoryArtifactFingerprint(artifact);
+        const staging = await this.createStagingDirectory();
+        const stagedMemory = join(staging, 'memory');
+        const previousMemory = join(staging, 'previous');
+        const journalPath = join(staging, 'commit.json');
+        await hydrateMemoryDirectory(artifact, stagedMemory, { memoryPath: this.#memoryPath });
+        await writeFile(journalPath, `${JSON.stringify({
+            version: 1,
+            baseFingerprint,
+            fingerprint,
+            processed: processed.map(({ checkpoint }) => checkpoint.sessionId),
+        })}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        if (!(await lease.verify()))
+            throw new Error('Memory writer lease was lost before replacement');
+        try {
+            await withStateLock(this, async () => {
+                const current = await readMemoryDirectory(this.currentDirectory, { memoryPath: this.#memoryPath });
+                if (memoryArtifactFingerprint(current) !== baseFingerprint) {
+                    throw new Error('Memory changed while the dream was running');
+                }
+                if (!(await lease.verify()))
+                    throw new Error('Memory writer lease was lost before replacement');
+                await rename(this.currentDirectory, previousMemory);
+                try {
+                    await rename(stagedMemory, this.currentDirectory);
+                    if (!(await lease.verify()))
+                        throw new Error('Memory writer lease was lost after replacement');
+                    const state = await this.readState();
+                    if (!(await lease.verify()))
+                        throw new Error('Memory writer lease was lost before state commit');
+                    if (state.memoryFingerprint !== baseFingerprint)
+                        throw new Error('Memory state changed while the dream was running');
+                    const processedAt = new Date().toISOString();
+                    const pending = { ...state.pending };
+                    const nextProcessed = { ...state.processed };
+                    for (const entry of processed) {
+                        const currentPending = pending[entry.checkpoint.sessionId];
+                        if (!currentPending || !sameCursor(currentPending.checkpoint, entry.checkpoint))
+                            continue;
+                        delete pending[entry.checkpoint.sessionId];
+                        nextProcessed[entry.checkpoint.sessionId] = {
+                            ...entry,
+                            processedAt,
+                            memoryFingerprint: fingerprint,
+                        };
+                    }
+                    await writeState(this.statePath, {
+                        version: STATE_VERSION,
+                        memoryFingerprint: fingerprint,
+                        pending,
+                        processed: nextProcessed,
+                        updatedAt: processedAt,
+                    });
+                }
+                catch (error) {
+                    const replacement = await safeLstat(this.currentDirectory);
+                    if (replacement)
+                        await rm(this.currentDirectory, { recursive: true, force: true });
+                    await rename(previousMemory, this.currentDirectory).catch(() => { });
+                    throw error;
+                }
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+        await rm(previousMemory, { recursive: true, force: true });
+        await rm(staging, { recursive: true, force: true });
+        return fingerprint;
+    }
+    async clearStaging() {
+        await rm(this.stagingDirectory, { recursive: true, force: true });
+        await mkdir(this.stagingDirectory, { recursive: true, mode: 0o700 });
+    }
+    get memoryPath() {
+        return this.#memoryPath;
+    }
+    async readState() {
+        const state = await readState(this.statePath);
+        if (!state)
+            throw new Error('Local memory state is missing or invalid');
+        return state;
+    }
+}
+async function recoverTransaction(store) {
+    const entries = await safeReadDir(store.stagingDirectory);
+    for (const entry of entries) {
+        const path = join(store.stagingDirectory, entry);
+        const journalPath = join(path, 'commit.json');
+        const journal = await readJson(journalPath);
+        if (!journal) {
+            await rm(path, { recursive: true, force: true });
+            continue;
+        }
+        const current = await safeLstat(store.currentDirectory);
+        const memory = join(path, 'memory');
+        const previous = join(path, 'previous');
+        if (current && typeof journal.fingerprint === 'string'
+            && await fingerprintAt(store.currentDirectory, store.memoryPath) === journal.fingerprint) {
+            await applyRecoveredStateUnlocked(store, journal.fingerprint, journal.processed);
+            await rm(path, { recursive: true, force: true });
+            continue;
+        }
+        if (!current && await safeLstat(previous)) {
+            await rename(previous, store.currentDirectory);
+        }
+        await rm(path, { recursive: true, force: true });
+        void memory;
+    }
+}
+async function applyRecoveredStateUnlocked(store, fingerprint, sessionIds) {
+    if (!Array.isArray(sessionIds))
+        return;
+    const state = await readState(store.statePath);
+    if (!state)
+        return;
+    const pending = { ...state.pending };
+    const processed = { ...state.processed };
+    const processedAt = new Date().toISOString();
+    for (const sessionId of sessionIds) {
+        if (typeof sessionId !== 'string')
+            continue;
+        const entry = pending[sessionId];
+        if (!entry)
+            continue;
+        delete pending[sessionId];
+        processed[sessionId] = { ...entry, processedAt, memoryFingerprint: fingerprint };
+    }
+    await writeState(store.statePath, { ...state, memoryFingerprint: fingerprint, pending, processed, updatedAt: processedAt });
+}
+async function withStateLock(store, operation) {
+    await mkdir(dirname(store.statePath), { recursive: true });
+    try {
+        await writeFile(store.statePath, '{}', { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (!isAlreadyExists(error))
+            throw error;
+    }
+    return withLocalFileLock(store.statePath, {
+        realpath: false,
+        retries: { retries: 20, minTimeout: 10, maxTimeout: 100 },
+    }, operationWithLock(operation));
+}
+function operationWithLock(operation) {
+    return async (lock) => {
+        const result = await operation();
+        lock.throwIfCompromised();
+        return result;
+    };
+}
+async function writeState(path, state) {
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    await rename(temporary, path);
+}
+async function readState(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (!isRecord(value) || value.version !== STATE_VERSION || typeof value.memoryFingerprint !== 'string'
+            || !isRecord(value.pending) || !isRecord(value.processed) || typeof value.updatedAt !== 'string')
+            return undefined;
+        return {
+            version: STATE_VERSION,
+            memoryFingerprint: value.memoryFingerprint,
+            pending: value.pending,
+            processed: value.processed,
+            updatedAt: value.updatedAt,
+        };
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+async function fingerprintAt(path, memoryPath) {
+    try {
+        return memoryArtifactFingerprint(await readMemoryDirectory(path, { memoryPath }));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+async function readJson(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        return isRecord(value) ? value : undefined;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        return undefined;
+    }
+}
+async function safeReadDir(path) {
+    try {
+        const { readdir } = await import('node:fs/promises');
+        return await readdir(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+}
+async function safeLstat(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+function sameCursor(left, right) {
+    return left?.leafId === right.leafId && left?.transcriptDigest === right.transcriptDigest;
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && Reflect.get(error, 'code') === 'ENOENT';
+}
+function isAlreadyExists(error) {
+    return typeof error === 'object' && error !== null && Reflect.get(error, 'code') === 'EEXIST';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=store.js.map