@nowcrew/daemon 0.6.88 → 0.6.90

package/dist/local-executor.js

@@ -1,22 +1,26 @@
+import { deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
+import { buildLocalRuntimeEnvironment } from "./local-runtime-environment.js";
+import { environmentForExecution } from "./agent-environments.js";
+import { prepareEnvironmentExecutionSnapshot } from "./agent-environment-execution.js";
 import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
-import { delimiter, join } from "node:path";
+import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
-import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
-import { materializePrivateCodexHome } from "./codex-home-launch.js";
-import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { spawnKimi } from "./runtimes/kimi.js";
 import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
-import { augmentedPath } from "./runtime-path.js";
 import { deliverCloudReports, prepareCloudReportExecution } from "./cloud-report-uploader.js";
 import { reportDeliveryContext } from "./cloud-report-receipt.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { NativeThreadContext, isolateMaintenanceSession } from "./native-thread-context.js";
 import { prepareThreadDelivery } from "./thread-input-delivery.js";
+import { resolveMemoryPruneWorkLog, workLogSha256 } from "./local-memory/work-log.js";
+import { withKeyedLease } from "./local-execution-lease.js";
+import { withWorkLogExecution, withWorkLogCommit, workLogExecutionKey } from "./local-memory/work-log-execution.js";
 import { providerErrorFromExit } from "./provider-error.js";
 import { createConsoleFormatter } from "./console-formatter.js";
 import { withLocalExecutionFacts, } from "./local-execution-prompt.js";
@@ -37,11 +41,11 @@ 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 { machinePackageManagerEnv } from "./package-manager-env.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
+import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
+import { localMemoryV2Environment } from "./config.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -159,28 +163,12 @@ async function launchLegacyRuntime(request) {
 function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
-const nativeSessionLeaseTails = new Map();
 const activeMemoryPrunes = new Map();
-async function withKeyedLease(key, operation, cancellation) {
-    const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => { release = resolve; });
-    const tail = predecessor.then(() => current);
-    nativeSessionLeaseTails.set(key, tail);
-    try {
-        await awaitWithCancellation(predecessor, cancellation);
-        return await operation();
-    }
-    finally {
-        release();
-        void tail.then(() => {
-            if (nativeSessionLeaseTails.get(key) === tail)
-                nativeSessionLeaseTails.delete(key);
-        });
-    }
-}
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
     input = isolateMaintenanceSession(input);
+    return withWorkLogExecution(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), () => executeLocalWithSession(input, callbacks, dependencies), dependencies.cancellation);
+}
+async function executeLocalWithSession(input, callbacks, dependencies) {
     const versionedProjectSkills = input.projectSkills !== undefined
         && !Array.isArray(input.projectSkills);
     if (versionedProjectSkills && (input.runtime.name !== "codex" && input.runtime.name !== "claude")) {
@@ -248,7 +236,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }, "workspace_prepare", error);
         throw error;
     }
-    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, input.localMemoryV2Enabled === true);
+    const memoryRollout = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle,
+        serverUrl: input.launch.serverUrl, requested: input.localMemoryV2Enabled === true,
+        selfTraining: isolatedMaintenance, ...(input.launch.description ? { description: input.launch.description } : {}) });
+    workspace = { ...workspace, localMemoryV2Enabled: memoryRollout.enabled };
+    input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -259,10 +252,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let localMemoryResultPath = null;
+    let environmentSnapshot;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     let nativeThreadContext = null;
-    const inheritedEnv = { ...process.env };
+    const machineSnapshot = dependencies.machineEnvironment ? await awaitWithCancellation(dependencies.machineEnvironment.acquire(), dependencies.cancellation) : undefined;
+    const inheritedEnv = { ...(machineSnapshot?.env ?? process.env) };
     const reportRoots = {
         root: workspace.dir,
         ...(input.launch.qaReportRoot === undefined ? {} : { qaReportRoot: input.launch.qaReportRoot }),
@@ -274,8 +269,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (key.startsWith("CREW_AGENT_MEMORY_") || ["CREW_CLOUD_PROVIDER", "CREW_OSS_UPLOAD_SCRIPT", "CREW_OSS_REPORT_UPLOAD"].includes(key))
             delete inheritedEnv[key];
     }
