@nowcrew/daemon 0.6.55 → 0.6.57

package/dist/config.js

@@ -59,6 +59,40 @@ function defaultCliPath() {
         return resolve(here, "../../cli/dist/main.js");
     }
 }
+// 临时 dev 验收名单。测试完成后删除此常量，恢复未配置时默认关闭的行为。
+const TEMP_LOCAL_MEMORY_V2_TEST_HANDLES = [
+    "memory-v2-test-a",
+    "memory-v2-test-b",
+    "memory-v2-test-c",
+];
+function isTemporaryDevServer(serverUrl) {
+    try {
+        const hostname = new URL(serverUrl).hostname.toLowerCase();
+        return hostname === "localhost"
+            || hostname === "127.0.0.1"
+            || hostname === "::1"
+            || hostname === "nowwork-dev.nowcoder.com";
+    }
+    catch {
+        return false;
+    }
+}
+function localMemoryV2Handles(env, serverUrl) {
+    const configured = env.CREW_LOCAL_MEMORY_V2_HANDLES;
+    if (configured === undefined) {
+        return isTemporaryDevServer(serverUrl)
+            ? new Set(TEMP_LOCAL_MEMORY_V2_TEST_HANDLES)
+            : new Set();
+    }
+    const raw = configured.trim();
+    if (raw === "")
+        return new Set();
+    const handles = raw.split(",").map((value) => value.trim()).filter(Boolean);
+    if (handles.some((handle) => !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(handle))) {
+        throw new ConfigError("CREW_LOCAL_MEMORY_V2_HANDLES contains an invalid agent handle");
+    }
+    return new Set(handles);
+}
 export const DEFAULT_SERVER_URL = "http://127.0.0.1:3001";
 function codexHomeModeEnv(env) {
     const value = env.CREW_CODEX_HOME_MODE;
@@ -108,6 +142,7 @@ export function loadConfig(env = process.env) {
         sessionMaxTurns: env.CREW_SESSION_MAX_TURNS != null ? Number(env.CREW_SESSION_MAX_TURNS) : 30,
         productName: env.CREW_PRODUCT_NAME ?? "nowwork",
         agentMemory: loadAgentMemoryConfig(env),
+        localMemoryV2Handles: localMemoryV2Handles(env, serverUrl),
         executionLimits,
     };
 }

package/dist/execution-runner.js

@@ -847,6 +847,7 @@ export async function runExecution(config, input, dependencies) {
                 softTokens: config.sessionSoftTokens,
                 maxTurns: config.sessionMaxTurns,
             },
+            localMemoryV2Enabled: config.localMemoryV2Handles?.has(spec.agent.handle) === true,
         };
         const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),

package/dist/local-executor.js

@@ -31,6 +31,7 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
 function memoryPruneFileFactFields(fileFacts) {
     const fields = {};
     for (const [label, fact] of Object.entries(fileFacts)) {
@@ -277,6 +278,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }, "workspace_prepare", error);
         throw error;
     }
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, input.localMemoryV2Enabled === true);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -286,6 +288,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneFailurePhase = "diagnostics_before";
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
+    let localMemoryResultPath = null;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     const inheritedEnv = { ...process.env };
@@ -371,7 +374,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             nearBudget,
             ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
         };
-        const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
             if (dependencies.cancellation?.isRequested())
                 throw new RuntimeCancelledError();
