@nowcrew/daemon 0.6.77 → 0.6.78

package/dist/machine-info.js

@@ -43,6 +43,7 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "execution_agent_memory_policy_v1",
     "execution_agent_memory_mapping_v1",
     "project_skills_v1",
+    "project_skill_projection_v2",
     PROJECT_WORKSPACES_CAPABILITY,
     TRAINING_PROJECT_DEPENDENCIES_CAPABILITY,
     RUNTIME_HEALTH_PROBE_CAPABILITY,
@@ -50,6 +51,7 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "agent_ability_workspace_v1",
     "agent_ability_runtime_assets_v1",
 ]);
+/** 能力只按平台过滤,进程存活期间静态(CLAUDE.md 红线)。Windows 在 junction/copy 真机 smoke 通过前不宣告 Project Skills。 */
 export const daemonCapabilities = (runtimePlatform = process.platform, readiness = NATIVE_PROJECT_WORKSPACE_READINESS) => {
     // Windows stays fail-closed until the native workspace adapter gate is verified on a real host.
     const nativeWorkspacePlatform = runtimePlatform === "darwin" || runtimePlatform === "linux";
@@ -59,6 +61,7 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
         && (nativeWorkspacePlatform
             || (capability !== "project_skills_v1"
+                && capability !== "project_skill_projection_v2"
                 && capability !== "agent_ability_release_v1"
                 && capability !== "agent_ability_workspace_v1"
                 && capability !== "agent_ability_runtime_assets_v1")))));

package/dist/main.js

