@nowcrew/daemon 0.6.80-beta.2 → 0.6.80-beta.3

package/dist/computer-cli.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { posix, resolve, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertProfileAgentsRootUnique, daemonHome, inspectProfileAgentsRoot, listProfiles, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, profileIsPrivate, profilePath, publicProfile, removeProfile, resolveAgentsRoot, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
-import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, readServiceDescriptor, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, } from "./computer-service.js";
+import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, readServiceDescriptor, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, storageServiceEnvironment, } from "./computer-service.js";
 import { releaseTagForServerUrl, assertReleaseTagForServerUrl } from "./automatic-install-target.js";
 import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { npmInvocation } from "./npm-command.js";
@@ -89,17 +89,6 @@ function translatedError(error, td) {
     }
     return td(error.message);
 }
-function storageServiceEnvironment(env) {
-    return {
-        ...(env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: env.NOWWORK_HOME }),
-        ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
-        ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
-            ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
-        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
-        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
-            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
-    };
-}
 export async function runComputerCommand(argv, overrides = {}) {
     const command = argv[0];
     if (!command || !COMPUTER_COMMANDS.has(command))
@@ -195,6 +184,8 @@ export async function runComputerCommand(argv, overrides = {}) {
             platform: deps.platform,
             explicit: deps.env.NOWWORK_LOCAL_HOME,
             mode: configuredLocalHomeMode,
+            ...(resolvedProfile === undefined ? {} : { profile: resolvedProfile }),
+            ...(home === undefined ? {} : { daemonHome: home }),
         });
         const profileStorage = {
             platform: deps.platform,

package/dist/computer-service.js

@@ -32,6 +32,18 @@ export const systemCommandRunner = async (command, args) => {
         };
     }
 };
