@nowcrew/daemon 0.5.35 → 0.5.37

package/dist/project-skills/controller.js

@@ -32,13 +32,46 @@ const ProjectCommandSchema = z.discriminatedUnion("type", [
         }).strict()).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
     }).strict(),
 ]);
+const DEFAULT_PROJECT_SCAN_TIMEOUT_MS = 10_000;
+class ProjectScanTimeoutError extends Error {
+    code = "project_scan_timeout";
+    constructor() {
+        super("project_scan_timeout");
+        this.name = "ProjectScanTimeoutError";
+    }
+}
+const withinScanDeadline = async (operation, timeoutMs) => {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new ProjectScanTimeoutError()), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+};
 export function createProjectSkillsController(deps) {
     let scanned = Object.freeze([]);
     const operationTail = createPromiseTail();
     let initialization = null;
     let initializationState = "idle";
-    const refresh = async () => {
-        scanned = await scanProjects(await deps.registry.list());
+    const scan = deps.scan ?? scanProjects;
+    const scanTimeoutMs = deps.scanTimeoutMs ?? DEFAULT_PROJECT_SCAN_TIMEOUT_MS;
+    const scanCurrent = async (deferredProjectId) => withinScanDeadline(scan(await deps.registry.list(), undefined, [
+        ...scanned
+            .map((project) => project.inventory.projectId)
+            .filter((projectId) => projectId !== deferredProjectId),
+        ...(deferredProjectId === undefined ? [] : [deferredProjectId]),
+    ]), scanTimeoutMs);
+    const refresh = async (deferredProjectId) => {
+        const next = await scanCurrent(deferredProjectId);
+        scanned = next;
     };
     const publishCurrent = async () => {
         await deps.publish(Object.freeze({
@@ -47,27 +80,38 @@ export function createProjectSkillsController(deps) {
         }));
     };
     const enqueue = (operation) => operationTail.enqueue(operation);
-    return {
-        initialize() {
-            if (initialization !== null)
-                return initialization;
-            initializationState = "initializing";
-            initialization = enqueue(refresh).then(() => { initializationState = "ready"; }, (error) => {
-                initializationState = "failed";
-                throw error;
-            });
+    const initialize = () => {
+        if (initializationState === "ready" && initialization !== null)
             return initialization;
-        },
+        if (initializationState === "initializing" && initialization !== null)
+            return initialization;
+        initializationState = "initializing";
+        const attempt = enqueue(refresh).then(() => { initializationState = "ready"; }, (error) => {
+            initializationState = "failed";
+            if (initialization === attempt)
+                initialization = null;
+            throw error;
+        });
+        initialization = attempt;
+        return attempt;
+    };
+    return {
+        initialize,
         publishCurrent: () => enqueue(publishCurrent),
         scannedProjects: () => scanned,
-        handle(input) {
-            return enqueue(async () => {
-                const parsed = ProjectCommandSchema.safeParse(input);
-                if (!parsed.success)
-                    return { ok: false, error: "invalid_project_command" };
-                if (initializationState !== "ready") {
+        async handle(input) {
+            const parsed = ProjectCommandSchema.safeParse(input);
+            if (!parsed.success)
+                return { ok: false, error: "invalid_project_command" };
+            if (parsed.data.type === "agent:skills:sync") {
+                try {
+                    await initialize();
+                }
+                catch {
                     return { ok: false, error: "project_skills_unavailable" };
                 }
+            }
+            return enqueue(async () => {
                 const command = parsed.data;
                 try {
                     if (command.type === "agent:skills:sync") {
@@ -79,7 +123,16 @@ export function createProjectSkillsController(deps) {
                         };
                     }
                     if (command.type === "project:add") {
+                        const existed = (await deps.registry.list())
+                            .some((project) => project.projectId === command.projectId);
                         await deps.registry.add(command.projectId, command.root);
+                        const next = await scanCurrent();
+                        const added = next.find((project) => project.inventory.projectId === command.projectId);
+                        if (!existed && added?.inventory.errorCode === "machine_project_skill_limit_exceeded") {
+                            await deps.registry.remove(command.projectId);
+                            return { ok: false, error: "machine_project_skill_limit_exceeded" };
+                        }
+                        scanned = next;
                     }
                     else if (command.type === "project:remove") {
                         await deps.registry.remove(command.projectId);
@@ -90,7 +143,9 @@ export function createProjectSkillsController(deps) {
                             return { ok: false, error: "project_not_found" };
                         }
                     }
-                    await refresh();
+                    if (command.type !== "project:add") {
+                        await refresh(command.type === "project:rescan" ? command.projectId : undefined);
+                    }
                     await publishCurrent();
                     return { ok: true, data: { projectId: command.projectId } };
                 }

package/dist/project-skills/registry.js

@@ -6,8 +6,7 @@ import { createPromiseTail } from "../promise-tail.js";
 import { atomicPrivateWrite } from "../atomic-private-write.js";
 const RegistryFileSchema = z.object({
     version: z.literal(1),
-    projects: z.record(z.object({ root: z.string().min(1).max(4_096) }).strict())
-        .refine((projects) => Object.keys(projects).length <= MAX_MACHINE_PROJECTS),
+    projects: z.record(z.object({ root: z.string().min(1).max(4_096) }).strict()),
 }).strict();
 export class ProjectRegistryError extends Error {
     code;
@@ -17,9 +16,22 @@ export class ProjectRegistryError extends Error {
         this.name = "ProjectRegistryError";
     }
 }
-const immutableList = (projects) => Object.freeze(Object.entries(projects)
-    .map(([projectId, project]) => Object.freeze({ projectId, root: project.root }))
-    .sort((left, right) => left.projectId.localeCompare(right.projectId)));
+const immutableList = (projects) => {
+    const sorted = Object.entries(projects)
+        .map(([projectId, project]) => Object.freeze({ projectId, root: project.root }))
+        .sort((left, right) => left.projectId.localeCompare(right.projectId));
+    if (sorted.length <= MAX_MACHINE_PROJECTS)
+        return Object.freeze(sorted);
+    const visible = sorted.slice(0, MAX_MACHINE_PROJECTS);
+    const boundary = visible.at(-1);
+    if (boundary !== undefined) {
+        visible[visible.length - 1] = Object.freeze({
+            ...boundary,
+            errorCode: "project_registry_limit_exceeded",
+        });
+    }
+    return Object.freeze(visible);
+};
 export function createProjectRegistry(agentsRoot) {
     const path = join(agentsRoot, ".crew", "projects.json");
     const writeTail = createPromiseTail();

package/dist/project-skills/scanner.js

@@ -15,6 +15,8 @@ const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
 });
 export async function scanProject(project, now = () => new Date()) {
     const scannedAt = now().toISOString();
+    if (project.errorCode !== undefined)
+        return unavailable(project.projectId, scannedAt, project.errorCode);
     const projectStat = await stat(project.root).catch(() => null);
     if (!projectStat?.isDirectory())
         return unavailable(project.projectId, scannedAt, "project_path_unavailable");
@@ -51,8 +53,12 @@ export async function scanProject(project, now = () => new Date()) {
             continue;
         }
         const frontmatter = parseSkillFrontmatter(markdown);
-        const name = frontmatter?.name ?? entry.name;
-        const description = frontmatter?.description ?? "";
+        const name = frontmatter.name;
+        const description = frontmatter.description;
+        if (name === undefined || description === undefined) {
+            invalidSkillCount += 1;
+            continue;
+        }
         if (!isProjectSkillName(name) || description.length > MAX_PROJECT_SKILL_DESCRIPTION_LENGTH) {
             invalidSkillCount += 1;
             continue;
@@ -84,20 +90,37 @@ export async function scanProject(project, now = () => new Date()) {
         resolved: Object.freeze(resolved),
     });
 }
-export function boundScannedProjects(projects) {
+export function boundScannedProjects(projects, retainedProjectIds = []) {
+    const retainedOrder = new Map(retainedProjectIds.map((projectId, index) => [projectId, index]));
+    const allocationOrder = [...projects].sort((left, right) => {
+        const leftOrder = retainedOrder.get(left.inventory.projectId);
+        const rightOrder = retainedOrder.get(right.inventory.projectId);
+        if (leftOrder !== undefined && rightOrder !== undefined)
+            return leftOrder - rightOrder;
+        if (leftOrder !== undefined)
+            return -1;
+        if (rightOrder !== undefined)
+            return 1;
+        return left.inventory.projectId.localeCompare(right.inventory.projectId);
+    });
     let skillCount = 0;
-    return Object.freeze(projects.map((project) => {
-        if (project.inventory.status !== "available")
-            return project;
+    const bounded = new Map();
+    for (const project of allocationOrder) {
+        if (project.inventory.status !== "available") {
+            bounded.set(project.inventory.projectId, project);
+            continue;
+        }
         const nextCount = skillCount + project.inventory.skills.length;
         if (nextCount <= MAX_MACHINE_PROJECT_SKILLS) {
             skillCount = nextCount;
-            return project;
+            bounded.set(project.inventory.projectId, project);
+            continue;
         }
-        return unavailable(project.inventory.projectId, project.inventory.scannedAt, "machine_project_skill_limit_exceeded");
-    }));
+        bounded.set(project.inventory.projectId, unavailable(project.inventory.projectId, project.inventory.scannedAt, "machine_project_skill_limit_exceeded"));
+    }
+    return Object.freeze(projects.map((project) => bounded.get(project.inventory.projectId) ?? project));
 }
-export async function scanProjects(projects, now = () => new Date()) {
+export async function scanProjects(projects, now = () => new Date(), retainedProjectIds = []) {
     const sorted = [...projects].sort((left, right) => left.projectId.localeCompare(right.projectId));
-    return boundScannedProjects(await Promise.all(sorted.map((project) => scanProject(project, now))));
+    return boundScannedProjects(await Promise.all(sorted.map((project) => scanProject(project, now))), retainedProjectIds);
 }

package/dist/serve.js

@@ -40,6 +40,7 @@ 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 { createProjectSkillsReconciler, ProjectProjectionError, } from "./project-skills/reconciler.js";
+import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -126,21 +127,58 @@ export function serve(config, opts = {}) {
         },
         reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
     });
-    const projectSkillsInitialized = projectSkillsController.initialize().then(() => true, (error) => {
-        dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
-            level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
-        });
-        return false;
+    let projectSkillsStatus = "initializing";
+    let projectSkillsInitialization = null;
+    let latestMachineHello = null;
+    let latestHelloSocket = null;
+    const effectiveMachineHello = (hello) => ({
+        ...hello,
+        projectSkillsStatus,
+        capabilities: projectSkillsStatus === "ready"
+            ? hello.capabilities
+            : hello.capabilities.filter((capability) => capability !== PROJECT_SKILLS_CAPABILITY),
     });
-    let projectSkillsAvailable = false;
+    const sendEffectiveMachineHello = () => {
+        if (latestMachineHello === null || latestHelloSocket?.readyState !== WebSocket.OPEN)
+            return;
+        const hello = effectiveMachineHello(latestMachineHello);
+        try {
+            latestHelloSocket.send(JSON.stringify(hello));
+            log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
+        }
+        catch { /* 非 OPEN,忽略 */ }
+    };
+    const ensureProjectSkillsInitialized = () => {
+        if (projectSkillsStatus === "ready")
+            return Promise.resolve(true);
+        if (projectSkillsInitialization !== null)
+            return projectSkillsInitialization;
+        projectSkillsStatus = "initializing";
+        const attempt = projectSkillsController.initialize().then(() => {
+            projectSkillsStatus = "ready";
+            return true;
+        }, (error) => {
+            projectSkillsStatus = "unavailable";
+            dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
+                level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
+            });
+            return false;
+        }).finally(() => {
+            if (projectSkillsInitialization === attempt)
+                projectSkillsInitialization = null;
+            sendEffectiveMachineHello();
+        });
+        projectSkillsInitialization = attempt;
+        return attempt;
+    };
     const initializedProjectSkillsReconciler = {
-        reconcile(handle, bindings) {
-            return projectSkillsAvailable
+        async reconcile(handle, bindings) {
+            return await ensureProjectSkillsInitialized()
                 ? projectSkillsReconciler.reconcile(handle, bindings)
                 : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
         },
-        prepareAndLaunch(agentsRoot, handle, bindings, launch) {
-            return projectSkillsAvailable
+        async prepareAndLaunch(agentsRoot, handle, bindings, launch) {
+            return await ensureProjectSkillsInitialized()
                 ? projectSkillsReconciler.prepareAndLaunch(agentsRoot, handle, bindings, launch)
                 : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
         },
@@ -248,12 +286,13 @@ export function serve(config, opts = {}) {
     // scheduled 重复 run 仍由 running 去重;普通同线程 wake 用 legacyTaskTails 串成 FIFO。
     // 每 agent 超过并行上限的任务继续进入 sharedQueues(不丢)。
     const running = new Set();
+    const activeExecutionTaskKeys = new Map();
     const legacyTaskTails = new Map();
     const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
     function connect() {
         if (stopped)
             return;
-        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsAvailable);
+        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsStatus === "ready");
         ws = createWebSocket(wsUrl);
         ws.on("open", () => {
             const openedSocket = ws;
@@ -282,18 +321,12 @@ export function serve(config, opts = {}) {
             });
             void helloPromise
                 .then((hello) => {
+                if (ws !== openedSocket || openedSocket.readyState !== WebSocket.OPEN)
+                    return;
                 detectedExecutionRuntimes = hello.executionRuntimes;
-                const effectiveHello = projectSkillsAvailable
-                    ? hello
-                    : {
-                        ...hello,
-                        capabilities: hello.capabilities.filter((capability) => capability !== PROJECT_SKILLS_CAPABILITY),
-                    };
-                try {
-                    ws?.send(JSON.stringify(effectiveHello));
-                    log(`📤 已上报机器信息: ${effectiveHello.hostname} · ${effectiveHello.os} · installed=[${effectiveHello.runtimes.join(",")}] · executable=[${effectiveHello.executionRuntimes.join(",")}] · agents=[${effectiveHello.agentHandles.join(",")}]`);
-                }
-                catch { /* 非 OPEN,忽略 */ }
+                latestMachineHello = hello;
+                latestHelloSocket = openedSocket;
+                sendEffectiveMachineHello();
             })
                 .catch(() => { });
             opts.onOpen?.(ws);
@@ -440,6 +473,18 @@ export function serve(config, opts = {}) {
                         }
                         return;
                     }
+                    const pruneTraceId = parseMemoryPruneTraceId(spec.instructions.wakePrompt);
+                    if (pruneTraceId !== null) {
+                        dslog("memory_prune.received", "Daemon 已收到长期记忆收尾 execution", {
+                            protocol: "execution_v1",
+                            prune_trace_id: pruneTraceId,
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            channel_id: spec.context.channelId,
+                            thread_id: spec.context.threadId ?? null,
+                            task_key: spec.workspace.taskKey,
+                        });
+                    }
                     const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
                     if (!reservation.accepted) {
                         dslog("execution.machine_queue_rejected", "机器执行队列已满", {
@@ -465,9 +510,41 @@ export function serve(config, opts = {}) {
                         });
                     }
                     executionReservations.set(spec.executionId, reservation);
+                    const executionTaskKey = `${spec.agent.handle}:${spec.workspace.taskKey}`;
+                    let executionTaskKeyActive = false;
+                    let executionTaskKeyFinished = false;
+                    const markExecutionTaskKeyActive = () => {
+                        if (executionTaskKeyActive || executionTaskKeyFinished)
+                            return;
+                        executionTaskKeyActive = true;
+                        const activeSameTask = (activeExecutionTaskKeys.get(executionTaskKey) ?? 0) + 1;
+                        activeExecutionTaskKeys.set(executionTaskKey, activeSameTask);
+                        dslog(activeSameTask > 1 ? "execution.task_key_overlap_detected" : "execution.task_key_started", activeSameTask > 1 ? "同一 Agent 任务键存在重叠 execution" : "Agent 任务键 execution 已开始", {
+                            ...(activeSameTask > 1 ? { level: "WARN" } : {}),
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            task_key: spec.workspace.taskKey,
+                            active_same_task: activeSameTask,
+                            ...reservation.facts,
+                        });
+                    };
                     const cancellation = cancellationFor(spec.executionId);
                     const cleanupExecutionReservation = () => {
+                        executionTaskKeyFinished = true;
                         reservation.release();
+                        if (executionTaskKeyActive) {
+                            const remainingSameTask = Math.max(0, (activeExecutionTaskKeys.get(executionTaskKey) ?? 1) - 1);
+                            if (remainingSameTask === 0)
+                                activeExecutionTaskKeys.delete(executionTaskKey);
+                            else
+                                activeExecutionTaskKeys.set(executionTaskKey, remainingSameTask);
+                            dslog("execution.task_key_finished", "Agent 任务键 execution 已结束", {
+                                execution_id: spec.executionId,
+                                agent_handle: spec.agent.handle,
+                                task_key: spec.workspace.taskKey,
+                                active_same_task: remainingSameTask,
+                            });
+                        }
                         cancellations.delete(spec.executionId);
                         executionReservations.delete(spec.executionId);
                         knownExecutionHashes.delete(spec.executionId);
@@ -506,6 +583,7 @@ export function serve(config, opts = {}) {
                             slot: {
                                 state: reservation.state,
                                 ready: reservation.ready.then(() => {
+                                    markExecutionTaskKeyActive();
                                     const snapshot = sharedSlots.snapshot();
                                     dslog("execution.machine_slot_ready", "execution 获得机器执行名额", {
                                         execution_id: spec.executionId,
@@ -567,7 +645,7 @@ export function serve(config, opts = {}) {
                     ? r.serverCapabilities.filter((c) => typeof c === "string")
                     : []);
                 if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
-                    if (await projectSkillsInitialized)
+                    if (await ensureProjectSkillsInitialized())
                         await projectSkillsController.publishCurrent();
                 }
                 return;
@@ -591,6 +669,10 @@ export function serve(config, opts = {}) {
                 const result = serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)
                     ? await projectSkillsController.handle(msg)
                     : { ok: false, error: "capability_unavailable" };
+                if (result.ok && (msg.type === "project:remove"
+                    || msg.type === "project:rescan")) {
+                    void ensureProjectSkillsInitialized();
+                }
                 try {
                     ws?.send(JSON.stringify({ type: "fs:result", reqId: request.reqId, ...result }));
                 }
@@ -671,6 +753,14 @@ export function serve(config, opts = {}) {
                 run_id: runId, agent_handle: msg.agentHandle, channel_id: msg.channelId,
                 thread_id: threadId ?? null, task_key: taskKey,
             };
+            const pruneTraceId = parseMemoryPruneTraceId(msg.wake?.content ?? "");
+            if (pruneTraceId !== null) {
+                dslog("memory_prune.received", "Daemon 已收到长期记忆收尾唤醒", {
+                    ...runKeys,
+                    protocol: "legacy",
+                    prune_trace_id: pruneTraceId,
+                });
+            }
             dslog("run.wake_received", `收到唤醒 ${msg.agentHandle}`, {
                 ...runKeys, reason: msg.reason ?? "", sender: msg.wake?.senderHandle,
                 wake_origin: msg.wake?.origin ?? null,
@@ -1013,7 +1103,7 @@ export function serve(config, opts = {}) {
             flush: flushSlog,
             writeStderr: (line) => process.stderr.write(line),
         });
-        projectSkillsAvailable = await projectSkillsInitialized;
+        void ensureProjectSkillsInitialized();
         connect();
     })();
     const stop = () => {
@@ -1030,6 +1120,7 @@ export function serve(config, opts = {}) {
             const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
             const pending = [
                 webSocketClosed,
+                updateController.drain(),
                 executionFrameQueue,
                 ...executionRuns.values(),
                 ...[...legacyRuns.values()].map((run) => run.done),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.35",
+  "version": "0.5.37",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,12 +16,19 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
+    "@nowcrew/cli": "workspace:^",
     "cross-spawn": "^7.0.6",
     "ws": "^8",
-    "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.13"
+    "zod": "^3.23.0"
   },
   "optionalDependencies": {
     "koffi": "^2.9.0"
@@ -33,11 +40,5 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
-  },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}