@nowcrew/daemon 0.6.19 → 0.6.21

package/dist/execution-runner.js

@@ -14,10 +14,13 @@ import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-de
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
 import { supervisorLaunch } from "./supervised-runtime.js";
 import { appendAgentMemoryContext } from "./agent-memory/policy.js";
+import { ProjectSkillRuntimeOwnershipUnverifiedError, } from "./project-skills/reconciler.js";
 import { projectSkillExecutionProjection, projectSkillProjectionErrorCode } from "./project-skills/execution-adapter.js";
+import { redactProjectSkillRuntimeRootError, } from "./project-skills/runtime-launch.js";
 import { createProjectRegistry } from "./project-skills/registry.js";
 import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
 import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
+import { PROJECT_SKILL_PROJECTION_V2_CAPABILITY } from "./project-skills/types.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
@@ -217,6 +220,10 @@ function rejection(executionId, reason, message, at) {
 export function projectWorkspaceCapabilityRejection(spec, capabilities, at) {
     const projectContext = spec.workspace.projectContext;
     const nativeRuntime = spec.runtime.name === "codex" || spec.runtime.name === "claude";
+    if (spec.agent.projectSkillBindingGeneration !== undefined
+        && (!nativeRuntime || !capabilities?.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY))) {
+        return rejection(spec.executionId, "capability_missing", `${PROJECT_SKILL_PROJECTION_V2_CAPABILITY} is unavailable`, at);
+    }
     return projectContext !== undefined
         && projectContext.projectIds.length > 0
         && (!nativeRuntime || !capabilities?.includes(PROJECT_WORKSPACES_CAPABILITY))
@@ -423,6 +430,21 @@ export async function runExecution(config, input, dependencies) {
     const resetBoundImDecision = dependencies.resetBoundImDecision ?? resetBoundImDecisionFile;
     const telemetry = new TelemetryQueue(dependencies.report, bestEffortTimeoutMs, positiveTelemetryLimit(dependencies.telemetryMaxPendingFrames, DEFAULT_TELEMETRY_MAX_PENDING_FRAMES), Math.max(config.executionLimits.maxEventBytes, positiveTelemetryLimit(dependencies.telemetryMaxPendingBytes, DEFAULT_TELEMETRY_MAX_PENDING_BYTES)));
     const supervisorState = { active: null, abortOnce: null };
+    const proveActiveSupervisorStopped = async (error, retainProjectSkillLease = false) => {
+        if (error instanceof ProjectSkillRuntimeOwnershipUnverifiedError)
+            throw error;
+        if (supervisorState.active === null || supervisorState.abortOnce === null)
+            return;
+        try {
+            await supervisorState.abortOnce();
+        }
+        catch (abortError) {
+            if (retainProjectSkillLease)
+                throw new ProjectSkillRuntimeOwnershipUnverifiedError();
+            const detail = abortError instanceof Error ? abortError.message : String(abortError);
+            throw new AggregateError([error, abortError], `Failed to stop the execution supervisor: ${detail}`);
+        }
+    };
     let launchClosed = false;
     const launchAttempts = new Set();
     const closeLaunchGate = async () => {
@@ -557,6 +579,22 @@ export async function runExecution(config, input, dependencies) {
                 },
             } : {}),
         };
