@nowcrew/daemon 0.6.91-beta.10 → 0.6.91-beta.12

package/dist/execution-journal.js

@@ -8,7 +8,7 @@ import { provePosixProcessGroupStopped } from "./execution-posix-stop-proof.js";
 export { JournalLockedError, JournalLockCorruptionError } from "./execution-journal-lock.js";
 const ExecutionIdSchema = z.string().uuid();
 const TimestampSchema = z.string().datetime({ offset: true });
-const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "memory_migration", "pi"]);
+const RuntimeSchema = z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness", "pi"]);
 const RUNTIME_READY_SUFFIX = ".runtime-ready";
 const RawJournalEntrySchema = z.object({
     executionId: ExecutionIdSchema,
@@ -523,8 +523,6 @@ export function createExecutionJournal(agentsRoot, options = {}) {
         }
     };
     const pruneInternal = async () => {
-        if (options.retainCompleted)
-            return;
         const protectedExecutionIds = new Set(options.protectedExecutionIds?.() ?? []);
         const entries = await readAll();
         const acknowledged = entries

package/dist/execution-protocol.js

@@ -319,7 +319,7 @@ const RawExecutionCompletedSchema = z.object({
     providerErrorCategory: ProviderErrorCategorySchema.optional(),
     providerHttpStatus: ProviderHttpStatusSchema.optional(),
     providerErrorCode: ProviderErrorCodeSchema.optional(),
-    runtime: z.union([RuntimeSchema, z.literal("memory_migration")]),
+    runtime: RuntimeSchema,
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),

package/dist/execution-runner.js

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { isLocalMemoryV2Enabled, localMemoryV2Environment, resolveReposRoot } from "./config.js";
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
@@ -839,9 +838,8 @@ export async function runExecution(config, input, dependencies) {
         const localMemoryGuardInBase = localMemoryV2Environment(config.serverUrl) === "custom";
         const boundedSystemPrompt = (context) => {
             const enabled = context.workspace.localMemoryV2Enabled ?? localMemoryV2Enabled;
-            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase && detectLocalMemoryStorageVersion(context.workspace.memory) !== 2 ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
+            const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${enabled && localMemoryGuardInBase ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
                 ...(selfTraining ? { isolateLocalMemory: true } : {}),
-                memoryQuery: spec.instructions.wakePrompt,
                 collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
             });
             const base = typeof systemPromptWithLocalFacts === "string"

package/dist/local-execution-prompt.js

@@ -2,9 +2,8 @@
  * 本机执行提示词的合成与预算裁剪。
  *
  * server 提示词是权威部分,绝不裁剪;项目工作区提示词是绑定执行的强制部分,放不下就直接失败;
- * 本机事实与旧格式预览可按预算省略；schema2身份和置顶规则必须保留，放不下则拒绝执行。
+ * 只有本机事实(CREW_HOME / work-log / MEMORY 注入)是可选增强,按整段丢弃或按字节截断。
  */
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 import { buildCollaborationToolsPrompt, buildRuntimeWorkspacePrompt, capMemoryForInject, capWorkLogForInject, } from "./prompt.js";
 const trainingProjectJson = (project) => JSON.stringify({
     repositoryKey: project.repositoryKey,
@@ -58,14 +57,10 @@ export function withLocalExecutionFacts(serverPrompt, maxBytes, options = {}) {
         }
         const remaining = maxBytes - requiredBytes - Math.max(0, reservedPromptBytes);
         const factsBytes = Buffer.byteLength(localFacts, "utf8");
-        if (factsBytes > remaining) {
-            if (!options.isolateLocalMemory && detectLocalMemoryStorageVersion(workspace.memory) === 2) {
-                throw new Error("local_memory_identity_budget_exceeded");
-            }
+        if (factsBytes > remaining)
             return `${serverPrompt}${collaborationPrompt}${mandatoryWorkspacePrompt}`;
-        }
         const memoryHeading = "\n\n## Injected MEMORY.md (bounded local context)\n";
-        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"), options.memoryQuery);
+        const memory = options.isolateLocalMemory ? "" : capMemoryForInject(workspace.memory, undefined, remaining - factsBytes - Buffer.byteLength(memoryHeading, "utf8"));
         const memorySection = memory === "" ? "" : memoryHeading + memory;
         const workLogSection = workLog === "" ? "" : `\n\n## Injected work-log (bounded local context)\n${workLog}`;
         const workLogBudget = remaining - factsBytes - Buffer.byteLength(memorySection, "utf8");

package/dist/local-executor.js

@@ -6,7 +6,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
-import { rotateAgentSession, safeKey, } from "./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";
@@ -42,12 +42,10 @@ import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLoc
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { commitLocalMemoryResultAfterExit, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
-import { reportLocalMemoryV2Deferred } from "./local-memory/rollout.js";
-import { prepareExecutionMemoryWorkspace } from "./local-memory/execution-workspace.js";
+import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
 import { localMemoryV2Environment } from "./config.js";
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -213,11 +211,37 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : "high"
         : runtime.reasoning;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    const preparedMemory = await prepareExecutionMemoryWorkspace(input, isolatedMaintenance, dependencies.cancellation);
-    let workspace = preparedMemory.workspace;
-    const memoryRollout = preparedMemory.mode;
+    let workspace;
+    try {
+        workspace = await awaitWithCancellation(prepareWorkspace({
+            agentsRoot: input.launch.agentsRoot,
+            handle: input.handle,
+            cliPath: input.launch.cliPath,
+            executionId: input.executionId,
+            ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+            ...(input.sessionContextFingerprint === undefined
+                ? {}
+                : { sessionContextFingerprint: input.sessionContextFingerprint }),
+            ...(input.launch.description ? { description: input.launch.description } : {}),
+            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
+        }), dependencies.cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({
+            executionId: input.executionId,
+            agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        }, "workspace_prepare", error);
+        throw error;
+    }
+    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 = preparedMemory.initialized;
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -367,7 +391,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         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", memoryRollout.legacyFallback);
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune");
         if (memoryPruneTraceId !== null) {
             executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
             promptContext = { ...promptContext, workspace: executionWorkspace };
@@ -387,11 +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,
-            storageVersion: detectLocalMemoryStorageVersion(executionWorkspace.memory),
-            strictRollout: !isolatedMaintenance && !memoryRollout.legacyFallback && (localMemoryV2Environment(input.launch.serverUrl) === "dev"
-                || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
+            strictRollout: !isolatedMaintenance && localMemoryV2Environment(input.launch.serverUrl) === "dev",
             deferred: memoryRollout.deferred,
-            ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;

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

@@ -50,17 +50,14 @@ export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
         .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((left, right) => (options.relevance?.(right) ?? 0) - (options.relevance?.(left) ?? 0) || compareEntries(left, right));
+    const candidates = projectable.filter((entry) => !protectedIds.has(entry.id)).sort(compareEntries);
     const selected = [];
     let renderedLength = 0;
-    let renderedBytes = 0;
     for (const entry of protectedEntries) {
         selected.push(entry);
         renderedLength += cardLength(entry, selected.length > 1);
-        renderedBytes += Buffer.byteLength(renderLocalMemoryIndexCard(entry), "utf8") + (selected.length > 1 ? 1 : 0);
     }
-    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap
-        || renderedBytes > (budget.indexByteCap ?? Infinity)) {
+    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap) {
         return {
             entries: selected,
             omittedIds: [...omittedIds, ...candidates.map((entry) => entry.id)],
@@ -68,15 +65,12 @@ export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
         };
     }
     for (const entry of candidates) {
-        const bytes = Buffer.byteLength(renderLocalMemoryIndexCard(entry), "utf8") + (selected.length > 0 ? 1 : 0);
-        if (selected.length >= budget.entryCap || renderedLength + cardLength(entry, selected.length > 0) > budget.indexCodePointCap
-            || renderedBytes + bytes > (budget.indexByteCap ?? Infinity)) {
+        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);
-        renderedBytes += bytes;
     }
     return {
         entries: selected,

package/dist/local-memory/prompt.js

@@ -1,7 +1,7 @@
 import { dslog } from "../slog.js";
 import { renderPendingMemoryContext, searchPendingMemoryCandidates } from "./pending.js";
 import { renderLocalMemoryResultInstructions, renderLocalMemoryV2WriteGuard } from "./runtime.js";
-import { LOCAL_MEMORY_V2_DEFERRED_GUIDANCE, LOCAL_MEMORY_LEGACY_GUIDANCE } from "./rollout.js";
+import { LOCAL_MEMORY_V2_DEFERRED_GUIDANCE } from "./rollout.js";
 const PENDING_READ_GUIDANCE = "\n\nV2新增资料预览未命中不代表没有资料；先查有效索引，必要时用 crew-memory search-pending --query '关键词'，按 nextCursor 续查；用 read-pending --id ID 分页读正文。容量暂存资料不能覆盖现行规则，未应用修改不作为记忆。用 crew-memory --help 查看参数。\n";
 export async function prepareLocalMemoryPrompt(input) {
     let pending = "";
@@ -22,11 +22,10 @@ export async function prepareLocalMemoryPrompt(input) {
         }
     }
     const original = input.renderBase(0);
-    const guard = input.legacyFallback ? LOCAL_MEMORY_LEGACY_GUIDANCE : input.deferred ? LOCAL_MEMORY_V2_DEFERRED_GUIDANCE
+    const guard = input.deferred ? LOCAL_MEMORY_V2_DEFERRED_GUIDANCE
         : input.strictRollout && input.enabled && input.resultPath === null ? renderLocalMemoryV2WriteGuard() : "";
-    const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath, input.storageVersion);
+    const structured = input.resultPath === null ? "" : renderLocalMemoryResultInstructions(input.resultPath);
     const guidance = input.enabled ? PENDING_READ_GUIDANCE : "";
-    let requiredMemoryBudgetError;
     // 短命令指引放在当前轮，独立于可舍弃预览；收尾契约仍保持系统与当前轮两份。
     for (const choice of [
         { suffix: pending + guard + structured, wake: guard + structured + guidance },
@@ -34,26 +33,11 @@ export async function prepareLocalMemoryPrompt(input) {
         { suffix: guard + structured, wake: guard + structured },
     ]) {
         const reserved = Buffer.byteLength(choice.suffix + choice.wake, "utf8");
-        let base;
-        try {
-            base = reserved === 0 ? original : input.renderBase(reserved);
-        }
-        catch (error) {
-            // 可选候选先让出预算；最后仍不能容纳身份/置顶时必须拒绝，不能省略必需记忆。
-            if (input.storageVersion === 2 && error instanceof Error
-                && ["local_memory_identity_budget_exceeded", "local_memory_pinned_budget_exceeded"].includes(error.message)) {
-                requiredMemoryBudgetError = error;
-                continue;
-            }
-            throw error;
-        }
-        const systemPrompt = base + choice.suffix;
+        const systemPrompt = (reserved === 0 ? original : input.renderBase(reserved)) + choice.suffix;
         if (input.maxBytes === undefined || Buffer.byteLength(systemPrompt + choice.wake, "utf8") <= input.maxBytes) {
             return { systemPrompt, resultPath: input.resultPath, wakePromptSuffix: choice.wake };
         }
     }
-    if (requiredMemoryBudgetError)
-        throw requiredMemoryBudgetError;
     if (input.strictRollout)
         throw new Error("local_memory_v2_prompt_over_budget");
     // 强制基础指令与契约本身仍无法共存时，保留既有非结构化兼容回退，不裁基础指令。

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

@@ -6,9 +6,6 @@ import { pathToFileURL } from "node:url";
 import { parseArgs, TextDecoder } from "node:util";
 import { z } from "zod";
 import { readPendingMemoryBody, searchPendingMemoryPage } from "./pending-query.js";
-import { detectLocalMemoryStorageVersion } from "./storage-format.js";
-import { searchFullMemoryIndex } from "./full-index-search.js";
-import { withMemoryAccess } from "./migration-access.js";
 const OUTPUT_BYTES = 12 * 1024;
 const FILE_BYTES = 32 * 1024 * 1024;
 const READ_LIMIT_MAX = 4_000;
@@ -30,12 +27,6 @@ const Common = {
     ifHash: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
 };
 const CommandSchema = z.discriminatedUnion("command", [
-    z.object({
-        command: z.literal("search-history"), ...Common,
-        query: z.string().trim().min(1).max(256),
-        limit: z.coerce.number().int().min(1).max(Number.MAX_SAFE_INTEGER).default(10),
-        afterLine: z.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
-    }).strict(),
     z.object({
         command: z.literal("search"), ...Common,
         query: z.string().trim().min(1).max(256),
@@ -63,7 +54,6 @@ const CommandSchema = z.discriminatedUnion("command", [
 ]);
 const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
 crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
-crew-memory search-history --query <关键词> [--limit 10] [--after-line 0] [--if-hash <sha256>]
 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>]
@@ -72,8 +62,7 @@ search 关键词按空白分隔，同一行须全部命中；返回完整文件
 读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
 读取的 --limit 超出范围时，工具会自动降到 2000 并在结果中标记 warning；保留原文件或候选 ID 及 offset，按 nextOffset 分页，不要一次读完整文件。
 后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
-schema=2 的 search 查询完整有效目录（active/pinned），按标题、摘要、触发词联合匹配并返回 ID、revision 和正文引用；search-history 显式查询历史/失效记录。预览未展示不代表记录不存在。
-旧格式 search 及 read 读取原文；read 按指定文件和哈希分页，不扫描 pending。
+search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
 search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
 complete=true 才表示全部候选已检索完成且无遗漏；warnings 或非零退出码表示读取未完成，不能当作零命中。
 read-pending 只返回候选正文；offset 非零时必须传 --if-hash，update/supersede 候选不可读取。
@@ -243,18 +232,6 @@ function writeResult(result, io) {
     io.out(output);
 }
 export async function runMemoryReadCommand(argv, io) {
-    if (!io.env.CREW_HOME || argv.includes("--help") || argv.includes("-h"))
-        return runMemoryReadUnlocked(argv, io);
-    try {
-        return await withMemoryAccess(io.env.CREW_HOME, () => runMemoryReadUnlocked(argv, io));
-    }
-    catch (error) {
-        const reason = error instanceof Error && /^(?:local_)?memory_[a-z_]+$/u.test(error.message) ? error.message : "memory_migration_access_failed";
-        io.err(JSON.stringify({ error: reason, message: "记忆读取受到迁移或状态保护，不能当作没有记忆。" }));
-        return 1;
-    }
-}
-async function runMemoryReadUnlocked(argv, io) {
     let command;
     try {
         const { values, positionals } = parseArgs({
@@ -312,18 +289,6 @@ async function runMemoryReadUnlocked(argv, io) {
         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 fullIndex = command.file === "MEMORY.md" && detectLocalMemoryStorageVersion(source.text) === 2;
-        if ((command.command === "search" || command.command === "search-history") && fullIndex) {
-            const normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);
-            const result = searchFullMemoryIndex(source.text, source.sha256, {
-                ...command, limit: normalized.limit, history: command.command === "search-history",
-            }, OUTPUT_BYTES - 256);
-            writeResult({ ...result, ...(normalized.warning ? { warning: normalized.warning,
-                    requestedLimit: normalized.warning.requestedLimit, limit: normalized.warning.appliedLimit } : {}) }, io);
-            return 0;
-        }
-        if (command.command === "search-history")
-            throw new Error("memory_history_requires_full_index");
         const result = command.command === "search"
             ? (() => {
                 const normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);

package/dist/local-memory/rollout.js

@@ -7,57 +7,30 @@ import { inventoryLimits, readMemoryInventorySource } from "./inventory-source.j
 import { previewMemoryInventory } from "./inventory-preview.js";
 import { parseLocalMemoryIndex } from "./write.js";
 import { dslog } from "../slog.js";
-import { createHash } from "node:crypto";
-import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./storage-format.js";
-import { MigrationStateSchema } from "./migration-schema.js";
 export const LOCAL_MEMORY_V2_DEFERRED_GUIDANCE = `
 
 ## 本轮本地记忆兼容状态
 开发环境已开放 V2，但该 Agent 的旧记忆尚未通过格式兼容检查，本轮未启用结构化 V2。
 本节覆盖前文和旧会话中直接改写共享记忆的要求：本轮 MEMORY.md 与 notes 只读，不得改写、迁移或清空。
 用户要求新增或更新长期规则时，内容和授权均只记录到本任务的 $CREW_TASK_LOG；保留日志，不要清空，不要宣称长期记忆已生效。旧资料兼容处理完成前，记忆收尾会明确报告需要处理。`;
-export const LOCAL_MEMORY_LEGACY_GUIDANCE = `
-
-## 本轮本地记忆兼容状态
-本 Agent 尚未完成 V2 格式转换，本轮继续原记忆流程。用户明确要求新增或修改长期规则时，可按原规则最小范围更新共享记忆；记忆收尾继续依据任务日志更新原 MEMORY.md 和 notes，确认成功后再清理日志。
-本节覆盖旧会话中因等待 V2 转换而冻结共享记忆写入的要求，但不是新的用户写入授权；本任务如明确要求不更新记忆，继续遵守。
-保留原身份、目标及无关资料，不自行迁移或重置文件，不宣称已启用 V2。`;
-export function reportLocalMemoryV2Deferred(executionId, handle, memoryPrune, legacyFallback = false) {
-    dslog("local_memory.v2_deferred", legacyFallback ? "旧格式继续原记忆流程，转换成功后再启用V2" : "记忆格式异常，保留原资料和待处理日志", {
-        execution_id: executionId, agent_handle: handle, reason: legacyFallback ? "legacy_compatible" : "requires_migration"
+export function reportLocalMemoryV2Deferred(executionId, handle, memoryPrune) {
+    dslog("local_memory.v2_deferred", "旧记忆尚未通过兼容检查，保留原资料和待处理日志", {
+        execution_id: executionId, agent_handle: handle, reason: "requires_migration"
     });
-    if (memoryPrune && !legacyFallback)
+    if (memoryPrune)
         throw new Error("local_memory_v2_requires_migration");
 }
 /** 只核对小型索引和其引用；不扫描全部历史任务、不迁移或生成新存储。 */
 export async function resolveLocalMemoryV2Rollout(input) {
     const environment = localMemoryV2Environment(input.serverUrl);
-    if (input.selfTraining)
-        return { enabled: false, deferred: false };
-    // 已提交的目标格式独立于新的迁移资格；关闭名单不能退回不兼容writer。
-    if (input.workspace.memory.includes("NOWWORK:MEMORY_INDEX:BEGIN schema=2")) {
-        try {
-            if (detectLocalMemoryStorageVersion(input.workspace.memory) !== 2)
-                throw new Error("invalid_storage");
-            parseFullMemoryIndex(input.workspace.memory);
-            const root = await realpath(input.workspace.dir);
-            const record = await readMemoryInventorySource(root, ".crew/memory/migration.v1.json", inventoryLimits.fileBytes);
-            const state = MigrationStateSchema.parse(JSON.parse(record.content));
-            if (state.phase !== "committed" || state.storageVersion !== 2 || state.identity.agentId !== input.handle
-                || state.identity.rootFingerprint !== createHash("sha256").update(root).digest("hex"))
-                throw new Error("invalid_state");
-            return { enabled: true, deferred: false };
-        }
-        catch {
-            return { enabled: false, deferred: true };
-        }
-    }
-    if (environment === "production")
+    if (input.selfTraining || environment === "production")
         return { enabled: false, deferred: false };
     if (environment === "custom")
         return { enabled: input.requested, deferred: false };
     const deferred = { enabled: false, deferred: true };
     const { workspace } = input;
+    if (Array.from(workspace.memory).length > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
+        return deferred;
     try {
         const root = await realpath(workspace.dir);
         const notesStat = await lstat(join(root, "notes"));
@@ -69,26 +42,8 @@ export async function resolveLocalMemoryV2Rollout(input) {
         // 完整种子且无旧明细才可按空记忆接入；marker 不能替代这项核对。
         const seededRole = /^## Role\n([\s\S]*?)\n\n## Core Goals\n/mu.exec(memory.content)?.[1];
         if (seededRole !== undefined && memory.content === memorySeed(input.handle, seededRole)) {
-            if (Array.from(memory.content).length <= LOCAL_MEMORY_TOTAL_CODE_POINT_CAP
-                && (await readdir(join(root, "notes"))).length === 0)
-                return { enabled: true, deferred: false };
+            return (await readdir(join(root, "notes"))).length === 0 ? { enabled: true, deferred: false } : deferred;
         }
-        if (!/NOWWORK:MEMORY_INDEX:/u.test(memory.content)) {
-            // 普通旧格式不是损坏V2。引用必须仍为根内可读文件，格式/容量例外保留原流程。
-            const entries = parseLocalMemoryIndex(memory.content);
-            // 已有受控ID或锚点的记录，不能因HTML标记丢失就退回旧writer。
-            if (entries.some(entry => !entry.id.startsWith("legacy:") || entry.anchor !== null))
-                return deferred;
-            let remaining = inventoryLimits.totalBytes - memory.bytes;
-            for (const file of new Set(entries.map(entry => entry.file))) {
-                if (!file.startsWith("notes/"))
-                    return deferred;
-                remaining -= (await readMemoryInventorySource(root, file, Math.min(remaining, inventoryLimits.fileBytes))).bytes;
-            }
-            return { enabled: false, deferred: true, legacyFallback: true };
-        }
-        if (Array.from(workspace.memory).length > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
-            return deferred;
         const generated = /<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->[\s\S]*?<!-- NOWWORK:MEMORY_INDEX:END -->/u.exec(memory.content)?.[0];
         if (!generated || Array.from(generated).length > LOCAL_MEMORY_INDEX_CODE_POINT_CAP)
             return deferred;

package/dist/local-memory/runtime.js

@@ -48,10 +48,7 @@ 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, storageVersion = 1) {
-    const storagePolicy = storageVersion === 2
-        ? "完整目录保存在 MEMORY.md，模型只看到有界预览；未展示记录仍然有效。涉及旧规则时先用 crew-memory search 查询完整目录，按当前 ID/revision 更新，不因预览未命中就重复新建。20条预览不是有效记录上限；完整存储超出资源上限会拒绝提交，不得自行删除或降级旧记录。已有 pending 仍是未应用候选，须重新核对授权、重复与版本后通过 changes 申请保存，不因迁移自动生效。"
-        : "daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。";
+export function renderLocalMemoryResultInstructions(resultPath) {
     return `
 
 ## Structured memory prune (daemon-managed)
@@ -73,7 +70,7 @@ 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、隐私或内部控制标记。${storagePolicy}
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
 写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }