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

package/dist/prompt.js

@@ -67,10 +67,23 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     const tail = workLog.slice(-WORKLOG_TAIL);
     return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
 }
-export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP) {
-    return memory.length > cap
-        ? `${memory.slice(0, cap)}\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md;功能明细仅按索引中的 file 读取)`
-        : memory;
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY) {
+    if (memory.length <= cap && Buffer.byteLength(memory, "utf8") <= maxBytes)
+        return memory;
+    const notice = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";
+    const noticeBytes = Buffer.byteLength(notice, "utf8");
+    if (notice.length > cap || noticeBytes > maxBytes)
+        return "";
+    let end = 0;
+    let bytes = noticeBytes;
+    for (const character of memory) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (notice.length + end + character.length > cap || bytes + size > maxBytes)
+            break;
+        end += character.length;
+        bytes += size;
+    }
+    return notice + memory.slice(0, end);
 }
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
@@ -99,7 +112,7 @@ export function buildSystemPrompt(ctx) {
     // scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
     const startupSequence = alwaysReport
         ? `## 启动序列(每轮汇报定时任务)
-1. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+1. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 2. 执行唤醒提示词里给出的定时指令。
 3. Return exactly one self-contained final report as your runtime final response.
 4. Do not call crew message send; the daemon delivers the final response.
@@ -107,14 +120,14 @@ export function buildSystemPrompt(ctx) {
 6. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。`
         : scheduled
             ? `## 启动序列(静默定时任务)
-1. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+1. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 2. 执行唤醒提示词里给出的定时指令。**默认零输出**:不判断"是否需要先确认/声明接手",本轮没有人在等你回复。
 3. 只有发现异常、需要人处理、或指令明确要求汇报时,才用 \`crew message send --send-draft\` 输出到频道(用法见上面"通信"一节)。
 4. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。
 5. 无异常时直接结束,不需要任何输出,不必读频道历史(除非指令要求)。`
             : `## 启动序列
 1. 若本轮来信可以直接回答,不要先发确认消息;处理完后只发一条完整回复。只有需要澄清、调用工具、协调他人或较长时间处理时,才先发有信息量的确认/进度消息。
-2. 使用本提示词末尾已注入的 MEMORY.md 索引;命中相关条目时,再按索引中的 file 从 $CREW_HOME 读取明细。
+2. 参考本提示词中的 MEMORY.md 预览;需要历史约束或经验时检索完整索引,再按索引中的 file 从 $CREW_HOME 读取明细。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
 4. 收到消息就处理,并用 \`crew message send\` 回复。
 5. **做完你负责的所有事再停。** 多步任务(调研/改码/测试)要全部完成、汇报结果后再停。新消息会在你存活期间自动送达,无需轮询等待。`;
@@ -329,13 +342,15 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:系统每次已把它(截断索引版)注入本提示词末尾。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`),先用这些字段判断当前问题是否相关;通常不必再读整份 MEMORY.md。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
 2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。
 
 **按需读取规则(提示词引导,不是 Daemon 自动召回保证)**:
-- 当前请求命中 MEMORY.md 某条目的 \`summary\` 或 \`triggers\`,或用户明确询问历史经验/偏好时,在最终回答或执行动作前用 \`Read $CREW_HOME/<file>\` 读取对应明细;不要再次拼接 \`notes/\`。
+- 需要历史约束、经验或偏好时,在最终回答或执行动作前先用只读命令 \`crew-memory search --query '关键词' [--after-line N]\` 搜索完整 \`$CREW_HOME/MEMORY.md\`;默认返回 JSON,有后续结果时按返回游标继续,不要把预览中未命中当成全文无结果。
+- 用 \`crew-memory read [--file MEMORY.md|notes/xxx.md] [--offset N] [--limit N]\` 读取命中范围,再按索引中的 file 从 $CREW_HOME 读取明细;默认返回 JSON。以当前有效索引及其指向的正文为依据,不自动读取 pending,也不把未决或已替代片段当成有效记忆。
+- 旧 daemon 没有 \`crew-memory\` 时,回退到 runtime 原生文件搜索和分段 Read:先搜索完整 \`$CREW_HOME/MEMORY.md\`,再用 \`Read $CREW_HOME/<file>\` 读取命中范围;不要再次拼接 \`notes/\`。工具提示截断或返回下一页时继续分页,不要一次读取整份大文件。
 - 未命中时不要为了“保险”读取全部 notes;只读取能直接影响当前任务的文件。MEMORY.md 注入的是索引,不会自动让 note 正文可用。
 
 **沉淀与瘦身由系统触发,不要平时自行扩展范围**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时按功能分类把可复用经验提炼进合适的 \`notes/<topic>.md\`,更新 MEMORY.md 索引。普通执行已经按用户明确要求写入时,收尾先检查、后修改,只在明确缺漏时做最小必要修正,不得重复追加或只为优化措辞而改写。最终结论必须且只能归类为:无变化、已修正、冲突、失败;无变化或已修正时必须满足对应后置条件并清空 work-log,冲突或失败时保留 work-log,任一记忆写入失败则保留 work-log。不要默认全部写入 \`notes/lessons.md\`。默认不要改 MEMORY.md/notes,但不能覆盖当前用户明确授权的最小范围更新。

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.4",
+  "version": "0.6.87-beta.5",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,6 +16,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
+    "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": "0.4.13",
@@ -36,12 +44,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",
-    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

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