@nowcrew/daemon 0.6.101-beta.2 → 0.6.101-beta.4

package/dist/local-memory/pending-query.js

@@ -15,7 +15,6 @@ const SearchSchema = z.object({
     cursor: z.string().max(2048).optional(), limit: z.number().int().min(1).max(40).default(10),
 }).strict();
 const excerpt = (text, cap) => Array.from(text).slice(0, cap).join("");
-const pendingState = (reason) => reason === "legacy_requires_migration" ? "migration_deferred" : "capacity_deferred";
 export async function searchPendingMemoryPage(input) {
     const parsed = SearchSchema.safeParse(input);
     if (!parsed.success)
@@ -62,8 +61,7 @@ export async function searchPendingMemoryPage(input) {
         const match = source && isRecallablePending(source.candidate) && pendingRecallScore(source.candidate, args.query) > 0
             ? { pendingId: source.candidate.pendingId, sha256: source.sha256, title: source.candidate.candidate.title,
                 summary: excerpt(source.candidate.candidate.summary, 180), triggers: source.candidate.candidate.triggers.slice(0, 4),
-                operation: "create", reason: source.candidate.reason,
-                state: pendingState(source.candidate.reason) }
+                operation: "create", state: "capacity_deferred" }
             : null;
         const addition = match ?? warning;
         const size = addition ? Buffer.byteLength(JSON.stringify(addition), "utf8") + 2 : 0;
@@ -98,6 +96,5 @@ export async function readPendingMemoryBody(input) {
         throw new Error("memory_pending_not_recallable");
     const candidate = source.candidate.candidate;
     return { pendingId: source.candidate.pendingId, sha256: source.sha256, title: candidate.title,
-        operation: "create", reason: source.candidate.reason,
-        state: pendingState(source.candidate.reason), content: candidate.detailBody };
+        operation: "create", state: "capacity_deferred", content: candidate.detailBody };
 }

package/dist/local-memory/pending-schema.js