+/** Build the non-secret storage environment persisted in managed services. */
+export function storageServiceEnvironment(env) {
+    return {
+        ...(env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: env.NOWWORK_HOME }),
+        ...(env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: env.NOWWORK_ENV_TAG }),
+        ...(env.NOWWORK_STORAGE_POLICY_PATH === undefined
+            ? {} : { NOWWORK_STORAGE_POLICY_PATH: env.NOWWORK_STORAGE_POLICY_PATH }),
+        ...(env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: env.NOWWORK_LOCAL_HOME }),
+        ...(env.NOWWORK_LOCAL_HOME_MODE === undefined && env.NOWWORK_STORAGE_MODE === undefined
+            ? {} : { NOWWORK_LOCAL_HOME_MODE: env.NOWWORK_LOCAL_HOME_MODE ?? env.NOWWORK_STORAGE_MODE }),
+    };
+}
 function serviceIdentitySuffix(profileHome, userHome) {
     if (profileHome === undefined || resolve(profileHome) === resolve(userHome, ".crew", "daemon"))
         return "";

package/dist/daemon-local-home.js

@@ -4,6 +4,13 @@ import { posix, win32 } from "node:path";
 const PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
 const CONTROL = /[\0\r\n]/u;
 const pathsFor = (platform) => platform === "win32" ? win32 : posix;
+function samePath(left, right, platform) {
+    const normalizedLeft = pathsFor(platform).resolve(left);
+    const normalizedRight = pathsFor(platform).resolve(right);
+    return platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
 export function parseDaemonLocalHomeMode(value) {
     if (value === undefined || value.trim() === "")
         return "auto";
@@ -86,6 +93,22 @@ export function resolveDaemonLocalStateRoot(input) {
         return legacyRoot;
     if (input.explicit !== undefined || mode === "nowwork")
         return nowworkRoot;
+    // Managed service descriptors created before local-home was persisted carry
+    // only --daemon-home. Do not treat every --daemon-home as legacy: migrated
+    // services also use that argument, but point it at ~/.nowwork/config.
+    // Prefer the descriptor's exact home when it identifies either layout.
+    if (input.daemonHome !== undefined && input.profile !== undefined) {
+        const nowworkDaemonHome = resolution("nowwork", nowworkRoot, input.profile, input.platform, "auto_nowwork_existing").daemonHome;
+        const legacyDaemonHome = resolution("legacy", legacyRoot, input.profile, input.platform, "auto_legacy_existing").daemonHome;
+        if (samePath(input.daemonHome, nowworkDaemonHome, input.platform))
+            return nowworkRoot;
+        if (samePath(input.daemonHome, legacyDaemonHome, input.platform))
+            return legacyRoot;
+        // An arbitrary explicit daemon home has historically implied the legacy
+        // local state root. Preserve that behavior unless the descriptor declares
+        // a mode explicitly.
+        return legacyRoot;
+    }
     const exists = input.exists ?? existsSync;
     // Once the new root exists, shared state must follow it even while the
     // legacy root is retained as a rollback source.

package/dist/daemon-update-eligibility.js

@@ -4,7 +4,7 @@ import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { daemonHome, loadProfile, resolveAgentsRoot } from "./computer-profile.js";
 import { builtDaemonEntry } from "./computer-cli.js";
-import { buildServiceSpec, readServiceDescriptor, serviceStatus, } from "./computer-service.js";
+import { buildServiceSpec, readServiceDescriptor, storageServiceEnvironment, serviceStatus, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { daemonInstallationLeaseHeld } from "./daemon-installation-lease.js";
 import { inspectLegacyServiceInstallation } from "./legacy-service-installation.js";
@@ -21,9 +21,9 @@ export async function managedDaemonCapabilities(eligibility) {
         return [];
     }
 }
-function defaults(profileName) {
+function defaults(profileName, selectedLocalHome) {
     const userHome = homedir();
-    const localHome = resolveDaemonLocalStateRoot({
+    const localHome = selectedLocalHome ?? resolveDaemonLocalStateRoot({
         userHome,
         platform: process.platform,
         explicit: process.env.NOWWORK_LOCAL_HOME,
@@ -31,6 +31,7 @@ function defaults(profileName) {
     });
     return {
         platform: process.platform,
+        localHome,
         profileHome: daemonHome(process.env, profileName),
         userHome,
         uid: process.getuid?.(),
@@ -65,7 +66,7 @@ async function registryCoversUpdateScope(services, descriptorPaths, targetDescri
     return true;
 }
 export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
-    const deps = { ...defaults(profileName), ...overrides };
+    const deps = { ...defaults(profileName, overrides.localHome), ...overrides };
     if (deps.platform !== "darwin" && deps.platform !== "linux" && deps.platform !== "win32") {
         return { eligible: false, reason: "unsupported_platform" };
     }
@@ -92,6 +93,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         nodePath: deps.nodePath,
         entryPath: deps.entryPath,
         profileHome: deps.profileHome,
+        environment: storageServiceEnvironment(process.env),
     });
     if (deps.platform === "win32") {
         const scope = await deps.inspectWindowsServiceUpdateScope(spec, installation.npmPrefix)
@@ -169,6 +171,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
             entryPath: deps.entryPath,
             profileHome: deps.profileHome,
             legacyServiceId: true,
+            environment: storageServiceEnvironment(process.env),
         });
         const legacyDescriptor = await deps.readServiceDescriptor(legacySpec).catch(() => null);
         if (legacyDescriptor !== legacySpec.descriptor) {

package/dist/local-executor.js

@@ -9,7 +9,7 @@ import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepS
 import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
 import { materializePrivateCodexHome } from "./codex-home-launch.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, sanitizeEnvVars, } from "./provider-env.js";
+import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
@@ -33,6 +33,8 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
+import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
+import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
@@ -50,15 +52,6 @@ const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
 const CODEX_COLLABORATION_EXEC_WARNING = "codex_collaboration_disabled_on_exec";
-const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const RESERVED_ENV = new Set([
-    "PATH",
-    "XDG_CONFIG_HOME",
-    "XDG_DATA_HOME",
-    "XDG_CACHE_HOME",
-    "GH_CONFIG_DIR",
-    "CLOUDSDK_CONFIG",
-]);
 function withoutClaudeInstructionFlag(env) {
     if (!(CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV in env))
         return env;
@@ -470,6 +463,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
+            ...(input.trainingProjectContext === undefined
+                ? {}
+                : machinePackageManagerEnv(inheritedEnv)),
             ...input.launch.systemEnv,
             PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
             CREW_SERVER_URL: input.launch.serverUrl,
@@ -512,6 +508,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             qa_runtime_root: childEnv.QA_RUNTIME_ROOT ?? null,
             qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
             inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
+            ...packageManagerEnvFacts(childEnv),
             training_root: join(crewHome, "training"),
             project_context_present: input.projectContext !== undefined,
             project_ids: JSON.stringify(input.projectContext === undefined

package/dist/main.js

@@ -31,6 +31,7 @@ import { runStorageWorkerCommand } from "./storage-worker-command.js";
 import { probeStorageMigrationRuntime } from "./storage-runtime-readiness.js";
 import { createStorageTargetConfirmationHandler } from "./storage-target-confirmation.js";
 import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
+import { storageServiceEnvironment } from "./computer-service.js";
 async function main() {
     const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
     if (workerResult !== null) {
@@ -78,9 +79,9 @@ async function main() {
         userHome: homedir(),
         platform: process.platform,
         explicit: process.env.NOWWORK_LOCAL_HOME,
-        mode: process.env.NOWWORK_LOCAL_HOME_MODE
-            ?? process.env.NOWWORK_STORAGE_MODE
-            ?? (values["daemon-home"] === undefined ? undefined : "legacy"),
+        mode: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE,
+        ...(values.profile === undefined ? {} : { profile: values.profile }),
+        ...(values["daemon-home"] === undefined ? {} : { daemonHome: values["daemon-home"] }),
     });
     if (values.profile) {
         const home = daemonHome(process.env, values.profile);
@@ -98,15 +99,7 @@ async function main() {
                 agentsRoot: resolveAgentsRoot(profile.agentsRoot, homedir(), process.platform),
                 nodePath: process.execPath,
                 entryPath: builtDaemonEntry(),
-                environment: {
-                    ...(process.env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: process.env.NOWWORK_HOME }),
-                    ...(process.env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: process.env.NOWWORK_ENV_TAG }),
-                    ...(process.env.NOWWORK_STORAGE_POLICY_PATH === undefined
-                        ? {} : { NOWWORK_STORAGE_POLICY_PATH: process.env.NOWWORK_STORAGE_POLICY_PATH }),
-                    ...(process.env.NOWWORK_LOCAL_HOME === undefined ? {} : { NOWWORK_LOCAL_HOME: process.env.NOWWORK_LOCAL_HOME }),
-                    ...(process.env.NOWWORK_LOCAL_HOME_MODE === undefined && process.env.NOWWORK_STORAGE_MODE === undefined
-                        ? {} : { NOWWORK_LOCAL_HOME_MODE: process.env.NOWWORK_LOCAL_HOME_MODE ?? process.env.NOWWORK_STORAGE_MODE }),
-                },
+                environment: storageServiceEnvironment(process.env),
             });
         }
         applyProfileToEnv(profile, process.env);

package/dist/managed-service-lifecycle.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { acquireDaemonInstallationLease } from "./daemon-installation-lease.js";
+import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { installService, ensureServiceEnabled, readServiceDescriptor, serviceAction, replaceInstalledServiceDescriptor, uninstallService, } from "./computer-service.js";
 import { ManagedServiceConflictError, ManagedServiceRegistryError, assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, managedServiceConflict, normalizeManagedServiceRecord, serviceDescriptorSha256, withManagedServiceRegistryLock, } from "./managed-service-registry.js";
 function requirePortableManagedSpec(spec) {
@@ -43,7 +43,7 @@ function sameManagedResource(left, right) {
 function descriptorDiffIsStorageEnvironmentOnly(previous, next) {
     if (!next.includes("\n  <key>EnvironmentVariables</key>\n"))
         return false;
-    const strip = (descriptor) => descriptor.replace(/\n  <key>EnvironmentVariables<\/key>\n  <dict>\n(?:    <key>(?:NOWWORK_HOME|NOWWORK_ENV_TAG|NOWWORK_STORAGE_POLICY_PATH)<\/key><string>[^<]*<\/string>\n)+  <\/dict>\n/u, "\n");
+    const strip = (descriptor) => descriptor.replace(/\n  <key>EnvironmentVariables<\/key>\n  <dict>\n(?:    <key>(?:NOWWORK_HOME|NOWWORK_ENV_TAG|NOWWORK_STORAGE_POLICY_PATH|NOWWORK_LOCAL_HOME|NOWWORK_LOCAL_HOME_MODE)<\/key><string>[^<]*<\/string>\n)+  <\/dict>\n/u, "\n");
     return strip(previous) === strip(next);
 }
 function assertRecordDescribesSpec(input) {
@@ -90,6 +90,7 @@ export async function installManagedService(input) {
             }
             const lease = await acquire(input.record.npmPrefix, {
                 ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+                ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
             });
             try {
                 await installService(input.spec, input.runner);
@@ -136,6 +137,7 @@ export async function installManagedService(input) {
         }
         const lease = await acquire(input.record.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             const descriptor = await readServiceDescriptor(input.spec);
@@ -170,6 +172,7 @@ export async function uninstallUnregisteredManagedService(input) {
         const acquire = input.acquireInstallationLease ?? acquireDaemonInstallationLease;
         const lease = await acquire(input.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             await uninstallService(input.spec, input.runner);
@@ -199,6 +202,7 @@ export async function uninstallManagedService(input) {
         }
         const lease = await acquire(input.record.npmPrefix, {
             ...(input.registry?.userHome === undefined ? {} : { userHome: input.registry.userHome }),
+            ...(input.registry?.localHome === undefined ? {} : { localHome: input.registry.localHome }),
         });
         try {
             if (descriptor !== null)

package/dist/package-manager-env.js

@@ -0,0 +1,75 @@
+import { readFileSync } from "node:fs";
+function nonEmpty(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized === "" ? undefined : normalized;
+}
+function registryUrl(value) {
+    const normalized = nonEmpty(value);
+    if (normalized === undefined)
+        return undefined;
+    try {
+        const protocol = new URL(normalized).protocol;
+        return protocol === "http:" || protocol === "https:" ? normalized : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function configuredPath(env) {
+    const explicit = env.CREW_PACKAGE_MANAGER_USERCONFIG?.trim();
+    if (explicit !== undefined && explicit !== "")
+        return explicit;
+    return undefined;
+}
+function registryFromNpmrc(path) {
+    if (path === undefined)
+        return undefined;
+    try {
+        const line = readFileSync(path, "utf8")
+            .split(/\r?\n/u)
+            .find((entry) => /^\s*registry\s*=/u.test(entry));
+        return registryUrl(line?.replace(/^\s*registry\s*=\s*/u, ""));
+    }
+    catch {
+        return undefined;
+    }
+}
+function npmrcHasAuth(path) {
+    if (path === undefined)
+        return false;
+    try {
+        return /^\s*(?:(?:\/\/[^=\s]+:)?_(?:auth|authToken|password))\s*=/imu.test(readFileSync(path, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Keep machine-owned npm credentials available for explicitly authorized
+ * training dependency installs. The daemon must opt in with
+ * CREW_PACKAGE_MANAGER_USERCONFIG; Agent env cannot reach this path.
+ */
+export function machinePackageManagerEnv(env = process.env) {
+    const npmUserConfig = configuredPath(env);
+    const yarnRegistry = npmUserConfig === undefined
+        ? undefined
+        : registryUrl(env.YARN_REGISTRY) ?? registryFromNpmrc(npmUserConfig);
+    const entries = npmUserConfig === undefined
+        ? []
+        : [["NPM_CONFIG_USERCONFIG", npmUserConfig]];
+    const alwaysAuth = npmrcHasAuth(npmUserConfig) ? "true" : undefined;
+    return Object.fromEntries(yarnRegistry === undefined && alwaysAuth === undefined
+        ? entries
+        : [
+            ...entries,
+            ...(yarnRegistry === undefined ? [] : [["YARN_REGISTRY", yarnRegistry]]),
+            ...(alwaysAuth === undefined ? [] : [["NPM_CONFIG_ALWAYS_AUTH", alwaysAuth]]),
+        ]);
+}
+export function packageManagerEnvFacts(env) {
+    return {
+        npm_userconfig_present: Boolean(env.NPM_CONFIG_USERCONFIG?.trim()),
+        yarn_registry_present: Boolean(env.YARN_REGISTRY?.trim()),
+        npm_always_auth_present: Boolean(env.NPM_CONFIG_ALWAYS_AUTH?.trim()),
+    };
+}

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