-    const sourceCodexHome = inheritedEnv.CODEX_HOME
-        ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
     let materializedDeepSeekHome;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
@@ -356,8 +349,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchSessionId = resumeSessionId ?? (rotated
             ? await rotateAgentSession(workspace.sessionDir)
             : workspace.agentSessionId);
-        await materializePrivateCodexHome({ runtime: runtime.name, homeDir: workspace.homeDir, ...(input.launch.codexHomeMode === undefined ? {} : { mode: input.launch.codexHomeMode }), ...(sourceCodexHome === undefined ? {} : { sourceHome: sourceCodexHome }), ...(launchSessionId === undefined ? {} : { sessionId: launchSessionId }), ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }), ...(dependencies.materializeDefaultCodexHome === undefined ? {} : { materialize: dependencies.materializeDefaultCodexHome }) });
-        const promptContext = {
+        let promptContext = {
             workspace: executionWorkspace,
             resuming,
             rotatedForBudget,
@@ -396,8 +388,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
-        const baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
-        memoryPruneTraceId = parseMemoryPruneTraceId(baseWakePrompt);
+        let baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        memoryPruneTraceId = isolatedMaintenance ? null : parseMemoryPruneTraceId(baseWakePrompt);
+        if (memoryRollout.deferred)
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune");
+        if (memoryPruneTraceId !== null) {
+            executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
+            promptContext = { ...promptContext, workspace: executionWorkspace };
+            baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        }
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
@@ -412,6 +411,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
             enabled: input.localMemoryV2Enabled === true, query: baseWakePrompt,
             resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
+            strictRollout: !isolatedMaintenance && localMemoryV2Environment(input.launch.serverUrl) === "dev",
+            deferred: memoryRollout.deferred,
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -480,48 +481,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             nativeThreadContext = new NativeThreadContext(join(executionWorkspace.runDir, `.crew-context-${input.executionId}.json`), contextThreadId, runtime.name, resumeSessionId, prior);
             await nativeThreadContext.initialize();
         }
-        const baseEnv = {
-            ...inheritedEnv,
-            ...sanitizeEnvVars(providerConfig.envVars),
-            ...(input.trainingProjectContext === undefined
-                ? {}
-                : machinePackageManagerEnv(inheritedEnv)),
-            ...input.launch.systemEnv,
-            PATH: `${workspace.crewDir}${delimiter}${augmentedPath()}`,
-            CREW_SERVER_URL: input.launch.serverUrl,
-            CREW_TOKEN: input.launch.token,
-            CREW_CHANNEL: input.channelId,
-            CREW_HOME: crewHome,
-            // Empty values override any stale inherited hints from an enclosing runtime.
-            CREW_THREAD_ROOT: contextThreadId ?? "",
-            CREW_THREAD_CONTEXT_FILE: nativeThreadContext?.path ?? "",
-            // Keep the daemon-selected storage root authoritative for runtimes.
-            // In profile-backed NowWork sessions the daemon config may differ from
-            // the daemon process environment, so inheriting CREW_AGENTS_ROOT is not
-            // sufficient for QA/project diagnostics.
-            CREW_AGENTS_ROOT: input.launch.agentsRoot,
-            ...(input.launch.reposRoot === undefined ? {} : { NOWWORK_REPOS_ROOT: input.launch.reposRoot }),
-            ...(input.launch.qaReportRoot === undefined ? {} : { QA_REPORT_HUB: input.launch.qaReportRoot }),
-            // Expose only the training root; ability-specific workspace layout stays
-            // owned by the training package rather than the NowWork daemon.
-            QA_RUNTIME_ROOT: join(crewHome, "training"),
-            QA_REPORT_DELIVERY_CONTEXT: JSON.stringify(reportContext),
-            CREW_TASK_DIR: executionWorkspace.runDir,
-            CREW_TASK_LOG: executionWorkspace.workLogPath,
-            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
-            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
-            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
-            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
-            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
-            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
-            ...(runtime.name === "kimi" && runtime.reasoning
-                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
-                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
-                : {}),
-        };
-        const providerEnv = applyProviderEnv(baseEnv, runtime.name, input.launch.codexHomeMode === undefined
-            ? providerConfig
-            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir, materializedDeepSeekHome);
+        const baseEnv = buildLocalRuntimeEnvironment({ input, workspace, executionWorkspace, inheritedEnv, providerConfig,
+            crewHome, contextThreadId, nativeThreadContextPath: nativeThreadContext?.path, reportContext, runtime });
+        const providerEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir, materializedDeepSeekHome);
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
             : providerEnv;
