@nowcrew/daemon 0.6.99-beta.3 → 0.6.99

package/dist/local-memory/runtime.js

@@ -2,12 +2,6 @@ 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) {
@@ -18,7 +12,7 @@ export function isLocalMemoryV2Eligible(input) {
     return input.enabledForHandle && input.memoryPrune;
 }
 const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
-async function writeLocalMemoryV2Marker(agentDir) {
+export async function initializeLocalMemoryV2(agentDir) {
     const crewDir = join(agentDir, ".crew");
     const memoryDir = join(crewDir, "memory");
     await mkdir(crewDir, { recursive: true });
@@ -37,151 +31,24 @@ async function writeLocalMemoryV2Marker(agentDir) {
             throw error;
     }
 }
-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) {
+export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle) {
     const initialized = workspace.localMemoryV2Initialized === true;
-    if (initialized)
-        return true;
-    // 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;
+    if (!enabledForHandle || initialized || workspace.localMemoryV2Initialized !== false
+        || workspace.agentHomePreexisted === true || workspace.memorySeedCreated !== true)
+        return initialized;
     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;
-        }
+        await initializeLocalMemoryV2(workspace.dir);
+        return true;
     }
-    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)
+    catch {
         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, 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 不进入普通召回，必须重新核对目标版本后处理。";
+export function renderLocalMemoryResultInstructions(resultPath) {
     return `
 
 ## Structured memory prune (daemon-managed)
@@ -203,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 将在处理成功后清理，失败时保留日志和候选用于排查或重试。
 `;
 }
@@ -214,20 +81,6 @@ 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"
@@ -245,9 +98,6 @@ 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") {
@@ -261,25 +111,12 @@ export async function commitLocalMemoryResultAfterExit(input) {
                 return workLogFailure(error);
             }
         }