+        // This is the sole production brand owner. Pre-spawn rejection has no process; startGuarded
+        // aborts its own failures, and this wrapper awaits full-tree stop for every later rejection.
+        const projectSkillLeaseSafeLaunchOwner = Object.freeze({
+            claim(launch) {
+                const safeLaunch = async (root) => {
+                    try {
+                        return await launch(root);
+                    }
+                    catch (error) {
+                        await proveActiveSupervisorStopped(error, true);
+                        throw redactProjectSkillRuntimeRootError(error, root);
+                    }
+                };
+                return safeLaunch;
+            },
+        });
         const localDependencies = {
             ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
@@ -564,6 +602,7 @@ export async function runExecution(config, input, dependencies) {
                 ? {}
                 : { startupTimeoutMs: dependencies.startupTimeoutMs }),
             ...(dependencies.projectSkills === undefined ? {} : { projectSkills: dependencies.projectSkills }),
+            projectSkillLeaseSafeLaunchOwner,
             ...(dependencies.abilityRelease === undefined ? {} : { abilityRelease: dependencies.abilityRelease }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
@@ -574,7 +613,26 @@ export async function runExecution(config, input, dependencies) {
                 try {
                     const processStartedAt = now().toISOString();
                     const launchControl = { cancel: null };
-                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)), {
+                    const startOwnedSupervisor = async () => {
+                        const handle = await startSupervisor(supervisorLaunch(request));
+                        let abortPromise = null;
+                        const abortOnce = () => {
+                            if (abortPromise === null) {
+                                try {
+                                    abortPromise = Promise.resolve(handle.abort());
+                                }
+                                catch (error) {
+                                    abortPromise = Promise.reject(error);
+                                }
+                            }
+                            return abortPromise;
+                        };
+                        const ownedHandle = { ...handle, abort: abortOnce };
+                        supervisorState.active = ownedHandle;
+                        supervisorState.abortOnce = abortOnce;
+                        return ownedHandle;
+                    };
+                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, startOwnedSupervisor, {
                         beforeRelease: ({ handle, abort }) => {
                             supervisorState.active = handle;
                             let stopPromise = null;
@@ -736,17 +794,19 @@ export async function runExecution(config, input, dependencies) {
         const cancelled = error instanceof ExecutionCancelledError || error instanceof RuntimeCancelledError;
         if (cancelled) {
             await closeLaunchGate();
-            await dependencies.cancellation?.waitForStop();
-        }
-        else if (supervisorState.active !== null && supervisorState.abortOnce !== null) {
             try {
-                await supervisorState.abortOnce();
+                await dependencies.cancellation?.waitForStop();
             }
-            catch (abortError) {
-                const detail = abortError instanceof Error ? abortError.message : String(abortError);
-                throw new AggregateError([error, abortError], `Failed to stop the execution supervisor: ${detail}`);
+            catch (stopError) {
+                if (spec.agent.projectSkillBindingGeneration !== undefined) {
+                    throw new ProjectSkillRuntimeOwnershipUnverifiedError();
+                }
+                throw stopError;
             }
         }
+        else {
+            await proveActiveSupervisorStopped(error, spec.agent.projectSkillBindingGeneration !== undefined);
+        }
         completion = cancelled
             ? ExecutionCompletedSchema.parse({
                 type: "execution:completed",

package/dist/local-executor.js

@@ -2,7 +2,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
-import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, resolveOrderedUniqueClaudeDirectories, spawnClaude, } from "./runtimes/claude.js";
+import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
 import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
@@ -21,7 +21,9 @@ import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancell
 import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
 import { dslog } from "./slog.js";
 import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
+import { ProjectProjectionError, } from "./project-skills/reconciler.js";
 import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
+import { projectSkillRuntimeDirectories, redactProjectSkillRuntimeRootText, redactProjectSkillRuntimeRootValue, } from "./project-skills/runtime-launch.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
@@ -195,6 +197,19 @@ async function withKeyedLease(key, operation, cancellation) {
     }
 }
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
+    const versionedProjectSkills = input.projectSkills !== undefined
+        && !Array.isArray(input.projectSkills);
+    if (versionedProjectSkills && (input.runtime.name !== "codex" && input.runtime.name !== "claude")) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    if (versionedProjectSkills && dependencies.projectSkills === undefined) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    if (input.projectSkills !== undefined
+        && dependencies.projectSkills !== undefined
+        && dependencies.projectSkillLeaseSafeLaunchOwner === undefined) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
     const stableProtocolRuntime = dependencies.launchRuntime !== undefined;
     const supportsNativeResume = input.runtime.name === "claude"
         || (stableProtocolRuntime && runtimeCapability(input.runtime.name).nativeResume);
@@ -263,6 +278,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (key.startsWith("CREW_AGENT_MEMORY_"))
             delete inheritedEnv[key];
     }
+    const sourceCodexHome = inheritedEnv.CODEX_HOME
+        ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
@@ -270,11 +287,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (isDeepSeekCodex) {
             await awaitWithCancellation((dependencies.materializeDeepSeekCodexHome ?? materializeDeepSeekCodexHome)(workspace.homeDir), dependencies.cancellation);
         }
-        else if (runtime.name === "codex") {
-            const sourceCodexHome = inheritedEnv.CODEX_HOME
-                ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
-            await awaitWithCancellation((dependencies.materializeDefaultCodexHome ?? materializeDefaultCodexHome)(workspace.homeDir, sourceCodexHome), dependencies.cancellation);
-        }
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
         const storedCurrentPrior = input.session.enabled && supportsNativeResume
@@ -336,6 +348,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchSessionId = resumeSessionId ?? (rotated
             ? await rotateAgentSession(workspace.sessionDir)
             : workspace.agentSessionId);
+        if (runtime.name === "codex") {
+            await awaitWithCancellation((dependencies.materializeDefaultCodexHome ?? materializeDefaultCodexHome)(workspace.homeDir, sourceCodexHome, launchSessionId), dependencies.cancellation);
+        }
         const promptContext = {
             workspace: executionWorkspace,
             resuming,
@@ -485,7 +500,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const runtimeLaunchAt = Date.now();
         memoryPruneFailurePhase = "runtime_launch";
-        const launchPreparedRuntime = async (abilityContext) => {
+        let activeProjectSkillRuntimeRoot;
+        const launchPreparedRuntime = async (runtimeRoot, abilityContext) => {
+            activeProjectSkillRuntimeRoot = runtimeRoot;
             const effectiveSystemPrompt = abilityContext === undefined
                 ? systemPrompt
                 : `${systemPrompt}\n\n${abilityContext.prompt}`;
@@ -521,31 +538,16 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     skill_count: abilityContext.skillCount,
                 });
             }
-            const codexSkillRoots = runtime.name === "codex" && input.projectContext !== undefined
-                ? [
-                    ...(input.projectSkills === undefined
-                        ? []
-                        : [join(workspace.dir, ".agents", "skills")]),
-                    ...(abilityContext?.skillRoot === undefined ? [] : [abilityContext.skillRoot]),
-                ]
-                : [];
-            const claudeAdditionalDirectories = runtime.name === "claude"
-                ? input.projectContext === undefined
-                    ? abilityContext?.skillRoot === undefined
-                        ? []
-                        : await resolveOrderedUniqueClaudeDirectories([
-                            join(workspace.dir, ".crew", "claude-skills"),
-                            workspace.dir,
-                            abilityContext.skillRoot,
-                        ])
-                    : await resolveOrderedUniqueClaudeDirectories([
-                        ...input.projectContext.secondary.map((project) => project.root),
-                        ...(input.projectSkills === undefined
-                            ? []
-                            : [join(workspace.dir, ".crew", "claude-skills")]),
-                        ...(abilityContext?.skillRoot === undefined ? [] : [abilityContext.skillRoot]),
-                    ], input.projectContext.primary === undefined ? [] : [input.projectContext.primary.root])
-                : [];
+            const { codexSkillRoots, claudeAdditionalDirectories } = await projectSkillRuntimeDirectories({
+                runtime: runtime.name,
+                ...(runtimeRoot === undefined ? {} : { runtimeRoot }),
+                agentRoot: workspace.dir,
+                projectSkillsPresent: input.projectSkills !== undefined,
+                ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
+                ...(abilityContext?.skillRoot === undefined
+                    ? {}
+                    : { abilitySkillRoot: abilityContext.skillRoot }),
+            });
             let runtimeEnv = childEnv;
             if (runtime.name === "claude"
                 && input.projectContext !== undefined
@@ -571,7 +573,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 runtime: runtime.name,
                 bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
                 cwd: input.projectContext?.primary?.root ?? executionWorkspace.runDir,
-                ...(input.projectSkills === undefined && input.abilityRelease === undefined ? {} : { agentRoot: workspace.dir }),
+                ...(runtimeRoot !== undefined
+                    || (input.projectSkills === undefined && input.abilityRelease === undefined)
+                    ? {}
+                    : { agentRoot: workspace.dir }),
                 systemPromptPath: workspace.systemPromptPath,
                 systemPrompt: effectiveSystemPrompt,
                 wakePrompt,
@@ -598,17 +603,22 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             memoryPruneFailurePhase = "runtime_launch";
             return launchRuntime(launchRequest);
         };
-        const launchWithAbility = () => input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
-            ? dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, launchPreparedRuntime)
-            : launchPreparedRuntime();
-        const child = input.projectSkills !== undefined && dependencies.projectSkills !== undefined
-            ? await (Array.isArray(input.projectSkills)
-                ? dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, launchWithAbility)
-                : dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, launchWithAbility, (warning) => callbacks.onConsole?.({
-                    stream: "system",
-                    text: formatProjectSkillRuntimeWarning(warning),
-                })))
-            : await launchWithAbility();
+        const launchWithAbility = (runtimeRoot) => input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
+            ? dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, (abilityContext) => launchPreparedRuntime(runtimeRoot, abilityContext))
+            : launchPreparedRuntime(runtimeRoot);
+        let child;
+        if (input.projectSkills !== undefined && dependencies.projectSkills !== undefined) {
+            const launchOwner = dependencies.projectSkillLeaseSafeLaunchOwner;
+            if (launchOwner === undefined)
+                throw new ProjectProjectionError("skill_projection_failed");
+            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, input.projectSkills, launchOwner.claim(launchWithAbility), (warning) => callbacks.onConsole?.({
+                stream: "system",
+                text: formatProjectSkillRuntimeWarning(warning),
+            }));
+        }
+        else {
+            child = await launchWithAbility();
+        }
         localMemoryTelemetry?.markRuntimeStarted();
         memoryPruneFailurePhase = "runtime_execution";
         if (child.cancel !== undefined) {
@@ -660,7 +670,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 usage = meta.usage;
             if (meta.model)
                 observedModel = meta.model;
-            for (const activity of normalizeEvent(event)) {
+            for (const rawActivity of normalizeEvent(event)) {
+                const activity = redactProjectSkillRuntimeRootValue(rawActivity, activeProjectSkillRuntimeRoot);
                 if (activity.kind === "sending")
                     sentViaCrew = true;
                 activities.push(activity);
@@ -668,18 +679,20 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
             const extracted = extractFinalText(event);
             if (extracted) {
+                const safeExtracted = redactProjectSkillRuntimeRootText(extracted, activeProjectSkillRuntimeRoot);
                 const incremental = typeof event === "object" && event !== null
                     && "type" in event && (event.type === "kimi.acp.text_delta"
                     || event.type === "hermes.acp.text_delta"
                     || event.type === "deepseek-harness.acp.text_delta"
                     || event.type === "opencode.text_delta");
-                finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
+                finalText = incremental ? `${finalText ?? ""}${safeExtracted}` : safeExtracted;
             }
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
-                callbacks.onExternalOutput?.(text);
+                callbacks.onExternalOutput?.(redactProjectSkillRuntimeRootText(text, activeProjectSkillRuntimeRoot));
+            }
+            for (const chunk of consoleFormatter.format(event)) {
+                callbacks.onConsole?.(redactProjectSkillRuntimeRootValue(chunk, activeProjectSkillRuntimeRoot));
             }
-            for (const chunk of consoleFormatter.format(event))
-                callbacks.onConsole?.(chunk);
         });
         let stderrTail = "";
         const codexStartupStageState = { last: null };
@@ -700,8 +713,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })
             : null;
         child.stderr.on("data", (data) => {
-            process.stderr.write(data);
-            const text = String(data);
+            const text = redactProjectSkillRuntimeRootText(String(data), activeProjectSkillRuntimeRoot);
+            process.stderr.write(text);
             stderrTail = (stderrTail + text).slice(-STDERR_TAIL_CAP);
             codexStartupStageParser?.push(text);
         });
