@nowcrew/daemon 0.6.88-beta.5 → 0.6.88-beta.7

package/dist/local-memory/read-cli.js

@@ -5,6 +5,7 @@ import { isAbsolute, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseArgs, TextDecoder } from "node:util";
 import { z } from "zod";
+import { readPendingMemoryBody, searchPendingMemoryPage } from "./pending-query.js";
 const OUTPUT_BYTES = 12 * 1024;
 const FILE_BYTES = 32 * 1024 * 1024;
 const FileSchema = z.string().min(1).refine((file) => {
@@ -33,14 +34,33 @@ const CommandSchema = z.discriminatedUnion("command", [
         offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
         limit: z.coerce.number().int().min(1).max(4000).default(2000),
     }).strict(),
+    z.object({
+        command: z.literal("search-pending"),
+        query: z.string().trim().min(1).max(256),
+        cursor: z.string().min(1).max(4096).optional(),
+        limit: z.coerce.number().int().min(1).max(40).default(10),
+    }).strict(),
+    z.object({
+        command: z.literal("read-pending"),
+        id: z.string().min(1).max(250).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+        ifHash: Common.ifHash,
+        offset: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+        limit: z.coerce.number().int().min(1).max(4000).default(2000),
+    }).strict(),
 ]);
 const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
 crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
 crew-memory read [--file MEMORY.md|notes/文件.md] [--offset 0] [--limit 2000]
-搜索关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
+crew-memory search-pending --query <关键词> [--cursor <游标>] [--limit 10]
+crew-memory read-pending --id <候选ID> [--offset 0] [--limit 2000] [--if-hash <sha256>]
+search 关键词按空白分隔，同一行须全部命中；返回完整文件中的行号和字符偏移。
 读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
 后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
-搜索结果是原始资料定位，不代表候选已生效；按当前有效索引读取明细，不扫描 pending。`;
+search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
+search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
+complete=true 才表示全部候选已检索完成且无遗漏；warnings 或非零退出码表示读取未完成，不能当作零命中。
+read-pending 只返回候选正文；offset 非零时必须传 --if-hash，update/supersede 候选不可读取。
+候选只供相关问题参考，未生效，不能覆盖有效规则；先读取当前有效索引与明细。`;
 function inside(root, path) {
     const value = relative(root, path);
     return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
@@ -152,8 +172,8 @@ function searchSource(text, sha256, command) {
         nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null,
     };
 }
-function readPage(text, sha256, command) {
-    const metadata = { file: command.file, sha256, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
+function readPage(text, source, command) {
+    const metadata = { ...source, offset: command.offset, nextOffset: Number.MAX_SAFE_INTEGER, eof: false, content: "" };
     let remaining = OUTPUT_BYTES - Buffer.byteLength(JSON.stringify(metadata), "utf8");
     let position = 0;
     let offset = 0;
@@ -175,8 +195,16 @@ function readPage(text, sha256, command) {
         count += 1;
     }
     const eof = position === text.length;
+    if (!eof && count === 0)
+        throw new Error("memory_output_too_large");
     return { ...metadata, content, eof, nextOffset: eof ? null : offset };
 }
+function writeResult(result, io) {
+    const output = JSON.stringify(result);
+    if (Buffer.byteLength(output, "utf8") > OUTPUT_BYTES)
+        throw new Error("memory_output_too_large");
+    io.out(output);
+}
 export async function runMemoryReadCommand(argv, io) {
     let command;
     try {
@@ -186,6 +214,7 @@ export async function runMemoryReadCommand(argv, io) {
                 query: { type: "string", short: "q" }, file: { type: "string" },
                 limit: { type: "string" }, offset: { type: "string" },
                 "after-line": { type: "string" }, "if-hash": { type: "string" },
+                id: { type: "string" }, cursor: { type: "string" },
                 json: { type: "boolean" }, help: { type: "boolean", short: "h" },
             },
         });
@@ -201,24 +230,44 @@ export async function runMemoryReadCommand(argv, io) {
             ...(afterLine === undefined ? {} : { afterLine }),
             ...(ifHash === undefined ? {} : { ifHash }),
         });
+        if (command.command === "read-pending" && command.offset > 0 && command.ifHash === undefined) {
+            throw new Error("memory_hash_required");
+        }
     }
     catch {
-        io.err(`memory_arguments_invalid: 参数不合法。\n${USAGE}`);
+        io.err(`memory_arguments_invalid: 参数不合法，记忆读取未完成。\n${USAGE}`);
         return 2;
     }
     try {
+        if (!io.env.CREW_HOME)
+            throw new Error("memory_home_missing");
+        if (command.command === "search-pending") {
+            const result = await searchPendingMemoryPage({ agentDir: io.env.CREW_HOME, query: command.query,
+                ...(command.cursor === undefined ? {} : { cursor: command.cursor }), limit: command.limit });
+            writeResult(result, io);
+            if (result.warnings.length > 0 || (!result.hasMore && !result.complete)) {
+                throw new Error("memory_pending_search_incomplete");
+            }
+            return 0;
+        }
+        if (command.command === "read-pending") {
+            const { content, ...metadata } = await readPendingMemoryBody({ agentDir: io.env.CREW_HOME,
+                pendingId: command.id, ...(command.ifHash === undefined ? {} : { ifHash: command.ifHash }) });
+            writeResult(readPage(content, metadata, command), io);
+            return 0;
+        }
         const source = await readSource(io.env.CREW_HOME, command.file);
         if (command.ifHash !== undefined && command.ifHash !== source.sha256)
             throw new Error("memory_file_changed");
         const result = command.command === "search"
             ? searchSource(source.text, source.sha256, command)
-            : readPage(source.text, source.sha256, command);
-        io.out(JSON.stringify(result));
+            : readPage(source.text, { file: command.file, sha256: source.sha256 }, command);
+        writeResult(result, io);
         return 0;
     }
     catch (error) {
         const code = error.code;
-        const known = error instanceof Error && /^memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
+        const known = error instanceof Error && /^(?:local_)?memory_[a-z_]+$/u.test(error.message) ? error.message : code ?? "memory_read_failed";
         io.err(JSON.stringify({ error: known, message: "记忆读取未完成；检查路径、文件版本或大小，不要将此错误当作没有记忆。" }));
         return 1;
     }

