praxis-agent 0.35.0 → 0.37.0

package/dist/persistence/subagent-lifecycle-store.js

@@ -2,20 +2,26 @@ import { readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isClaudeSessionId } from '../compatibility/claude/paths.js';
 import { isClaudeAgentId } from '../compatibility/claude/sidechain.js';
+import { createAgentLifecycle, continueLifecycle, isTerminalLifecycleState, markLifecycleOrphaned, parseAgentLifecycleSnapshot, recoverLifecycle, transitionLifecycle, } from '../core/agent-orchestration.js';
+import { ExclusiveFileLease, } from '../platform/exclusive-file-lease.js';
 import { writeFileAtomically } from '../platform/atomic-write.js';
-const statuses = new Set([
-    'running',
-    'completed',
-    'failed',
-    'killed',
-]);
+function statusFor(snapshot) {
+    if (snapshot.state === 'completed')
+        return 'completed';
+    if (snapshot.state === 'failed')
+        return 'failed';
+    if (snapshot.state === 'cancelled')
+        return 'killed';
+    return 'running';
+}
+function publicRecord(record) {
+    return Object.assign({ ...record }, { status: statusFor(record.lifecycle) });
+}
 function assertIdentity(sessionId, agentId) {
-    if (!isClaudeSessionId(sessionId)) {
+    if (!isClaudeSessionId(sessionId))
         throw new Error(`Invalid subagent lifecycle session ID: ${sessionId}`);
-    }
-    if (!isClaudeAgentId(agentId)) {
+    if (!isClaudeAgentId(agentId))
         throw new Error(`Invalid subagent lifecycle agent ID: ${agentId}`);
-    }
 }
 function isNonnegativeInteger(value) {
     return Number.isSafeInteger(value) && Number(value) >= 0;
@@ -24,54 +30,43 @@ function isNonnegativeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0;
 }
 function isUsage(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;
-    }
     const usage = value;
     if (!isNonnegativeInteger(usage.inputTokens) ||
-        !isNonnegativeInteger(usage.outputTokens)) {
+        !isNonnegativeInteger(usage.outputTokens))
         return false;
-    }
     for (const field of [
         'cacheReadInputTokens',
         'cacheCreationInputTokens',
         'webSearchRequests',
-    ]) {
-        if (usage[field] !== undefined && !isNonnegativeInteger(usage[field])) {
+    ])
+        if (usage[field] !== undefined && !isNonnegativeInteger(usage[field]))
             return false;
-        }
-    }
-    for (const field of ['contextWindow', 'maxOutputTokens']) {
+    for (const field of ['contextWindow', 'maxOutputTokens'])
         if (usage[field] !== undefined &&
-            (!Number.isSafeInteger(usage[field]) || Number(usage[field]) < 1)) {
+            (!Number.isSafeInteger(usage[field]) || Number(usage[field]) < 1))
             return false;
-        }
-    }
     return true;
 }
 function isRunResult(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;
-    }
     const result = value;
     if (typeof result.text !== 'string' ||
         !isUsage(result.usage) ||
         !isNonnegativeInteger(result.toolUseCount) ||
-        !isNonnegativeInteger(result.durationMs)) {
+        !isNonnegativeInteger(result.durationMs))
         return false;
-    }
     if (result.modelUsage !== undefined &&
         (typeof result.modelUsage !== 'object' ||
             result.modelUsage === null ||
             Array.isArray(result.modelUsage) ||
-            !Object.values(result.modelUsage).every(isUsage))) {
+            !Object.values(result.modelUsage).every(isUsage)))
         return false;