@@ -405,6 +407,29 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
+        if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
+            && isLocalMemoryV2Eligible({
+                enabledForHandle: true,
+                agentHomePreexisted: workspace.agentHomePreexisted === true,
+                memorySeedCreated: executionWorkspace.memorySeedCreated === true && (localMemoryV2Initialized || workspace.localMemoryV2Initialized !== false),
+                localMemoryV2Initialized,
+                memoryPrune: true,
+            })) {
+            localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
+        }
+        const baseSystemPrompt = resolvePrompt(input.systemPrompt, promptContext);
+        const structuredMemoryInstructions = localMemoryResultPath === null
+            ? null
+            : renderLocalMemoryResultInstructions(localMemoryResultPath);
+        const structuredPromptFits = structuredMemoryInstructions === null
+            || input.maxSystemPromptBytes === undefined
+            || Buffer.byteLength(baseSystemPrompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
+                <= input.maxSystemPromptBytes;
+        if (!structuredPromptFits)
+            localMemoryResultPath = null;
+        const systemPrompt = localMemoryResultPath === null
+            ? baseSystemPrompt
+            : `${baseSystemPrompt}${structuredMemoryInstructions ?? ""}`;
         try {
             localMemoryTelemetry = createLocalMemoryTelemetry({
                 executionId: input.executionId,
@@ -892,6 +917,24 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const { exitCode, spawnError, terminationSignal } = runtimeExit;
         localMemoryTelemetry?.markRuntimeExited(exitCode);
         memoryPruneRuntimeExitCode = exitCode;
+        if (localMemoryResultPath !== null) {
+            const committed = await commitLocalMemoryResultAfterExit({
+                resultPath: localMemoryResultPath,
+                agentDir: executionWorkspace.dir,
+                executionId: input.executionId,
+                pruneTraceId: memoryPruneTraceId,
+                exitCode,
+            });
+            if (committed.status === "failed") {
+                dslog("local_memory.commit_failed", "结构化本地记忆候选未落地，保留结果文件", {
+                    level: "WARN",
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    error_code: committed.error,
+                    result_path: localMemoryResultPath,
+                });
+            }
+        }
         const errorTail = [
             stderrTail.trim(),
             spawnError === undefined

package/dist/local-memory/index-budget.js

@@ -0,0 +1,74 @@
+export const LOCAL_MEMORY_TOTAL_CODE_POINT_CAP = 6_000;
+export const LOCAL_MEMORY_INDEX_CODE_POINT_CAP = 3_000;
+export const LOCAL_MEMORY_INDEX_ENTRY_CAP = 20;
+const PROJECTABLE_STATUSES = new Set(["pinned", "active"]);
+function codePointLength(value) {
+    return Array.from(value).length;
+}
+export function renderLocalMemoryIndexCard(entry) {
+    return `### ${entry.title}\n`
+        + `- id: ${entry.id}\n`
+        + `- file: ${entry.file}\n`
+        + `- type: ${entry.type}\n`
+        + `- status: ${entry.status}\n`
+        + `- summary: ${entry.summary}\n`
+        + `- triggers: ${entry.triggers.join(", ")}\n`
+        + `- priority: ${entry.priority}\n`
+        + `- revision: ${entry.revision}\n`
+        + `- anchor: ${entry.anchor ?? ""}\n`
+        + `- updated: ${entry.updated}\n`
+        + (entry.reviewAfter === null ? "" : `- review_after: ${entry.reviewAfter}\n`);
+}
+function compareEntries(left, right) {
+    const statusRank = (status) => status === "pinned" ? 0 : 1;
+    const priorityRank = (priority) => (priority === "high" ? 0 : priority === "medium" ? 1 : 2);
+    return statusRank(left.status) - statusRank(right.status)
+        || priorityRank(left.priority) - priorityRank(right.priority)
+        || right.updated.localeCompare(left.updated)
+        || left.id.localeCompare(right.id);
+}
+function cardLength(entry, hasPrevious) {
+    return codePointLength(renderLocalMemoryIndexCard(entry)) + (hasPrevious ? 1 : 0);
+}
+function overBudgetReason(entries) {
+    return entries.some((entry) => entry.status === "pinned")
+        ? "index_over_budget_pinned"
+        : "index_over_budget_active";
+}
+export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
+    const projectable = entries.filter((entry) => PROJECTABLE_STATUSES.has(entry.status));
+    const omittedIds = entries
+        .filter((entry) => !PROJECTABLE_STATUSES.has(entry.status))
+        .map((entry) => entry.id);
+    const protectedIds = options.protectedIds ?? new Set();
+    const protectedEntries = projectable.filter((entry) => protectedIds.has(entry.id)).sort(compareEntries);
+    const candidates = projectable.filter((entry) => !protectedIds.has(entry.id)).sort(compareEntries);
+    const selected = [];
+    let renderedLength = 0;
+    for (const entry of protectedEntries) {
+        selected.push(entry);
+        renderedLength += cardLength(entry, selected.length > 1);
+    }
+    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap) {
+        return {
+            entries: selected,
+            omittedIds: [...omittedIds, ...candidates.map((entry) => entry.id)],
+            reason: overBudgetReason(selected),
+        };
+    }
+    for (const entry of candidates) {
+        if (selected.length >= budget.entryCap || renderedLength + cardLength(entry, selected.length > 0) > budget.indexCodePointCap) {
+            omittedIds.push(entry.id);
+            continue;
+        }
+        selected.push(entry);
+        renderedLength += cardLength(entry, selected.length > 1);
+    }
+    return {
+        entries: selected,
+        omittedIds,
+        reason: omittedIds.length === entries.filter((item) => !PROJECTABLE_STATUSES.has(item.status)).length
+            ? null
+            : "index_over_budget",
+    };
+}

package/dist/local-memory/pending.js

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+const CandidateSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: z.string().nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: z.string().nullable(),
+    title: z.string().min(1),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: z.string().min(1),
+    triggers: z.array(z.string()).min(1),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: z.enum(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]),
+    detailBody: z.string().min(1),
+    reviewAfter: z.string().nullable(),
+}).strict();
+const PendingSchema = z.object({
+    schemaVersion: z.literal(1),
+    pendingId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    createdAt: z.string().min(1),
+    reason: z.literal("index_over_budget"),
+    source: z.object({
+        executionId: z.string().min(1),
+        pruneTraceId: z.string().min(1).nullable(),
+    }).strict(),
+    candidate: CandidateSchema,
+}).strict();
+function within(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+async function pendingDirectory(agentDir) {
+    const agentRoot = await realpath(agentDir);
+    const memoryRoot = resolve(agentRoot, ".crew", "memory");
+    await mkdir(memoryRoot, { recursive: true });
+    const memoryStat = await lstat(memoryRoot);
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_pending_path_invalid");
+    const resolvedMemoryRoot = await realpath(memoryRoot);
+    if (resolvedMemoryRoot !== memoryRoot || !within(agentRoot, resolvedMemoryRoot)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const directory = join(memoryRoot, "pending");
+    try {
+        const stat = await lstat(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error("local_memory_pending_path_invalid");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await mkdir(directory);
+    }
+    const resolvedDirectory = await realpath(directory);
+    if (resolvedDirectory !== directory || !within(agentRoot, resolvedDirectory)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    return directory;
+}
+async function assertRegularFile(path) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("local_memory_pending_path_invalid");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function atomicWrite(path, content) {
+    const temporary = join(dirname(path), `.${basename(path)}.tmp-${randomUUID()}`);
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function persistPendingMemoryCandidate(input) {
+    const parsed = PendingSchema.safeParse(input.candidate);
+    if (!parsed.success)
+        throw new Error("local_memory_pending_invalid");
+    const directory = await pendingDirectory(input.agentDir);
+    const target = join(directory, `${parsed.data.pendingId}.json`);
+    await assertRegularFile(target);
+    await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
+    return target;
+}
+export async function readPendingMemoryCandidates(input) {
+    const directory = await pendingDirectory(input.agentDir);
+    const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
+    const result = [];
+    for (const name of names) {
+        const path = join(directory, name);
+        try {
+            await assertRegularFile(path);
+            const parsed = PendingSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+            if (parsed.success && `${parsed.data.pendingId}.json` === name)
+                result.push(parsed.data);
+        }
+        catch {
+            // A damaged pending item is diagnosable and must not hide other candidates.
+        }
+    }
+    return result;
+}

package/dist/local-memory/runtime.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+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;
+}
+const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
+export async function initializeLocalMemoryV2(agentDir) {
+    const crewDir = join(agentDir, ".crew");
+    const memoryDir = join(crewDir, "memory");
+    await mkdir(crewDir, { recursive: true });
+    const crewStat = await lstat(crewDir);
+    if (!crewStat.isDirectory() || crewStat.isSymbolicLink())
+        throw new Error("local_memory_marker_path_invalid");
+    await mkdir(memoryDir, { recursive: true });
+    const memoryStat = await lstat(memoryDir);
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_marker_path_invalid");
+    try {
+        await writeFile(join(memoryDir, LOCAL_MEMORY_V2_MARKER), "1\n", { encoding: "utf8", mode: 0o600, flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle) {
+    const initialized = workspace.localMemoryV2Initialized === true;
+    if (!enabledForHandle || initialized || workspace.localMemoryV2Initialized !== false
+        || workspace.agentHomePreexisted === true || workspace.memorySeedCreated !== true)
+        return initialized;
+    try {
+        await initializeLocalMemoryV2(workspace.dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function localMemoryResultPath(runDir, executionId) {
+    const suffix = createHash("sha256").update(executionId, "utf8").digest("hex").slice(0, 32);
+    return join(runDir, `.memory-result.v1-${suffix}.json`);
+}
+export function renderLocalMemoryResultInstructions(resultPath) {
+    return `
+
+## Structured memory prune (daemon-managed)
+本轮长期记忆收尾只提交候选，不要直接编辑 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/。
+将一个合法 JSON 对象写入以下 daemon 提供的文件，写入完成后再结束本轮：
+${resultPath}
+
+JSON 顶层必须包含：
+{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[]}
+每个 changes 项使用 operation=create|update|supersede、title、kind、summary、triggers、priority、detailCategory、detailBody、reviewAfter；create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null，update/supersede 按现有索引填写版本和 id。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 中等待后续治理。
+`;
+}
+export async function commitLocalMemoryResultAfterExit(input) {
+    if (input.exitCode !== 0)
+        return { status: "skipped" };
+    let raw;
+    try {
+        raw = await readFile(input.resultPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { status: "missing" };
+        return { status: "failed", error: error instanceof Error ? error.message : "read_failed" };
+    }
+    try {
+        const result = parseLocalMemoryResult(raw);
+        await applyLocalMemoryResult({
+            agentDir: input.agentDir,
+            result,
+            executionId: input.executionId,
+            pruneTraceId: input.pruneTraceId,
+        });
+        await rm(input.resultPath, { force: true });
+        return { status: "applied" };
+    }
+    catch (error) {
+        return { status: "failed", error: error instanceof Error ? error.message : "apply_failed" };
+    }
+}

package/dist/local-memory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/local-memory/write.js

@@ -0,0 +1,448 @@
+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 { 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 } 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,
+    expectedRevision: z.number().int().positive(),
+    expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
+    targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
+    reason: z.enum(["user_explicit", "manual_review"]),
+}).strict();
+const ResultSchema = z.object({
+    schemaVersion: z.literal(1),
+    purpose: z.literal("memory_prune"),
+    baseCatalogRevision: z.number().int().nonnegative(),
+    outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
+    changes: z.array(ChangeSchema).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;
+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;
+}
+function detailPath(category) {
+    return `notes/${category}.md`;
+}
+function parseStatus(value) {
+    return value === "candidate" || value === "active" || value === "pinned"
+        || value === "stale" || value === "superseded" || value === "archived"
+        ? value
+        : "active";
+}
+function parseCard(titleLine, body) {
+    const fields = {};
+    for (const line of body.split(/\r?\n/u)) {
+        const match = FIELD_LINE.exec(line);
+        if (match?.[1] !== undefined && match[2] !== undefined)
+            fields[match[1].toLowerCase()] = match[2];
+    }
+    const title = titleLine.trim().replace(/^\[|\]$/gu, "").trim();
+    const file = fields.file?.trim();
+    if (!title || !file)
+        return null;
+    const priority = fields.priority === "high" || fields.priority === "low" ? fields.priority : "medium";
+    const revision = Number(fields.revision);
+    return {
+        id: fields.id?.trim() || `legacy:${file}:${title}`,
+        title,
+        file,
+        type: fields.type === "procedural" || fields.type === "episodic" || fields.type === "preference"
+            ? fields.type
+            : "semantic",
+        status: parseStatus(fields.status),
+        summary: fields.summary?.trim() ?? "",
+        triggers: [...new Set((fields.triggers ?? "").split(/[,，、]/u).map((value) => value.trim()).filter(Boolean))],
+        priority,
+        updated: fields.updated?.trim() ?? "",
+        anchor: fields.anchor?.trim() || null,
+        revision: Number.isInteger(revision) && revision > 0 ? revision : 1,
+        reviewAfter: fields.review_after?.trim() || null,
+    };
+}
+function indexSection(memory) {
+    const heading = INDEX_HEADING.exec(memory);
+    if (heading === null || heading.index === undefined)
+        return "";
+    const start = heading.index + heading[0].length;
+    const rest = memory.slice(start);
+    const next = NEXT_SECTION.exec(rest);
+    return next?.index === undefined ? rest : rest.slice(0, next.index);
+}
+function parseCards(section) {
+    const withoutComments = section.replace(/<!--[\s\S]*?-->/gu, "");
+    const headings = [...withoutComments.matchAll(CARD_HEADING)];
+    return headings.flatMap((heading, index) => {
+        if (heading.index === undefined || heading[1] === undefined)
+            return [];
+        const bodyStart = heading.index + heading[0].length;
+        const bodyEnd = headings[index + 1]?.index ?? withoutComments.length;
+        const card = parseCard(heading[1], withoutComments.slice(bodyStart, bodyEnd));
+        return card === null ? [] : [card];
+    });
+}
+export function parseLocalMemoryIndex(memory) {
+    const section = indexSection(memory);
+    const generated = GENERATED_INDEX_PATTERN.exec(section)?.[0];
+    return parseCards(generated ?? section);
+}
+function parseUnmarkedMemoryIndex(memory) {
+    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
+    return parseCards(section);
+}
+function renderGeneratedIndex(entries) {
+    const cards = entries
+        .filter((entry) => entry.status === "pinned" || entry.status === "active")
+        .map(renderLocalMemoryIndexCard)
+        .join("\n");
+    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+}
+function replaceGeneratedIndex(memory, entries) {
+    const generated = renderGeneratedIndex(entries);
+    if (GENERATED_INDEX_PATTERN.test(memory))
+        return memory.replace(GENERATED_INDEX_PATTERN, generated);
+    const heading = INDEX_HEADING.exec(memory);
+    if (heading?.index !== undefined) {
+        const afterHeading = heading.index + heading[0].length;
+        return `${memory.slice(0, afterHeading)}\n${generated}${memory.slice(afterHeading)}`;
+    }
+    return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
+}
+function noteSection(id, revision, title, body) {
+    return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
+        + `## ${title}\n\n${body.trim()}\n`
+        + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
+}
+function notePattern(id) {
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
+}
+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");
+        }
+    }
+}
+export function parseLocalMemoryResult(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("local_memory_result_json_invalid");
+    }
+    const parsed = ResultSchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`local_memory_result_invalid:${parsed.error.issues[0]?.path.join(".") ?? "unknown"}`);
+    validateCandidate(parsed.data);
+    return parsed.data;
+}
+function entryFromChange(change, id, revision, status) {
+    return {
+        id,
+        title: change.title,
+        file: detailPath(change.detailCategory),
+        type: change.kind,
+        status,
+        summary: change.summary,
+        triggers: [...new Set(change.triggers)],
+        priority: change.priority,
+        updated: new Date().toISOString().slice(0, 10),
+        anchor: id,
+        revision,
+        reviewAfter: change.reviewAfter,
+    };
+}
+function matchesCreateCandidate(entry, change) {
+    const triggers = [...new Set(change.triggers)];
+    return entry.title === change.title
+        && entry.file === detailPath(change.detailCategory)
+        && entry.type === change.kind
+        && entry.summary === change.summary
+        && entry.priority === change.priority
+        && entry.reviewAfter === change.reviewAfter
+        && entry.triggers.length === triggers.length
+        && entry.triggers.every((trigger, index) => trigger === triggers[index]);
+}
+function stableId(executionId, index, change) {
+    const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
+    return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
+}
+function normalize(value) {
+    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
+function activeOrPinnedIds(entries) {
+    return new Set(entries.filter((entry) => entry.status === "active" || entry.status === "pinned").map((entry) => entry.id));
+}
+function emptyResult() {
+    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
+}
+function isWithin(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+async function assertWritablePaths(agentDir, memoryPath) {
+    const agentRoot = await realpath(agentDir);
+    const notesPath = join(agentDir, "notes");
+    const notesRoot = await realpath(notesPath);
+    if (notesRoot !== resolve(agentRoot, "notes") || !isWithin(agentRoot, notesRoot))
+        throw new Error("local_memory_notes_path_invalid");
+    const memoryStat = await lstat(memoryPath);
+    if (!memoryStat.isFile() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_memory_path_invalid");
+}
+async function readNote(path) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("local_memory_note_path_invalid");
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+async function atomicWrite(path, content) {
+    const temporary = `${path}.tmp-${randomUUID()}`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function projectIndex(memory, entries, protectedIds) {
+    const empty = replaceGeneratedIndex(memory, []);
+    if (codePointLength(empty) > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
+        throw new Error("local_memory_memory_over_budget");
+    const emptyIndex = renderGeneratedIndex([]);
+    const remainingTotal = LOCAL_MEMORY_TOTAL_CODE_POINT_CAP - codePointLength(empty);
+    const selection = selectLocalMemoryIndexEntries(entries, {
+        indexCodePointCap: Math.min(Math.max(0, LOCAL_MEMORY_INDEX_CODE_POINT_CAP - codePointLength(emptyIndex)), remainingTotal),
+        entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP,
+    }, { protectedIds });
+    return {
+        memory: replaceGeneratedIndex(memory, selection.entries),
+        omittedIds: selection.omittedIds,
+        reason: selection.reason,
+    };
+}
+const applyTails = new Map();
+async function withApplyLease(agentDir, operation) {
+    const key = resolve(agentDir);
+    const previous = applyTails.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolveCurrent) => { release = resolveCurrent; });
+    const tail = previous.then(() => current);
+    applyTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        void tail.then(() => {
+            if (applyTails.get(key) === tail)
+                applyTails.delete(key);
+        });
+    }
+}
+export async function applyLocalMemoryResult(input) {
+    validateCandidate(input.result);
+    if (input.result.outcome !== "proposed")
+        return emptyResult();
+    const memoryPath = join(input.agentDir, "MEMORY.md");
+    await assertWritablePaths(input.agentDir, memoryPath);
+    return withApplyLease(input.agentDir, async () => {
+        const memory = await readFile(memoryPath, "utf8");
+        if (parseUnmarkedMemoryIndex(memory).length > 0)
+            throw new Error("local_memory_legacy_index_requires_migration");
+        let entries = [...parseLocalMemoryIndex(memory)];
+        for (const entry of entries) {
+            if (!isWithin(resolve(input.agentDir, "notes"), resolve(input.agentDir, entry.file))) {
+                throw new Error("local_memory_note_path_invalid");
+            }
+        }
+        const contentIds = new Set(input.result.changes.flatMap((change) => [
+            ...(change.operation === "update" && change.memoryId !== null ? [change.memoryId] : []),
+            ...(change.supersedesMemoryId === null ? [] : [change.supersedesMemoryId]),
+        ]));
+        for (const statusChange of input.result.statusChanges) {
+            if (contentIds.has(statusChange.memoryId))
+                throw new Error("local_memory_status_conflict");
+            const current = entries.find((entry) => entry.id === statusChange.memoryId);
+            if (current === undefined || current.revision !== statusChange.expectedRevision || current.status !== statusChange.expectedStatus) {
+                throw new Error("local_memory_status_conflict");
+            }
+            entries = entries.map((entry) => entry.id === statusChange.memoryId
+                ? { ...entry, status: statusChange.targetStatus, revision: entry.revision + 1 }
+                : entry);
+        }
+        const createdIds = [];
+        const updatedIds = [];
+        const statusChangedIds = input.result.statusChanges.map((change) => change.memoryId);
+        const deferredIds = [];
+        const pendingCandidates = [];
+        const noteUpdates = new Map();
+        const randomId = input.randomId ?? randomUUID;
+        const executionId = input.executionId ?? "unknown";
+        const defer = (change, index) => {
+            const candidateId = input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
+            const pendingId = `pending-${candidateId.slice("mem_".length)}`;
+            pendingCandidates.push({
+                schemaVersion: 1,
+                pendingId,
+                createdAt: new Date().toISOString(),
+                reason: "index_over_budget",
+                source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+                candidate: change,
+            });
+            deferredIds.push(pendingId);
+        };
+        for (const [index, change] of input.result.changes.entries()) {
+            const id = change.operation === "update"
+                ? change.memoryId
+                : input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
+            const existingCreate = change.operation === "create" ? entries.find((entry) => entry.id === id) : undefined;
+            const current = change.operation === "update" ? entries.find((entry) => entry.id === id) : undefined;
+            if (change.operation === "update") {
+                if (current === undefined)
+                    throw new Error("local_memory_revision_conflict_missing_id");
+                if (change.baseRevision !== current.revision)
+                    throw new Error("local_memory_revision_conflict");
+            }
+            const superseded = change.operation === "supersede"
+                ? entries.find((entry) => entry.id === change.supersedesMemoryId)
+                : undefined;
+            if (change.operation === "supersede") {
+                if (superseded === undefined)
+                    throw new Error("local_memory_supersede_missing_id");
+                if (change.baseRevision !== superseded.revision)
+                    throw new Error("local_memory_supersede_revision_conflict");
+            }
+            if (change.operation === "create") {
+                if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
+                    throw new Error("local_memory_duplicate_candidate");
+                }
+                if (existingCreate === undefined && entries.some((entry) => normalize(entry.title) === normalize(change.title)
+                    || normalize(entry.summary) === normalize(change.summary))) {
+                    throw new Error("local_memory_duplicate_candidate");
+                }
+            }
+            const revision = existingCreate?.revision ?? (current === undefined ? 1 : current.revision + 1);
+            const entry = existingCreate ?? entryFromChange(change, id, revision, current?.status ?? "active");
+            const candidateEntries = existingCreate !== undefined
+                ? entries
+                : change.supersedesMemoryId === null
+                    ? current === undefined ? [...entries, entry] : entries.map((item) => item.id === id ? entry : item)
+                    : [
+                        ...entries.map((item) => item.id === change.supersedesMemoryId
+                            ? { ...item, status: "superseded", revision: item.revision + 1 }
+                            : item),
+                        entry,
+                    ];
+            const protectedIds = new Set(activeOrPinnedIds(entries));
+            if (change.supersedesMemoryId !== null)
+                protectedIds.delete(change.supersedesMemoryId);
+            const projection = projectIndex(memory, candidateEntries, protectedIds);
+            const omitted = (entry.status === "active" || entry.status === "pinned") && projection.omittedIds.includes(id);
+            if (change.operation === "update" && omitted)
+                throw new Error(projection.reason ?? "local_memory_index_over_budget");
+            if ((change.operation === "create" || change.operation === "supersede") && omitted) {
+                defer(change, index);
+                continue;
+            }
+            const notePath = resolve(input.agentDir, entry.file);
+            if (!isWithin(resolve(input.agentDir, "notes"), notePath))
+                throw new Error("local_memory_note_path_invalid");
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const replacement = noteSection(id, revision, change.title, change.detailBody);
+            const existingSection = replaceNote(previous, id, replacement);
+            const next = existingSection ?? (current === undefined
+                ? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`
+                : null);
+            if (next === null)
+                throw new Error("local_memory_note_anchor_missing");
+            noteUpdates.set(notePath, next);
+            entries = candidateEntries;
+            if (change.operation === "update")
+                updatedIds.push(id);
+            else if (existingCreate === undefined)
+                createdIds.push(id);
+        }
+        const finalProjection = projectIndex(memory, entries, activeOrPinnedIds(entries));
+        if (finalProjection.reason !== null)
+            throw new Error(finalProjection.reason);
+        for (const candidate of pendingCandidates)
+            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
+        for (const [path, content] of noteUpdates)
+            await atomicWrite(path, content);
+        if (noteUpdates.size > 0 || statusChangedIds.length > 0)
+            await atomicWrite(memoryPath, finalProjection.memory);
+        return {
+            createdIds,
+            updatedIds,
+            statusChangedIds,
+            deferredIds,
+            pendingIds: deferredIds,
+        };
+    });
+}

package/dist/runner.js

@@ -105,6 +105,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             softTokens: config.sessionSoftTokens,
             maxTurns: config.sessionMaxTurns,
         },
+        localMemoryV2Enabled: config.localMemoryV2Handles?.has(input.handle) === true,
     }, {
         onActivity,
         onConsole,

package/dist/workspace.js

@@ -8,7 +8,7 @@
  *
  * spawn runtime 时把 <ws>/.crew 置于 PATH 最前,于是 agent 的 `crew ...` 命中 wrapper。
  */
-import { mkdir, writeFile, readFile, chmod, access } from "node:fs/promises";
+import { mkdir, writeFile, readFile, chmod, access, lstat } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { dslog } from "./slog.js";
@@ -34,8 +34,28 @@ async function exists(p) {
         return false;
     }
 }
+async function hasLocalMemoryV2Marker(agentDir) {
+    const crewDir = join(agentDir, ".crew");
+    const memoryDir = join(crewDir, "memory");
+    const markerPath = join(agentDir, ".crew", "memory", "v2-enabled");
+    try {
+        const crewStat = await lstat(crewDir);
+        const memoryStat = await lstat(memoryDir);
+        if (!crewStat.isDirectory() || crewStat.isSymbolicLink()
+            || !memoryStat.isDirectory() || memoryStat.isSymbolicLink())
+            return false;
+        const stat = await lstat(markerPath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return false;
+        return (await readFile(markerPath, "utf8")) === "1\n";
+    }
+    catch {
+        return false;
+    }
+}
 export async function prepareWorkspace(input) {
     const dir = join(input.agentsRoot, input.handle);
+    const agentHomePreexisted = await exists(dir);
     const crewDir = join(dir, ".crew");
     await mkdir(crewDir, { recursive: true });
     // 预先创建明细目录,让收尾流程可以按功能创建 notes/<topic>.md。
@@ -43,6 +63,7 @@ export async function prepareWorkspace(input) {
     // MEMORY.md:首次创建"持久身份 + 知识索引"骨架,之后由 agent 自己维护
     const memoryPath = join(dir, "MEMORY.md");
     const memorySeedCreated = !(await exists(memoryPath));
+    const localMemoryV2Initialized = await hasLocalMemoryV2Marker(dir);
     if (memorySeedCreated) {
         try {
             await writeFile(memoryPath, memorySeed(input.handle, input.description), "utf8");
@@ -124,7 +145,9 @@ export async function prepareWorkspace(input) {
         crewDir,
         systemPromptPath,
         memory,
+        agentHomePreexisted,
         memorySeedCreated,
+        localMemoryV2Initialized,
         homeDir,
         runDir,
         workLogPath,

package/package.json

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