@nowcrew/daemon 0.6.77-beta.9 → 0.6.78

package/dist/control-plane-url.js

@@ -1,18 +1,12 @@
 import { executionBackendCapability } from "./execution-backend.js";
 import { daemonCapabilities, EXECUTION_PROTOCOL } from "./machine-info.js";
-import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./project-skills/types.js";
-export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe, projectSkillsAvailable = true, capabilities = daemonCapabilities(runtimePlatform)) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe, capabilities = daemonCapabilities(runtimePlatform)) {
     const query = new URLSearchParams({ key: machineToken });
     if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
-    for (const capability of capabilities) {
-        if (projectSkillsAvailable
-            || (capability !== PROJECT_SKILLS_CAPABILITY
-                && capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY)) {
-            query.append("capability", capability);
-        }
-    }
+    for (const capability of capabilities)
+        query.append("capability", capability);
     return `${serverUrl.replace(/^http/, "ws").replace(/\/+$/, "")}/daemon/connect?${query.toString()}`;
 }

package/dist/execution-runner.js

@@ -17,8 +17,7 @@ import { HostReservationCancelledError } from "./host-execution-coordinator.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 { projectSkillExecutionProjection, projectSkillProjectionApplies, projectSkillProjectionErrorCode, } from "./project-skills/execution-adapter.js";
 import { createProjectRegistry } from "./project-skills/registry.js";
 import { ProjectDependencyError, } from "./project-dependencies.js";
 import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
@@ -737,7 +736,7 @@ export async function runExecution(config, input, dependencies) {
                     }
                     catch (error) {
                         await proveActiveSupervisorStopped(error, true);
-                        throw redactProjectSkillRuntimeRootError(error, root);
+                        throw error;
                     }
                 };
                 return safeLaunch;
@@ -974,14 +973,14 @@ export async function runExecution(config, input, dependencies) {
                 await dependencies.cancellation?.waitForStop();
             }
             catch (stopError) {
-                if (spec.agent.projectSkillBindingGeneration !== undefined) {
+                if (projectSkillProjectionApplies(spec)) {
                     throw new ProjectSkillRuntimeOwnershipUnverifiedError();
                 }
                 throw stopError;
             }
         }
         else {
-            await proveActiveSupervisorStopped(error, spec.agent.projectSkillBindingGeneration !== undefined);
+            await proveActiveSupervisorStopped(error, projectSkillProjectionApplies(spec));
         }
         const failureCompletion = cancelled
             ? ExecutionCompletedSchema.parse({

package/dist/local-executor.js

@@ -24,8 +24,9 @@ import { isRuntimeReadyEvent, isRuntimeRunningEvent, } from "./runtime-startup-g
 import { dslog } from "./slog.js";
 import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
 import { ProjectProjectionError, } from "./project-skills/reconciler.js";
+import { projectSkillProjectionApplies } from "./project-skills/execution-adapter.js";
 import { formatProjectSkillRuntimeWarning } from "./project-skills/runtime-warning.js";
-import { projectSkillRuntimeDirectories, redactProjectSkillRuntimeRootText, redactProjectSkillRuntimeRootValue, } from "./project-skills/runtime-launch.js";
+import { projectSkillRuntimeDirectories, } from "./project-skills/runtime-launch.js";
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
@@ -525,12 +526,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         });
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
-        let activeProjectSkillRuntimeRoot;
         const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
             ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
             : undefined;
         const prepareRuntimeLaunch = async (runtimeRoot) => {
-            activeProjectSkillRuntimeRoot = runtimeRoot;
             const effectiveSystemPrompt = abilityContext === undefined
                 ? systemPrompt
                 : `${systemPrompt}\n\n${abilityContext.prompt}`;
@@ -681,11 +680,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             return launchRuntime(launchRequest);
         };
         let child;