package/dist/local-memory/runtime.js

@@ -69,8 +69,8 @@ outcome 只允许 no_change、proposed、conflict、failed。新增、更新、
 \`\`\`
 
 每个 changes 项须保留示例中的全部字段。operation=create|update|supersede；kind=procedural|semantic|episodic|preference；priority=high|medium|low；detailCategory=preferences|project-rules|testing|debugging|git|incidents|lessons。create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null；update 按现有索引填写 memoryId/baseRevision，supersedesMemoryId 为 null；supersede 填 supersedesMemoryId/baseRevision，memoryId 为 null。
-只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
-写入候选文件不等于已经记住，只有 daemon 校验并提交成功后记忆才生效。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在提交成功后清理，失败时保留日志和候选用于排查或重试。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
+写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
 /** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */

package/dist/local-memory/write.js

@@ -2,29 +2,12 @@ import { createHash, randomUUID } from "node:crypto";
 import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
-import { containsLikelySecret } from "../agent-memory/policy.js";
+import { dslog } from "../slog.js";
+import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemoryChange, } from "./candidate.js";
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
-const CategorySchema = z.enum([
-    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
-]);
-const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
-const ChangeSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    title: SingleLineText.max(120),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: SingleLineText,
-    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: CategorySchema,
-    detailBody: z.string().trim().min(1).max(12_000),
-    reviewAfter: SingleLineText.nullable(),
-}).strict();
 const StatusChangeSchema = z.object({
-    memoryId: SingleLineText,
+    memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
     expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
     targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
@@ -35,7 +18,7 @@ const ResultSchema = z.object({
     purpose: z.literal("memory_prune"),
     baseCatalogRevision: z.number().int().nonnegative(),
     outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
-    changes: z.array(ChangeSchema).max(50),
+    changes: z.array(LocalMemoryChangeSchema).max(50),
     statusChanges: z.array(StatusChangeSchema).max(50),
 }).strict();
 const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
@@ -43,8 +26,6 @@ const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
 const NEXT_SECTION = /^##\s+(?!#)/mu;
 const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
 const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
-const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
-const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
 function codePointLength(value) {
     return Array.from(value).length;
 }
@@ -148,34 +129,12 @@ function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
     return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
-function containsReservedText(change) {
-    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
-}
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
         throw new Error("local_memory_no_change_has_operations");
     }
-    for (const change of result.changes) {
-        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
-        if (containsLikelySecret(text))
-            throw new Error("local_memory_secret_candidate");
-        if (CONTROL_CHARACTER_PATTERN.test(text))
-            throw new Error("local_memory_control_character");
-        if (containsReservedText(change))
-            throw new Error("local_memory_reserved_marker");
-        if (change.operation === "create"
-            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_create_revision_invalid");
-        }
-        if (change.operation === "update"
-            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_update_revision_missing");
-        }
-        if (change.operation === "supersede"
-            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
-            throw new Error("local_memory_supersede_revision_missing");
-        }
-    }
+    for (const change of result.changes)
+        validateLocalMemoryChange(change);
 }
 export function parseLocalMemoryResult(raw) {
     let value;
@@ -477,7 +436,16 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+            if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
+                throw error;
+            // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
+            dslog("local_memory.pending_promotion_skipped", "pending目录超出扫描预算，本轮跳过自动提升", {
+                level: "WARN", execution_id: input.executionId, prune_trace_id: input.pruneTraceId,
+                reason: "memory_pending_directory_over_budget",
+            });
+            return [];
+        });
         for (const pending of pendingCandidatesOnDisk) {
             const change = pending.candidate;
             if (change.operation !== "create")

package/dist/project-skills/capability.js

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

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