@nowcrew/daemon 0.6.97-beta.1 → 0.6.97-beta.2

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

@@ -6,7 +6,18 @@ 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;
@@ -27,11 +38,19 @@ 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,
@@ -53,7 +72,8 @@ const CommandSchema = z.discriminatedUnion("command", [
     }).strict(),
 ]);
 const USAGE = `只读记忆工具，默认输出 JSON，不修改任何记忆文件。
-crew-memory search --query <关键词> [--file MEMORY.md|notes/文件.md] [--limit 10] [--after-line 0]
+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 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>]
@@ -62,11 +82,12 @@ search 关键词按空白分隔，同一行须全部命中；返回完整文件
 读取的 offset/limit 按 Unicode 字符计数；用 nextOffset 继续，eof=true 表示结束。
 读取的 --limit 超出范围时，工具会自动降到 2000 并在结果中标记 warning；保留原文件或候选 ID 及 offset，按 nextOffset 分页，不要一次读完整文件。
 后续页可传 --if-hash <前一页的 sha256>，文件变化时停止，避免混读不同版本。
-search/read 读取 MEMORY.md 和 notes 原文，不过滤失效段落，也不扫描 pending。
-search-pending 只查因容量延期的 create 候选；有 nextCursor 就继续，即使本页 matches 为空。
+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 为空。
 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);
@@ -107,33 +128,21 @@ async function readSource(home, file) {
         await handle.close();
     }
 }
-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;
+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));
     }
-    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;
+    catch {
+        return new Set();
     }
-    return text.length;
 }
 function normalizeLimit(requestedLimit, max, safe) {
     if (requestedLimit <= max)
@@ -143,50 +152,6 @@ 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,
@@ -232,6 +197,19 @@ 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({
@@ -264,6 +242,7 @@ export async function runMemoryReadCommand(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");
@@ -289,10 +268,53 @@ export async function runMemoryReadCommand(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 result = command.command === "search"
-            ? (() => {
+        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 normalized = normalizeLimit(command.limit, SEARCH_LIMIT_MAX, SEARCH_LIMIT_SAFE);
-                return searchSource(source.text, source.sha256, { ...command, limit: normalized.limit }, normalized.warning);
+                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 } : {}) };
             })()
             : (() => {
                 const normalized = normalizeLimit(command.limit, READ_LIMIT_MAX, READ_LIMIT_SAFE);

package/dist/local-memory/rollout.js

@@ -7,30 +7,80 @@ 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 function reportLocalMemoryV2Deferred(executionId, handle, memoryPrune) {
-    dslog("local_memory.v2_deferred", "旧记忆尚未通过兼容检查，保留原资料和待处理日志", {
-        execution_id: executionId, agent_handle: handle, reason: "requires_migration"
+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" } : {}),
     });
-    if (memoryPrune)
-        throw new Error("local_memory_v2_requires_migration");
+    if (memoryPrune && !legacyFallback && !allowPendingOnly) {
+        throw new Error(failure === "inspection_failed" ? "local_memory_inspection_failed" : "local_memory_v2_requires_migration");
+    }
 }
 /** 只核对小型索引和其引用；不扫描全部历史任务、不迁移或生成新存储。 */
 export async function resolveLocalMemoryV2Rollout(input) {
     const environment = localMemoryV2Environment(input.serverUrl);
-    if (input.selfTraining || environment === "production")
+    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")
         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"));
@@ -42,8 +92,26 @@ 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)) {
-            return (await readdir(join(root, "notes"))).length === 0 ? { enabled: true, deferred: false } : deferred;
+            if (Array.from(memory.content).length <= LOCAL_MEMORY_TOTAL_CODE_POINT_CAP
+                && (await readdir(join(root, "notes"))).length === 0)
+                return { enabled: true, deferred: false };
         }
+        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;
@@ -76,7 +144,7 @@ export async function resolveLocalMemoryV2Rollout(input) {
         }
         return { enabled: true, deferred: false };
     }
-    catch {
-        return deferred;
+    catch (error) {
+        return { ...deferred, failure: localMemoryRolloutFailure(error) };
     }
 }

package/dist/local-memory/runtime.js

@@ -2,6 +2,12 @@ import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { applyMemoryMigration, prepareMemoryMigration, recoverMemoryMigration } from "./migration-store.js";
+import { MigrationStateSchema } from "./migration-schema.js";
+import { detectLocalMemoryStorageVersion } from "./storage-format.js";
+import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from "./initialization-identity.js";
+import { inventory } from "./migration-io.js";
+import { initializeExactWorkspaceSeed } from "./migration-plan.js";
 import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
 import { verifyWorkLogSource } from "./work-log.js";
 export function isLocalMemoryV2Eligible(input) {
@@ -12,7 +18,7 @@ export function isLocalMemoryV2Eligible(input) {
     return input.enabledForHandle && input.memoryPrune;
 }
 const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
-export async function initializeLocalMemoryV2(agentDir) {
+async function writeLocalMemoryV2Marker(agentDir) {
     const crewDir = join(agentDir, ".crew");
     const memoryDir = join(crewDir, "memory");
     await mkdir(crewDir, { recursive: true });
@@ -31,24 +37,151 @@ export async function initializeLocalMemoryV2(agentDir) {
             throw error;
     }
 }
-export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle) {
+function initializedIntent(identity, state) {
+    return {
+        ...identity,
+        kind: "server_write_intent",
+        sourceDigest: state.sourceDigest,
+        planDigest: state.planDigest,
+        intentVersion: 1,
+        // New-Agent initialization is derived from the exact pristine seed.  Keep
+        // the receipt deterministic so a crash between intent publication and the
+        // mutable state update can be retried without creating a conflicting fact.
+        confirmedAt: "1970-01-01T00:00:00.000Z",
+    };
+}
+/**
+ * Initialize a pristine new Agent through the same journaled schema2
+ * publication path used by migration.  The marker is written only after the
+ * committed catalog and state have both been verified.
+ */
+async function initializeLocalMemoryV2WithBinding(agentDir, agentId, binding) {
+    const identity = await localMemoryInitializationIdentity(agentDir, agentId, binding);
+    let state = await prepareMemoryMigration({
+        agentDir,
+        identity,
+        serverHistory: { kind: "none", isNewAgent: true },
+    });
+    if (state.origin !== "initialized")
+        throw new Error("local_memory_v2_initialization_source_invalid");
+    if (state.phase === "prepared") {
+        state = await applyMemoryMigration({
+            agentDir,
+            identity,
+            intentReceipt: initializedIntent(identity, state),
+        });
+    }
+    else if (state.phase === "applying" || state.phase === "repair_required") {
+        state = await recoverMemoryMigration({
+            agentDir,
+            identity,
+            intentReceipt: state.intentReceipt ?? initializedIntent(identity, state),
+            stoppedReceipt: {
+                kind: "migration_process_stopped",
+                migrationId: identity.migrationId,
+                machineId: identity.machineId,
+                executionId: identity.executionId,
+                ownerIdentity: identity.ownerIdentity,
+                pid: null,
+                stoppedAt: new Date().toISOString(),
+                proof: "journal_reconciled",
+            },
+            cancelled: false,
+        });
+    }
+    const memory = await readFile(join(agentDir, "MEMORY.md"), "utf8");
+    if (state.phase !== "committed" || state.origin !== "initialized" || state.storageVersion !== 2
+        || detectLocalMemoryStorageVersion(memory) !== 2) {
+        throw new Error("local_memory_v2_initialization_incomplete");
+    }
+    await writeLocalMemoryV2Marker(agentDir);
+}
+/** Fresh initialization requires the identity from the authenticated ready frame. */
+export function initializeLocalMemoryV2(agentDir, agentId, binding) {
+    return initializeLocalMemoryV2WithBinding(agentDir, agentId, binding);
+}
+export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle, agentId, binding) {
     const initialized = workspace.localMemoryV2Initialized === true;
-    if (!enabledForHandle || initialized || workspace.localMemoryV2Initialized !== false
-        || workspace.agentHomePreexisted === true || workspace.memorySeedCreated !== true)
-        return initialized;
-    try {
-        await initializeLocalMemoryV2(workspace.dir);
+    if (initialized)
         return true;
-    }
-    catch {
+    // Real workspaces always report this boolean.  Keep partial/mock workspace
+    // callers side-effect free instead of probing an unrelated filesystem path.
+    if (workspace.localMemoryV2Initialized !== false)
         return false;
+    let resumable = false;
+    let effectiveBinding = binding;
+    try {
+        const state = MigrationStateSchema.parse(JSON.parse(await readFile(join(workspace.dir, ".crew", "memory", "migration.v1.json"), "utf8")));
+        const identity = await localMemoryInitializationIdentity(workspace.dir, agentId, binding);
+        const legacyIdentity = binding === undefined
+            ? identity
+            : await localMemoryInitializationIdentity(workspace.dir, agentId);
+        resumable = state.origin === "initialized"
+            && state.phase !== "rolled_back"
+            && (isLocalMemoryInitializationIdentity(state.identity, identity)
+                || isLocalMemoryInitializationIdentity(state.identity, legacyIdentity));
+        if (resumable && isLocalMemoryInitializationIdentity(state.identity, legacyIdentity))
+            effectiveBinding = undefined;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        try {
+            const migrations = await lstat(join(workspace.dir, ".crew", "memory", "migrations"));
+            if (!migrations.isDirectory() || migrations.isSymbolicLink()) {
+                throw new Error("local_memory_v2_initialization_residue_invalid");
+            }
+            const identity = await localMemoryInitializationIdentity(workspace.dir, agentId, binding);
+            const legacyIdentity = binding === undefined
+                ? identity
+                : await localMemoryInitializationIdentity(workspace.dir, agentId);
+            let operationIdentity = identity;
+            const operation = await lstat(join(workspace.dir, ".crew", "memory", "migrations", identity.migrationId))
+                .catch(async (error) => {
+                if (error.code !== "ENOENT" || identity.migrationId === legacyIdentity.migrationId)
+                    throw error;
+                operationIdentity = legacyIdentity;
+                return lstat(join(workspace.dir, ".crew", "memory", "migrations", legacyIdentity.migrationId));
+            });
+            if (!operation.isDirectory() || operation.isSymbolicLink()) {
+                throw new Error("local_memory_v2_initialization_residue_invalid");
+            }
+            const current = await inventory(workspace.dir);
+            const memory = current.files.get("MEMORY.md");
+            resumable = current.files.size === 1 && memory !== undefined
+                && current.directories.every(path => path === "notes" || path === ".crew/memory/pending")
+                && initializeExactWorkspaceSeed(memory) !== null;
+            if (resumable && operationIdentity.migrationId === legacyIdentity.migrationId)
+                effectiveBinding = undefined;
+        }
+        catch (residueError) {
+            if (residueError.code !== "ENOENT")
+                throw residueError;
+        }
     }
+    const pristineFirstInitialization = enabledForHandle
+        && workspace.localMemoryV2Initialized === false
+        && workspace.agentHomePreexisted !== true
+        && workspace.memorySeedCreated === true;
+    if (!resumable && !pristineFirstInitialization)
+        return false;
+    // Never create another unbound sentinel. Undefined is retained solely to
+    // finish a pre-upgrade journal already proven above.
+    if (!resumable && effectiveBinding === undefined)
+        return false;
+    await initializeLocalMemoryV2WithBinding(workspace.dir, agentId, effectiveBinding);
+    return true;
 }
 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) {
+export function renderLocalMemoryResultInstructions(resultPath, storageVersion = 1, migrationDeferred = false) {
+    const storagePolicy = migrationDeferred
+        ? "该 Agent 的旧记忆仍在迁移审阅中。本轮只允许提交新的 create 候选；daemon 会把候选原子保存到 .crew/memory/pending/，reason=legacy_requires_migration，并提供 search-pending/read-pending 查询。候选不会进入 active，也不会自动注入普通上下文；更新、替代和 statusChanges 必须留待迁移完成后按当前 V2 ID/revision/hash 重新核对。旧 MEMORY.md、notes 和已有 active/pending 保持不变。"
+        : storageVersion === 2
+            ? "完整目录保存在 MEMORY.md，模型只看到有界预览；未展示记录仍然有效。涉及旧规则时先用 crew-memory search 查询完整目录，按当前 ID/revision 更新，不因预览未命中就重复新建。20条预览不是有效记录上限；完整存储超出资源上限会拒绝提交，不得自行删除或降级旧记录。已有 pending 仍是未应用候选，须重新核对授权、重复与版本后通过 changes 申请保存，不因迁移自动生效。"
+            : "daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。";
     return `
 
 ## Structured memory prune (daemon-managed)
