@nowcrew/daemon 0.6.77-beta.9 → 0.6.78

package/dist/project-skills/resolution-records.js

@@ -0,0 +1,63 @@
+import { posix, win32 } from "node:path";
+import { compareProjectSkillRefs, isProjectId, isProjectSkillName, MAX_AGENT_PROJECT_SKILL_BINDINGS, } from "./types.js";
+const MAX_SOURCE_PATH_BYTES = 16 * 1024;
+/** Thrown when resolution records fail the shape/normalization invariants below. */
+export class ProjectSkillResolutionRecordsCorruptError extends Error {
+    constructor() {
+        super("skill_projection_state_corrupt");
+        this.name = "ProjectSkillResolutionRecordsCorruptError";
+    }
+}
+const corrupt = () => { throw new ProjectSkillResolutionRecordsCorruptError(); };
+const normalizeWindowsPath = (sourcePath) => {
+    let value = sourcePath.replaceAll("/", "\\");
+    if (/^\\\\\?\\UNC\\/iu.test(value))
+        value = `\\\\${value.slice(8)}`;
+    else if (/^\\\\\?\\[A-Za-z]:\\/u.test(value))
+        value = value.slice(4);
+    if (!win32.isAbsolute(value))
+        return corrupt();
+    return win32.normalize(value).toLowerCase();
+};
+const normalizeSourcePath = (sourcePath, platform) => {
+    if (sourcePath.includes("\0") || Buffer.byteLength(sourcePath, "utf8") > MAX_SOURCE_PATH_BYTES) {
+        return corrupt();
+    }
+    if (platform === "win32")
+        return normalizeWindowsPath(sourcePath);
+    if (!posix.isAbsolute(sourcePath))
+        return corrupt();
+    return posix.normalize(sourcePath);
+};
+export function normalizeProjectSkillResolutionRecords(records, platform = process.platform) {
+    if (records.length > MAX_AGENT_PROJECT_SKILL_BINDINGS)
+        return corrupt();
+    const seen = new Set();
+    const normalized = records.map((record) => {
+        if (!isProjectId(record.projectId) || !isProjectSkillName(record.skillName))
+            return corrupt();
+        const key = `${record.projectId}\0${record.skillName}`;
+        if (seen.has(key))
+            return corrupt();
+        seen.add(key);
+        if (record.mode === "missing") {
+            if (record.sourcePath !== null)
+                return corrupt();
+            return Object.freeze({
+                projectId: record.projectId,
+                skillName: record.skillName,
+                sourcePath: null,
+                mode: "missing",
+            });
+        }
+        if (record.mode !== "resolved" || record.sourcePath === null)
+            return corrupt();
+        return Object.freeze({
+            projectId: record.projectId,
+            skillName: record.skillName,
+            sourcePath: normalizeSourcePath(record.sourcePath, platform),
+            mode: "resolved",
+        });
+    }).sort(compareProjectSkillRefs);
+    return Object.freeze(normalized);
+}

package/dist/project-skills/runtime-launch.js

@@ -1,48 +1,6 @@
 import { join } from "node:path";
 import { resolveOrderedUniqueClaudeDirectories } from "../runtimes/claude.js";
 import { ProjectProjectionError, } from "./reconciler.js";