-    }
-    for (const field of ['durationApiMs', 'durationApiWithoutRetriesMs']) {
-        if (result[field] !== undefined && !isNonnegativeNumber(result[field])) {
+    for (const field of ['durationApiMs', 'durationApiWithoutRetriesMs'])
+        if (result[field] !== undefined && !isNonnegativeNumber(result[field]))
             return false;
-        }
-    }
     return ((result.isolationPath === undefined ||
         typeof result.isolationPath === 'string') &&
         (result.isolationRetained === undefined ||
@@ -80,9 +75,8 @@ function isRunResult(value) {
             typeof result.isolationWarning === 'string'));
 }
 function isNotification(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;
-    }
     const notification = value;
     const accounting = notification.accounting;
     return (typeof notification.id === 'string' &&
@@ -103,12 +97,76 @@ function isNotification(value) {
                     0 &&
                 typeof accounting.delivered === 'boolean')));
 }
-/** Praxis-private state for a retained Claude-compatible sidechain. */
+function ownerFromLease(lease) {
+    return { token: lease.token, pid: lease.pid, acquiredAt: lease.createdAt };
+}
+export class SubagentExecution {
+    store;
+    lease;
+    token;
+    generation;
+    current;
+    released = false;
+    constructor(store, lease, token, generation, current) {
+        this.store = store;
+        this.lease = lease;
+        this.token = token;
+        this.generation = generation;
+        this.current = current;
+    }
+    get snapshot() {
+        return this.current;
+    }
+    async transition(state) {
+        this.ensureActive();
+        this.current = await this.store.mutateOwned(this.lease, this.generation, (record) => this.store.withLifecycle(record, transitionLifecycle(record.lifecycle, state, this.token)));
+        return this.current;
+    }
+    async running() {
+        return this.transition('running');
+    }
+    async beginCancellation() {
+        return this.transition('cancelling');
+    }
+    async finish(state, result, detail, notification) {
+        this.ensureActive();
+        this.current = await this.store.mutateOwned(this.lease, this.generation, (record) => {
+            const lifecycle = transitionLifecycle(record.lifecycle, state, this.token);
+            const notifications = [...(record.notifications ?? [])];
+            if (notification && result)
+                notifications.push({ ...notification, result, consumed: false });
+            return this.store.withLifecycle(record, lifecycle, {
+                ...(detail === undefined ? {} : { detail }),
+                ...(result === undefined ? {} : { result }),
+                ...(notifications.length === 0 ? {} : { notifications }),
+            });
+        }, true);
+        return this.current;
+    }
+    async release() {
+        if (this.released)
+            return;
+        try {
+            if (!isTerminalLifecycleState(this.current.state))
+                this.current = await this.store.mutateOwned(this.lease, this.generation, (record) => this.store.withLifecycle(record, markLifecycleOrphaned(record.lifecycle, this.token)));
+        }
+        finally {
+            this.released = true;
+            await this.lease.release();
+        }
+    }
+    ensureActive() {
+        if (this.released)
+            throw new Error('Lifecycle execution has been released');
+    }
+}
 export class SubagentLifecycleStore {
     sessionId;
     agentId;
     transcriptPath;
     path;
+    ownerLock;
+    mutationLock;
     mutation = Promise.resolve();
     constructor(praxisRoot, sessionId, agentId, transcriptPath) {
         this.sessionId = sessionId;
@@ -116,141 +174,151 @@ export class SubagentLifecycleStore {
         this.transcriptPath = transcriptPath;
         assertIdentity(sessionId, agentId);
         this.path = join(praxisRoot, 'subagent-lifecycle', sessionId, `${agentId}.json`);
+        this.ownerLock = new ExclusiveFileLease(`${this.path}.owner.lock`);
+        this.mutationLock = new ExclusiveFileLease(`${this.path}.mutation.lock`);
     }
     async read() {
-        let source;
+        const record = await this.readStored();
+        return record ? publicRecord(record) : null;
+    }
+    async acquire(mode = 'start') {
+        const lease = await this.ownerLock.tryAcquire();
+        if (!lease)
+            throw new Error(`Subagent lifecycle execution is already owned: ${this.path}`);
+        let mutationLease;
         try {
-            source = await readFile(this.path, 'utf8');
+            mutationLease = await this.acquireMutationLock();
         }
         catch (error) {
-            if (error.code === 'ENOENT')
-                return null;
+            await lease.release();
             throw error;
         }
-        let value;
         try {
-            value = JSON.parse(source);
+            const record = await this.readStored();
+            const owner = ownerFromLease(lease);
+            let lifecycle;
+            if (!record) {
+                if (mode !== 'start')
+                    throw new Error(`Cannot ${mode} missing subagent lifecycle state: ${this.path}`);
+                lifecycle = createAgentLifecycle(owner);
+            }
+            else if (mode === 'start') {
+                throw new Error(`Subagent lifecycle already exists: ${this.path}`);
+            }
+            else if (mode === 'recover') {
+                lifecycle = recoverLifecycle(record.lifecycle, owner);
+            }
+            else {
+                lifecycle = continueLifecycle(record.lifecycle, owner);
+            }
+            const next = this.withLifecycle(record ?? this.baseRecord(lifecycle), lifecycle);
+            await this.writeStored(next, false);
+            return new SubagentExecution(this, lease, owner.token, lifecycle.generation, lifecycle);
         }
         catch (error) {
-            throw new Error(`Corrupt subagent lifecycle state: ${this.path}`, {
-                cause: error,
-            });
-        }
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+            await lease.release();
+            throw error;
         }
-        const record = value;
-        if (record.version !== 1 ||
-            record.sessionId !== this.sessionId ||
-            record.agentId !== this.agentId ||
-            typeof record.status !== 'string' ||
-            !statuses.has(record.status) ||
-            typeof record.updatedAt !== 'string' ||
-            Number.isNaN(Date.parse(record.updatedAt)) ||
-            (record.transcriptBytes !== undefined &&
-                !isNonnegativeInteger(record.transcriptBytes)) ||
-            (record.detail !== undefined && typeof record.detail !== 'string') ||
-            (record.result !== undefined && !isRunResult(record.result)) ||
-            (record.notifications !== undefined &&
-                (!Array.isArray(record.notifications) ||
-                    !record.notifications.every(isNotification)))) {
-            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+        finally {
+            await mutationLease.release();
         }
-        return record;
     }
-    write(status, detail, terminal) {
-        return this.mutate(async (current) => {
-            const notifications = [...(current?.notifications ?? [])];
-            if (terminal?.notification) {
-                notifications.push({
-                    ...terminal.notification,
-                    result: terminal.result,
-                    consumed: false,
-                });
+    start() {
+        return this.acquire('start');
+    }
+    continue() {
+        return this.acquire('continue');
+    }
+    recover() {
+        return this.acquire('recover');
+    }
+    async reconcileOwnerLoss() {
+        const current = await this.readStored();
+        if (!current || isTerminalLifecycleState(current.lifecycle.state)) {
+            return { owned: false, snapshot: current?.lifecycle ?? null };
+        }
+        const probe = await this.ownerLock.tryAcquire();
+        if (!probe) {
+            const reread = await this.readStored();
+            if (!reread || isTerminalLifecycleState(reread.lifecycle.state)) {
+                return { owned: false, snapshot: reread?.lifecycle ?? null };
             }
-            return this.record({
-                status,
-                ...(detail === undefined ? {} : { detail }),
-                ...(terminal === undefined ? {} : { result: terminal.result }),
-                ...(notifications.length === 0 ? {} : { notifications }),
+            return { owned: true, snapshot: reread.lifecycle };
+        }
+        try {
+            const observed = await this.readStored();
+            if (!observed || isTerminalLifecycleState(observed.lifecycle.state)) {
+                return { owned: false, snapshot: observed?.lifecycle ?? null };
+            }
+            const reconciled = await this.mutate(async (latest) => {
+                if (!latest)
+                    return observed;
+                if (latest.lifecycle.generation !== observed.lifecycle.generation ||
+                    latest.lifecycle.owner?.token !== observed.lifecycle.owner?.token)
+                    return latest;
+                return this.withLifecycle(latest, markLifecycleOrphaned(latest.lifecycle, latest.lifecycle.owner?.token ?? ''));
             });
-        });
+            return { owned: false, snapshot: reconciled.lifecycle };
+        }
+        finally {
+            await probe.release();
+        }
     }
     acknowledgeNotification(id) {
         return this.mutate(async (current) => {
-            if (!current) {
+            if (!current)
                 throw new Error(`Missing subagent lifecycle state: ${this.path}`);
-            }
             const notifications = current.notifications ?? [];
-            const matched = notifications.find((notification) => notification.id === id && !notification.consumed);
-            if (!matched)
+            if (!notifications.some((n) => n.id === id && !n.consumed))
                 return current;
-            return this.record({
-                status: current.status,
-                ...(current.detail === undefined ? {} : { detail: current.detail }),
-                ...(current.result === undefined ? {} : { result: current.result }),
-                notifications: notifications.map((notification) => notification.id === id
-                    ? { ...notification, consumed: true }
-                    : notification),
-            }, { transcriptBytes: current.transcriptBytes });
-        });
+            return this.withLifecycle(current, current.lifecycle, {
+                notifications: notifications.map((n) => n.id === id ? { ...n, consumed: true } : n),
+            });
+        }).then(() => undefined);
     }
     prepareNotificationDetached(id, model) {
-        if (model.trim().length === 0) {
+        if (model.trim().length === 0)
             throw new Error('Detached notification model must not be blank');
-        }
         return this.mutate(async (current) => {
-            if (!current) {
+            if (!current)
                 throw new Error(`Missing subagent lifecycle state: ${this.path}`);
-            }
             const notifications = current.notifications ?? [];
-            const matched = notifications.find((notification) => notification.id === id);
+            const matched = notifications.find((n) => n.id === id);
             if (!matched || matched.accounting?.kind === 'detached')
                 return current;
-            return this.record({
-                status: current.status,
-                ...(current.detail === undefined ? {} : { detail: current.detail }),
-                ...(current.result === undefined ? {} : { result: current.result }),
-                notifications: notifications.map((notification) => notification.id === id
+            return this.withLifecycle(current, current.lifecycle, {
+                notifications: notifications.map((n) => n.id === id
                     ? {
-                        ...notification,
+                        ...n,
                         accounting: {
                             kind: 'detached',
                             model,
                             delivered: false,
                         },
                     }
-                    : notification),
-            }, { transcriptBytes: current.transcriptBytes });
-        });
+                    : n),
+            });
+        }).then(() => undefined);
     }
     confirmNotificationDetached(id) {
         return this.mutate(async (current) => {
-            if (!current) {
+            if (!current)
                 throw new Error(`Missing subagent lifecycle state: ${this.path}`);
-            }
             const notifications = current.notifications ?? [];
-            const matched = notifications.find((notification) => notification.id === id);
+            const matched = notifications.find((n) => n.id === id);
             if (!matched?.accounting || matched.accounting.delivered)
                 return current;
-            return this.record({
-                status: current.status,
-                ...(current.detail === undefined ? {} : { detail: current.detail }),
-                ...(current.result === undefined ? {} : { result: current.result }),
-                notifications: notifications.map((notification) => notification.id === id && notification.accounting
-                    ? {
-                        ...notification,
-                        accounting: { ...notification.accounting, delivered: true },
-                    }
-                    : notification),
-            }, { transcriptBytes: current.transcriptBytes });
-        });
+            return this.withLifecycle(current, current.lifecycle, {
+                notifications: notifications.map((n) => n.id === id && n.accounting
+                    ? { ...n, accounting: { ...n.accounting, delivered: true } }
+                    : n),
+            });
+        }).then(() => undefined);
     }
     async matchesTranscript(record) {
         if (record.transcriptBytes === undefined ||
-            this.transcriptPath === undefined) {
+            this.transcriptPath === undefined)
             return true;
-        }
         try {
             return (await stat(this.transcriptPath)).size === record.transcriptBytes;
         }
