@nowcrew/daemon 0.6.19 → 0.6.21

package/dist/project-skills/runtime-root-leases.js

@@ -0,0 +1,487 @@
+import { randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, opendir, unlink } from "node:fs/promises";
+import { posix, win32 } from "node:path";
+import { durableDirectorySync } from "../atomic-private-write.js";
+import { AtomicNoReplaceRenameError, atomicRenameNoReplace, } from "../atomic-no-replace-rename.js";
+import { createProjectSkillRuntimeLeaseArtifact, leaseArtifactIdentityFromStat, matchesLeaseArtifactIdentity, parseProjectSkillRuntimeLeaseArtifact, } from "./runtime-root-lease-artifact.js";
+import { ProjectSkillRuntimeStoreError, createProjectSkillRuntimeLeaseRecord, projectSkillRuntimeLeaseKey, } from "./runtime-root-domain.js";
+const STORE_DIRECTORY_NAME = "project-skill-runtime";
+const LEASES_DIRECTORY_NAME = "leases";
+const MAX_LEASE_BYTES = 64 * 1024;
+const MAX_LEASE_ENTRIES = 2_048;
+const FINAL_LEASE_NAME = /^([a-f0-9]{64})\.json$/u;
+const STAGING_LEASE_NAME = /^\.lease-private-([a-f0-9]{64})\.json$/u;
+const CLAIM_LEASE_NAME = /^\.lease-claim-([a-f0-9]{64})\.json$/u;
+const DISCARD_STAGE_NAME = /^\.lease-discard-stage-([a-f0-9]{64})\.json$/u;
+const DISCARD_RELEASE_NAME = /^\.lease-discard-release-([a-f0-9]{64})\.json$/u;
+const leaseOperationTails = new Map();
+const codeOf = (error) => error.code;
+const fail = (code = "skill_projection_runtime_root_unmanaged") => {
+    throw new ProjectSkillRuntimeStoreError(code);
+};
+const mapLeaseError = (error) => {
+    if (error instanceof ProjectSkillRuntimeStoreError)
+        throw error;
+    if (error instanceof AtomicNoReplaceRenameError)
+        return fail("skill_projection_failed");
+    return fail("skill_projection_failed");
+};
+const ownedByCurrentUser = (uid) => process.getuid === undefined || uid === BigInt(process.getuid());
+const identityFromStat = (identity) => Object.freeze({
+    dev: identity.dev,
+    ino: identity.ino,
+    birthtimeNs: identity.birthtimeNs,
+    size: identity.size,
+    mtimeNs: identity.mtimeNs,
+});
+const sameIdentity = (left, right) => left.dev === right.dev
+    && left.ino === right.ino
+    && left.birthtimeNs === right.birthtimeNs
+    && left.size === right.size
+    && left.mtimeNs === right.mtimeNs;
+const sameLease = (left, right) => left.executionId === right.executionId
+    && left.rootId === right.rootId
+    && left.nonce === right.nonce;
+const sameSnapshot = (left, right) => sameIdentity(left.identity, right.identity)
+    && left.raw === right.raw
+    && sameLease(left.record, right.record);
+const withLeaseOperation = async (key, operation) => {
+    const previous = leaseOperationTails.get(key) ?? Promise.resolve();
+    let release;
+    const turn = new Promise((resolve) => { release = resolve; });
+    const tail = previous.then(() => turn);
+    leaseOperationTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (leaseOperationTails.get(key) === tail)
+            leaseOperationTails.delete(key);
+    }
+};
+const requireOwnedDirectory = async (directory) => {
+    const info = await lstat(directory, { bigint: true }).catch(() => fail());
+    if (!info.isDirectory() || info.isSymbolicLink() || !ownedByCurrentUser(info.uid))
+        return fail();
+};
+const ensurePrivateDirectory = async (directory, parent, syncDirectory) => {
+    let created = false;
+    try {
+        await mkdir(directory, { mode: 0o700 });
+        created = true;
+    }
+    catch (error) {
+        if (codeOf(error) !== "EEXIST")
+            throw error;
+    }
+    await requireOwnedDirectory(directory);
+    await chmod(directory, 0o700).catch(() => fail());
+    if (created)
+        await syncDirectory(parent);
+};
+const boundedNames = async (directory, maximumEntries) => {
+    const handle = await opendir(directory).catch(() => fail());
+    const names = [];
+    try {
+        for (;;) {
+            const entry = await handle.read();
+            if (entry === null)
+                break;
+            names.push(entry.name);
+            if (names.length > maximumEntries) {
+                return fail("skill_projection_runtime_store_limit_exceeded");
+            }
+        }
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+    return Object.freeze(names.sort());
+};
+const readBoundedLease = async (handle) => {
+    const buffer = Buffer.allocUnsafe(MAX_LEASE_BYTES + 1);
+    let offset = 0;
+    while (offset < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
+        if (bytesRead === 0)
+            break;
+        offset += bytesRead;
+    }
+    if (offset > MAX_LEASE_BYTES)
+        return fail("skill_projection_runtime_store_limit_exceeded");
+    return buffer.subarray(0, offset).toString("utf8");
+};
+const artifactName = (location, record) => {
+    const executionKey = projectSkillRuntimeLeaseKey(record.executionId);
+    const stagingKey = projectSkillRuntimeLeaseKey(record.nonce);
+    if (location === "final")
+        return `${executionKey}.json`;
+    if (location === "staging")
+        return `.lease-private-${stagingKey}.json`;
+    if (location === "claim")
+        return `.lease-claim-${executionKey}.json`;
+    if (location === "discard-stage")
+        return `.lease-discard-stage-${stagingKey}.json`;
+    return `.lease-discard-release-${executionKey}.json`;
+};
+const classifyName = (name) => {
+    const candidates = [
+        [FINAL_LEASE_NAME, "final"],
+        [STAGING_LEASE_NAME, "staging"],
+        [CLAIM_LEASE_NAME, "claim"],
+        [DISCARD_STAGE_NAME, "discard-stage"],
+        [DISCARD_RELEASE_NAME, "discard-release"],
+    ];
+    for (const [pattern, location] of candidates) {
+        const match = pattern.exec(name);
+        if (match !== null)
+            return Object.freeze({ location, token: match[1] });
+    }
+    return null;
+};
+const readLeasePath = async (filePath, name, location, token) => {
+    let before;
+    try {
+        before = await lstat(filePath, { bigint: true });
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return null;
+        return fail();
+    }
+    if (!before.isFile() || before.isSymbolicLink() || !ownedByCurrentUser(before.uid)
+        || before.size > BigInt(MAX_LEASE_BYTES))
+        return fail();
+    const handle = await open(filePath, "r").catch(() => fail());
+    try {
+        const opened = await handle.stat({ bigint: true });
+        if (!opened.isFile() || opened.isSymbolicLink() || !ownedByCurrentUser(opened.uid)
+            || opened.dev !== before.dev || opened.ino !== before.ino
+            || opened.birthtimeNs !== before.birthtimeNs || opened.size !== before.size)
+            return fail();
+        const raw = await readBoundedLease(handle);
+        const after = await handle.stat({ bigint: true });
+        const pathAfter = await lstat(filePath, { bigint: true }).catch(() => fail());
+        if (Buffer.byteLength(raw, "utf8") !== Number(after.size)
+            || after.dev !== opened.dev || after.ino !== opened.ino
+            || after.birthtimeNs !== opened.birthtimeNs || after.size !== opened.size
+            || after.mtimeNs !== opened.mtimeNs
+            || pathAfter.dev !== after.dev || pathAfter.ino !== after.ino
+            || pathAfter.birthtimeNs !== after.birthtimeNs || pathAfter.size !== after.size
+            || pathAfter.mtimeNs !== after.mtimeNs)
+            return fail();
+        let candidate;
+        try {
+            candidate = JSON.parse(raw);
+        }
+        catch {
+            return fail();
+        }
+        let artifact;
+        try {
+            artifact = parseProjectSkillRuntimeLeaseArtifact(candidate);
+        }
+        catch {
+            return fail();
+        }
+        if (!matchesLeaseArtifactIdentity(artifact.fileIdentity, after))
+            return fail();
+        const record = artifact.record;
+        const expectedToken = location === "staging" || location === "discard-stage"
+            ? projectSkillRuntimeLeaseKey(record.nonce)
+            : projectSkillRuntimeLeaseKey(record.executionId);
+        if (token !== expectedToken || name !== artifactName(location, record))
+            return fail();
+        return Object.freeze({
+            location,
+            name,
+            path: filePath,
+            token,
+            identity: identityFromStat(after),
+            raw,
+            artifact,
+            record,
+        });
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+};
+const scanLeases = async (context) => {
+    const snapshots = [];
+    const executionIds = new Set();
+    for (const name of await boundedNames(context.leasesDirectory, context.maximumEntries)) {
+        const classified = classifyName(name);
+        if (classified === null)
+            return fail();
+        const snapshot = await readLeasePath(context.path.join(context.leasesDirectory, name), name, classified.location, classified.token);
+        if (snapshot === null || executionIds.has(snapshot.record.executionId))
+            return fail();
+        executionIds.add(snapshot.record.executionId);
+        snapshots.push(snapshot);
+    }
+    return Object.freeze(snapshots.sort((left, right) => left.record.executionId.localeCompare(right.record.executionId)));
+};
+const revalidateSnapshot = async (expected) => {
+    const current = await readLeasePath(expected.path, expected.name, expected.location, expected.token);
+    if (current === null || !sameSnapshot(current, expected))
+        return fail();
+    return current;
+};
+export function createProjectSkillRuntimeLeaseStore(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const path = platform === "win32" ? win32 : posix;
+    const syncDirectory = platform === "win32"
+        ? options.directorySync ?? (async () => undefined)
+        : options.directorySync ?? durableDirectorySync;
+    const atomicRename = options.atomicRename ?? atomicRenameNoReplace;
+    const randomId = options.randomId ?? randomUUID;
+    const maximumEntries = options.maximumEntries ?? MAX_LEASE_ENTRIES;
+    if (!Number.isInteger(maximumEntries)
+        || maximumEntries <= 0
+        || maximumEntries > MAX_LEASE_ENTRIES) {
+        return fail("skill_projection_runtime_store_limit_exceeded");
+    }
+    const contextFor = async (agentRoot) => {
+        await requireOwnedDirectory(agentRoot);
+        const crewDirectory = path.join(agentRoot, ".crew");
+        const storeDirectory = path.join(crewDirectory, STORE_DIRECTORY_NAME);
+        const leasesDirectory = path.join(storeDirectory, LEASES_DIRECTORY_NAME);
+        await ensurePrivateDirectory(crewDirectory, agentRoot, syncDirectory);
+        await ensurePrivateDirectory(storeDirectory, crewDirectory, syncDirectory);
+        await ensurePrivateDirectory(leasesDirectory, storeDirectory, syncDirectory);
+        return Object.freeze({ leasesDirectory, maximumEntries, path, syncDirectory });
+    };
+    const moveSnapshot = async (context, expected, destinationLocation) => {
+        await revalidateSnapshot(expected);
+        const destinationName = artifactName(destinationLocation, expected.record);
+        const destinationPath = context.path.join(context.leasesDirectory, destinationName);
+        const moved = await atomicRename(expected.path, destinationPath);
+        if (moved !== "published")
+            return fail();
+        const classified = classifyName(destinationName);
+        const after = await readLeasePath(destinationPath, destinationName, destinationLocation, classified.token);
+        if (after === null || !sameSnapshot(after, expected))
+            return fail();
+        return after;
+    };
+    const deleteStaging = async (context, expected) => {
+        const discard = expected.location === "discard-stage"
+            ? await revalidateSnapshot(expected)
+            : await moveSnapshot(context, expected, "discard-stage");
+        await revalidateSnapshot(discard);
+        await unlink(discard.path);
+        await context.syncDirectory(context.leasesDirectory);
+    };
+    const deleteReleaseArtifact = async (context, expected, hookContext) => {
+        const discard = expected.location === "discard-release"
+            ? await revalidateSnapshot(expected)
+            : await moveSnapshot(context, expected, "discard-release");
+        if (hookContext !== undefined) {
+            await options.afterLeaseDeleteRenamedBeforeParentSync?.(hookContext);
+        }
+        await revalidateSnapshot(discard);
+        await unlink(discard.path);
+        if (hookContext !== undefined)
+            await options.afterLeaseDeletedBeforeParentSync?.(hookContext);
+        await context.syncDirectory(context.leasesDirectory);
+    };
+    const restoreReleaseArtifact = async (context, expected) => {
+        const restored = await moveSnapshot(context, expected, "final");
+        await context.syncDirectory(context.leasesDirectory);
+        await revalidateSnapshot(restored);
+    };
+    const releaseSnapshot = async (context, expected) => {
+        const snapshots = await scanLeases(context);
+        const current = snapshots.find(({ record }) => record.executionId === expected.executionId);
+        if (current === undefined || !sameLease(current.record, expected))
+            return;
+        if (current.location === "claim" || current.location === "discard-release") {
+            await deleteReleaseArtifact(context, current);
+            return;
+        }
+        if (current.location !== "final")
+            return fail();
+        const claimName = artifactName("claim", expected);
+        const claimPath = context.path.join(context.leasesDirectory, claimName);
+        const hookContext = Object.freeze({
+            finalPath: current.path,
+            claimPath,
+            executionId: expected.executionId,
+            rootId: expected.rootId,
+        });
+        const claim = await moveSnapshot(context, current, "claim");
+        await options.afterLeaseClaimRenamedBeforeParentSync?.(hookContext);
+        await context.syncDirectory(context.leasesDirectory);
+        await revalidateSnapshot(claim);
+        await options.afterLeaseClaimDurableBeforeDelete?.(hookContext);
+        await deleteReleaseArtifact(context, claim, hookContext);
+    };
+    const ownedLease = (agentRoot, record) => Object.freeze({
+        executionId: record.executionId,
+        rootId: record.rootId,
+        release: async () => {
+            try {
+                const context = await contextFor(agentRoot);
+                await withLeaseOperation(path.resolve(context.leasesDirectory), () => releaseSnapshot(context, record));
+            }
+            catch (error) {
+                return mapLeaseError(error);
+            }
+        },
+    });
+    const list = async (agentRoot) => {
+        try {
+            const context = await contextFor(agentRoot);
+            return await withLeaseOperation(path.resolve(context.leasesDirectory), async () => {
+                const snapshots = await scanLeases(context);
+                if (snapshots.some(({ location }) => location !== "final"))
+                    return fail();
+                return Object.freeze(snapshots.map(({ record }) => record));
+            });
+        }
+        catch (error) {
+            return mapLeaseError(error);
+        }
+    };
+    return Object.freeze({
+        acquire: async (agentRoot, input) => {
+            try {
+                createProjectSkillRuntimeLeaseRecord({ ...input, nonce: "pending" });
+            }
+            catch (error) {
+                return mapLeaseError(error);
+            }
+            try {
+                const context = await contextFor(agentRoot);
+                return await withLeaseOperation(path.resolve(context.leasesDirectory), async () => {
+                    const snapshots = await scanLeases(context);
+                    if (snapshots.some(({ location }) => location !== "final"))
+                        return fail();
+                    const existing = snapshots
+                        .find(({ record }) => record.executionId === input.executionId);
+                    if (existing !== undefined) {
+                        if (existing.record.rootId !== input.rootId)
+                            return fail();
+                        return ownedLease(agentRoot, existing.record);
+                    }
+                    if (snapshots.length >= context.maximumEntries) {
+                        return fail("skill_projection_runtime_store_limit_exceeded");
+                    }
+                    const desired = createProjectSkillRuntimeLeaseRecord({ ...input, nonce: randomId() });
+                    const finalName = artifactName("final", desired);
+                    const stagingName = artifactName("staging", desired);
+                    const finalPath = context.path.join(context.leasesDirectory, finalName);
+                    const stagingPath = context.path.join(context.leasesDirectory, stagingName);
+                    const classified = classifyName(stagingName);
+                    const hookContext = Object.freeze({
+                        stagingPath,
+                        finalPath,
+                        executionId: desired.executionId,
+                        rootId: desired.rootId,
+                    });
+                    let handle = null;
+                    try {
+                        handle = await open(stagingPath, "wx", 0o600);
+                        const created = await handle.stat({ bigint: true });
+                        if (!created.isFile() || created.isSymbolicLink() || !ownedByCurrentUser(created.uid)
+                            || created.size !== 0n)
+                            return fail();
+                        const artifact = createProjectSkillRuntimeLeaseArtifact({
+                            record: desired,
+                            fileIdentity: leaseArtifactIdentityFromStat(created),
+                        });
+                        const raw = `${JSON.stringify(artifact)}\n`;
+                        if (Buffer.byteLength(raw, "utf8") > MAX_LEASE_BYTES) {
+                            return fail("skill_projection_runtime_store_limit_exceeded");
+                        }
+                        await handle.writeFile(raw, "utf8");
+                        await handle.sync();
+                        const staged = await handle.stat({ bigint: true });
+                        if (!staged.isFile() || staged.isSymbolicLink() || !ownedByCurrentUser(staged.uid)
+                            || !matchesLeaseArtifactIdentity(artifact.fileIdentity, staged)
+                            || staged.size !== BigInt(Buffer.byteLength(raw, "utf8")))
+                            return fail();
+                        const expected = Object.freeze({
+                            location: "staging",
+                            name: stagingName,
+                            path: stagingPath,
+                            token: classified.token,
+                            identity: identityFromStat(staged),
+                            raw,
+                            artifact,
+                            record: desired,
+                        });
+                        await options.afterLeaseFileSynced?.(hookContext);
+                        await handle.close();
+                        handle = null;
+                        await revalidateSnapshot(expected);
+                        await context.syncDirectory(context.leasesDirectory);
+                        await options.afterLeaseStagingDurableBeforeRename?.(hookContext);
+                        const durableStaging = await revalidateSnapshot(expected);
+                        const published = await moveSnapshot(context, durableStaging, "final");
+                        await options.afterLeaseRenamedBeforeParentSync?.(hookContext);
+                        await context.syncDirectory(context.leasesDirectory);
+                        await revalidateSnapshot(published);
+                        return ownedLease(agentRoot, desired);
+                    }
+                    finally {
+                        await handle?.close().catch(() => undefined);
+                    }
+                });
+            }
+            catch (error) {
+                return mapLeaseError(error);
+            }
+        },
+        list,
+        protectedExecutionIds: async (agentRoot) => {
+            try {
+                const context = await contextFor(agentRoot);
+                return await withLeaseOperation(path.resolve(context.leasesDirectory), async () => {
+                    const snapshots = await scanLeases(context);
+                    return Object.freeze(snapshots
+                        .filter(({ location }) => location === "final"
+                        || location === "claim"
+                        || location === "discard-release")
+                        .map(({ record }) => record.executionId));
+                });
+            }
+            catch (error) {
+                return mapLeaseError(error);
+            }
+        },
+        recover: async (agentRoot, canRelease) => {
+            try {
+                const context = await contextFor(agentRoot);
+                await withLeaseOperation(path.resolve(context.leasesDirectory), async () => {
+                    const snapshots = await scanLeases(context);
+                    for (const snapshot of snapshots) {
+                        if (snapshot.location === "staging" || snapshot.location === "discard-stage") {
+                            await deleteStaging(context, snapshot);
+                            continue;
+                        }
+                        const terminal = await canRelease(snapshot.record.executionId);
+                        if (snapshot.location === "final") {
+                            if (terminal)
+                                await releaseSnapshot(context, snapshot.record);
+                        }
+                        else if (terminal) {
+                            await deleteReleaseArtifact(context, snapshot);
+                        }
+                        else {
+                            await restoreReleaseArtifact(context, snapshot);
+                        }
+                    }
+                    // Also makes an earlier deletion durable when a crash occurred after unlink but before sync.
+                    await context.syncDirectory(context.leasesDirectory);
+                });
+            }
+            catch (error) {
+                return mapLeaseError(error);
+            }
+        },
+    });
+}

package/dist/project-skills/runtime-root-source-identity.js

@@ -0,0 +1,60 @@
+import { lstat, open } from "node:fs/promises";
+import { ProjectSkillRuntimeStoreError } from "./runtime-root-domain.js";
+const fail = () => {
+    throw new ProjectSkillRuntimeStoreError("skill_projection_failed");
+};
+const exactEntryIdentity = (info, kind) => Object.freeze({
+    kind,
+    dev: info.dev,
+    ino: info.ino,
+    uid: info.uid,
+    mode: info.mode,
+    birthtimeNs: info.birthtimeNs,
+    size: info.size,
+    mtimeNs: info.mtimeNs,
+    ctimeNs: info.ctimeNs,
+});
+const sameEntryIdentity = (left, right) => left.kind === right.kind
+    && left.dev === right.dev
+    && left.ino === right.ino
+    && left.uid === right.uid
+    && left.mode === right.mode
+    && left.birthtimeNs === right.birthtimeNs
+    && left.size === right.size
+    && left.mtimeNs === right.mtimeNs
+    && left.ctimeNs === right.ctimeNs;
+export const sameResolvedProjectSkillSourceIdentity = (left, right) => sameEntryIdentity(left.directory, right.directory)
+    && sameEntryIdentity(left.skillFile, right.skillFile);
+export const captureResolvedProjectSkillSourceIdentity = async (sourcePath, path) => {
+    let skillHandle = null;
+    try {
+        const skillPath = path.join(sourcePath, "SKILL.md");
+        const sourceBefore = await lstat(sourcePath, { bigint: true });
+        const skillBefore = await lstat(skillPath, { bigint: true });
+        if (!sourceBefore.isDirectory() || sourceBefore.isSymbolicLink()
+            || !skillBefore.isFile() || skillBefore.isSymbolicLink())
+            return fail();
+        const directoryIdentity = exactEntryIdentity(sourceBefore, "directory");
+        const skillIdentity = exactEntryIdentity(skillBefore, "file");
+        skillHandle = await open(skillPath, "r");
+        const openedSkill = await skillHandle.stat({ bigint: true });
+        const sourceAfter = await lstat(sourcePath, { bigint: true });
+        const skillAfter = await lstat(skillPath, { bigint: true });
+        if (!openedSkill.isFile()
+            || !sourceAfter.isDirectory() || sourceAfter.isSymbolicLink()
+            || !skillAfter.isFile() || skillAfter.isSymbolicLink()
+            || !sameEntryIdentity(directoryIdentity, exactEntryIdentity(sourceAfter, "directory"))
+            || !sameEntryIdentity(skillIdentity, exactEntryIdentity(openedSkill, "file"))
+            || !sameEntryIdentity(skillIdentity, exactEntryIdentity(skillAfter, "file")))
+            return fail();
+        return Object.freeze({ directory: directoryIdentity, skillFile: skillIdentity });
+    }
+    catch (error) {
+        if (error instanceof ProjectSkillRuntimeStoreError)
+            throw error;
+        return fail();
+    }
+    finally {
+        await skillHandle?.close().catch(() => undefined);
+    }
+};

package/dist/project-skills/runtime-root-startup.js

@@ -0,0 +1,49 @@
+import { mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { readAppliedProjectSkillManifest } from "./projection-state.js";
+import { initializeAfterProjectSkillLeaseProtection, recoverProjectSkillRuntimeRoots, } from "./runtime-root-bootstrap.js";
+import { createProjectSkillRuntimeRootGc } from "./runtime-root-gc.js";
+import { createProjectSkillRuntimeLeaseStore } from "./runtime-root-leases.js";
+import { createProjectSkillRuntimeRootStore } from "./runtime-root-store.js";
+export function createProjectSkillRuntimeRootStartup() {
+    const roots = createProjectSkillRuntimeRootStore();
+    const leases = createProjectSkillRuntimeLeaseStore();
+    const gc = createProjectSkillRuntimeRootGc({ runtimeRoots: roots });
+    const agentRoots = async (agentsRoot) => {
+        await mkdir(agentsRoot, { recursive: true, mode: 0o700 });
+        return (await readdir(agentsRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => join(agentsRoot, entry.name));
+    };
+    return Object.freeze({
+        probeNativePublicationPrimitiveReadiness: () => roots.probeNativePublicationPrimitiveReadiness(),
+        initializeAfterLeaseProtection: async (agentsRoot, initialize) => initializeAfterProjectSkillLeaseProtection({
+            agentRoots: await agentRoots(agentsRoot),
+            leases,
+            initialize,
+        }),
+        recover: async (agentsRoot, journal, protectedExecutionIds) => {
+            await recoverProjectSkillRuntimeRoots({
+                agentRoots: await agentRoots(agentsRoot),
+                journal,
+                roots,
+                leases,
+                gc,
+                currentRootId: async (agentRoot) => (await readAppliedProjectSkillManifest(agentRoot))?.rootId ?? null,
+                afterLeaseRecovery: async () => {
+                    const remaining = await initializeAfterProjectSkillLeaseProtection({
+                        agentRoots: await agentRoots(agentsRoot),
+                        leases,
+                        initialize: async (snapshot) => snapshot,
+                    });
+                    protectedExecutionIds.clear();
+                    for (const executionId of remaining)
+                        protectedExecutionIds.add(executionId);
+                },
+            });
+        },
+    });
+}
+export async function recoverProjectSkillRuntimeRootsAtStartup(agentsRoot, journal) {
+    await createProjectSkillRuntimeRootStartup().recover(agentsRoot, journal, new Set());
+}