-const runtimeRootSecrets = (root) => Object.freeze([...new Set([
-        root.rootDirectory,
-        root.codexSkillRoot,
-        root.claudeAdditionalDirectory,
-        root.rootId,
-    ].flatMap((value) => [
-        value,
-        value.replaceAll("\\", "/"),
-        value.replaceAll("/", "\\"),
-    ]))].sort((left, right) => right.length - left.length));
-export function redactProjectSkillRuntimeRootText(text, root) {
-    if (root === undefined)
-        return text;
-    return runtimeRootSecrets(root)
-        .reduce((redacted, secret) => redacted.replaceAll(secret, "[project-skill-root]"), text);
-}
-export function redactProjectSkillRuntimeRootError(error, root) {
-    if (!(error instanceof Error)) {
-        return typeof error === "string" ? redactProjectSkillRuntimeRootText(error, root) : error;
-    }
-    const message = redactProjectSkillRuntimeRootText(error.message, root);
-    if (message === error.message)
-        return error;
-    const redacted = new Error(message);
-    redacted.name = error.name;
-    return redacted;
-}
-/** Recursively redacts exact v2 root identities before Runtime output crosses daemon boundaries. */
-export function redactProjectSkillRuntimeRootValue(value, root) {
-    if (root === undefined)
-        return value;
-    if (typeof value === "string")
-        return redactProjectSkillRuntimeRootText(value, root);
-    if (Array.isArray(value)) {
-        return value.map((item) => redactProjectSkillRuntimeRootValue(item, root));
-    }
-    if (typeof value === "object" && value !== null) {
-        return Object.fromEntries(Object.entries(value)
-            .map(([key, item]) => [key, redactProjectSkillRuntimeRootValue(item, root)]));
-    }
-    return value;
-}
 /** Maps one captured daemon-local root to the exact native Runtime registration seam. */
 export function projectSkillRuntimeLaunchFacts(runtime, root) {
     if (root === undefined)

package/dist/project-skills/runtime-root-bootstrap.js

@@ -16,18 +16,12 @@ export async function initializeAfterProjectSkillLeaseProtection(input) {
 /**
  * Runs only after execution-journal restart reconciliation has settled. A lease without a terminal
  * journal fact remains durable and prevents the caller from marking Project Skill v2 ready.
- *
- * 重连时本进程仍在跑的 execution 合法持有 lease(`liveExecutionIds`):既不释放,也不算 unresolved。
- * 否则一次网络抖动就会让 daemon 在整条连接上摘掉 Project Skills 能力(incident: 2026-09-02,
- * 绑定项目的 Agent 全部 execution_spec_incompatible)。
  */
 export async function recoverProjectSkillRuntimeRoots(input) {
     for (const agentRoot of input.agentRoots) {
         await input.roots.recover(agentRoot);
         let unresolvedLease = false;
         await input.leases.recover(agentRoot, async (executionId) => {
-            if (input.liveExecutionIds?.has(executionId))
-                return false;
             const entry = await input.journal.get(executionId);
             const releasable = entry?.state === "completed" || entry?.state === "interrupted";
             if (!releasable)

package/dist/project-skills/runtime-root-startup.js

@@ -22,14 +22,13 @@ export function createProjectSkillRuntimeRootStartup() {
             leases,
             initialize,
         }),
-        recover: async (agentsRoot, journal, protectedExecutionIds, liveExecutionIds) => {
+        recover: async (agentsRoot, journal, protectedExecutionIds) => {
             await recoverProjectSkillRuntimeRoots({
                 agentRoots: await agentRoots(agentsRoot),
                 journal,
                 roots,
                 leases,
                 gc,
-                ...(liveExecutionIds === undefined ? {} : { liveExecutionIds }),
                 currentRootId: async (agentRoot) => (await readAppliedProjectSkillManifest(agentRoot))?.rootId ?? null,
                 afterLeaseRecovery: async () => {
                     const remaining = await initializeAfterProjectSkillLeaseProtection({

package/dist/project-skills/runtime-warning.js

@@ -1,6 +1,4 @@
 /** Stable, path-free console text; only logical IDs from the server snapshot are included. */
 export function formatProjectSkillRuntimeWarning(warning) {
-    return warning.code === "skill_projection_advanced"
-        ? "[runtime-warning] skill_projection_advanced"
-        : `[runtime-warning] project_skill_unavailable project=${warning.projectId} skill=${warning.skillName}`;
+    return `[runtime-warning] project_skill_unavailable project=${warning.projectId} skill=${warning.skillName}`;
 }

package/dist/project-skills/scanner.js

@@ -2,7 +2,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { compareProjectSkillRefs, isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
 import { parseSkillFrontmatter } from "../skill-frontmatter.js";
-import { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, normalizeProjectSkillResolutionRecords, } from "./projection-state.js";
+import { normalizeProjectSkillResolutionRecords } from "./resolution-records.js";
 const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
     inventory: Object.freeze({
         projectId,
@@ -143,19 +143,3 @@ export function projectSkillResolutionRecords(bindings, projects, platform = pro
     });
     return normalizeProjectSkillResolutionRecords(records, platform);
 }
-/** Daemon-local expectation derived from one immutable scanner snapshot; no path crosses the wire. */
-export function projectSkillProjectionExpectation(snapshot, projects, platform = process.platform) {
-    const bindings = Object.freeze(snapshot.bindings
-        .map((binding) => Object.freeze({
-        projectId: binding.projectId,
-        skillName: binding.skillName,
-    }))
-        .sort(compareProjectSkillRefs));
-    const resolutions = projectSkillResolutionRecords(bindings, projects, platform);
-    return Object.freeze({
-        bindings,
-        generation: snapshot.generation,
-        bindingDigest: computeProjectSkillBindingDigest(bindings),
-        resolutionDigest: computeProjectSkillResolutionDigest(resolutions, platform),
-    });
-}

package/dist/project-skills/serve-startup.js

@@ -1,29 +1,6 @@
 import { createExecutionJournal } from "../execution-journal.js";
 import { reconcileExecutionJournal } from "../execution-recovery.js";
 import { dslog, flushSlog } from "../slog.js";
-/**
- * 每次连接 preflight 的 Runtime root / lease 恢复。重连时本进程仍在跑的 execution 合法持有 lease,
- * 必须当作存活而非孤儿;失败也必须留痕,否则整条连接静默摘掉 Project Skills 能力
- * (incident: 2026-09-02,绑定项目的 Agent 全部 execution_spec_incompatible)。
- */
-export function createProjectSkillReconnectRecovery(startup, agentsRoot, journal, protectedExecutionIds, liveExecutionIds) {
-    return async () => {
-        const live = liveExecutionIds();
-        try {
-            await startup.recover(agentsRoot, journal(), protectedExecutionIds, live);
-            return true;
-        }
-        catch (error) {
-            dslog("project_skills.preflight_recovery_failed", "Project Skill runtime root 恢复失败,本连接不宣告 Project Skills 能力", {
-                level: "ERROR",
-                error_code: error.code ?? "unknown",
-                error_message: error.message,
-                live_execution_count: live.size,
-            });
-            return false;
-        }
-    };
-}
 export async function initializeProjectSkillProtectedExecutionJournal(input) {
     return input.startup.initializeAfterLeaseProtection(input.config.agentsRoot, async (snapshot) => {
         input.protectedExecutionIds.clear();

package/dist/project-skills/startup-cleanup.js

@@ -0,0 +1,24 @@
+import { cleanupLegacyProjectSkillState, sweepAllExecutionProjections } from "./legacy-cleanup.js";
+export async function runProjectSkillStartupCleanup(agentsRoot, journal, log) {
+    try {
+        const swept = await sweepAllExecutionProjections(agentsRoot, async (executionId) => {
+            const entry = await journal.get(executionId);
+            return entry !== null && entry.state !== "completed" && entry.state !== "interrupted";
+        });
+        const legacy = await cleanupLegacyProjectSkillState({ agentsRoot, journal });
+        const degraded = swept.failed > 0 || legacy.failedAgents.length > 0 || legacy.keptStores.length > 0;
+        log("project_skills.startup_cleanup", "启动清扫执行投影与旧运行时状态", {
+            removed_projections: swept.removed, kept_projections: swept.kept,
+            failed_projection_sweeps: swept.failed,
+            removed_legacy_stores: legacy.removedStores.length, kept_legacy_stores: legacy.keptStores.length,
+            failed_legacy_agents: legacy.failedAgents.length,
+            removed_shared_entries: legacy.removedSharedEntries,
+            ...(degraded ? { level: "WARN" } : {}),
+        });
+    }
+    catch (error) {
+        log("project_skills.startup_cleanup_failed", "启动清扫失败,能力不受影响", {
+            level: "WARN", error_message: error.message,
+        });
+    }
+}

package/dist/serve.js

@@ -8,7 +8,8 @@ import { randomUUID } from "node:crypto";
 import { dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, daemonCapabilities, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { collectMachineHello, daemonCapabilities, daemonCapabilityBindings, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { initReleaseSlog, reportDaemonConnectionClose, reportReleaseError } from "./release-channel-guard.js";
 import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
@@ -19,6 +20,7 @@ import { normalizeScheduledContext } from "./scheduled-report.js";
 import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
 import { runWithOriginDecisionGuard } from "./origin-decision.js";
+import { createExecutionJournal } from "./execution-journal.js";
 import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
 import { hashExecutionSpec, projectWorkspaceCapabilityRejection, runExecution, } from "./execution-runner.js";
@@ -40,10 +42,8 @@ import { createProjectRegistryWiring } from "./project-registry-wiring.js";
 import { createProjectSkillsController, } from "./project-skills/controller.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
-import { createProjectSkillRuntimeRootStartup, } from "./project-skills/runtime-root-startup.js";
-import { createProjectSkillControllerReadiness, withProjectSkillCapabilityStatus } from "./project-skills/capability.js";
-import { createProjectSkillReconnectRecovery, initializeProjectSkillProtectedExecutionJournal } from "./project-skills/serve-startup.js";
-import { createProjectSkillConnectionCapabilityProvider, createProjectSkillMachineHelloPublisher } from "./project-skills/serve-capability.js";
+import { createMachineHelloPublisher } from "./project-skills/machine-hello-publisher.js";
+import { runProjectSkillStartupCleanup } from "./project-skills/startup-cleanup.js";
 import { createAgentAbilityRuntime } from "./agent-ability/runtime.js";
 import { createProjectSkillsReconciler, } from "./project-skills/reconciler.js";
 import { initializedProjectSkillsReconciler } from "./project-skills/initialized-reconciler.js";
@@ -76,7 +76,6 @@ export function serve(config, opts = {}) {
     let stopPromise = null;
     let executionJournal;
     const injectedExecutionJournal = opts.execution?.journal;
-    const protectedExecutionIds = new Set();
     const agentMemory = opts.execution?.dependencies?.agentMemory
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
@@ -154,9 +153,10 @@ export function serve(config, opts = {}) {
     let projectSkillsController;
     const projectSkillsReconciler = opts.projectSkills?.reconciler ?? createProjectSkillsReconciler({
         agentsRoot: config.agentsRoot,
-        coordinator: projectionCoordinator,
         scannedProjects: () => projectSkillsController.scannedProjects(),
-        protectedExecutionIds,
+        onCleanupFailed: (executionId, error) => dslog("project_skills.cleanup_failed", "执行投影目录清理失败,留待下次启动清扫", {
+            level: "WARN", execution_id: executionId, error_code: error.code ?? "unknown",
+        }),
     });
     projectSkillsController = opts.projectSkills?.controller ?? createProjectSkillsController({
         registry: projectRegistry,
@@ -171,30 +171,21 @@ export function serve(config, opts = {}) {
         },
         isAdmissionClosed: () => storageMigrationAdmissionClosed(),
         reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
-        ensureSnapshot: (handle, snapshot, options) => projectSkillsReconciler.ensureSnapshot(handle, snapshot, options),
     });
-    const projectSkillRuntimeRootStartup = opts.projectSkills?.runtimeRootStartup
-        ?? createProjectSkillRuntimeRootStartup();
-    const projectSkillControllerReadiness = createProjectSkillControllerReadiness({
-        initialize: () => projectSkillsController.initialize(),
-        onUnavailable: (error) => dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
-            level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
-        }),
-        onSettled: () => machineHelloPublisher.republish(),
+    const logRegistryFailure = (error) => dslog("project_skills.registry_failed", "本机项目注册表读取失败,本次不上报项目清单(能力不受影响)", {
+        level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
     });
-    const machineHelloPublisher = createProjectSkillMachineHelloPublisher({
-        status: projectSkillControllerReadiness.status,
-        effective: (hello, status) => {
-            const effective = withProjectSkillCapabilityStatus(hello, status);
+    const machineHelloPublisher = createMachineHelloPublisher({
+        effective: (hello) => {
             const configuredIdentity = opts.storageMigration?.identity;
             const currentIdentity = typeof configuredIdentity === "function"
                 ? configuredIdentity()
                 : configuredIdentity;
-            return currentIdentity === undefined ? effective : { ...effective, ...currentIdentity };
+            return currentIdentity === undefined ? hello : { ...hello, ...currentIdentity };
         },
         onSent: (hello) => log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`),
     });
-    const initializedProjectSkills = initializedProjectSkillsReconciler(projectSkillControllerReadiness.ensure, projectSkillsReconciler);
+    const initializedProjectSkills = initializedProjectSkillsReconciler(() => projectSkillsController.ensureScanned(), projectSkillsReconciler);
     const configuredCapabilities = opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform);
     const storageCapabilities = storageMigrationCapabilities(configuredCapabilities, opts.storageMigration);
     const storageStatusDelivery = createServeStorageStatusDelivery(opts.storageMigration, {
@@ -212,15 +203,7 @@ export function serve(config, opts = {}) {
         sendStatus: storageStatusDelivery.send,
     });
     storageMigrationAdmissionClosed = storageMigrationRuntime.isAdmissionClosed;
-    const prepareProjectSkillCapabilities = createProjectSkillConnectionCapabilityProvider({
-        platform: process.platform,
-        baseCapabilities: storageCapabilities,
-        additionalCapabilities: () => managedDaemonCapabilities(updateEligibility),
-        probeRuntimeRootStorePrimitive: projectSkillRuntimeRootStartup.probeNativePublicationPrimitiveReadiness,
-        initializeController: projectSkillControllerReadiness.ensure,
-        recoverRuntimeRootsAndLeases: createProjectSkillReconnectRecovery(projectSkillRuntimeRootStartup, config.agentsRoot, () => executionJournal, protectedExecutionIds, () => new Set(executionRuns.keys())),
-        applyReadiness: projectSkillControllerReadiness.applyPreflight,
-    });
+    const prepareCapabilities = async () => daemonCapabilityBindings(process.platform, [...storageCapabilities, ...await managedDaemonCapabilities(updateEligibility)]);
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -325,10 +308,10 @@ export function serve(config, opts = {}) {
     async function connect() {
         if (stopped)
             return;
-        const capabilities = await prepareProjectSkillCapabilities();
+        const capabilities = await prepareCapabilities();
         if (stopped)
             return;
-        const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillControllerReadiness.status() === "ready", capabilities.controlPlaneUrl);
+        const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, capabilities.controlPlaneUrl);
         ws = createWebSocket(wsUrl);
         let connectionEpochToken;
         ws.on("open", () => {
@@ -844,8 +827,9 @@ export function serve(config, opts = {}) {
                     ? r.serverCapabilities.filter((c) => typeof c === "string")
                     : []);
                 if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
-                    if (await projectSkillControllerReadiness.ensure())
-                        await projectSkillsController.publishCurrent();
+                    void projectSkillsController.initialize()
+                        .then(() => projectSkillsController.publishCurrent())
+                        .catch(logRegistryFailure);
                 }
                 return;
             }
@@ -870,10 +854,6 @@ export function serve(config, opts = {}) {
                 const result = serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)
                     ? await projectSkillsController.handle(msg, connectionEpochToken)
                     : { ok: false, error: "capability_unavailable" };
-                if (result.ok && (msg.type === "project:remove"
-                    || msg.type === "project:rescan")) {
-                    void projectSkillControllerReadiness.ensure();
-                }
                 try {
                     ws?.send(JSON.stringify({ type: "fs:result", reqId: request.reqId, ...result }));
                 }
@@ -1336,13 +1316,32 @@ export function serve(config, opts = {}) {
         });
     }
     const ready = (async () => {
-        executionJournal = await initializeProjectSkillProtectedExecutionJournal({
-            config,
+        executionJournal = injectedExecutionJournal ?? createExecutionJournal(config.agentsRoot, {
+            onOperationTiming: (event) => {
+                if (event.operation !== "mark_runtime_ready"
+                    && event.queueWaitMs < 250
+                    && event.operationMs < 250)
+                    return;
+                dslog("execution.journal_operation", "execution journal 操作完成", {
+                    level: event.outcome === "succeeded" ? "INFO" : "ERROR",
+                    execution_id: event.executionId,
+                    operation: event.operation,
+                    outcome: event.outcome,
+                    queue_wait_ms: event.queueWaitMs,
+                    operation_ms: event.operationMs,
+                    total_ms: event.queueWaitMs + event.operationMs,
+                });
+            },
+        });
+        await reconcileExecutionJournal(executionJournal, {
+            agentsRoot: config.agentsRoot,
+            serverUrl: config.serverUrl,
             ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
-            startup: projectSkillRuntimeRootStartup,
-            protectedExecutionIds,
-            ...(injectedExecutionJournal === undefined ? {} : { injectedJournal: injectedExecutionJournal }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
         });
+        await runProjectSkillStartupCleanup(config.agentsRoot, executionJournal, dslog);
         await connect();
     })();
     const stop = () => {

package/package.json

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