-        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({
+        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" };
@@ -310,10 +147,5 @@ export async function commitLocalMemoryResultAfterExit(input) {
     catch {
         return { status: "failed", error: "local_memory_result_cleanup_failed" };
     }
-    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" } : {}) };
+    return { status: "applied" };
 }

package/dist/local-memory/write.js

@@ -6,8 +6,6 @@ import { dslog } from "../slog.js";
 import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemoryChange, } from "./candidate.js";
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
-import { assertLocalMemoryStorageSize, detectLocalMemoryStorageVersion, LOCAL_MEMORY_GENERATED_INDEX_PATTERN, LOCAL_MEMORY_NOTE_BYTE_CAP, LOCAL_MEMORY_READ_BYTE_CAP, parseFullMemoryIndex, replaceFullMemoryIndex, selectLocalMemoryPreview, } from "./storage-format.js";
-import { assertMemoryInventoryHealth, assertMemoryWriterAllowed, withMemoryAccess } from "./migration-access.js";
 const StatusChangeSchema = z.object({
     memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
@@ -92,14 +90,12 @@ function parseCards(section) {
     });
 }
 export function parseLocalMemoryIndex(memory) {
-    if (detectLocalMemoryStorageVersion(memory) === 2)
-        return parseFullMemoryIndex(memory);
     const section = indexSection(memory);
     const generated = GENERATED_INDEX_PATTERN.exec(section)?.[0];
     return parseCards(generated ?? section);
 }
 function parseUnmarkedMemoryIndex(memory) {
-    const section = indexSection(memory).replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, "");
+    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
     return parseCards(section);
 }
 function replaceGeneratedIndex(memory, entries) {
@@ -126,36 +122,11 @@ function noteSection(id, revision, title, body) {
 }
 function notePattern(id) {
     const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}(?=\\s|-->)[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
-}
-function uniqueNoteSection(content, id) {
-    const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    const begins = [...content.matchAll(new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}(?=\\s|-->)`, "gu"))];
-    const ends = [...content.matchAll(new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->`, "gu"))];
-    if (begins.length === 0 && ends.length === 0)
-        return null;
-    const section = notePattern(id).exec(content)?.[0];
-    if (begins.length !== 1 || ends.length !== 1 || section === undefined
-        || (section.match(/NOWWORK:MEMORY_ENTRY:(?:BEGIN|END)/gu) ?? []).length !== 2) {
-        throw new Error("local_memory_note_anchor_invalid");
-    }
-    return section;
+    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
 }
 function replaceNote(content, id, replacement) {
     const pattern = notePattern(id);
-    return uniqueNoteSection(content, id) !== null ? content.replace(pattern, () => replacement) : null;
-}
-function updateNoteRevision(content, id, revision) {
-    const section = uniqueNoteSection(content, id);
-    const beginning = `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} `;
-    const ending = `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->`;
-    if (section === null || content.split(beginning).length !== 2 || content.split(ending).length !== 2) {
-        throw new Error("local_memory_note_anchor_missing");
-    }
-    const updated = section.replace(/^(<!--\s*NOWWORK:MEMORY_ENTRY:BEGIN\s+id=[A-Za-z0-9_-]+\s+revision=)[1-9][0-9]*(\s*-->)/u, (_match, prefix, suffix) => `${prefix}${revision}${suffix}`);
-    if (!updated.startsWith(`${beginning}revision=${revision} -->`))
-        throw new Error("local_memory_note_anchor_missing");
-    return content.replace(notePattern(id), () => updated);
+    return pattern.test(content) ? content.replace(pattern, replacement) : null;
 }
 function validateCandidate(result) {
     if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
@@ -209,25 +180,6 @@ function stableId(executionId, index, change) {
     const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
     return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
 }
-function migrationPendingId(change) {
-    // Keep the digest independent of object insertion order for callers that
-    // reach applyLocalMemoryResult directly instead of the JSON/Zod boundary.
-    const canonicalChange = {
-        operation: change.operation,
-        memoryId: change.memoryId,
-        baseRevision: change.baseRevision,
-        supersedesMemoryId: change.supersedesMemoryId,
-        title: change.title,
-        kind: change.kind,
-        summary: change.summary,
-        triggers: change.triggers,
-        priority: change.priority,
-        detailCategory: change.detailCategory,
-        detailBody: change.detailBody,
-        reviewAfter: change.reviewAfter,
-    };
-    return `pending-migration-${createHash("sha256").update(JSON.stringify(canonicalChange), "utf8").digest("hex").slice(0, 12)}`;
-}
 function normalize(value) {
     return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
 }
@@ -247,14 +199,14 @@ function detailCategoryFromFile(file) {
     return DETAIL_CATEGORIES.has(category) ? category : null;
 }
 function readNoteBody(content, id) {
-    const section = uniqueNoteSection(content, id);
-    if (section === null)
+    const begin = content.indexOf(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id}`);
+    if (begin < 0)
         return null;
-    const bodyStart = section.indexOf("\n\n");
-    const bodyEnd = section.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
+    const bodyStart = content.indexOf("\n\n", begin);
+    const bodyEnd = content.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
     if (bodyStart < 0 || bodyEnd < 0)
         return null;
-    return section.slice(bodyStart + 2, bodyEnd).trim();
+    return content.slice(bodyStart + 2, bodyEnd).trim();
 }
 function archivedChange(entry, detailBody) {
     const detailCategory = detailCategoryFromFile(entry.file);
@@ -278,34 +230,6 @@ function archivedChange(entry, detailBody) {
 function emptyResult() {
     return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
 }
-async function stageMigrationDeferredPending(input) {
-    if (input.result.outcome !== "proposed")
-        return emptyResult();
-    if (input.result.statusChanges.length > 0 || input.result.changes.some((change) => change.operation !== "create")) {
-        throw new Error("local_memory_migration_pending_create_only");
-    }
-    const executionId = input.executionId ?? "unknown";
-    const pending = input.result.changes.map((change) => ({
-        schemaVersion: 1,
-        pendingId: migrationPendingId(change),
-        createdAt: new Date().toISOString(),
-        reason: "legacy_requires_migration",
-        source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
-        candidate: change,
-    }));
-    await assertMemoryAccessDirectory(input.agentDir);
-    await withMemoryAccess(input.agentDir, async () => {
-        const memory = await readFile(join(input.agentDir, "MEMORY.md"), "utf8").catch(() => null);
-        if (memory === null || detectLocalMemoryStorageVersion(memory) !== 1) {
-            throw new Error("local_memory_migration_pending_storage_invalid");
-        }
-        for (const candidate of pending) {
-            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
-        }
-    }, { pendingOnly: true });
-    const pendingIds = [...new Set(pending.map((candidate) => candidate.pendingId))];
-    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: pendingIds, pendingIds };
-}
 function isWithin(root, candidate) {
     const path = relative(root, candidate);
     return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
@@ -320,29 +244,12 @@ async function assertWritablePaths(agentDir, memoryPath) {
     if (!memoryStat.isFile() || memoryStat.isSymbolicLink())
         throw new Error("local_memory_memory_path_invalid");
 }
-async function assertMemoryAccessDirectory(agentDir) {
-    try {
-        const stat = await lstat(join(agentDir, ".crew/memory"));
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            throw new Error("local_memory_pending_path_invalid");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-}
 async function readNote(path) {
     try {
         const stat = await lstat(path);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error("local_memory_note_path_invalid");
-        if (stat.size > LOCAL_MEMORY_NOTE_BYTE_CAP)
-            throw new Error("local_memory_note_byte_limit");
-        const content = await readFile(path, "utf8");
-        if (Buffer.byteLength(content, "utf8") > LOCAL_MEMORY_NOTE_BYTE_CAP)
-            throw new Error("local_memory_note_byte_limit");
-        return content;
+        return await readFile(path, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -362,11 +269,6 @@ async function atomicWrite(path, content) {
     }
 }
 function projectIndex(memory, entries, protectedIds) {
-    if (detectLocalMemoryStorageVersion(memory) === 2) {
-        const updated = replaceFullMemoryIndex(memory, entries);
-        selectLocalMemoryPreview(updated);
-        return { memory: updated, omittedIds: [], reason: null };
-    }
     const empty = replaceGeneratedIndex(memory, []);
     if (codePointLength(empty) > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
         throw new Error("local_memory_memory_over_budget");
@@ -404,29 +306,12 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    if (input.migrationDeferredPending)
-        return stageMigrationDeferredPending(input);
-    if (input.result.outcome !== "proposed" && input.requiredStorageVersion !== 2)
+    if (input.result.outcome !== "proposed")
         return emptyResult();
     const memoryPath = join(input.agentDir, "MEMORY.md");
-    if (input.result.outcome === "proposed")
-        await assertWritablePaths(input.agentDir, memoryPath);
-    await assertMemoryAccessDirectory(input.agentDir);
-    return withApplyLease(input.agentDir, async () => withMemoryAccess(input.agentDir, async () => {
-        await assertMemoryWriterAllowed(input.agentDir, input.writerCapabilities ?? []);
-        const memoryStat = await lstat(memoryPath);
-        if (memoryStat.size > 16 * 1024 * 1024)
-            throw new Error("local_memory_storage_byte_limit");
+    await assertWritablePaths(input.agentDir, memoryPath);
+    return withApplyLease(input.agentDir, async () => {
         const memory = await readFile(memoryPath, "utf8");
-        assertLocalMemoryStorageSize(memory);
-        const fullStorage = detectLocalMemoryStorageVersion(memory) === 2;
-        if (input.requiredStorageVersion === 2 && !fullStorage) {
-            throw new Error("local_memory_v2_state_invalid_before_commit");
-        }
-        // A V2 no-op is still a commit decision.  Return only after the access
-        // lock and committed-state writer gate have validated the same snapshot.
-        if (input.result.outcome !== "proposed")
-            return emptyResult();
         if (parseUnmarkedMemoryIndex(memory).length > 0)
             throw new Error("local_memory_legacy_index_requires_migration");
         let entries = [...parseLocalMemoryIndex(memory)];
@@ -457,26 +342,6 @@ export async function applyLocalMemoryResult(input) {
         const pendingCandidates = [];
         const resolvedPendingIds = new Set();
         const noteUpdates = new Map();
-        const noteCache = new Map();
-        let totalReadBytes = Buffer.byteLength(memory, "utf8");
-        const readStoredNote = async (path) => {
-            const cached = noteUpdates.get(path) ?? noteCache.get(path);
-            if (cached !== undefined)
-                return cached;
-            const stat = await lstat(path).catch((error) => {
-                if (error.code === "ENOENT")
-                    return null;
-                throw error;
-            });
-            if (stat !== null && totalReadBytes + stat.size > LOCAL_MEMORY_READ_BYTE_CAP)
-                throw new Error("local_memory_read_byte_limit");
-            const content = await readNote(path);
-            totalReadBytes += Buffer.byteLength(content, "utf8");
-            if (totalReadBytes > LOCAL_MEMORY_READ_BYTE_CAP)
-                throw new Error("local_memory_read_byte_limit");
-            noteCache.set(path, content);
-            return content;
-        };
         let allowActiveEviction = false;
         const randomId = input.randomId ?? randomUUID;
         const executionId = input.executionId ?? "unknown";
@@ -518,21 +383,10 @@ export async function applyLocalMemoryResult(input) {
                 if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
                     throw new Error("local_memory_duplicate_candidate");
                 }
-                if (existingCreate === undefined && entries.some((entry) => (!fullStorage || entry.status === "active" || entry.status === "pinned")
-                    && (normalize(entry.title) === normalize(change.title) || normalize(entry.summary) === normalize(change.summary)))) {
+                if (existingCreate === undefined && entries.some((entry) => normalize(entry.title) === normalize(change.title)
+                    || normalize(entry.summary) === normalize(change.summary))) {
                     throw new Error("local_memory_duplicate_candidate");
                 }
-                if (existingCreate !== undefined) {
-                    if (existingCreate.revision !== 1 || existingCreate.status !== "active") {
-                        throw new Error("local_memory_create_replay_conflict");
-                    }
-                    const stored = await readStoredNote(resolve(input.agentDir, existingCreate.file));
-                    if (uniqueNoteSection(stored, id)?.trimEnd() !== noteSection(id, 1, change.title, change.detailBody).trimEnd()) {
-                        throw new Error("local_memory_create_replay_conflict");
-                    }
-                    // A proven duplicate is a no-op; it must never rewrite a newer body or status.
-                    continue;
-                }
             }
             const revision = existingCreate?.revision ?? (current === undefined ? 1 : current.revision + 1);
             const entry = existingCreate ?? entryFromChange(change, id, revision, current?.status ?? "active");
@@ -546,7 +400,7 @@ export async function applyLocalMemoryResult(input) {
                             : item),
                         entry,
                     ];
-            const allowEvictionForChange = !fullStorage && change.operation === "create" && change.priority === "high";
+            const allowEvictionForChange = change.operation === "create" && change.priority === "high";
             const protectedIds = new Set(allowEvictionForChange ? pinnedIds(entries) : activeOrPinnedIds(entries));
             if (allowEvictionForChange)
                 allowActiveEviction = true;
@@ -563,7 +417,7 @@ export async function applyLocalMemoryResult(input) {
             const notePath = resolve(input.agentDir, entry.file);
             if (!isWithin(resolve(input.agentDir, "notes"), notePath))
                 throw new Error("local_memory_note_path_invalid");
-            const previous = await readStoredNote(notePath);
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
             const replacement = noteSection(id, revision, change.title, change.detailBody);
             const existingSection = replaceNote(previous, id, replacement);
             const next = existingSection ?? (current === undefined
@@ -581,7 +435,7 @@ export async function applyLocalMemoryResult(input) {
         // Pending create candidates are durable overflow, not dead ends. Promote only
         // when the current catalog has room; supersede/update candidates stay pending
         // until a fresh revision-aware decision can safely replay them.
-        const pendingCandidatesOnDisk = fullStorage ? [] : await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir }).catch((error) => {
             if (!(error instanceof Error) || error.message !== "memory_pending_directory_over_budget")
                 throw error;
             // 自动提升是可选工作，目录查询预算不应阻断本轮已验证的更新或腾位操作。
@@ -592,10 +446,6 @@ export async function applyLocalMemoryResult(input) {
             return [];
         });
         for (const pending of pendingCandidatesOnDisk) {
-            // Migration-deferred candidates require reviewed import; only capacity
-            // overflow is eligible for the existing automatic promotion path.
-            if (pending.reason !== "index_over_budget")
-                continue;
             const change = pending.candidate;
             if (change.operation !== "create")
                 continue;
@@ -610,7 +460,7 @@ export async function applyLocalMemoryResult(input) {
                     || normalize(entry.summary) === normalize(change.summary)));
             if (duplicate !== undefined) {
                 const duplicatePath = resolve(input.agentDir, duplicate.file);
-                const duplicateBody = readNoteBody(await readStoredNote(duplicatePath), duplicate.id);
+                const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
                 if (duplicateBody === change.detailBody
                     || duplicateBody === unwrappedNoteBody(change.title, change.detailBody).trim()) {
                     resolvedPendingIds.add(pending.pendingId);
@@ -628,7 +478,7 @@ export async function applyLocalMemoryResult(input) {
             const notePath = resolve(input.agentDir, entry.file);
             if (!isWithin(resolve(input.agentDir, "notes"), notePath))
                 throw new Error("local_memory_note_path_invalid");
-            const previous = await readStoredNote(notePath);
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
             const replacement = noteSection(id, 1, change.title, change.detailBody);
             const existingSection = replaceNote(previous, id, replacement);
             const next = existingSection ?? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`;
@@ -637,17 +487,6 @@ export async function applyLocalMemoryResult(input) {
             createdIds.push(id);
             resolvedPendingIds.add(pending.pendingId);
         }
-        if (fullStorage) {
-            const changedMetadataIds = new Set([
-                ...statusChangedIds,
-                ...input.result.changes.flatMap(change => change.supersedesMemoryId === null ? [] : [change.supersedesMemoryId]),
-            ]);
-            for (const id of changedMetadataIds) {
-                const entry = entries.find(item => item.id === id);
-                const notePath = resolve(input.agentDir, entry.file);
-                noteUpdates.set(notePath, updateNoteRevision(await readStoredNote(notePath), id, entry.revision));
-            }
-        }
         let finalProjection = projectIndex(memory, entries, allowActiveEviction ? pinnedIds(entries) : activeOrPinnedIds(entries));
         if (finalProjection.reason !== null
             && (!allowActiveEviction || finalProjection.reason === "index_over_budget_pinned")) {
@@ -659,7 +498,7 @@ export async function applyLocalMemoryResult(input) {
                 .filter((entry) => entry?.status === "active");
             for (const entry of omittedActiveEntries) {
                 const notePath = resolve(input.agentDir, entry.file);
-                const content = await readStoredNote(notePath);
+                const content = noteUpdates.get(notePath) ?? await readNote(notePath);
                 const detailBody = readNoteBody(content, entry.id);
                 const change = detailBody === null ? null : archivedChange(entry, detailBody);
                 if (change === null)
@@ -680,13 +519,6 @@ export async function applyLocalMemoryResult(input) {
             if (finalProjection.reason !== null)
                 throw new Error(finalProjection.reason);
         }
-        // Complete every resource check before the first persistent write.
-        assertLocalMemoryStorageSize(finalProjection.memory);
-        for (const content of noteUpdates.values()) {
-            if (Buffer.byteLength(content, "utf8") > LOCAL_MEMORY_NOTE_BYTE_CAP)
-                throw new Error("local_memory_note_byte_limit");
-        }
-        await assertMemoryInventoryHealth(input.agentDir);
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
@@ -703,5 +535,5 @@ export async function applyLocalMemoryResult(input) {
             deferredIds,
             pendingIds: deferredIds,
         };
-    }));
+    });
 }