@@ -761,7 +774,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         memoryPruneRuntimeExitCode = exitCode;
         const errorTail = [
             stderrTail.trim(),
-            spawnError,
+            spawnError === undefined
+                ? undefined
+                : redactProjectSkillRuntimeRootText(spawnError, activeProjectSkillRuntimeRoot),
             terminationSignal ? `terminated by ${terminationSignal}` : undefined,
         ].filter(Boolean).join(" ").trim();
         const finish = exitActivity(runtime.name, exitCode, errorTail);

package/dist/machine-info.js

@@ -61,7 +61,9 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
 export const daemonCapabilityBindings = (runtimePlatform = process.platform, injectedCapabilities) => {
     const snapshot = injectedCapabilities === undefined
         ? daemonCapabilities(runtimePlatform)
-        : Object.freeze([...injectedCapabilities]);
+        : (Object.isFrozen(injectedCapabilities)
+            ? injectedCapabilities
+            : Object.freeze([...injectedCapabilities]));
     return Object.freeze({
         controlPlaneUrl: snapshot,
         machineHello: snapshot,
@@ -169,6 +171,10 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
     const executionRuntimes = backend.supported
         ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
         : [];
+    const baseCapabilities = dependencies.capabilities ?? daemonCapabilities(runtimePlatform);
+    const capabilities = additionalCapabilities.length === 0 && Object.isFrozen(baseCapabilities)
+        ? baseCapabilities
+        : Object.freeze([...baseCapabilities, ...additionalCapabilities]);
     return {
         type: "machine:hello",
         hostname: hostname(),
@@ -176,10 +182,7 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         daemonVersion: daemonVersion(),
         runtimes,
         executionRuntimes,
-        capabilities: Object.freeze([
-            ...(dependencies.capabilities ?? daemonCapabilities(runtimePlatform)),
-            ...additionalCapabilities,
-        ]),
+        capabilities,
         ...(dependencies.profileName === undefined ? {} : {
             layoutVersion: 1,
             profileName: dependencies.profileName,

package/dist/project-skills/capability.js

@@ -0,0 +1,109 @@
+import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./types.js";
+export function projectSkillV2RolloutReady(platform, readiness) {
+    const platformReady = platform === "darwin"
+        || platform === "linux"
+        || (platform === "win32" && readiness.nativeWindowsSmokePassed);
+    return platformReady
+        && readiness.runtimeRootStorePrimitiveReady
+        && readiness.runtimeRootStoreRecoveryReady
+        && readiness.leaseRecoveryReady
+        && readiness.controllerReady
+        && readiness.executionHandlerReady
+        && readiness.codexAdapterReady
+        && readiness.claudeAdapterReady;
+}
+export function effectiveProjectSkillCapabilities(capabilities, projectSkillsReady, projectSkillV2Ready) {
+    const projectSkillCapabilitiesReady = projectSkillsReady && projectSkillV2Ready;
+    if (!projectSkillCapabilitiesReady
+        && !capabilities.includes(PROJECT_SKILLS_CAPABILITY)
+        && !capabilities.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY)
+        && Object.isFrozen(capabilities))
+        return capabilities;
+    const filtered = capabilities.filter((capability) => capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY
+        && (projectSkillCapabilitiesReady || capability !== PROJECT_SKILLS_CAPABILITY));
+    if (!projectSkillCapabilitiesReady || !filtered.includes(PROJECT_SKILLS_CAPABILITY)) {
+        return Object.freeze(filtered);
+    }
+    const v1Index = filtered.indexOf(PROJECT_SKILLS_CAPABILITY);
+    return Object.freeze([
+        ...filtered.slice(0, v1Index + 1),
+        PROJECT_SKILL_PROJECTION_V2_CAPABILITY,
+        ...filtered.slice(v1Index + 1),
+    ]);
+}
+export function withProjectSkillCapabilityStatus(value, status) {
+    return {
+        ...value,
+        projectSkillsStatus: status,
+        capabilities: status === "ready"
+            ? value.capabilities
+            : effectiveProjectSkillCapabilities(value.capabilities, false, false),
+    };
+}
+const settleReadinessGate = async (operation) => {
+    try {
+        return await operation() === true;
+    }
+    catch {
+        return false;
+    }
+};
+export async function createProjectSkillConnectionCapabilitySnapshot(input) {
+    const runtimeRootStorePrimitiveReady = await settleReadinessGate(input.probeRuntimeRootStorePrimitive);
+    const controllerReady = await settleReadinessGate(input.initializeController);
+    const recoveryReady = await settleReadinessGate(input.recoverRuntimeRootsAndLeases);
+    const readiness = Object.freeze({
+        runtimeRootStorePrimitiveReady,
+        runtimeRootStoreRecoveryReady: recoveryReady,
+        leaseRecoveryReady: recoveryReady,
+        controllerReady,
+        executionHandlerReady: true,
+        codexAdapterReady: true,
+        claudeAdapterReady: true,
+        nativeWindowsSmokePassed: false,
+    });
+    const projectSkillsReady = projectSkillV2RolloutReady(input.platform, readiness);
+    return Object.freeze({
+        capabilities: effectiveProjectSkillCapabilities(input.baseCapabilities, projectSkillsReady, projectSkillsReady),
+        projectSkillsReady,
+        readiness,
+    });
+}
+export async function prepareProjectSkillConnectionCapabilities(input) {
+    const snapshot = await createProjectSkillConnectionCapabilitySnapshot({
+        ...input,
+        baseCapabilities: [...input.baseCapabilities, ...await input.additionalCapabilities()],
+    });
+    input.applyReadiness(snapshot.projectSkillsReady);
+    return snapshot.capabilities;
+}
+export function createProjectSkillControllerReadiness(input) {
+    let status = "initializing";
+    let initialization = null;
+    const ensure = () => {
+        if (status === "ready")
+            return Promise.resolve(true);
+        if (initialization !== null)
+            return initialization;
+        status = "initializing";
+        const attempt = input.initialize().then(() => {
+            status = "ready";
+            return true;
+        }, (error) => {
+            status = "unavailable";
+            input.onUnavailable(error);
+            return false;
+        }).finally(() => {
+            if (initialization === attempt)
+                initialization = null;
+            input.onSettled();
+        });
+        initialization = attempt;
+        return attempt;
+    };
+    return Object.freeze({
+        status: () => status,
+        ensure,
+        applyPreflight: (ready) => { status = ready ? "ready" : "unavailable"; },
+    });
+}

package/dist/project-skills/controller-convergence.js

@@ -0,0 +1,57 @@
+import { ProjectProjectionError, } from "./reconciler.js";
+export const MAX_REMEMBERED_PROJECT_SKILL_AGENTS = 64;
+const compareBinary = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const copySnapshot = (snapshot) => Object.freeze({
+    bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
+    generation: snapshot.generation,
+});
+export function createProjectSkillSnapshotEpoch(maxEntries = MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
+    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    const snapshots = new Map();
+    return Object.freeze({
+        begin() {
+            snapshots.clear();
+        },
+        remember(handle, snapshot) {
+            const previous = snapshots.get(handle);
+            if (previous !== undefined && snapshot.generation < previous.generation)
+                return;
+            if (previous === undefined && snapshots.size >= maxEntries) {
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
+            snapshots.set(handle, copySnapshot(snapshot));
+        },
+        forget(handle) {
+            snapshots.delete(handle);
+        },
+        entries() {
+            return Object.freeze([...snapshots.entries()]
+                .sort(([left], [right]) => compareBinary(left, right))
+                .map(([handle, snapshot]) => Object.freeze([handle, copySnapshot(snapshot)])));
+        },
+    });
+}
+const stableErrorCode = (reason) => reason?.code === "skill_projection_snapshot_corrupt"
+    ? "skill_projection_snapshot_corrupt"
+    : "skill_projection_failed";
+export function toPathPrivateConvergenceResults(entries, results) {
+    return Object.freeze(entries.map(([handle], index) => {
+        const result = results[index];
+        if (result?.status === "fulfilled") {
+            return Object.freeze({ handle, status: "fulfilled" });
+        }
+        return Object.freeze({
+            handle,
+            status: "rejected",
+            errorCode: stableErrorCode(result?.reason),
+        });
+    }));
+}