@@ -260,40 +328,199 @@ export class SubagentLifecycleStore {
             throw error;
         }
     }
-    async record(value, boundary) {
-        let transcriptBytes = boundary?.transcriptBytes;
-        if (boundary === undefined && this.transcriptPath !== undefined) {
+    baseRecord(lifecycle) {
+        return {
+            version: 2,
+            sessionId: this.sessionId,
+            agentId: this.agentId,
+            lifecycle,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    withLifecycle(current, lifecycle, extra = {}) {
+        return {
+            version: 2,
+            sessionId: this.sessionId,
+            agentId: this.agentId,
+            lifecycle,
+            updatedAt: new Date().toISOString(),
+            ...(extra.detail === undefined
+                ? current.detail === undefined
+                    ? {}
+                    : { detail: current.detail }
+                : { detail: extra.detail }),
+            ...(extra.result === undefined
+                ? current.result === undefined
+                    ? {}
+                    : { result: current.result }
+                : { result: extra.result }),
+            ...(extra.notifications === undefined
+                ? current.notifications === undefined
+                    ? {}
+                    : { notifications: current.notifications }
+                : { notifications: extra.notifications }),
+            ...(current.transcriptBytes === undefined
+                ? {}
+                : { transcriptBytes: current.transcriptBytes }),
+        };
+    }
+    async mutateOwned(lease, generation, operation, refreshTranscript = false) {
+        const record = await this.mutate(async (current) => {
+            if (!current)
+                throw new Error(`Missing subagent lifecycle state: ${this.path}`);
+            if (current.lifecycle.generation !== generation ||
+                current.lifecycle.owner?.token !== lease.token)
+                throw new Error('Lifecycle execution owner token is stale or missing');
+            return operation(current);
+        }, refreshTranscript);
+        return record.lifecycle;
+    }
+    mutate(operation, refreshTranscript = false) {
+        const queued = this.mutation.then(async () => {
+            const lock = await this.acquireMutationLock();
             try {
-                transcriptBytes = (await stat(this.transcriptPath)).size;
+                const result = await operation(await this.readStored());
+                await this.writeStored(result, refreshTranscript);
+                return result;
             }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
+            finally {
+                await lock.release();
             }
+        });
+        this.mutation = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    async acquireMutationLock() {
+        const deadline = Date.now() + 5_000;
+        for (;;) {
+            const lock = await this.mutationLock.tryAcquire();
+            if (lock)
+                return lock;
+            if (Date.now() >= deadline)
+                throw new Error(`Subagent lifecycle mutation is busy: ${this.path}`);
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    async readStored() {
+        let source;
+        try {
+            source = await readFile(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        let value;
+        try {
+            value = JSON.parse(source);
+        }
+        catch (error) {
+            throw new Error(`Corrupt subagent lifecycle state: ${this.path}`, {
+                cause: error,
+            });
+        }
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+        const record = value;
+        if (record.version === 1)
+            return this.normalizeLegacy(record);
+        let lifecycle;
+        try {
+            lifecycle = parseAgentLifecycleSnapshot(record.lifecycle);
+        }
+        catch {
+            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+        }
+        if (record.version !== 2 ||
+            record.sessionId !== this.sessionId ||
+            record.agentId !== this.agentId ||
+            typeof record.updatedAt !== 'string' ||
+            Number.isNaN(Date.parse(record.updatedAt)) ||
+            (record.transcriptBytes !== undefined &&
+                !isNonnegativeInteger(record.transcriptBytes)) ||
+            (record.detail !== undefined && typeof record.detail !== 'string') ||
+            (record.result !== undefined && !isRunResult(record.result)) ||
+            (record.notifications !== undefined &&
+                (!Array.isArray(record.notifications) ||
+                    !record.notifications.every(isNotification))))
+            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+        return { ...record, lifecycle };
+    }
+    normalizeLegacy(record) {
+        if (record.sessionId !== this.sessionId ||
+            record.agentId !== this.agentId ||
+            typeof record.status !== 'string' ||
+            !['running', 'completed', 'failed', 'killed'].includes(record.status) ||
+            typeof record.updatedAt !== 'string' ||
+            Number.isNaN(Date.parse(record.updatedAt)) ||
+            (record.transcriptBytes !== undefined &&
+                !isNonnegativeInteger(record.transcriptBytes)) ||
+            (record.detail !== undefined && typeof record.detail !== 'string') ||
+            (record.result !== undefined && !isRunResult(record.result)) ||
+            (record.notifications !== undefined &&
+                (!Array.isArray(record.notifications) ||
+                    !record.notifications.every(isNotification))))
+            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
+        const status = record.status;
+        const state = status === 'killed'
+            ? 'cancelled'
+            : status === 'running'
+                ? 'orphaned'
+                : status;
+        const terminal = isTerminalLifecycleState(state);
+        let lifecycle;
+        try {
+            lifecycle = parseAgentLifecycleSnapshot({
+                generation: 1,
+                revision: 0,
+                state,
+                owner: null,
+                previousOwnerToken: null,
+                terminalAt: terminal ? record.updatedAt : null,
+                acceptance: 'pending',
+            });
+        }
+        catch {
+            throw new Error(`Invalid subagent lifecycle state: ${this.path}`);
         }
         return {
-            version: 1,
+            version: 2,
             sessionId: this.sessionId,
             agentId: this.agentId,
-            status: value.status,
-            updatedAt: new Date().toISOString(),
-            ...(transcriptBytes === undefined ? {} : { transcriptBytes }),
-            ...(value.detail === undefined ? {} : { detail: value.detail }),
-            ...(value.result === undefined ? {} : { result: value.result }),
-            ...(value.notifications === undefined
+            lifecycle,
+            updatedAt: record.updatedAt,
+            ...(record.transcriptBytes === undefined
+                ? {}
+                : { transcriptBytes: record.transcriptBytes }),
+            ...(record.detail === undefined
+                ? {}
+                : { detail: record.detail }),
+            ...(record.result === undefined
                 ? {}
-                : { notifications: value.notifications }),
+                : { result: record.result }),
+            ...(record.notifications === undefined
+                ? {}
+                : {
+                    notifications: record.notifications,
+                }),
         };
     }
-    mutate(mutation) {
-        const operation = this.mutation.then(async () => {
-            const record = await mutation(await this.read());
-            await writeFileAtomically(this.path, `${JSON.stringify(record)}\n`, {
-                mode: 0o600,
-            });
+    async writeStored(record, refreshTranscript) {
+        let transcriptBytes = record.transcriptBytes;
+        if (refreshTranscript && this.transcriptPath !== undefined) {
+            try {
+                transcriptBytes = (await stat(this.transcriptPath)).size;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        const next = transcriptBytes === undefined ? record : { ...record, transcriptBytes };
+        await writeFileAtomically(this.path, `${JSON.stringify(next)}\n`, {
+            mode: 0o600,
         });
-        this.mutation = operation.catch(() => undefined);
-        return operation;
     }
 }
 //# sourceMappingURL=subagent-lifecycle-store.js.map

package/dist/persistence/transcript-file-append.d.ts

@@ -0,0 +1,2 @@
+export declare function classifyTranscriptAppend(written: Uint8Array, previousByteLength: number, encodedLine: Uint8Array): 'appended' | 'interleaved-write';
+//# sourceMappingURL=transcript-file-append.d.ts.map

package/dist/persistence/transcript-file-append.js

@@ -0,0 +1,10 @@
+export function classifyTranscriptAppend(written, previousByteLength, encodedLine) {
+    const expectedEnd = previousByteLength + encodedLine.length;
+    if (written.length === expectedEnd &&
+        Buffer.from(written)
+            .subarray(previousByteLength, expectedEnd)
+            .equals(encodedLine))
+        return 'appended';
+    return 'interleaved-write';
+}
+//# sourceMappingURL=transcript-file-append.js.map

package/dist/platform/exclusive-file-lease.d.ts

@@ -1,4 +1,7 @@
 export interface ExclusiveFileLeaseHandle {
+    readonly token: string;
+    readonly pid: number;
+    readonly createdAt: string;
     release(): Promise<void>;
 }
 export declare class ExclusiveFileLease {