@@ -8,7 +8,7 @@ const ArchivedMemoryChangeSchema = LocalMemoryChangeSchema.extend({
 export const PendingIdSchema = z.string().max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
 export const PendingMemorySchema = z.object({
     schemaVersion: z.literal(1), pendingId: PendingIdSchema,
-    createdAt: z.string().min(1).max(100), reason: z.enum(["index_over_budget", "legacy_requires_migration"]),
+    createdAt: z.string().min(1).max(100), reason: z.literal("index_over_budget"),
     source: z.object({ executionId: z.string().min(1).max(500), pruneTraceId: z.string().min(1).max(500).nullable() }).strict(),
     candidate: ArchivedMemoryChangeSchema,
 }).strict();

package/dist/local-memory/pending.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, realpath, rename, rm, readFile, writeFile } from "node:fs/promises";
+import { lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { isRecallablePending, parsePendingMemoryCandidate } from "./pending-schema.js";
 import { pendingFileNames, pendingReadDirectory, PENDING_FILE_BYTES, readPendingSource } from "./pending-source.js";
@@ -103,17 +103,6 @@ export async function persistPendingMemoryCandidate(input) {
     const directory = await pendingDirectory(input.agentDir);
     const target = join(directory, `${parsed.pendingId}.json`);
     await assertRegularFile(target);
-    try {
-        const existing = parsePendingMemoryCandidate(JSON.parse(await readFile(target, "utf8")));
-        const dedupKey = (value) => value.reason === "legacy_requires_migration"
-            ? JSON.stringify({ schemaVersion: value.schemaVersion, reason: value.reason, candidate: value.candidate })
-            : JSON.stringify({ ...value, createdAt: "" });
-        if (dedupKey(existing) === dedupKey(parsed))
-            return target;
-    }
-    catch {
-        // A malformed existing candidate is replaced by the validated input below.
-    }
     await atomicWrite(target, `${JSON.stringify(parsed, null, 2)}\n`);
     return target;
 }
@@ -175,10 +164,7 @@ function truncateCodePoints(value, maxCodePoints) {
     return Array.from(value).slice(0, Math.max(0, maxCodePoints)).join("");
 }
 export function renderPendingMemoryContext(candidates, maxCodePoints = 2_000) {
-    // Migration-deferred candidates remain explicitly searchable, but must not
-    // be injected into the ordinary prompt before a reviewed migration promotes
-    // them to the active catalog.
-    const recallable = candidates.filter((candidate) => isRecallablePending(candidate) && candidate.reason === "index_over_budget");
+    const recallable = candidates.filter(isRecallablePending);
     if (recallable.length === 0 || maxCodePoints <= 0)
         return "";
     const header = `\n\n## Archived memory candidates (daemon-managed)\n容量暂存的新增资料，仅为部分预览，不代表完整检索；可参考但不能覆盖现行规则，未包含内容请按需查询。\n`;

package/dist/local-memory/prompt.js

@@ -1,8 +1,8 @@
 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";
-const PENDING_READ_GUIDANCE = "\n\nV2新增资料预览未命中不代表没有资料；先查有效索引，必要时用 crew-memory search-pending --query '关键词'，按 nextCursor 续查；用 read-pending --id ID 分页读正文。容量暂存或迁移延期资料不能覆盖现行规则，未应用修改不作为记忆；迁移延期候选必须等 reviewed migration 后再按当前 ID/revision/hash 处理。用 crew-memory --help 查看参数。\n";
+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 = "";
     if (input.enabled) {
@@ -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, input.migrationDeferred === true);
+    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,18 +6,7 @@ import { pathToFileURL } from "node:url";
 import { parseArgs, TextDecoder } from "node:util";
 import { z } from "zod";
 import { readPendingMemoryBody, searchPendingMemoryPage } from "./pending-query.js";
-import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./storage-format.js";
-import { searchFullMemoryIndex } from "./full-index-search.js";
-import { searchLegacyMemorySources } from "./legacy-adapter.js";
-import { withMemoryAccess } from "./migration-access.js";
-import { readMemoryInventorySource, scanMemorySources } from "./inventory-source.js";
-import { MigrationStateSchema } from "./migration-schema.js";
-import { findControlledPreservedSourcePaths } from "./inventory-v2.js";
 const OUTPUT_BYTES = 12 * 1024;
-// A V2 page may carry coverage metadata for legacy sources. Reserve room for
-// that metadata so a mixed result never exceeds the command's output limit.
-const FULL_INDEX_RESULT_BYTES = 4 * 1024;
-const FULL_INDEX_LEGACY_SCAN_BYTES = OUTPUT_BYTES - 4 * 1024;
 const FILE_BYTES = 32 * 1024 * 1024;
 const READ_LIMIT_MAX = 4_000;
 const READ_LIMIT_SAFE = 2_000;
@@ -38,19 +27,11 @@ 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),
-        cursor: z.string().min(1).max(4096).optional(),
-    }).strict(),
     z.object({
         command: z.literal("search"), ...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),
-        cursor: z.string().min(1).max(4096).optional(),
     }).strict(),
     z.object({
         command: z.literal("read"), ...Common,
@@ -72,8 +53,7 @@ const CommandSchema = z.discriminatedUnion("command", [
     }).strict(),
 ]);
 const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
-crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0] [--cursor <游标>]
-crew-memory search-history --query <关键词> [--limit 10] [--after-line 0] [--cursor <游标>] [--if-hash <sha256>]
+crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
 crew-memory read [--file MEMORY.md|notes/文件.md] [--offset 0] [--limit 2000]
 crew-memory search-pending --query <关键词> [--cursor <游标>] [--limit 10]
 crew-memory read-pending --id <候选ID> [--offset 0] [--limit 2000] [--if-hash <sha256>]