-        if (input.projectSkills !== undefined && dependencies.projectSkills !== undefined) {
+        const projectionBindings = projectSkillProjectionApplies({
+            agent: { projectSkills: input.projectSkills },
+            runtime: input.runtime,
+        })
+            ? input.projectSkills
+            : undefined;
+        if (projectionBindings !== 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(launchPreparedRuntime), (warning) => callbacks.onConsole?.({
+            child = await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.executionId, input.handle, projectionBindings, launchOwner.claim(launchPreparedRuntime), (warning) => callbacks.onConsole?.({
                 stream: "system",
                 text: formatProjectSkillRuntimeWarning(warning),
             }));
@@ -818,8 +823,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 usage = meta.usage;
             if (meta.model)
                 observedModel = meta.model;
-            for (const rawActivity of normalizeEvent(event)) {
-                const activity = redactProjectSkillRuntimeRootValue(rawActivity, activeProjectSkillRuntimeRoot);
+            for (const activity of normalizeEvent(event)) {
                 if (activity.kind === "sending")
                     sentViaCrew = true;
                 activities.push(activity);
@@ -827,19 +831,18 @@ 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 ?? ""}${safeExtracted}` : safeExtracted;
+                finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
             }
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
-                callbacks.onExternalOutput?.(redactProjectSkillRuntimeRootText(text, activeProjectSkillRuntimeRoot));
+                callbacks.onExternalOutput?.(text);
             }
             for (const chunk of consoleFormatter.format(event)) {
-                callbacks.onConsole?.(redactProjectSkillRuntimeRootValue(chunk, activeProjectSkillRuntimeRoot));
+                callbacks.onConsole?.(chunk);
             }
         });
         let stderrTail = "";
@@ -861,7 +864,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })
             : null;
         child.stderr.on("data", (data) => {
-            const text = redactProjectSkillRuntimeRootText(String(data), activeProjectSkillRuntimeRoot);
+            const text = String(data);
             process.stderr.write(text);
             stderrTail = (stderrTail + text).slice(-STDERR_TAIL_CAP);
             codexStartupStageParser?.push(text);
@@ -940,9 +943,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const errorTail = [
             stderrTail.trim(),
-            spawnError === undefined
-                ? undefined
-                : redactProjectSkillRuntimeRootText(spawnError, activeProjectSkillRuntimeRoot),
+            spawnError === undefined ? undefined : spawnError,
             terminationSignal ? `terminated by ${terminationSignal}` : undefined,
         ].filter(Boolean).join(" ").trim();
         const providerError = providerErrorFromExit(exitCode, errorTail);
@@ -994,11 +995,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 : null,
             // 契约答案 = 整轮最后一个闭合的标签块(六个 runtime 语义一致的"后到者胜",半截块与
             // 叙述里的开标签不算数);从未闭合过时才回落到对 finalText 的宽容提取,保住"收尾被
-            // 截断"这一老兜底。解码器存的是原文,这里补脱敏。注意这放宽了"externalAnswer 非空
+            // 截断"这一老兜底。注意这放宽了"externalAnswer 非空
             // ⇒ finalText 非空"的旧不变式;是否上报仍由 execution-runner 按 exitCode===0 把关。
             externalAnswer: input.captureFinal
                 ? (externalOutput.lastClosedBlock !== null
-                    ? redactProjectSkillRuntimeRootText(externalOutput.lastClosedBlock, activeProjectSkillRuntimeRoot)
+                    ? externalOutput.lastClosedBlock
                     : finalText !== null ? extractExternalAnswer(finalText) : null)
                 : null,
             sentViaCrew,

package/dist/local-memory/runtime.js

@@ -3,9 +3,11 @@ import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
 export function isLocalMemoryV2Eligible(input) {
-    return input.enabledForHandle
-        && (input.localMemoryV2Initialized || (!input.agentHomePreexisted && input.memorySeedCreated))
-        && input.memoryPrune;
+    // The allowlist is the rollout boundary. The marker and seed/pre-existing
+    // state are retained as diagnostics and for backward-compatible marker
+    // creation, but must not prevent an explicitly allowlisted Agent from using
+    // the structured memory-prune protocol.
+    return input.enabledForHandle && input.memoryPrune;
 }
 const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
 export async function initializeLocalMemoryV2(agentDir) {

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