@nowcrew/daemon 0.6.87-beta.3 → 0.6.87-beta.5

package/dist/storage-ownership.js

@@ -1,8 +1,11 @@
-import { createHash } from "node:crypto";
-import { lstat, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { z } from "zod";
+import { atomicRenameNoReplace } from "./atomic-no-replace-rename.js";
+import { durableDirectorySync } from "./atomic-private-write.js";
 const FingerprintSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const UuidSchema = z.string().uuid();
 const StorageOwnershipClaimSchema = z.object({
     version: z.literal(1),
     machineId: z.string().uuid(),
@@ -38,8 +41,10 @@ export function createStorageOwnershipClaim(input) {
 export function storageOwnershipClaimPath(nowworkHome) {
     return join(nowworkHome, "storage-layout.json");
 }
-export async function readStorageOwnershipClaim(nowworkHome) {
-    const path = storageOwnershipClaimPath(nowworkHome);
+export function workspaceStorageOwnershipClaimPath(nowworkHome, workspaceId) {
+    return join(nowworkHome, ".storage-ownership", `${UuidSchema.parse(workspaceId).toLowerCase()}.json`);
+}
+async function readClaim(path) {
     const metadata = await lstat(path);
     if (!metadata.isFile())
         throw new Error("storage ownership claim must be a file");
@@ -53,3 +58,86 @@ export async function readStorageOwnershipClaim(nowworkHome) {
     }
     return expected;
 }
+function missingClaim(message) {
+    return Object.assign(new Error(message), { code: "ENOENT" });
+}
+export async function readStorageOwnershipClaim(nowworkHome, workspaceId) {
+    if (workspaceId !== undefined) {
+        const normalizedWorkspaceId = UuidSchema.parse(workspaceId).toLowerCase();
+        try {
+            return await readClaim(workspaceStorageOwnershipClaimPath(nowworkHome, normalizedWorkspaceId));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const legacy = await readClaim(storageOwnershipClaimPath(nowworkHome));
+        if (legacy.workspaceId !== normalizedWorkspaceId) {
+            throw missingClaim(`storage ownership claim is not provisioned for workspace '${normalizedWorkspaceId}'`);
+        }
+        return legacy;
+    }
+    return readClaim(storageOwnershipClaimPath(nowworkHome));
+}
+export async function resolveWorkspaceStorageOwnershipClaim(input) {
+    const machineId = UuidSchema.parse(input.machineId).toLowerCase();
+    const workspaceId = UuidSchema.parse(input.workspaceId).toLowerCase();
+    try {
+        const existing = await readStorageOwnershipClaim(input.nowworkHome, workspaceId);
+        const expected = createStorageOwnershipClaim({
+            machineId,
+            workspaceId,
+            environment: input.environment,
+            volumeFingerprint: existing.volumeFingerprint,
+            workspaceRootFingerprint: input.workspaceRootFingerprint,
+            ownerEpoch: existing.ownerEpoch,
+        });
+        if (existing.claimFingerprint !== expected.claimFingerprint) {
+            throw new Error("storage ownership claim conflicts with the authenticated workspace identity");
+        }
+        return existing;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const anchor = await readClaim(storageOwnershipClaimPath(input.nowworkHome));
+    if (anchor.environment !== input.environment.toLowerCase()) {
+        throw new Error("storage ownership volume anchor environment does not match");
+    }
+    const claim = createStorageOwnershipClaim({
+        machineId,
+        workspaceId,
+        environment: input.environment,
+        volumeFingerprint: anchor.volumeFingerprint,
+        workspaceRootFingerprint: input.workspaceRootFingerprint,
+        ownerEpoch: 1,
+    });
+    const path = workspaceStorageOwnershipClaimPath(input.nowworkHome, workspaceId);
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    let handle = null;
+    try {
+        handle = await open(temporary, "wx", 0o600);
+        await handle.writeFile(`${JSON.stringify({ version: 1, ...claim })}\n`, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        const published = await atomicRenameNoReplace(temporary, path);
+        if (published === "published") {
+            await durableDirectorySync(directory);
+            return claim;
+        }
+        const raced = await readClaim(path);
+        if (raced.claimFingerprint !== claim.claimFingerprint) {
+            throw new Error("storage ownership claim was concurrently provisioned for another identity");
+        }
+        return raced;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+}

package/dist/storage-runtime-controller.js

@@ -5,12 +5,13 @@ import { buildServiceSpec } from "./computer-service.js";
 import { buildManagedServiceRecord } from "./managed-service-lifecycle.js";
 import { createStorageControlController } from "./storage-control.js";
 import { runStorageDoctor } from "./storage-doctor.js";
-import { storageHelloIdentity } from "./storage-identity.js";
+import { storageHelloIdentity, storageWorkspaceRootFingerprint, } from "./storage-identity.js";
 import { storageLayout, validateStorageEnvironment } from "./storage-layout.js";
 import { StorageMigrationFailure } from "./storage-migration-controller.js";
 import { launchStorageMigrationWorker, writeStorageWorkerHandoff } from "./storage-worker-handoff.js";
 import { writeStorageWorkerOperation } from "./storage-worker-operation.js";
 import { latestSourceStorageMigrationReceipt, monitorStorageMigrationStatus, storageMigrationStatusReplay, } from "./storage-status-replay.js";
+import { resolveWorkspaceStorageOwnershipClaim, } from "./storage-ownership.js";
 const UUID = z.string().uuid();
 function fingerprint(value) {
     return `sha256:${createHash("sha256").update(value).digest("hex")}`;
@@ -22,13 +23,13 @@ function deterministicUuid(value) {
     const hex = chars.join("");
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
-function storageId(input, workspaceId) {
-    if (input.ownership.workspaceId !== workspaceId || input.ownership.environment !== input.environment) {
+function storageId(input, workspaceId, ownership) {
+    if (ownership.workspaceId !== workspaceId || ownership.environment !== input.environment) {
         throw new Error("Storage ownership claim does not match the migration identity");
     }
-    return `storage_${input.ownership.claimFingerprint.slice("sha256:".length)}`;
+    return `storage_${ownership.claimFingerprint.slice("sha256:".length)}`;
 }
-function installationBase(input, workspaceId, migrationId, createdAt) {
+function installationBase(input, workspaceId, migrationId, createdAt, ownership) {
     const layout = storageLayout({
         nowworkHome: input.nowworkHome,
         environment: input.environment,
@@ -43,7 +44,7 @@ function installationBase(input, workspaceId, migrationId, createdAt) {
         serverUrl: input.serverUrl,
         environment: input.environment,
         workspaceId,
-        storageId: storageId(input, workspaceId),
+        storageId: storageId(input, workspaceId, ownership),
         nowworkHome: input.nowworkHome,
         runtimeRoot: layout.runtimeRoot,
         credentialRef: `profile:${input.profile}`,
@@ -99,6 +100,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
         writeHandoff: writeStorageWorkerHandoff,
         launchWorker: launchStorageMigrationWorker,
         monitorWorker: monitorStorageMigrationStatus,
+        resolveOwnership: resolveWorkspaceStorageOwnershipClaim,
         now: () => new Date(),
         ...injected,
     };
@@ -108,6 +110,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
     let gate = null;
     let sendStatus = null;
     let control = null;
+    let ownership = input.ownership;
+    let identityBindTail = Promise.resolve();
     const pendingControlMessages = [];
     let drainingPendingControlMessages = false;
     const drainPendingControlMessages = () => {
@@ -197,8 +201,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
                 backupsRoot: input.local.backupsRoot,
                 backupArtifacts: input.backupArtifacts.map((artifact) => ({ ...artifact })),
                 ownership: {
-                    ownerEpoch: input.ownership.ownerEpoch,
-                    ownershipClaimFingerprint: input.ownership.claimFingerprint,
+                    ownerEpoch: ownership.ownerEpoch,
+                    ownershipClaimFingerprint: ownership.claimFingerprint,
                 },
                 acceptedWarnings: [...input.policy.acceptedWarnings],
             },
@@ -214,7 +218,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             installation: {
                 configRoot: input.local.configRoot,
                 target: {
-                    ...installationBase(input, workspaceId, doctor.manifest.migrationId, createdAt),
+                    ...installationBase(input, workspaceId, doctor.manifest.migrationId, createdAt, ownership),
                     storageMigrationId: doctor.manifest.migrationId,
                 },
             },
@@ -236,8 +240,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             sourceStorageFingerprint,
             targetStorageFingerprint: identity.storageIdFingerprint,
             ownership: {
-                ownerEpoch: input.ownership.ownerEpoch,
-                ownershipClaimFingerprint: input.ownership.claimFingerprint,
+                ownerEpoch: ownership.ownerEpoch,
+                ownershipClaimFingerprint: ownership.claimFingerprint,
             },
             runDoctor: async (migrationId) => dependencies.runDoctor(await doctorInput(migrationId)),
             runMigration: async (doctor) => {
@@ -294,7 +298,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             sendStatus,
         });
     };
-    const bindServerIdentity = (server) => {
+    const bindServerIdentityOnce = async (server) => {
         const nextWorkspaceId = UUID.parse(server.workspaceId).toLowerCase();
         const nextMachineId = UUID.parse(server.machineId).toLowerCase();
         if (workspaceId !== null && workspaceId !== nextWorkspaceId) {
@@ -303,13 +307,6 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
         if (machineId !== null && machineId !== nextMachineId) {
             throw new Error("Storage migration server machine identity changed");
         }
-        if (input.ownership.workspaceId !== nextWorkspaceId
-            || input.ownership.machineId !== nextMachineId
-            || input.ownership.environment !== input.environment) {
-            throw new Error("Storage ownership claim does not match authenticated server identity");
-        }
-        const createdAt = dependencies.now().toISOString();
-        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt);
         const layout = storageLayout({
             nowworkHome: input.nowworkHome,
             environment: input.environment,
@@ -317,13 +314,36 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             runtimeBase: input.local.runtimeBase,
             platform: input.platform,
         });
-        const nextIdentity = storageHelloIdentity({ installation, layout, ownership: input.ownership });
+        if (ownership.workspaceId !== nextWorkspaceId
+            || ownership.machineId !== nextMachineId
+            || ownership.environment !== input.environment) {
+            ownership = await dependencies.resolveOwnership({
+                nowworkHome: input.nowworkHome,
+                machineId: nextMachineId,
+                workspaceId: nextWorkspaceId,
+                environment: input.environment,
+                workspaceRootFingerprint: storageWorkspaceRootFingerprint(layout.workspaceRoot),
+            });
+        }
+        if (ownership.workspaceId !== nextWorkspaceId
+            || ownership.machineId !== nextMachineId
+            || ownership.environment !== input.environment) {
+            throw new Error("Storage ownership claim does not match authenticated server identity");
+        }
+        const createdAt = dependencies.now().toISOString();
+        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt, ownership);
+        const nextIdentity = storageHelloIdentity({ installation, layout, ownership });
         workspaceId = nextWorkspaceId;
         machineId = nextMachineId;
         identity = nextIdentity;
         ensureControl();
         drainPendingControlMessages();
     };
+    const bindServerIdentity = (server) => {
+        const current = identityBindTail.then(() => bindServerIdentityOnce(server));
+        identityBindTail = current.catch(() => undefined);
+        return current;
+    };
     const attach = (runtime) => {
         gate = runtime.gate;
         sendStatus = runtime.sendStatus;

package/dist/storage-runtime.js

@@ -1,7 +1,7 @@
 import { findInstallationForProfile, readInstallations, resolveLocalStorageRoots, } from "./storage-config.js";
 import { storageHelloIdentity } from "./storage-identity.js";
 import { storageLayout } from "./storage-layout.js";
-import { readStorageOwnershipClaim } from "./storage-ownership.js";
+import { readStorageOwnershipClaim, resolveWorkspaceStorageOwnershipClaim, } from "./storage-ownership.js";
 const canonicalServerUrl = (value) => value.replace(/\/+$/u, "");
 export function resolveStorageRuntime(input) {
     const installation = findInstallationForProfile(input.records, input.profile);
@@ -45,7 +45,7 @@ export async function loadStorageRuntime(input) {
         return null;
     let ownership;
     try {
-        ownership = await readStorageOwnershipClaim(baseline.layout.persistentRoot);
+        ownership = await readStorageOwnershipClaim(baseline.layout.persistentRoot, baseline.layout.workspaceId);
     }
     catch (error) {
         if (error.code !== "ENOENT")
@@ -53,3 +53,39 @@ export async function loadStorageRuntime(input) {
     }
     return ownership === undefined ? baseline : resolveStorageRuntime({ ...input, records, ownership });
 }
+export async function bindStorageRuntimeOwnership(runtime, server) {
+    const workspaceId = server.workspaceId.toLowerCase();
+    const machineId = server.machineId.toLowerCase();
+    if (runtime.installation.workspaceId !== workspaceId) {
+        throw new Error("Storage runtime server workspace identity changed");
+    }
+    const existing = runtime.identity.storageOwnership;
+    if (existing !== undefined) {
+        if (existing.machineId !== machineId)
+            throw new Error("Storage runtime server machine identity changed");
+        return runtime;
+    }
+    const ownership = await resolveWorkspaceStorageOwnershipClaim({
+        nowworkHome: runtime.layout.persistentRoot,
+        machineId,
+        workspaceId,
+        environment: runtime.installation.environment,
+        workspaceRootFingerprint: runtime.identity.workspaceRootFingerprint,
+    });
+    return Object.freeze({
+        ...runtime,
+        identity: storageHelloIdentity({ installation: runtime.installation, layout: runtime.layout, ownership }),
+    });
+}
+export function createStorageRuntimeOwnershipBinding(initial) {
+    let runtime = initial;
+    let bindTail = Promise.resolve();
+    const bind = (server) => {
+        const current = bindTail.then(async () => {
+            runtime = await bindStorageRuntimeOwnership(runtime, server);
+        });
+        bindTail = current.catch(() => undefined);
+        return current;
+    };
+    return Object.freeze({ identity: () => runtime.identity, bind });
+}

package/dist/storage-serve-adapter.js

@@ -9,6 +9,15 @@ export function storageMigrationCapabilities(configured, options) {
             ...(options.ready ? [STORAGE_MIGRATION_CAPABILITY] : []),
         ])]);
 }
+export function bindStorageMigrationServerIdentity(options, identity, callbacks) {
+    const bind = options?.bindServerIdentity;
+    if (bind === undefined) {
+        if (options?.ready === true)
+            callbacks.onBound();
+        return;
+    }
+    void Promise.resolve().then(() => bind(identity)).then(callbacks.onBound).catch(callbacks.onError);
+}
 export function createServeStorageStatusDelivery(options, dependencies) {
     return createStorageStatusDelivery({
         ...(options?.statusOutboxPath === undefined ? {} : { outboxPath: options.statusOutboxPath }),
@@ -17,28 +26,36 @@ export function createServeStorageStatusDelivery(options, dependencies) {
     });
 }
 export function attachStorageMigrationRuntime(options, dependencies) {
-    let admissionClosed = false;
+    let migrationAdmissionClosed = false;
+    let identityAdmissionClosed = options?.bindServerIdentity !== undefined;
     if (options?.ready === true) {
         options.attach?.({
             gate: {
                 isBusy: dependencies.isBusy,
                 closeAndFlush: async () => {
-                    admissionClosed = true;
+                    migrationAdmissionClosed = true;
                     await dependencies.waitForExecutionFrames();
                     if (dependencies.isBusy()) {
-                        admissionClosed = false;
+                        migrationAdmissionClosed = false;
                         throw Object.assign(new Error("active execution entered before storage migration quiesce"), {
                             code: "runtime_busy",
                         });
                     }
                     await dependencies.flushLocalState();
                 },
-                reopen: () => { admissionClosed = false; },
+                reopen: () => { migrationAdmissionClosed = false; },
             },
             sendStatus: dependencies.sendStatus,
         });
     }
-    return Object.freeze({ isAdmissionClosed: () => admissionClosed });
+    return Object.freeze({
+        isAdmissionClosed: () => migrationAdmissionClosed || identityAdmissionClosed,
+        beginIdentityBinding: () => {
+            if (options?.bindServerIdentity !== undefined)
+                identityAdmissionClosed = true;
+        },
+        completeIdentityBinding: () => { identityAdmissionClosed = false; },
+    });
 }
 export function replayStorageMigrationStatus(options, socket, isCurrent, onError, deliver) {
     return options?.replayStatus?.((frame) => {

package/dist/workspace.js

@@ -11,6 +11,8 @@
 import { mkdir, writeFile, readFile, chmod, access, lstat } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 import { dslog } from "./slog.js";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
@@ -96,6 +98,19 @@ export async function prepareWorkspace(input) {
     await chmod(wrapper, 0o755);
     // win32 侧 wrapper:cmd/PowerShell 不认 shebang 脚本,并存 crew.cmd(unix 下无害不会被命中)
     await writeFile(join(crewDir, "crew.cmd"), `@echo off\r\nnode ${JSON.stringify(input.cliPath)} %*\r\n`, "utf8");
+    if (!input.skipLocalMemory) {
+        const sourceMode = import.meta.url.endsWith(".ts");
+        const reader = fileURLToPath(new URL(`./local-memory/read-cli.${sourceMode ? "ts" : "js"}`, import.meta.url));
+        const readerArgs = sourceMode
+            ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href, reader]
+            : [reader];
+        const readerWrapper = join(crewDir, "crew-memory");
+        const posixArgs = readerArgs.map((arg) => `'${arg.replace(/'/gu, "'\\''")}'`).join(" ");
+        const windowsArgs = readerArgs.map((arg) => `"${arg.replace(/%/gu, "%%")}"`).join(" ");
+        await writeFile(readerWrapper, `#!/bin/sh\nexec node ${posixArgs} "$@"\n`, "utf8");
+        await chmod(readerWrapper, 0o755);
+        await writeFile(join(crewDir, "crew-memory.cmd"), `@echo off\r\nnode ${windowsArgs} %*\r\n`, "utf8");
+    }
     // 每个 agent 独立的 XDG 配置根:隔离第三方 CLI 凭证,避免 agent 之间互相串号
     const homeDir = join(dir, ".home");
     await mkdir(join(homeDir, ".config"), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.87-beta.3",
+  "version": "0.6.87-beta.5",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",

package/dist/project-skills/capability.js

@@ -1,109 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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),
-        });
-    }));
-}