@nowcrew/daemon 0.6.18 → 0.6.20

package/dist/project-skills/initialized-reconciler.js

@@ -10,11 +10,11 @@ export function initializedProjectSkillsReconciler(ensureInitialized, reconciler
         async reconcile(handle, bindings) {
             return (await ready()).reconcile(handle, bindings);
         },
-        async ensureSnapshot(handle, snapshot) {
-            return (await ready()).ensureSnapshot(handle, snapshot);
+        async ensureSnapshot(handle, snapshot, options) {
+            return (await ready()).ensureSnapshot(handle, snapshot, options);
         },
-        async prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning) {
-            return (await ready()).prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning);
+        async prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning) {
+            return (await ready()).prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning);
         },
     };
 }

package/dist/project-skills/projection-state-domain.js

@@ -6,6 +6,7 @@ const MANAGED_BY = "nowcrew-project-skills-v2";
 const MAX_SOURCE_PATH_BYTES = 16 * 1024;
 const MAX_GENERATION = 2_147_483_647;
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const CANONICAL_ROOT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 export class ProjectSkillProjectionStateError extends Error {
     code;
     constructor(code) {
@@ -106,7 +107,8 @@ export function createAppliedProjectSkillManifest(input) {
     const bindings = canonicalBindings(input.bindings);
     const resolutions = normalizeProjectSkillResolutionRecords(input.resolutions, input.platform);
     if (bindings.length !== resolutions.length
-        || bindings.some((binding, index) => !sameBinding(binding, resolutions[index]))) {
+        || bindings.some((binding, index) => !sameBinding(binding, resolutions[index]))
+        || !CANONICAL_ROOT_ID.test(input.rootId)) {
         return corrupt();
     }
     return Object.freeze({
@@ -115,19 +117,26 @@ export function createAppliedProjectSkillManifest(input) {
         bindings,
         bindingDigest: digest(bindings),
         resolutionDigest: digest(resolutions),
+        rootId: input.rootId,
     });
 }
 const ProjectSkillRefSchema = z.object({
     projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH),
     skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH),
 }).strict();
-const AppliedManifestSchema = z.object({
+const LegacyAppliedManifestSchema = z.object({
     managedBy: z.literal(MANAGED_BY),
     generation: z.number().int().min(0).max(MAX_GENERATION),
     bindings: z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
     bindingDigest: z.string().regex(DIGEST),
     resolutionDigest: z.string().regex(DIGEST),
 }).strict();
+const AppliedManifestSchema = z.union([
+    LegacyAppliedManifestSchema.extend({
+        rootId: z.string().regex(CANONICAL_ROOT_ID),
+    }).strict(),
+    LegacyAppliedManifestSchema,
+]);
 /** Strict local-store boundary parser; not re-exported from the public projection-state facade. */
 export const parseAppliedProjectSkillManifest = (candidate) => {
     if (candidate && typeof candidate === "object" && "managedBy" in candidate
@@ -149,5 +158,13 @@ export const parseAppliedProjectSkillManifest = (candidate) => {
         bindings,
         bindingDigest: parsed.data.bindingDigest,
         resolutionDigest: parsed.data.resolutionDigest,
+        rootId: "rootId" in parsed.data ? parsed.data.rootId : null,
     });
 };
+/** Publication boundary parser; it must run before creating or settling any filesystem state. */
+export const parsePublishableAppliedProjectSkillManifest = (candidate) => {
+    const parsed = parseAppliedProjectSkillManifest(candidate);
+    if (parsed.rootId === null)
+        return corrupt();
+    return Object.freeze({ ...parsed, rootId: parsed.rootId });
+};

package/dist/project-skills/projection-state-store.js

@@ -3,7 +3,7 @@ import { chmod, link, lstat, mkdir, open, opendir, rename, rmdir, unlink } from
 import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { durableDirectorySync } from "../atomic-private-write.js";
-import { parseAppliedProjectSkillManifest, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
+import { parseAppliedProjectSkillManifest, parsePublishableAppliedProjectSkillManifest, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
 const MANIFEST_FILE_NAME = "project-skills-v2.json";
 const MAX_MANIFEST_BYTES = 256 * 1024;
 const MAX_CONSISTENT_READ_ATTEMPTS = 6;
@@ -665,7 +665,7 @@ export async function readAppliedProjectSkillManifest(agentRoot, options = {}) {
         : parseManifestRaw(snapshot.raw);
 }
 export async function writeAppliedProjectSkillManifest(agentRoot, manifest, options = {}) {
-    const parsed = parseAppliedProjectSkillManifest(manifest);
+    const parsed = parsePublishableAppliedProjectSkillManifest(manifest);
     const syncDirectory = projectionDirectorySync(options);
     await realOwnedDirectory(agentRoot, false);
     const stateDirectory = join(agentRoot, ".crew");
@@ -827,6 +827,7 @@ export const projectSkillManifestStoreInternals = Object.freeze({
     isAbsenceMarkerRaw,
     loadOperation,
     parseAppliedProjectSkillManifest,
+    parsePublishableAppliedProjectSkillManifest,
     parseManifestRaw,
     pathUnmanaged,
     projectionDirectorySync,

package/dist/project-skills/projection-state-transaction.js

@@ -190,11 +190,15 @@ const prepareManifestTransition = async (agentRoot, next, options = {}) => {
     return Object.freeze({ agentRoot, operationId: operation.intent.nonce, previous, next });
 };
 export async function prepareAppliedProjectSkillManifestUpdate(agentRoot, manifest, options = {}) {
-    return prepareManifestTransition(agentRoot, store.parseAppliedProjectSkillManifest(manifest), options);
+    return prepareManifestTransition(agentRoot, store.parsePublishableAppliedProjectSkillManifest(manifest), options);
 }
 export async function prepareAppliedProjectSkillManifestRemoval(agentRoot, options = {}) {
     return prepareManifestTransition(agentRoot, null, options);
 }
+/** Settles a durable standalone applied-manifest operation before current-state selection. */
+export async function recoverAppliedProjectSkillManifestUpdates(agentRoot, options = {}) {
+    await stateContext(agentRoot, options, true);
+}
 export async function publishPreparedProjectSkillManifestUpdate(update, options = {}) {
     if (await completedWithoutOperation(update, update.next, options))
         return;

package/dist/project-skills/projection-state.js

@@ -1,3 +1,3 @@
 export { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, createAppliedProjectSkillManifest, normalizeProjectSkillResolutionRecords, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
 export { appliedProjectSkillManifestPath, readAppliedProjectSkillManifest, writeAppliedProjectSkillManifest, } from "./projection-state-store.js";
-export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";
+export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, recoverAppliedProjectSkillManifestUpdates, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";

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();
         },
     };
 }