@@ -30,6 +30,7 @@ import { storageMigrationStatusReplay } from "./storage-status-replay.js";
 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";
 async function main() {
     const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
     if (workerResult !== null) {
@@ -73,8 +74,16 @@ async function main() {
     if (values["daemon-home"])
         process.env.CREW_DAEMON_HOME = values["daemon-home"];
     let activeDaemonHome;
+    const localHome = resolveDaemonLocalStateRoot({
+        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"),
+    });
     if (values.profile) {
-        const home = daemonHome();
+        const home = daemonHome(process.env, values.profile);
         activeDaemonHome = home;
         const profile = await loadProfile(values.profile, home);
         if (cmd === "serve") {
@@ -83,6 +92,7 @@ async function main() {
                 platform: process.platform,
                 profile: profile.name,
                 userHome: homedir(),
+                localHome,
                 uid: process.getuid?.(),
                 daemonHome: home,
                 agentsRoot: resolveAgentsRoot(profile.agentsRoot, homedir(), process.platform),
@@ -141,7 +151,7 @@ async function main() {
             : daemonGlobalInstallation(builtDaemonEntry(), process.platform);
         const installationLease = installation === null
             ? null
-            : await acquireDaemonInstallationLease(installation.npmPrefix);
+            : await acquireDaemonInstallationLease(installation.npmPrefix, { localHome });
         const migrationRuntime = values.profile === undefined || activeDaemonHome === undefined || storageRuntime !== null
             ? { ready: false, reason: "not_legacy_source" }
             : await probeStorageMigrationRuntime({
@@ -198,6 +208,7 @@ async function main() {
         await runWithDaemonInstallationLease(installationLease, async () => {
             const service = serve(runtimeConfig, {
                 ...(values.profile === undefined ? {} : { profileName: values.profile }),
+                localHome,
                 ...(storageMigration === undefined ? {} : { storageMigration }),
             });
             await runServeLifecycle(service);

package/dist/managed-service-diagnostics.js

@@ -16,6 +16,7 @@ export async function inspectManagedServiceDiagnostics(input) {
     const inspectLease = input.inspectInstallationLease
         ?? (() => inspectDaemonInstallationLease(input.expectedRecord.npmPrefix, {
             ...(userHome === undefined ? {} : { userHome }),
+            ...(registry.localHome === undefined ? {} : { localHome: registry.localHome }),
         }));
     let services = null;
     let registryCheck;

package/dist/managed-service-registry.js

@@ -5,6 +5,7 @@ import { homedir } from "node:os";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 import { acquireProfileSaveLock } from "./computer-profile-lock.js";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const AbsolutePathSchema = z.string().min(1).refine(isAbsolute, "must be an absolute path");
 const ManagedServiceRecordSchema = z.object({
     version: z.literal(1),
@@ -42,11 +43,15 @@ export class ManagedServiceConflictError extends ManagedServiceRegistryError {
         this.owner = owner;
     }
 }
-function registryDirectory(userHome) {
-    return resolve(userHome, ".crew", "daemon", "managed-services");
+function registryDirectory(userHome, localHome) {
+    const root = localHome ?? resolveDaemonLocalStateRoot({
+        userHome,
+        platform: process.platform,
+    });
+    return resolve(root, "daemon", "managed-services");
 }
-export function managedServiceRegistryPath(userHome = homedir()) {
-    return resolve(registryDirectory(userHome), "registry.json");
+export function managedServiceRegistryPath(userHome = homedir(), localHome) {
+    return resolve(registryDirectory(userHome, localHome), "registry.json");
 }
 export async function listManagedServiceDescriptorPaths(platform, userHome = homedir()) {
     const directory = platform === "darwin"
@@ -219,14 +224,14 @@ export function managedServiceConflict(services, candidate) {
 }
 export async function withManagedServiceRegistryLock(options, operation) {
     const userHome = options.userHome ?? homedir();
-    const directory = registryDirectory(userHome);
+    const directory = registryDirectory(userHome, options.localHome);
     const release = await acquireProfileSaveLock(directory, {
         ...(options.lockTimeoutMs === undefined ? {} : { timeoutMs: options.lockTimeoutMs }),
         ...(options.lockRetryMs === undefined ? {} : { retryMs: options.lockRetryMs }),
     });
     let operationError;
     try {
-        const path = managedServiceRegistryPath(userHome);
+        const path = managedServiceRegistryPath(userHome, options.localHome);
         const services = await readRegistryFile(path);
         return await operation({
             services,
@@ -258,7 +263,7 @@ export async function withManagedServiceRegistryLock(options, operation) {
     }
 }
 export async function readManagedServiceRegistry(options = {}) {
-    return readRegistryFile(managedServiceRegistryPath(options.userHome ?? homedir()));
+    return readRegistryFile(managedServiceRegistryPath(options.userHome ?? homedir(), options.localHome));
 }
 export async function registerManagedService(input, options = {}) {
     const candidate = normalizeManagedServiceRecord(input);

package/dist/managed-service-startup.js

@@ -17,7 +17,10 @@ export async function assertManagedServiceStartup(input) {
         ...(input.environment === undefined ? {} : { environment: input.environment }),
     });
     const readRegistry = input.readManagedServices
-        ?? (() => readManagedServiceRegistry({ userHome: input.userHome }));
+        ?? (() => readManagedServiceRegistry({
+            userHome: input.userHome,
+            ...(input.localHome === undefined ? {} : { localHome: input.localHome }),
+        }));
     const listDescriptors = input.listManagedDescriptorPaths
         ?? (() => listManagedServiceDescriptorPaths(input.platform, input.userHome));
     const readDescriptor = input.readServiceDescriptor ?? readServiceDescriptor;

package/dist/npm-command.js

@@ -0,0 +1,9 @@
+import { posix, win32 } from "node:path";
+/** Execute POSIX npm through its owning Node binary so service PATH is irrelevant. */
+export function npmInvocation(platform, nodePath = process.execPath) {
+    const paths = platform === "win32" ? win32 : posix;
+    const npmPath = paths.join(paths.dirname(nodePath), platform === "win32" ? "npm.cmd" : "npm");
+    return platform === "win32"
+        ? { command: npmPath, argsPrefix: [] }
+        : { command: nodePath, argsPrefix: [npmPath] };
+}

package/dist/project-skills/controller.js

@@ -1,11 +1,9 @@
 import { z } from "zod";
-import { projectSkillResolutionRecords, scanProjects } from "./scanner.js";
+import { scanProjects } from "./scanner.js";
 import { ProjectRegistryError } from "./registry.js";
 import { isProjectId, isProjectSkillName, compareProjectSkillRefs, MAX_AGENT_PROJECT_SKILL_BINDINGS, } from "./types.js";
-import { ProjectProjectionError, } from "./reconciler.js";
 import { AgentHandleSchema } from "../execution-protocol.js";
 import { createPromiseTail } from "../promise-tail.js";
-import { createProjectSkillSnapshotEpoch, MAX_REMEMBERED_PROJECT_SKILL_AGENTS, toPathPrivateConvergenceResults, } from "./controller-convergence.js";
 const ProjectIdSchema = z.string().refine(isProjectId);
 const AgentSkillsSyncSchema = z.object({
     type: z.literal("agent:skills:sync"),
@@ -50,7 +48,7 @@ const ProjectCommandSchema = z.discriminatedUnion("type", [
     }
 });
 const DEFAULT_PROJECT_SCAN_TIMEOUT_MS = 10_000;
-class ProjectScanTimeoutError extends Error {
+export class ProjectScanTimeoutError extends Error {
     code = "project_scan_timeout";
     constructor() {
         super("project_scan_timeout");
@@ -87,7 +85,6 @@ export function createProjectSkillsController(deps) {
     let initializationState = "idle";
     const scan = deps.scan ?? scanProjects;
     const scanTimeoutMs = deps.scanTimeoutMs ?? DEFAULT_PROJECT_SCAN_TIMEOUT_MS;
-    const snapshotEpoch = createProjectSkillSnapshotEpoch();
     let connectionEpochIdentity = Object.freeze({});
     const assertCurrentEpoch = (token) => {
         if (token !== undefined && token !== connectionEpochIdentity)
@@ -110,51 +107,6 @@ export function createProjectSkillsController(deps) {
         }));
     };
     const enqueue = (operation) => operationTail.enqueue(operation);
-    const applyV2Snapshot = async (handle, snapshot, epochToken) => {
-        if (deps.ensureSnapshot === undefined)
-            throw new ProjectProjectionError("skill_projection_failed");
-        assertCurrentEpoch(epochToken);
-        const acceptedEpochIdentity = connectionEpochIdentity;
-        const rememberedEntries = snapshotEpoch.entries();
-        const firstAcceptedInEpoch = !rememberedEntries.some(([candidate]) => candidate === handle);
-        if (firstAcceptedInEpoch && rememberedEntries.length >= MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
-            throw new ProjectProjectionError("skill_projection_failed");
-        }
-        if (firstAcceptedInEpoch) {
-            await deps.ensureSnapshot(handle, snapshot, Object.freeze({ refreshCopyProjection: true }));
-        }
-        else {
-            await deps.ensureSnapshot(handle, snapshot);
-        }
-        assertCurrentEpoch(epochToken);
-        if (acceptedEpochIdentity === connectionEpochIdentity)
-            snapshotEpoch.remember(handle, snapshot);
-        return Object.freeze(projectSkillResolutionRecords(snapshot.bindings, scanned)
-            .map((record) => Object.freeze({
-            projectId: record.projectId,
-            skillName: record.skillName,
-            status: record.mode === "resolved" ? "linked" : "unavailable",
-        })));
-    };
-    const convergeV2Snapshots = async (refreshCopyProjection, epochToken) => {
-        assertCurrentEpoch(epochToken);
-        const acceptedEpochIdentity = connectionEpochIdentity;
-        const entries = snapshotEpoch.entries();
-        if (deps.ensureSnapshot === undefined || entries.length === 0)
-            return;
-        const results = await Promise.allSettled(entries.map(([handle, snapshot]) => refreshCopyProjection
-            ? deps.ensureSnapshot(handle, snapshot, Object.freeze({ refreshCopyProjection: true }))
-            : deps.ensureSnapshot(handle, snapshot)));
-        if (acceptedEpochIdentity !== connectionEpochIdentity) {
-            if (epochToken !== undefined)
-                throw new ProjectSkillStaleEpochError();
-            return;
-        }
-        try {
-            deps.onConvergence?.(toPathPrivateConvergenceResults(entries, results));
-        }
-        catch { /* convergence diagnostics must not change a successful inventory mutation */ }
-    };
     const initialize = () => {
         if (initializationState === "ready" && initialization !== null)
             return initialization;
@@ -173,10 +125,10 @@ export function createProjectSkillsController(deps) {
     return {
         beginConnectionEpoch: () => {
             connectionEpochIdentity = Object.freeze({});
-            snapshotEpoch.begin();
             return connectionEpochIdentity;
         },
         initialize,
+        ensureScanned: () => initialize(),
         publishCurrent: () => enqueue(publishCurrent),
         scannedProjects: () => scanned,
         async handle(input, epochToken) {
@@ -208,25 +160,9 @@ export function createProjectSkillsController(deps) {
                 try {
                     assertCurrentEpoch(epochToken);
                     if (command.type === "agent:skills:sync") {
-                        if (command.generation !== undefined) {
-                            const snapshot = Object.freeze({
-                                bindings: Object.freeze(command.bindings.map((binding) => Object.freeze({ ...binding }))),
-                                generation: command.generation,
-                            });
-                            return {
-                                ok: true,
-                                data: { bindings: await applyV2Snapshot(command.handle, snapshot, epochToken) },
-                            };
-                        }
-                        if (deps.reconcile === undefined)
-                            return { ok: false, error: "skill_projection_failed" };
                         const bindings = await deps.reconcile(command.handle, command.bindings);
                         assertCurrentEpoch(epochToken);
-                        snapshotEpoch.forget(command.handle);
-                        return {
-                            ok: true,
-                            data: { bindings },
-                        };
+                        return { ok: true, data: { bindings } };
                     }
                     if (command.type === "project:add") {
                         const existed = (await deps.registry.list())
@@ -260,7 +196,6 @@ export function createProjectSkillsController(deps) {
                     assertCurrentEpoch(epochToken);
                     await publishCurrent();
                     assertCurrentEpoch(epochToken);
-                    await convergeV2Snapshots(command.type === "project:rescan", epochToken);
                     return { ok: true, data: { projectId: command.projectId } };
                 }
                 catch (error) {
@@ -274,8 +209,8 @@ export function createProjectSkillsController(deps) {
                                     ? "skill_projection_stale"
                                     : error.code === "skill_projection_failed"
                                         ? "skill_projection_failed"
-                                        : error.code === "skill_projection_snapshot_corrupt"
-                                            ? "skill_projection_snapshot_corrupt"
+                                        : error.code === "project_skills_unavailable"
+                                            ? "project_skills_unavailable"
                                             : "project_operation_failed",
                     };
                 }

package/dist/project-skills/execution-adapter.js

@@ -8,4 +8,11 @@ export function projectSkillExecutionProjection(bindings, generation) {
             generation,
         });
 }
+/**
+ * 投影门控与 ownership 判定的唯一谓词:只有绑定了 Project Skills 且运行时是 codex/claude 的执行
+ * 才会有投影目录,也才需要在停止无法证明时保留它。两处判定分开写过一次,结果 kimi + projectSkills
+ * 会在取消路径上错抛 ownership 未确认。
+ */
+export const projectSkillProjectionApplies = (spec) => spec.agent.projectSkills !== undefined
+    && (spec.runtime.name === "codex" || spec.runtime.name === "claude");
 export const projectSkillProjectionErrorCode = (error) => error instanceof ProjectProjectionError ? error.code : null;

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

@@ -0,0 +1,163 @@
+/**
+ * 按执行投影:每次 execution 在 Agent 目录下独占一个短命目录,投影绑定的 Project Skills;
+ * 用完即删,启动时按 journal 清扫。没有共享状态,所以没有 manifest / 目录身份 / 租约 / GC。
+ * (取代 2026-08-21 版本化 runtime root;incident: 2026-09-04 st_dev 漂移摘掉整机能力)
+ */
+import { lstat, mkdir, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { DirectoryProjectionError, projectDirectory } from "../directory-projection.js";
+/** 稳定错误:code 与既有 skill_projection_failed 对齐,reason 是 path-free 的细分原因。 */
+export class ExecutionProjectionError extends Error {
+    reason;
+    code = "skill_projection_failed";
+    constructor(reason) {
+        super(`execution projection failed: ${reason}`);
+        this.reason = reason;
+        this.name = "ExecutionProjectionError";
+    }
+}
+export const EXECUTION_PROJECTION_PARENT = Object.freeze([".crew", "project-skills"]);
+const DIRECTORY_PREFIX = "exec-";
+const SAFE_EXECUTION_ID = /^[A-Za-z0-9._-]{1,128}$/u;
+const projectionParent = (agentRoot) => join(agentRoot, ...EXECUTION_PROJECTION_PARENT);
+export function executionProjectionDescriptor(agentRoot, executionId) {
+    if (!SAFE_EXECUTION_ID.test(executionId) || executionId === "." || executionId === "..") {
+        throw new ExecutionProjectionError("unmanaged_path");
+    }
+    const rootDirectory = join(projectionParent(agentRoot), `${DIRECTORY_PREFIX}${executionId}`);
+    const runtime = join(rootDirectory, "runtime");
+    return Object.freeze({
+        executionId,
+        rootDirectory,
+        codexSkillRoot: join(runtime, ".claude", "skills"),
+        claudeAdditionalDirectory: runtime,
+    });
+}
+const ownedByCurrentUser = (uid) => process.getuid === undefined || uid === process.getuid();
+/** 每一层都必须是本用户的真实目录;symlink / 他人目录 → unmanaged_path。 */
+const assertManagedDirectory = async (path) => {
+    let info;
+    try {
+        info = await lstat(path);
+    }
+    catch {
+        throw new ExecutionProjectionError("unmanaged_path");
+    }
+    if (!info.isDirectory() || info.isSymbolicLink() || !ownedByCurrentUser(info.uid)) {
+        throw new ExecutionProjectionError("unmanaged_path");
+    }
+};
+const isErrno = (error, code) => typeof error === "object" && error !== null && error.code === code;
+export async function materializeExecutionProjection(input) {
+    const platform = input.platform ?? process.platform;
+    const project = input.projectDirectory ?? projectDirectory;
+    const root = executionProjectionDescriptor(input.agentRoot, input.executionId);
+    const parent = projectionParent(input.agentRoot);
+    // 逐层 assert-then-create:先证明这一层是本用户的真实目录,再在其下创建下一层。
+    // 反过来(先 recursive mkdir 再 assert)会让 `.crew` 是 symlink 的情况先在别人的树里建好目录。
+    const crewRoot = join(input.agentRoot, EXECUTION_PROJECTION_PARENT[0]);
+    await assertManagedDirectory(input.agentRoot);
+    try {
+        await mkdir(crewRoot, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        throw new ExecutionProjectionError("mkdir_failed");
+    }
+    await assertManagedDirectory(crewRoot);
+    try {
+        await mkdir(parent, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        throw new ExecutionProjectionError("mkdir_failed");
+    }
+    await assertManagedDirectory(parent);
+    try {
+        await mkdir(root.rootDirectory, { mode: 0o700 });
+    }
+    catch (error) {
+        throw new ExecutionProjectionError(isErrno(error, "EEXIST") ? "execution_projection_exists" : "mkdir_failed");
+    }
+    const modes = [];
+    try {
+        await mkdir(root.codexSkillRoot, { recursive: true, mode: 0o700 });
+        for (const record of input.resolutions) {
+            if (record.mode !== "resolved" || record.sourcePath === null)
+                continue;
+            let projected;
+            try {
+                // `projectDirectory`'s symlink path never lstats the source (POSIX symlink() happily
+                // creates a dangling link), so a source that vanished between scan and materialize would
+                // otherwise be silently projected as a broken link instead of failing loudly.
+                const sourceExists = await lstat(record.sourcePath).then(() => true, () => false);
+                if (!sourceExists)
+                    throw new ExecutionProjectionError("link_failed");
+                projected = await project(record.sourcePath, join(root.codexSkillRoot, record.skillName), platform);
+            }
+            catch (error) {
+                if (error instanceof ExecutionProjectionError)
+                    throw error;
+                const copying = platform === "win32" && error instanceof DirectoryProjectionError
+                    && error.code === "directory_projection_limit_exceeded";
+                throw new ExecutionProjectionError(copying ? "copy_failed" : "link_failed");
+            }
+            modes.push({ skillName: record.skillName, mode: projected.mode });
+        }
+    }
+    catch (error) {
+        await rm(root.rootDirectory, { recursive: true, force: true }).catch(() => undefined);
+        if (error instanceof ExecutionProjectionError)
+            throw error;
+        throw new ExecutionProjectionError("mkdir_failed");
+    }
+    return Object.freeze({ root, modes: Object.freeze(modes) });
+}
+export async function removeExecutionProjection(agentRoot, executionId) {
+    const root = executionProjectionDescriptor(agentRoot, executionId);
+    await rm(root.rootDirectory, { recursive: true, force: true });
+}
+export async function sweepExecutionProjections(agentRoot, isLive) {
+    const parent = projectionParent(agentRoot);
+    const parentExists = await lstat(parent).then(() => true, (error) => {
+        if (isErrno(error, "ENOENT"))
+            return false;
+        throw error;
+    });
+    if (!parentExists)
+        return Object.freeze({ removed: Object.freeze([]), kept: Object.freeze([]) });
+    // Every layer must still be a real, owned directory — a symlink swapped in for `.crew` or
+    // `.crew/project-skills` (or the agent root itself) must never let readdir/rm follow it out
+    // of the managed tree and delete something outside it.
+    await assertManagedDirectory(agentRoot);
+    await assertManagedDirectory(join(agentRoot, EXECUTION_PROJECTION_PARENT[0]));
+    await assertManagedDirectory(parent);
+    const entries = await readdir(parent, { withFileTypes: true });
+    const removed = [];
+    const kept = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith(DIRECTORY_PREFIX))
+            continue;
+        const candidate = join(parent, entry.name);
+        const candidateInfo = await lstat(candidate).catch(() => null);
+        if (candidateInfo === null || candidateInfo.isSymbolicLink())
+            continue;
+        const executionId = entry.name.slice(DIRECTORY_PREFIX.length);
+        if (!SAFE_EXECUTION_ID.test(executionId))
+            continue;
+        let live;
+        try {
+            live = await isLive(executionId);
+        }
+        catch {
+            // An `isLive` failure is ambiguous, not evidence of death — err toward keeping the
+            // directory rather than deleting a possibly-live execution's projection.
+            live = true;
+        }
+        if (live) {
+            kept.push(executionId);
+            continue;
+        }
+        await rm(candidate, { recursive: true, force: true });
+        removed.push(executionId);
+    }
+    return Object.freeze({ removed: Object.freeze(removed.sort()), kept: Object.freeze(kept.sort()) });
+}

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

@@ -1,18 +1,20 @@
-import { ProjectProjectionError, } from "./reconciler.js";
-/** Gates every projection entrypoint on the daemon's bounded registry/scanner initialization. */
-export function initializedProjectSkillsReconciler(ensureInitialized, reconciler) {
+import { ProjectProjectionError } from "./reconciler.js";
+/** 执行前等待注册表首次扫描;超时/失败 → 本次执行 project_skills_unavailable,不影响能力宣告。 */
+export function initializedProjectSkillsReconciler(ensureScanned, reconciler) {
     const ready = async () => {
-        if (await ensureInitialized())
+        try {
+            await ensureScanned();
             return reconciler;
-        throw new ProjectProjectionError("skill_projection_failed");
+        }
+        catch (error) {
+            const code = error.code;
+            throw new ProjectProjectionError("project_skills_unavailable", code === "project_scan_timeout" ? "registry_scan_timeout" : "registry_unavailable");
+        }
     };
     return {
         async reconcile(handle, bindings) {
             return (await ready()).reconcile(handle, bindings);
         },
-        async ensureSnapshot(handle, snapshot, options) {
-            return (await ready()).ensureSnapshot(handle, snapshot, options);
-        },
         async prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning) {
             return (await ready()).prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning);
         },