@@ -538,10 +500,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const abilityContext = input.abilityRelease !== undefined && dependencies.abilityRelease !== undefined
             ? await dependencies.abilityRelease.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.abilityRelease, async (context) => context)
             : undefined;
+        if (providerConfig.environmentPlan !== undefined && !isolatedMaintenance) {
+            environmentSnapshot = await prepareEnvironmentExecutionSnapshot({ plan: providerConfig.environmentPlan, agentRoot: workspace.dir, runDir: executionWorkspace.runDir, executionId: input.executionId, ambient: inheritedEnv, runtime: runtime.name, providerConfig, runtimeEnvironment: childEnv, authoritativeKeys: Object.keys(input.launch.systemEnv ?? {}),
+                executionBaseEnvironment: childEnv,
+                ...(machineSnapshot === undefined ? {} : { machineEnvironmentVersion: { bootId: machineSnapshot.status.bootId, generation: machineSnapshot.status.generation } }),
+                selectedEnvironment: environmentForExecution(providerConfig.environmentPlan, workspace.dir, input.projectContext?.primary?.root ?? executionWorkspace.runDir, input.projectContext?.primary?.projectId),
+                projectRoots: [...(input.projectContext?.primary ? [input.projectContext.primary] : []), ...(input.projectContext?.secondary ?? [])] });
+        }
         const prepareRuntimeLaunch = async (runtimeRoot) => {
-            const effectiveSystemPrompt = abilityContext === undefined
-                ? systemPrompt
-                : `${systemPrompt}\n\n${abilityContext.prompt}`;
+            const effectiveSystemPrompt = [systemPrompt, abilityContext?.prompt, environmentSnapshot?.prompt].filter(Boolean).join("\n\n");
             if (Buffer.byteLength(effectiveSystemPrompt, "utf8") + Buffer.byteLength(memoryPrompt.wakePromptSuffix, "utf8")
                 > (input.maxSystemPromptBytes ?? Number.MAX_SAFE_INTEGER)) {
                 throw new Error("ability_runtime_context_size_exceeded");
@@ -577,7 +544,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 });
             }
             const trainingRoots = input.trainingProjectContext?.projects.map((project) => project.root) ?? [];