@@ -82,12 +62,11 @@ 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/search-history 及 read 读取原文；search-history 是显式 legacy fallback，不把旧内容当作已结构化 V2 记录；read 按指定文件和哈希分页，不扫描 pending。
-search-pending 只查容量延期或迁移延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
+search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
+search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
 complete=true 才表示全部候选已检索完成且无遗漏；warnings 或非零退出码表示读取未完成，不能当作零命中。
 read-pending 只返回候选正文；offset 非零时必须传 --if-hash，update/supersede 候选不可读取。
-候选只供相关问题参考，未生效，不能覆盖有效规则；先读取当前有效索引与明细。迁移延期候选会标记为 migration_deferred，必须等 reviewed migration 后再按当前 ID/revision/hash 处理。`;
+候选只供相关问题参考，未生效，不能覆盖有效规则；先读取当前有效索引与明细。`;
 function inside(root, path) {
     const value = relative(root, path);
     return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
@@ -128,21 +107,33 @@ async function readSource(home, file) {
         await handle.close();
     }
 }
-async function readControlledPreservedSourcePaths(home, memory) {
-    try {
-        const root = await realpath(home);
-        const stateSource = await readMemoryInventorySource(root, ".crew/memory/migration.v1.json", FILE_BYTES);
-        const state = MigrationStateSchema.parse(JSON.parse(stateSource.content));
-        if (state.phase !== "committed" || state.storageVersion !== 2)
-            return new Set();
-        const scan = await scanMemorySources(root, { includeOperationalFiles: false });
-        const sourceHashes = new Map(state.manifest.files
-            .flatMap(file => file.before.exists ? [[file.path, file.before.sha256]] : []));
-        return new Set(findControlledPreservedSourcePaths(parseFullMemoryIndex(memory), scan.sources, state.manifest.recordMappings, sourceHashes));
+function characterCount(text) {
+    let count = 0;
+    for (const _character of text)
+        count += 1;
+    return count;
+}
+function excerpt(text, limit) {
+    let value = "";
+    let count = 0;
+    for (const character of text) {
+        if (count++ >= limit)
+            return `${value}...`;
+        value += character;
     }
-    catch {
-        return new Set();
+    return value;
+}
+function originalLowercaseIndex(text, index) {
+    let originalIndex = 0;
+    let lowerIndex = 0;
+    for (const character of text) {
+        // 逐字符只累计小写长度；匹配仍用整行小写，保留长度不变的词尾 sigma 上下文规则。
+        lowerIndex += character.toLowerCase().length;
+        if (index < lowerIndex)
+            return originalIndex;
+        originalIndex += character.length;
     }
+    return text.length;
 }
 function normalizeLimit(requestedLimit, max, safe) {
     if (requestedLimit <= max)
@@ -152,6 +143,50 @@ function normalizeLimit(requestedLimit, max, safe) {
         warning: { code: "memory_limit_clamped", requestedLimit, appliedLimit: safe, recovered: true },
     };
 }
+function searchSource(text, sha256, command, warning) {
+    const terms = command.query.toLowerCase().split(/\s+/u);
+    const matches = [];
+    let line = 0;
+    let offset = 0;
+    let heading = "";
+    let matchCount = 0;
+    let hasMore = false;
+    let remaining = OUTPUT_BYTES - Buffer.byteLength(JSON.stringify({ file: command.file, sha256 })) - 512;
+    for (const match of text.matchAll(/[^\n]*(?:\n|$)/gu)) {
+        if (match[0] === "")
+            break;
+        line += 1;
+        const raw = match[0];
+        const content = raw.replace(/\r?\n$/u, "");
+        const title = /^#{1,6}\s+(.+?)\s*$/u.exec(content)?.[1];
+        if (title !== undefined)
+            heading = excerpt(title, 96);
+        const lower = content.toLowerCase();
+        if (terms.every((term) => lower.includes(term))) {
+            matchCount += 1;
+            if (line > command.afterLine) {
+                let start = Math.max(0, originalLowercaseIndex(content, lower.indexOf(terms[0])) - 60);
+                if (start > 0 && /[\uDC00-\uDFFF]/u.test(content[start]))
+                    start -= 1;
+                const item = { line, offset, heading, text: `${start > 0 ? "..." : ""}${excerpt(content.slice(start), 240)}` };
+                const bytes = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+                if (hasMore || matches.length >= command.limit || bytes > remaining) {
+                    hasMore = true;
+                }
+                else {
+                    matches.push(item);
+                    remaining -= bytes;
+                }
+            }
+        }
+        offset += characterCount(raw);
+    }
+    return {
+        file: command.file, sha256, matches, matchCount, hasMore,
+        nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null,
+        ...(warning === undefined ? {} : { warning, requestedLimit: warning.requestedLimit, limit: warning.appliedLimit }),
+    };
+}
 function readPage(text, source, command, warning) {
     const metadata = {
         ...source,
@@ -197,19 +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);
-    const pendingOnly = argv[0] === "search-pending" || argv[0] === "read-pending";
-    try {
-        return await withMemoryAccess(io.env.CREW_HOME, () => runMemoryReadUnlocked(argv, io), pendingOnly ? { pendingOnly: true } : {});
-    }
-    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({
@@ -242,7 +264,6 @@ async function runMemoryReadUnlocked(argv, io) {
         io.err(`memory_arguments_invalid: 参数不合法，记忆读取未完成；请按以下参数范围修正后重试，不要当作没有记忆。\n${USAGE}`);
         return 2;
     }
-    const fileWasExplicit = argv.some((arg) => arg === "--file" || arg.startsWith("--file="));
     try {
         if (!io.env.CREW_HOME)
             throw new Error("memory_home_missing");
@@ -268,53 +289,10 @@ 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",
-            }, FULL_INDEX_RESULT_BYTES);
-            const indexedFiles = new Set(["MEMORY.md", ...parseFullMemoryIndex(source.text).map((match) => match.file)]);
-            const preservedSourceFiles = await readControlledPreservedSourcePaths(io.env.CREW_HOME, source.text);
-            const legacyExcludedFiles = fileWasExplicit
-                ? indexedFiles
-                : new Set([...indexedFiles, ...preservedSourceFiles]);
-            const legacy = await searchLegacyMemorySources({ agentDir: io.env.CREW_HOME, query: command.query,
-                limit: normalized.limit, outputBytes: FULL_INDEX_LEGACY_SCAN_BYTES,
-                ...(command.cursor === undefined ? {} : { cursor: command.cursor }),
-                ...(fileWasExplicit ? { files: [command.file], excludeFiles: legacyExcludedFiles } : { excludeFiles: legacyExcludedFiles }) });
-            if (result.matches.length === 0 && (command.cursor === undefined || legacy.matchCount > 0)) {
-                if (legacy.unindexedFiles.length > 0 && (legacy.matchCount > 0 || result.matchCount === 0)) {
-                    writeResult({ ...legacy, ...(normalized.warning ? { warning: normalized.warning,
-                            requestedLimit: normalized.warning.requestedLimit, limit: normalized.warning.appliedLimit } : {}) }, io);
-                    return 0;
-                }
-            }
-            writeResult({ source: "v2", legacy: false, ...result,
-                unindexedFiles: legacy.unindexedFiles,
-                unindexedFileCount: legacy.unindexedFileCount,
-                unindexedFilesTruncated: legacy.unindexedFilesTruncated,
-                complete: result.complete && legacy.matchCount === 0 && legacy.complete,
-                ...(legacy.matchCount === 0 ? {} : { unindexedMatchCount: legacy.matchCount }),
-                ...(legacy.matchCount === 0 ? {} : {
-                    legacyHasMore: legacy.hasMore,
-                    legacyNextCursor: legacy.nextCursor,
-                    legacyNextAfterLine: legacy.nextAfterLine,
-                    v2AfterLine: result.matches.at(-1)?.line ?? result.nextAfterLine,
-                }),
-                ...(normalized.warning ? { warning: normalized.warning,
-                    requestedLimit: normalized.warning.requestedLimit, limit: normalized.warning.appliedLimit } : {}) }, io);
-            return 0;
-        }
-        const result = command.command === "search" || command.command === "search-history"
-            ? await (async () => {
+        const result = command.command === "search"
+            ? (() => {
                 const normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);
-                const legacy = await searchLegacyMemorySources({ agentDir: io.env.CREW_HOME, query: command.query,
-                    limit: normalized.limit, outputBytes: OUTPUT_BYTES - 256, afterLine: command.afterLine,
-                    ...(command.cursor === undefined ? {} : { cursor: command.cursor }),
-                    ...(fileWasExplicit ? { files: [command.file] } : {}) });
-                return { ...legacy, ...(normalized.warning ? { warning: normalized.warning,
-                        requestedLimit: normalized.warning.requestedLimit, limit: normalized.warning.appliedLimit } : {}) };
+                return searchSource(source.text, source.sha256, { ...command, limit: normalized.limit }, normalized.warning);
             })()
             : (() => {
                 const normalized = normalizeLimit(command.limit, READ_LIMIT_MAX, READ_LIMIT_SAFE);

package/dist/local-memory/rollout.js

@@ -7,80 +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";
-import { assertMigrationStateIntegrity } from "./migration-state-invariants.js";
-const TRANSIENT_INSPECTION_ERRORS = new Set([
-    "EACCES", "EPERM", "EIO", "EBUSY", "EAGAIN", "EINTR", "ESTALE", "EMFILE", "ENFILE", "ENOMEM", "ETIMEDOUT",
-    "source_changed", "memory_migration_access_busy",
-]);
-export function localMemoryRolloutFailure(error) {
-    const code = error?.code;
-    const reason = error instanceof Error ? error.message : "";
-    return (typeof code === "string" && TRANSIENT_INSPECTION_ERRORS.has(code))
-        || TRANSIENT_INSPECTION_ERRORS.has(reason)
-        ? "inspection_failed"
-        : "requires_migration";
-}
 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, failure = "requires_migration", allowPendingOnly = false) {
-    dslog("local_memory.v2_deferred", allowPendingOnly
-        ? "迁移尚未完成，新增候选隔离保存到 pending"
-        : legacyFallback ? "旧格式继续原记忆流程，转换成功后再启用V2" : "记忆格式异常，保留原资料和待处理日志", {
-        execution_id: executionId,
-        agent_handle: handle,
-        reason: legacyFallback ? "legacy_compatible" : failure,
-        writer_mode: allowPendingOnly ? "pending_only" : legacyFallback ? "legacy" : "blocked",
-        ...(allowPendingOnly ? { pending_reason: "legacy_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 && !allowPendingOnly) {
-        throw new Error(failure === "inspection_failed" ? "local_memory_inspection_failed" : "local_memory_v2_requires_migration");
-    }
+    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));
-            assertMigrationStateIntegrity(state, state.identity);
-            if (state.phase !== "committed" || state.storageVersion !== 2
-                || state.identity.agentId !== (input.agentId ?? input.handle)
-                || state.identity.rootFingerprint !== createHash("sha256").update(root).digest("hex")
-                || state.identity.ownerIdentity !== String((await lstat(root)).uid))
-                throw new Error("invalid_state");
-            return { enabled: true, deferred: false };
-        }
-        catch (error) {
-            return { enabled: false, deferred: true, failure: localMemoryRolloutFailure(error) };
-        }
-    }
-    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"));
@@ -92,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;
@@ -144,7 +76,7 @@ export async function resolveLocalMemoryV2Rollout(input) {
         }
         return { enabled: true, deferred: false };
     }
-    catch (error) {
-        return { ...deferred, failure: localMemoryRolloutFailure(error) };
+    catch {
+        return deferred;
     }
 }