@nowcrew/daemon 0.6.19 → 0.6.21

package/dist/project-skills/reconciler.js

@@ -3,8 +3,12 @@ import { randomUUID } from "node:crypto";
 import { dirname, join, posix, win32 } from "node:path";
 import { isManagedDirectoryProjectionCopy, projectDirectory, } from "../directory-projection.js";
 import { runtimeProjectionLifetime, } from "./agent-projection-coordinator.js";
-import { commitPreparedProjectSkillManifestUpdate, computeProjectSkillBindingDigest, createAppliedProjectSkillManifest, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, publishPreparedProjectSkillManifestUpdate, readAppliedProjectSkillManifest, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state.js";
+import { commitPreparedProjectSkillManifestUpdate, computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, createAppliedProjectSkillManifest, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, publishPreparedProjectSkillManifestUpdate, readAppliedProjectSkillManifest, recoverAppliedProjectSkillManifestUpdates, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state.js";
 import { compareProjectSkillRefs, } from "./types.js";
+import { PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION, ProjectSkillRuntimeStoreError, } from "./runtime-root-domain.js";
+import { createProjectSkillRuntimeRootStore, } from "./runtime-root-store.js";
+import { createProjectSkillRuntimeLeaseStore, } from "./runtime-root-leases.js";
+import { createProjectSkillRuntimeRootGc, } from "./runtime-root-gc.js";
 import { projectSkillProjectionExpectation, projectSkillResolutionRecords, } from "./scanner.js";
 import { cleanupProjectionStaging, isManagedProjectionRoot, markProjectionStaging, PROJECTION_ROOT_MARKER_NAME, projectionTargets, recoverProjectionSwitch, switchProjectionSet, } from "./projection-set-switch.js";
 export class ProjectProjectionError extends Error {
@@ -15,6 +19,17 @@ export class ProjectProjectionError extends Error {
         this.name = "ProjectProjectionError";
     }
 }
+/** A process may still own its leased root; only startup/journal recovery may clear this state. */
+export class ProjectSkillRuntimeOwnershipUnverifiedError extends AggregateError {
+    code = "project_skill_runtime_ownership_unverified";
+    constructor() {
+        super([
+            new Error("project_skill_runtime_lifetime_rejected"),
+            new Error("project_skill_runtime_stop_unverified"),
+        ], "project_skill_runtime_ownership_unverified");
+        this.name = "ProjectSkillRuntimeOwnershipUnverifiedError";
+    }
+}
 export const decideProjectSkillProjection = (expected, applied) => {
     if (applied === null || expected.generation > applied.generation) {
         return Object.freeze({ kind: "ensure-applied" });
@@ -25,11 +40,46 @@ export const decideProjectSkillProjection = (expected, applied) => {
     if (expected.bindingDigest !== applied.bindingDigest) {
         return Object.freeze({ kind: "reject", code: "skill_projection_snapshot_corrupt" });
     }
+    if (applied.rootId === null)
+        return Object.freeze({ kind: "ensure-applied" });
     return expected.resolutionDigest === applied.resolutionDigest
         ? Object.freeze({ kind: "use-current" })
         : Object.freeze({ kind: "ensure-applied" });
 };
+/** Unlike the v1 lock lifetime helper, a rejected v2 exit is not a full-tree stop proof. */
+const verifiedRuntimeProjectionLifetime = (value) => {
+    if (typeof value !== "object" || value === null || !("exit" in value))
+        return Promise.resolve();
+    const exit = value.exit;
+    return exit instanceof Promise ? exit : Promise.resolve();
+};
+const ownershipVerifiedRuntimeProjection = (value) => {
+    if (typeof value !== "object" || value === null || !("exit" in value))
+        return value;
+    const exit = value.exit;
+    if (!(exit instanceof Promise))
+        return value;
+    return {
+        ...value,
+        exit: exit.catch(() => { throw new ProjectSkillRuntimeOwnershipUnverifiedError(); }),
+    };
+};
 const exists = async (path) => lstat(path).then(() => true, () => false);
+const canonicalConflictFreeBindings = (bindings) => {
+    const unique = [...new Map(bindings.map((binding) => [
+            `${binding.projectId}\0${binding.skillName}`,
+            binding,
+        ])).values()].sort(compareProjectSkillRefs);
+    const names = new Map();
+    for (const binding of unique) {
+        const owner = names.get(binding.skillName);
+        if (owner !== undefined && owner !== binding.projectId) {
+            throw new ProjectProjectionError("skill_name_conflict");
+        }
+        names.set(binding.skillName, binding.projectId);
+    }
+    return Object.freeze(unique);
+};
 const normalizeWindowsLinkIdentity = (value) => {
     if (/^\\\\\?\\UNC\\/iu.test(value))
         return `\\\\${value.slice(8)}`;
@@ -107,6 +157,10 @@ export function createProjectSkillsReconciler(deps) {
         commit: commitUpdate,
         rollback: rollbackUpdate,
     });
+    const runtimeRoots = deps.runtimeRoots ?? createProjectSkillRuntimeRootStore({ platform });
+    const runtimeLeases = deps.runtimeLeases ?? createProjectSkillRuntimeLeaseStore({ platform });
+    const runtimeRootGc = deps.runtimeRootGc ?? createProjectSkillRuntimeRootGc({ platform, runtimeRoots });
+    const protectedExecutionIds = deps.protectedExecutionIds ?? new Set();
     let lastProjectionDiagnostics = Object.freeze([]);
     const reconcileUnlocked = async (handle, bindings, projects = deps.scannedProjects(), recover = true, manifestPublication) => {
         const agentRoot = join(deps.agentsRoot, handle);
@@ -118,18 +172,7 @@ export function createProjectSkillsReconciler(deps) {
                 throw new ProjectProjectionError("skill_projection_failed");
             }
         }
-        const uniqueBindings = [...new Map(bindings.map((binding) => [
-                `${binding.projectId}\0${binding.skillName}`,
-                binding,
-            ])).values()].sort(compareProjectSkillRefs);
-        const names = new Map();
-        for (const binding of uniqueBindings) {
-            const owner = names.get(binding.skillName);
-            if (owner !== undefined && owner !== binding.projectId) {
-                throw new ProjectProjectionError("skill_name_conflict");
-            }
-            names.set(binding.skillName, binding.projectId);
-        }
+        const uniqueBindings = canonicalConflictFreeBindings(bindings);
         const linked = [];
         const resolutions = [];
         const resolutionRecords = [];
@@ -229,94 +272,163 @@ export function createProjectSkillsReconciler(deps) {
         if (decision.kind === "reject")
             throw new ProjectProjectionError(decision.code);
     };
-    const ensureAppliedLocked = async (handle, expected, projectsSnapshot) => {
-        const agentRoot = join(deps.agentsRoot, handle);
-        try {
-            await recoverProjectionSwitch(agentRoot, deps.syncDirectory, manifestOperations);
+    const mapRuntimeRootError = (error) => {
+        if (error instanceof ProjectProjectionError)
+            throw error;
+        if (error instanceof ProjectSkillRuntimeStoreError
+            && error.code === "skill_projection_snapshot_corrupt") {
+            throw new ProjectProjectionError("skill_projection_snapshot_corrupt");
         }
-        catch {
+        throw new ProjectProjectionError("skill_projection_failed");
+    };
+    const exactManifest = (left, right) => left !== null && JSON.stringify(left) === JSON.stringify(right);
+    const warningsFor = (records) => Object.freeze(records
+        .filter((record) => record.mode === "missing")
+        .map((record) => Object.freeze({
+        projectId: record.projectId,
+        skillName: record.skillName,
+        code: "project_skill_unavailable",
+    })));
+    const withWarnings = (decision, warnings) => {
+        if (decision.kind === "reject" || warnings.length === 0) {
+            return decision;
+        }
+        return Object.freeze({ ...decision, warnings });
+    };
+    const actualResolutionRecords = async (bindings, projects) => Object.freeze(await Promise.all(projectSkillResolutionRecords(bindings, projects, platform).map(async (record) => {
+        if (record.mode === "missing" || record.sourcePath === null)
+            return record;
+        const sourcePath = record.sourcePath;
+        const [source, skillFile] = await Promise.all([
+            lstat(sourcePath).catch(() => null),
+            stat(join(sourcePath, "SKILL.md")).catch(() => null),
+        ]);
+        if (source?.isDirectory() === true
+            && !source.isSymbolicLink()
+            && skillFile?.isFile() === true) {
+            return record;
+        }
+        return Object.freeze({
+            projectId: record.projectId,
+            skillName: record.skillName,
+            sourcePath: null,
+            mode: "missing",
+        });
+    })));
+    const commitAppliedRoot = async (agentRoot, applied) => {
+        const update = await prepareUpdate(agentRoot, applied, readOptions);
+        await publishUpdate(update);
+        await deps.afterManifestPublishedBeforeCommit?.();
+        await commitUpdate(update);
+        if (!exactManifest(await readApplied(agentRoot, readOptions), applied)) {
             throw new ProjectProjectionError("skill_projection_failed");
         }
-        const current = await readApplied(agentRoot, readOptions);
-        const lockedDecision = decideProjectSkillProjection(expected, current);
-        rejectDecision(lockedDecision);
-        if (lockedDecision.kind !== "ensure-applied")
-            return lockedDecision;
-        const projects = projectsSnapshot ?? deps.scannedProjects();
-        const reconciled = await reconcileUnlocked(handle, expected.bindings, projects, false, async (records) => {
-            const applied = createAppliedProjectSkillManifest({
-                bindings: expected.bindings,
-                generation: expected.generation,
-                resolutions: records,
-                platform,
+    };
+    const ensureRuntimeRootLocked = async (handle, requested, options = {}) => {
+        const agentRoot = join(deps.agentsRoot, handle);
+        try {
+            canonicalConflictFreeBindings(requested.bindings);
+            await recoverProjectionSwitch(agentRoot, deps.syncDirectory, manifestOperations);
+            await recoverAppliedProjectSkillManifestUpdates(agentRoot, readOptions);
+            await runtimeRoots.recover(agentRoot);
+            const projects = deps.scannedProjects();
+            const wireRequest = Object.freeze({
+                bindings: requested.bindings,
+                generation: requested.generation,
+            });
+            let cachedRequested;
+            try {
+                cachedRequested = projectSkillProjectionExpectation(wireRequest, projects, platform);
+            }
+            catch (error) {
+                if (error instanceof ProjectProjectionError)
+                    throw error;
+                throw new ProjectProjectionError("skill_projection_snapshot_corrupt");
+            }
+            const localResolutions = await actualResolutionRecords(cachedRequested.bindings, projects);
+            const localRequested = Object.freeze({
+                ...cachedRequested,
+                resolutionDigest: computeProjectSkillResolutionDigest(localResolutions, platform),
             });
-            const lockedExpectation = Object.freeze({
-                bindings: expected.bindings,
-                generation: expected.generation,
-                bindingDigest: expected.bindingDigest,
-                resolutionDigest: applied.resolutionDigest,
+            validateExpectation(localRequested);
+            if ("resolutionDigest" in requested)
+                validateExpectation(requested);
+            const current = await readApplied(agentRoot, readOptions);
+            const callerDecision = decideProjectSkillProjection(localRequested, current);
+            rejectDecision(callerDecision);
+            const desiredBindings = callerDecision.kind === "use-advanced" && current !== null
+                ? current.bindings
+                : localRequested.bindings;
+            const desiredGeneration = callerDecision.kind === "use-advanced" && current !== null
+                ? current.generation
+                : localRequested.generation;
+            const resolutions = callerDecision.kind === "use-advanced"
+                ? await actualResolutionRecords(desiredBindings, projects)
+                : localResolutions;
+            const desiredExpectation = Object.freeze({
+                bindings: desiredBindings,
+                generation: desiredGeneration,
+                bindingDigest: computeProjectSkillBindingDigest(desiredBindings),
+                resolutionDigest: computeProjectSkillResolutionDigest(resolutions, platform),
             });
-            const update = await prepareUpdate(agentRoot, applied, readOptions);
+            const inventory = await runtimeRoots.list(agentRoot);
+            const currentRecord = current?.rootId === null || current?.rootId === undefined
+                ? undefined
+                : inventory.find((record) => record.rootId === current.rootId);
+            const reusableIdentity = current !== null
+                && current.rootId !== null
+                && current.generation === desiredExpectation.generation
+                && current.bindingDigest === desiredExpectation.bindingDigest
+                && current.resolutionDigest === desiredExpectation.resolutionDigest
+                && currentRecord?.materializationRevision === PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION
+                && currentRecord.bindingDigest === current.bindingDigest
+                && currentRecord.resolutionDigest === current.resolutionDigest;
+            let runtimeRoot;
+            let published = false;
+            const reusableRootId = reusableIdentity ? current.rootId : null;
+            const currentInspection = reusableRootId === null
+                ? null
+                : await runtimeRoots.inspect(agentRoot, reusableRootId);
+            const reusable = currentInspection !== null
+                && (!options.refreshCopyProjection || !currentInspection.containsCopyProjection);
+            if (reusable) {
+                runtimeRoot = currentInspection.descriptor;
+            }
+            else {
+                runtimeRoot = await runtimeRoots.publish({
+                    agentRoot,
+                    bindingDigest: desiredExpectation.bindingDigest,
+                    resolutionDigest: desiredExpectation.resolutionDigest,
+                    resolutions,
+                });
+                published = true;
+                await deps.afterRootPublishedBeforeAppliedCommit?.(runtimeRoot);
+                const applied = createAppliedProjectSkillManifest({
+                    bindings: desiredBindings,
+                    generation: desiredGeneration,
+                    resolutions,
+                    rootId: runtimeRoot.rootId,
+                    platform,
+                });
+                await commitAppliedRoot(agentRoot, applied);
+            }
+            const baseDecision = callerDecision.kind === "use-advanced"
+                ? callerDecision
+                : Object.freeze({ kind: published ? "ensure-applied" : "use-current" });
             return Object.freeze({
-                update,
-                operations: manifestOperations,
-                verify: async () => {
-                    const rechecked = await readApplied(agentRoot, readOptions);
-                    const finalDecision = decideProjectSkillProjection(lockedExpectation, rechecked);
-                    rejectDecision(finalDecision);
-                    if (finalDecision.kind !== "use-current") {
-                        throw new ProjectProjectionError("skill_projection_failed");
-                    }
-                },
-                ...(deps.afterManifestPublishedBeforeCommit === undefined
-                    ? {}
-                    : { afterPublishedBeforeCommit: deps.afterManifestPublishedBeforeCommit }),
-                ...(deps.unlinkSwitchJournal === undefined
-                    ? {}
-                    : { unlinkJournal: deps.unlinkSwitchJournal }),
+                decision: withWarnings(baseDecision, warningsFor(resolutions)),
+                runtimeRoot,
             });
-        });
-        const warnings = reconciled.resolutions
-            .filter((resolution) => resolution.status === "unavailable")
-            .map((resolution) => Object.freeze({
-            projectId: resolution.projectId,
-            skillName: resolution.skillName,
-            code: "project_skill_unavailable",
-        }));
-        return warnings.length === 0
-            ? Object.freeze({ kind: "ensure-applied" })
-            : Object.freeze({ kind: "ensure-applied", warnings: Object.freeze(warnings) });
-    };
-    const ensureApplied = async (handle, expected) => {
-        validateExpectation(expected);
-        return deps.coordinator.runExclusive(deps.agentsRoot, handle, () => ensureAppliedLocked(handle, expected));
-    };
-    const ensureSnapshot = async (handle, snapshot) => deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
-        const projects = deps.scannedProjects();
-        let expected;
-        try {
-            expected = projectSkillProjectionExpectation(snapshot, projects, platform);
-            validateExpectation(expected);
         }
         catch (error) {
-            if (error instanceof ProjectProjectionError)
-                throw error;
-            throw new ProjectProjectionError("skill_projection_snapshot_corrupt");
+            return mapRuntimeRootError(error);
         }
-        const decision = await ensureAppliedLocked(handle, expected, projects);
-        if (decision.kind !== "use-current")
-            return decision;
-        const warnings = projectSkillResolutionRecords(snapshot.bindings, projects, platform)
-            .filter((record) => record.mode === "missing")
-            .map((record) => Object.freeze({
-            projectId: record.projectId,
-            skillName: record.skillName,
-            code: "project_skill_unavailable",
-        }));
-        return warnings.length === 0
-            ? decision
-            : Object.freeze({ kind: "use-current", warnings: Object.freeze(warnings) });
-    });
+    };
+    const ensureApplied = async (handle, expected, options = {}) => {
+        validateExpectation(expected);
+        return deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => (await ensureRuntimeRootLocked(handle, expected, options)).decision);
+    };
+    const ensureSnapshot = async (handle, snapshot, options = {}) => deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => (await ensureRuntimeRootLocked(handle, snapshot, options)).decision);
     const reconcileLegacyUnlocked = async (handle, bindings) => {
         const agentRoot = join(deps.agentsRoot, handle);
         try {
@@ -351,26 +463,87 @@ export function createProjectSkillsReconciler(deps) {
         ensureSnapshot,
         ensureApplied,
         projectionDiagnostics: () => lastProjectionDiagnostics,
-        async prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning) {
+        async prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning) {
             if (agentsRoot !== deps.agentsRoot) {
                 throw new ProjectProjectionError("skill_projection_failed");
             }
             if (Array.isArray(projection)) {
                 return deps.coordinator.runExclusiveUntil(deps.agentsRoot, handle, async () => {
                     await reconcileLegacyUnlocked(handle, projection);
-                    return launch();
+                    return launch(undefined);
                 }, runtimeProjectionLifetime);
             }
-            const decision = "resolutionDigest" in projection
-                ? await ensureApplied(handle, projection)
-                : await ensureSnapshot(handle, projection);
-            if (decision.kind === "use-advanced")
-                onWarning?.({ code: decision.warning });
-            if ("warnings" in decision) {
-                for (const warning of decision.warnings ?? [])
-                    onWarning?.(warning);
+            let captured;
+            try {
+                captured = await deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
+                    const ensured = await ensureRuntimeRootLocked(handle, projection);
+                    const agentRoot = join(deps.agentsRoot, handle);
+                    const alreadyProtected = protectedExecutionIds.has(executionId);
+                    protectedExecutionIds.add(executionId);
+                    let lease;
+                    try {
+                        lease = await runtimeLeases.acquire(agentRoot, {
+                            executionId,
+                            rootId: ensured.runtimeRoot.rootId,
+                        });
+                    }
+                    catch (error) {
+                        let durableLeaseMayExist = true;
+                        try {
+                            durableLeaseMayExist = (await runtimeLeases.protectedExecutionIds(agentRoot))
+                                .includes(executionId);
+                        }
+                        catch {
+                            // Inventory ambiguity retains protection until startup recovery can fail closed.
+                        }
+                        if (!durableLeaseMayExist && !alreadyProtected) {
+                            protectedExecutionIds.delete(executionId);
+                        }
+                        throw error;
+                    }
+                    return Object.freeze({ ...ensured, lease });
+                });
+            }
+            catch (error) {
+                return mapRuntimeRootError(error);
+            }
+            const releaseLease = async () => {
+                await deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
+                    await captured.lease.release();
+                    protectedExecutionIds.delete(captured.lease.executionId);
+                    try {
+                        const agentRoot = join(deps.agentsRoot, handle);
+                        const leases = await runtimeLeases.list(agentRoot);
+                        const applied = await readApplied(agentRoot, readOptions);
+                        await runtimeRootGc.collect(agentRoot, {
+                            currentRootId: applied?.rootId ?? null,
+                            leasedRootIds: leases.map(({ rootId }) => rootId),
+                            keepHistory: 2,
+                        });
+                    }
+                    catch {
+                        // GC is best-effort after a successful lease release.
+                    }
+                });
+            };
+            try {
+                if (captured.decision.kind === "use-advanced") {
+                    onWarning?.({ code: captured.decision.warning });
+                }
+                if ("warnings" in captured.decision) {
+                    for (const warning of captured.decision.warnings ?? [])
+                        onWarning?.(warning);
+                }
+                const child = ownershipVerifiedRuntimeProjection(await launch(captured.runtimeRoot));
+                void verifiedRuntimeProjectionLifetime(child).then(releaseLease, () => undefined).catch(() => undefined);
+                return child;
+            }
+            catch (error) {
+                if (error instanceof ProjectSkillRuntimeOwnershipUnverifiedError)
+                    throw error;
+                await releaseLease().catch(() => undefined);
+                throw error;
             }
-            return launch();
         },
     };
 }

package/dist/project-skills/runtime-launch.js

@@ -0,0 +1,102 @@
+import { join } from "node:path";
+import { resolveOrderedUniqueClaudeDirectories } from "../runtimes/claude.js";
+import { ProjectProjectionError, } from "./reconciler.js";
+const runtimeRootSecrets = (root) => Object.freeze([...new Set([
+        root.rootDirectory,
+        root.codexSkillRoot,
+        root.claudeAdditionalDirectory,
+        root.rootId,
+    ].flatMap((value) => [
+        value,
+        value.replaceAll("\\", "/"),
+        value.replaceAll("/", "\\"),
+    ]))].sort((left, right) => right.length - left.length));
+export function redactProjectSkillRuntimeRootText(text, root) {
+    if (root === undefined)
+        return text;
+    return runtimeRootSecrets(root)
+        .reduce((redacted, secret) => redacted.replaceAll(secret, "[project-skill-root]"), text);
+}
+export function redactProjectSkillRuntimeRootError(error, root) {
+    if (!(error instanceof Error)) {
+        return typeof error === "string" ? redactProjectSkillRuntimeRootText(error, root) : error;
+    }
+    const message = redactProjectSkillRuntimeRootText(error.message, root);
+    if (message === error.message)
+        return error;
+    const redacted = new Error(message);
+    redacted.name = error.name;
+    return redacted;
+}
+/** Recursively redacts exact v2 root identities before Runtime output crosses daemon boundaries. */
+export function redactProjectSkillRuntimeRootValue(value, root) {
+    if (root === undefined)
+        return value;
+    if (typeof value === "string")
+        return redactProjectSkillRuntimeRootText(value, root);
+    if (Array.isArray(value)) {
+        return value.map((item) => redactProjectSkillRuntimeRootValue(item, root));
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value)
+            .map(([key, item]) => [key, redactProjectSkillRuntimeRootValue(item, root)]));
+    }
+    return value;
+}
+/** Maps one captured daemon-local root to the exact native Runtime registration seam. */
+export function projectSkillRuntimeLaunchFacts(runtime, root) {
+    if (root === undefined)
+        return Object.freeze({});
+    if (runtime === "codex") {
+        return Object.freeze({ codexSkillRoot: root.codexSkillRoot });
+    }
+    if (runtime === "claude") {
+        return Object.freeze({ claudeAdditionalDirectory: root.claudeAdditionalDirectory });
+    }
+    throw new ProjectProjectionError("skill_projection_failed");
+}
+/** Builds Runtime-native arrays while keeping v1 shared roots separate from v2 exact roots. */
+export async function projectSkillRuntimeDirectories(input) {
+    const facts = projectSkillRuntimeLaunchFacts(input.runtime, input.runtimeRoot);
+    const codexSkillRoots = input.runtime === "codex"
+        && (input.runtimeRoot !== undefined || input.projectContext !== undefined)
+        ? Object.freeze([
+            ...(facts.codexSkillRoot === undefined
+                ? input.projectSkillsPresent ? [join(input.agentRoot, ".agents", "skills")] : []
+                : [facts.codexSkillRoot]),
+            ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+        ])
+        : Object.freeze([]);
+    if (input.runtime !== "claude") {
+        return Object.freeze({ codexSkillRoots, claudeAdditionalDirectories: Object.freeze([]) });
+    }
+    if (input.runtimeRoot !== undefined) {
+        if (facts.claudeAdditionalDirectory === undefined) {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        return Object.freeze({
+            codexSkillRoots,
+            claudeAdditionalDirectories: await resolveOrderedUniqueClaudeDirectories([
+                ...(input.projectContext?.secondary.map((project) => project.root) ?? []),
+                facts.claudeAdditionalDirectory,
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ], input.projectContext?.primary === undefined ? [] : [input.projectContext.primary.root]),
+        });
+    }
+    const claudeAdditionalDirectories = input.projectContext === undefined
+        ? !input.projectSkillsPresent && input.abilitySkillRoot === undefined
+            ? Object.freeze([])
+            : await resolveOrderedUniqueClaudeDirectories([
+                join(input.agentRoot, ".crew", "claude-skills"),
+                input.agentRoot,
+                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+            ])
+        : await resolveOrderedUniqueClaudeDirectories([
+            ...input.projectContext.secondary.map((project) => project.root),
+            ...(input.projectSkillsPresent
+                ? [join(input.agentRoot, ".crew", "claude-skills")]
+                : []),
+            ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+        ], input.projectContext.primary === undefined ? [] : [input.projectContext.primary.root]);
+    return Object.freeze({ codexSkillRoots, claudeAdditionalDirectories });
+}

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

@@ -0,0 +1,47 @@
+import { ProjectSkillRuntimeStoreError } from "./runtime-root-domain.js";
+/**
+ * Generic startup hard gate. The callback is the only place a journal owner may be constructed or
+ * initialized, and is unreachable until every durable lease inventory has populated the synchronous
+ * retention snapshot. Task 9 wires this gate into `serve`; Task 5 deliberately does not advertise v2.
+ */
+export async function initializeAfterProjectSkillLeaseProtection(input) {
+    const protectedExecutionIds = new Set();
+    for (const agentRoot of input.agentRoots) {
+        for (const executionId of await input.leases.protectedExecutionIds(agentRoot)) {
+            protectedExecutionIds.add(executionId);
+        }
+    }
+    return input.initialize(protectedExecutionIds);
+}
+/**
+ * Runs only after execution-journal restart reconciliation has settled. A lease without a terminal
+ * journal fact remains durable and prevents the caller from marking Project Skill v2 ready.
+ */
+export async function recoverProjectSkillRuntimeRoots(input) {
+    for (const agentRoot of input.agentRoots) {
+        await input.roots.recover(agentRoot);
+        let unresolvedLease = false;
+        await input.leases.recover(agentRoot, async (executionId) => {
+            const entry = await input.journal.get(executionId);
+            const releasable = entry?.state === "completed" || entry?.state === "interrupted";
+            if (!releasable)
+                unresolvedLease = true;
+            return releasable;
+        });
+        if (unresolvedLease) {
+            throw new ProjectSkillRuntimeStoreError("skill_projection_snapshot_corrupt");
+        }
+    }
+    await input.afterLeaseRecovery?.();
+    for (const agentRoot of input.agentRoots) {
+        if (input.gc !== undefined && input.leases.list !== undefined && input.currentRootId !== undefined) {
+            const leased = await input.leases.list(agentRoot);
+            const currentRootId = await input.currentRootId(agentRoot);
+            await input.gc.collect(agentRoot, {
+                currentRootId,
+                leasedRootIds: leased.map(({ rootId }) => rootId),
+                keepHistory: 2,
+            }).catch(() => undefined);
+        }
+    }
+}