@@ -70,7 +203,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、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中。容量暂存的 create 可按需检索参考但不能覆盖现行规则；有空间的后续 proposed 提交可提升。未应用的 update/supersede 不进入普通召回，必须重新核对目标版本后处理。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。${storagePolicy}
 写入候选文件只表示提交候选，不能提前宣称已经记住或规则已经更新；daemon 在本轮结束后才处理，候选持久化与进入有效索引也不是同一结果。本结构化轮次覆盖前文提前清理工作日志的要求：保留 $CREW_TASK_LOG，不要清空或删除；daemon 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
@@ -81,6 +214,20 @@ export function renderLocalMemoryV2WriteGuard() {
 ## V2 shared memory write safety
 本节覆盖前文关于普通任务直接更新共享记忆的例外规则。本 Agent 已启用结构化本地记忆 V2。普通任务不得直接编辑共享的 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/ 文件；即使用户明确要求记住内容，也只把候选、用户授权和分类理由记录到本任务的 $CREW_TASK_LOG，留给任务结束后的 memory-prune 结构化收尾应用。只有 memory-prune 收尾提示明确要求写入 daemon 提供的 result 文件时，才按该协议提交候选。`;
 }
+async function localMemoryStorageFacts(agentDir) {
+    const memory = await readFile(join(agentDir, "MEMORY.md"), "utf8");
+    const storageVersion = detectLocalMemoryStorageVersion(memory);
+    let committedState = false;
+    try {
+        const state = MigrationStateSchema.parse(JSON.parse(await readFile(join(agentDir, ".crew", "memory", "migration.v1.json"), "utf8")));
+        committedState = state.phase === "committed" && state.storageVersion === 2;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT" && storageVersion === 2)
+            throw error;
+    }
+    return { storageVersion, committedState };
+}
 function workLogFailure(error) {
     const reason = error instanceof Error ? error.message : "";
     return { status: "failed", error: reason === "local_memory_work_log_source_changed"
@@ -98,6 +245,9 @@ export async function commitLocalMemoryResultAfterExit(input) {
             return { status: "missing" };
         return { status: "failed", error: error instanceof Error ? error.message : "read_failed" };
     }
+    let storageBefore;
+    let storageAfter;
+    let applied;
     try {
         const result = parseLocalMemoryResult(raw);
         if (result.outcome === "conflict" || result.outcome === "failed") {
@@ -111,12 +261,25 @@ export async function commitLocalMemoryResultAfterExit(input) {
                 return workLogFailure(error);
             }
         }
-        await applyLocalMemoryResult({
+        storageBefore = await localMemoryStorageFacts(input.agentDir);
+        if (input.requiredStorageVersion === 2
+            && (storageBefore.storageVersion !== 2 || !storageBefore.committedState)) {
+            return { status: "failed", error: "local_memory_v2_state_invalid_before_commit" };
+        }
+        applied = await applyLocalMemoryResult({
             agentDir: input.agentDir,
             result,
             executionId: input.executionId,
             pruneTraceId: input.pruneTraceId,
+            ...(input.writerCapabilities === undefined ? {} : { writerCapabilities: input.writerCapabilities }),
+            ...(input.requiredStorageVersion === undefined ? {} : { requiredStorageVersion: input.requiredStorageVersion }),
+            ...(input.migrationDeferredPending ? { migrationDeferredPending: true } : {}),
         });
+        storageAfter = await localMemoryStorageFacts(input.agentDir);
+        if (input.requiredStorageVersion === 2
+            && (storageAfter.storageVersion !== 2 || !storageAfter.committedState)) {
+            return { status: "failed", error: "local_memory_v2_state_invalid_after_commit" };
+        }
     }
     catch (error) {
         return { status: "failed", error: error instanceof Error ? error.message : "apply_failed" };
@@ -147,5 +310,10 @@ export async function commitLocalMemoryResultAfterExit(input) {
     catch {
         return { status: "failed", error: "local_memory_result_cleanup_failed" };
     }
-    return { status: "applied" };
+    return { status: "applied", storageVersionBefore: storageBefore.storageVersion,
+        storageVersionAfter: storageAfter.storageVersion, committedState: storageAfter.committedState,
+        createdIds: applied.createdIds, updatedIds: applied.updatedIds,
+        statusChangedIds: applied.statusChangedIds, pendingIds: applied.pendingIds,
+        ...(input.migrationDeferredPending
+            ? { pendingReason: "legacy_requires_migration" } : {}) };
 }