-            const { codexSkillRoots, claudeAdditionalDirectories } = await projectSkillRuntimeDirectories({
+            const { codexSkillRoots, claudeAdditionalDirectories, harnessSkillRoots } = await projectSkillRuntimeDirectories({
                 runtime: runtime.name,
                 ...(runtimeRoot === undefined ? {} : { runtimeRoot }),
                 agentRoot: workspace.dir,
@@ -615,7 +582,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const workspaceRoots = [...legacyRoots, ...trainingRoots];
             const launchRequest = {
                 runtime: runtime.name,
-                bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
+                bin: runtime.name === "deepseek-harness" ? deepSeekHarnessLauncher(runtimeEnv).bin : runtime.name,
+                ...(runtime.name === "deepseek-harness" ? { harnessStateRoot: executionWorkspace.runDir, harnessSkillRoots: harnessSkillRoots ?? [] } : {}),
                 cwd: input.projectContext?.primary?.root ?? executionWorkspace.runDir,
                 ...(runtimeRoot !== undefined
                     || (input.projectSkills === undefined && input.abilityRelease === undefined)
@@ -731,7 +699,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         // (incident: 2026-09-02, boss-alarm 排查结论未投递)。所有 runtime 的文本都喂给它。
         const externalOutput = new ExternalAnswerDecoder();
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
-        const consoleFormatter = createConsoleFormatter();
+        const consoleFormatter = createConsoleFormatter(runtime.name);
         let runtimeReady = false;
         let runtimeRunning = false;
         let resolveRuntimeReady;
@@ -937,14 +905,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         memoryPruneRuntimeExitCode = exitCode;
         if (localMemoryResultPath !== null) {
             memoryPruneFailurePhase = "memory_commit";
-            const committed = await commitLocalMemoryResultAfterExit({
-                resultPath: localMemoryResultPath,
+            const resultPath = localMemoryResultPath;
+            const commit = () => commitLocalMemoryResultAfterExit({
+                resultPath,
                 agentDir: executionWorkspace.dir,
                 executionId: input.executionId,
                 pruneTraceId: memoryPruneTraceId,
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
+                expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
             });
+            const committed = exitCode !== 0 ? await commit() : await withWorkLogCommit(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), commit, dependencies.cancellation);
             if (committed.status === "failed" || committed.status === "missing") {
                 const reason = committed.error ?? "local_memory_result_missing";
                 dslog("local_memory.commit_failed", "结构化本地记忆提交或清理未完成，保留可用恢复材料", {
@@ -1122,6 +1093,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 active_prune_count: activePruneCount,
             });
         }
+        if (environmentSnapshot)
+            await rm(environmentSnapshot.directory, { recursive: true, force: true }).catch(() => { });
         const attachmentDirectories = new Set([
             ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
             ...(materialized === null ? [] : [materialized.directory]),

package/dist/local-memory/candidate.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { containsLikelySecret } from "../agent-memory/policy.js";
+const CategorySchema = z.enum([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+export const LocalMemorySingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
+export const LocalMemoryChangeSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: LocalMemorySingleLineText.regex(/^[^<>]+$/u).nullable(),
+    title: LocalMemorySingleLineText.max(120),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: LocalMemorySingleLineText,
+    triggers: z.array(LocalMemorySingleLineText.max(80)).min(1).max(16),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: CategorySchema,
+    detailBody: z.string().trim().min(1).max(12_000),
+    reviewAfter: LocalMemorySingleLineText.nullable(),
+}).strict();
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
+const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
+export function validateLocalMemoryChange(change) {
+    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 (RESERVED_MEMORY_MARKER.test(text))
+        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");
+    }
+}

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

@@ -19,6 +19,14 @@ export function renderLocalMemoryIndexCard(entry) {
         + `- updated: ${entry.updated}\n`
         + (entry.reviewAfter === null ? "" : `- review_after: ${entry.reviewAfter}\n`);
 }
+/** 写入和预演共用完整索引，预算包含起止标记与分隔换行。 */
+export function renderGeneratedIndex(entries) {
+    const cards = entries
+        .filter(entry => PROJECTABLE_STATUSES.has(entry.status))
+        .map(renderLocalMemoryIndexCard)
+        .join("\n");
+    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+}
 function compareEntries(left, right) {
     const statusRank = (status) => status === "pinned" ? 0 : 1;
     const priorityRank = (priority) => (priority === "high" ? 0 : priority === "medium" ? 1 : 2);

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

@@ -0,0 +1,61 @@
+const CommandSchema = z.object({
+    "agent-dir": z.string().min(1).refine(isAbsolute),
+    "dry-run": z.literal(true),
+}).strict();
+const USAGE = "只读记忆盘点与转换预演，不写文件，不支持 --apply。\n"
+    + "pnpm --filter @nowcrew/daemon exec tsx src/local-memory/inventory-cli.ts --agent-dir <单个Agent绝对路径> --dry-run\n"
+    + "报告包含原始记忆，需作为敏感本地资料保存；退出码0仅代表盘点及格式预演无阻塞，不代表批准迁移。\n";
+export async function runMemoryInventoryCommand(args, io) {
+    if (args.length === 1 && args[0] === "--help") {
+        io.out(USAGE);
+        return 0;
+    }
+    let command;
+    try {
+        const parsed = parseArgs({ args, allowPositionals: false, options: {
+                "agent-dir": { type: "string" }, "dry-run": { type: "boolean" },
+            } });
+        command = CommandSchema.parse(parsed.values);
+    }
+    catch {
+        io.err(USAGE);
+        return 2;
+    }
+    try {
+        const scan = await scanMemorySources(command["agent-dir"]);
+        const scanComplete = scan.issues.length === 0;
+        const analysis = previewMemoryInventory(scan.sources, scanComplete);
+        const complete = scanComplete && !analysis.issues.some((issue) => issue.code === "missing_detail");
+        const issues = [...scan.issues, ...analysis.issues];
+        const referenced = new Set(analysis.entries.map((entry) => entry.sourceFields.file));
+        const files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const report = {
+            schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
+            complete, scanComplete, requiresHumanReview: true,
+            coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
+            limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
+            limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
+            pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
+            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
+            resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
+        };
+        io.out(JSON.stringify(report, null, 2) + "\n");
+        return issues.length ? 1 : 0;
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.code ?? error.message : "inventory_failed";
+        io.err(`记忆盘点失败：${code}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+    process.exitCode = await runMemoryInventoryCommand(process.argv.slice(2), {
+        out: (text) => process.stdout.write(text), err: (text) => process.stderr.write(text),
+    });
+}
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { inventoryLimits, scanMemorySources } from "./inventory-source.js";
+import { previewMemoryInventory } from "./inventory-preview.js";

package/dist/local-memory/inventory-preview.js

@@ -0,0 +1,159 @@
+import { createHash } from "node:crypto";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, } from "./index-budget.js";
+import { parseLocalMemoryIndex } from "./write.js";
+const GENERATED = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/gu;
+const REFERENCE = /^notes\/(?!.*(?:^|\/)\.\.?\/)(?:[^/\\\u0000-\u001f]+\/)*[^/\\\u0000-\u001f]+\.md$/u;
+const FIELD = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
+const WRITABLE_FILES = new Set(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]
+    .map((category) => `notes/${category}.md`));
+const length = (text) => Array.from(text).length;
+const digest = (text) => createHash("sha256").update(text).digest("hex");
+export function previewMemoryInventory(sources, readComplete, mode = "migration") {
+    const issues = [];
+    const entries = [];
+    const sourceMap = new Map(sources.map((source) => [source.path, source]));
+    const memory = sourceMap.get("MEMORY.md")?.content ?? "";
+    const add = (code, path = "MEMORY.md") => issues.push({ code, path });
+    // 掩盖注释但保留UTF-16位置，避免把模板示例当成条目，也保留原文供人工复核。
+    const comments = [...memory.matchAll(/<!--[\s\S]*?-->/gu)];
+    // 现有写入器允许正文包含箭头 A --> B；未闭合的注释仍须拒绝。
+    if ((memory.match(/<!--/gu) ?? []).length !== comments.length
+        || (mode === "migration" && (memory.match(/-->/gu) ?? []).length !== comments.length))
+        add("comment_boundary_invalid");
+    const masked = memory.replace(/<!--[\s\S]*?-->/gu, (comment) => comment.replace(/[^\r\n]/gu, (character) => " ".repeat(character.length)));
+    const sections = [...masked.matchAll(/^##[\t ]+Knowledge Index[\t ]*\r?$/gmu)];
+    const heading = sections[0];
+    if (sections.length !== 1 || heading?.index === undefined)
+        add("index_heading_invalid");
+    const start = heading === undefined ? 0 : heading.index + heading[0].length;
+    const next = /^##[\t ]+(?!#)/mu.exec(masked.slice(start));
+    const end = next?.index === undefined ? memory.length : start + next.index;
+    const generated = [...memory.matchAll(GENERATED)];
+    const markerCount = (memory.match(/NOWWORK:MEMORY_INDEX:/gu) ?? []).length;
+    if (markerCount !== generated.length * 2 || generated.length > 1
+        || generated.some((block) => block.index < start || block.index + block[0].length > end))
+        add("index_marker_invalid");
+    const heads = [...masked.slice(start, end).matchAll(/^###[\t ]+(.+?)[\t ]*\r?$/gmu)];
+    if (heads.length > 1000)
+        add("card_limit_exceeded");
+    const ranges = [];
+    for (const [i, head] of heads.slice(0, 1000).entries()) {
+        const cardStart = start + head.index;
+        const cardEnd = heads[i + 1]?.index === undefined ? end : start + heads[i + 1].index;
+        const tailStart = cardStart + head[0].length;
+        const tail = masked.slice(tailStart, cardEnd);
+        const fields = {};
+        const issueStart = issues.length;
+        let lastFieldEnd = tailStart;
+        let proseSeen = false;
+        for (const line of tail.matchAll(/[^\n]*(?:\n|$)/gu)) {
+            const field = FIELD.exec(line[0].replace(/\r?\n$/u, ""));
+            if (field) {
+                const key = field[1].toLowerCase();
+                if (fields[key] !== undefined)
+                    add("duplicate_field");
+                if (proseSeen)
+                    add("ambiguous_card_body");
+                fields[key] = field[2];
+                lastFieldEnd = tailStart + line.index + line[0].length;
+            }
+            else if (line[0].trim())
+                proseSeen = true;
+        }
+        const rawCard = memory.slice(cardStart, lastFieldEnd);
+        const format = generated.some((block) => cardStart >= block.index && cardStart < block.index + block[0].length)
+            ? "managed" : "legacy";
+        const parsed = parseLocalMemoryIndex(`## Knowledge Index\n${rawCard}`)[0];
+        // 状态更新会把已归一化的空触发词数组写回；字段缺失仍是格式错误。
+        const missingTriggers = mode === "existing_v2" && format === "managed" ? fields.triggers === undefined : !fields.triggers;
+        if (!parsed || !fields.type || !fields.summary || missingTriggers || !fields.priority || !fields.updated
+            || (format === "legacy" && !fields.scope)
+            || !["procedural", "semantic", "episodic", "preference"].includes(fields.type)
+            || !["high", "medium", "low"].includes(fields.priority))
+            add("invalid_card");
+        const file = fields.file ?? "";
+        if (!REFERENCE.test(file) || file.split("/").some((part) => part === "." || part === ".."))
+            add("invalid_reference", file);
+        const detail = sourceMap.get(file)?.content ?? null;
+        if (detail === null)
+            add("missing_detail", file);
+        let proposed = null;
+        if (parsed) {
+            const id = format === "legacy" ? `mem_${digest(rawCard).slice(0, 32)}` : parsed.id;
+            proposed = { ...parsed, id, anchor: id, revision: format === "legacy" ? 1 : parsed.revision };
+            if (format === "managed") {
+                if (!fields.id || !/^[a-zA-Z0-9_-]+$/u.test(fields.id) || fields.anchor !== fields.id
+                    || !/^[1-9][0-9]*$/u.test(fields.revision ?? "") || !Number.isSafeInteger(parsed.revision)
+                    || !["active", "pinned"].includes(fields.status ?? ""))
+                    add("managed_metadata_invalid");
+                const begin = `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${parsed.id} revision=${parsed.revision} -->`;
+                const finish = `<!-- NOWWORK:MEMORY_ENTRY:END id=${parsed.id} -->`;
+                if (!detail?.includes(begin) || !detail.includes(finish)
+                    || detail.indexOf(finish) < detail.indexOf(begin)
+                    || detail.split(begin).length !== 2 || detail.split(finish).length !== 2)
+                    add("managed_anchor_invalid", file);
+            }
+            else if (fields.status && fields.status !== "active") {
+                add("legacy_status_requires_review", file);
+            }
+            if (format === "legacy" && /NOWWORK:MEMORY_(?:ENTRY|INDEX):/u.test(detail ?? ""))
+                add("legacy_detail_contains_markers", file);
+        }
+        entries.push({
+            title: head[1], format, disposition: issues.length === issueStart ? "review_required" : "blocked",
+            sourceFields: fields, rawCard, detail, proposed,
+        });
+        ranges.push({ start: cardStart, end: lastFieldEnd });
+    }
+    for (const entry of entries) {
+        if (entries.filter((other) => other.sourceFields.file === entry.sourceFields.file).length > 1
+            && entry.format === "legacy")
+            add("shared_legacy_detail", entry.sourceFields.file);
+        if (entries.filter((other) => other.proposed?.id === entry.proposed?.id).length > 1)
+            add("duplicate_id");
+        // 已管理条目由ID区分，现有update允许同名；迁移预演仍要求人工审核同名来源。
+        if ((mode === "migration" || entry.format === "legacy")
+            && entries.filter((other) => other.title.trim().toLowerCase() === entry.title.trim().toLowerCase()).length > 1)
+            add("duplicate_title");
+    }
+    const compatibilityIssues = entries.filter((entry) => !WRITABLE_FILES.has(entry.sourceFields.file ?? ""))
+        .map((entry) => ({ code: "detail_category_mapping_required", path: entry.sourceFields.file ?? "" }));
+    let preview = null;
+    if (readComplete && issues.length === 0) {
+        const index = renderGeneratedIndex(entries.map(entry => entry.proposed));
+        let retained = memory;
+        for (const range of [...ranges].reverse())
+            retained = retained.slice(0, range.start) + retained.slice(range.end);
+        retained = retained.replace(GENERATED, "");
+        // 新生成块仅替换索引卡片，角色、目标、维护说明和其它段落保留。
+        const insertAt = start;
+        const projected = retained.slice(0, insertAt) + `\n${index}\n` + retained.slice(insertAt);
+        const budget = {
+            entries: entries.length, indexCodePoints: length(index), totalCodePoints: length(projected),
+            entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP, indexCodePointCap: LOCAL_MEMORY_INDEX_CODE_POINT_CAP,
+            totalCodePointCap: LOCAL_MEMORY_TOTAL_CODE_POINT_CAP,
+            fits: entries.length <= LOCAL_MEMORY_INDEX_ENTRY_CAP && length(index) <= LOCAL_MEMORY_INDEX_CODE_POINT_CAP
+                && length(projected) <= LOCAL_MEMORY_TOTAL_CODE_POINT_CAP,
+        };
+        preview = {
+            memory: projected, budget, writerCompatible: compatibilityIssues.length === 0,
+            notes: entries.filter((entry) => entry.format === "legacy").map((entry) => ({
+                path: entry.sourceFields.file,
+                content: `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${entry.proposed.id} revision=1 -->\n`
+                    + `## ${entry.title}\n\n旧索引范围（仍需结合正文人工确认）：${entry.sourceFields.scope}\n\n`
+                    + `${entry.detail}${entry.detail.endsWith("\n") ? "" : "\n"}`
+                    + `<!-- NOWWORK:MEMORY_ENTRY:END id=${entry.proposed.id} -->\n`,
+            })),
+        };
+        if (!budget.fits)
+            add("projection_over_budget");
+    }
+    const shownDetails = new Set();
+    const compactEntries = entries.map((entry) => {
+        const file = entry.sourceFields.file ?? "";
+        const detail = shownDetails.has(file) ? null : entry.detail;
+        shownDetails.add(file);
+        return { ...entry, detail };
+    });
+    return { entries: compactEntries, issues: [...issues, ...compatibilityIssues], preview, rawMemory: memory };
+}