@nowcrew/daemon 0.6.98 → 0.6.99-beta.1

package/dist/local-executor.js

@@ -6,7 +6,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
-import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
+import { rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
@@ -39,13 +39,20 @@ import { projectSkillRuntimeDirectories, } from "./project-skills/runtime-launch
 import { logIdentityRosterRuntimePrepared } from "./identity-roster-telemetry.js";
 import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, logMemoryPruneDiagnosticsFailure, memoryPruneSnapshotFields, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
+import { LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS } from "./local-memory-diagnostics.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { logRuntimeEnvironmentContract } from "./runtime-environment-telemetry.js";
-import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { commitLocalMemoryResultAfterExit, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
-import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
+import { reportLocalMemoryV2Deferred } from "./local-memory/rollout.js";
+import { prepareExecutionMemoryWorkspace } from "./local-memory/execution-workspace.js";
 import { localMemoryV2Environment } from "./config.js";
+import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
+import { MEMORY_STATE_GUARD_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY } from "./memory-migration-protocol.js";
+import { resolveLocalMemoryWriterMode } from "./local-memory/writer-mode.js";
+import { logLocalMemoryCommitApplied } from "./local-memory/commit-telemetry.js";
+import { shouldUseMigrationDeferredPending } from "./local-memory/migration-pending.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -59,7 +66,6 @@ const STDERR_TAIL_CAP = 2_000;
 // the old failure mode where a callback could hold execution slots forever.
 const RUNTIME_RUNNING_CALLBACK_TIMEOUT_MS = 30_000;
 const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
-const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
 const CODEX_COLLABORATION_EXEC_WARNING = "codex_collaboration_disabled_on_exec";
 function withoutClaudeInstructionFlag(env) {
@@ -211,37 +217,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : "high"
         : runtime.reasoning;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    let workspace;
-    try {
-        workspace = await awaitWithCancellation(prepareWorkspace({
-            agentsRoot: input.launch.agentsRoot,
-            handle: input.handle,
-            cliPath: input.launch.cliPath,
-            executionId: input.executionId,
-            ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-            ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-            ...(input.sessionContextFingerprint === undefined
-                ? {}
-                : { sessionContextFingerprint: input.sessionContextFingerprint }),
-            ...(input.launch.description ? { description: input.launch.description } : {}),
-            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
-        }), dependencies.cancellation);
-    }
-    catch (error) {
-        logLocalMemoryContextPrepareFailure({
-            executionId: input.executionId,
-            agentHandle: input.handle,
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-        }, "workspace_prepare", error);
-        throw error;
-    }
-    const memoryRollout = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle,
-        serverUrl: input.launch.serverUrl, requested: input.localMemoryV2Enabled === true,
-        selfTraining: isolatedMaintenance, ...(input.launch.description ? { description: input.launch.description } : {}) });
-    workspace = { ...workspace, localMemoryV2Enabled: memoryRollout.enabled };
+    const preparedMemory = await prepareExecutionMemoryWorkspace(input, isolatedMaintenance, dependencies.cancellation);
+    let workspace = preparedMemory.workspace;
+    const memoryRollout = preparedMemory.mode;
     input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
-    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
+    const localMemoryV2Initialized = preparedMemory.initialized;
+    let localMemoryWriterMode = resolveLocalMemoryWriterMode(workspace, memoryRollout);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -252,6 +233,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
     let localMemoryResultPath = null;
+    let migrationDeferredPending = false;
     let environmentSnapshot;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
@@ -390,29 +372,41 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         let baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = isolatedMaintenance ? null : parseMemoryPruneTraceId(baseWakePrompt);
-        if (memoryRollout.deferred)
-            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune");
+        localMemoryWriterMode = resolveLocalMemoryWriterMode(executionWorkspace, memoryRollout);
+        migrationDeferredPending = shouldUseMigrationDeferredPending({ pruneTraceId: memoryPruneTraceId,
+            writerMode: localMemoryWriterMode, rolloutEnabled: memoryRollout.enabled,
+            legacyFallback: memoryRollout.legacyFallback,
+            failure: memoryRollout.failure, memory: executionWorkspace.memory });
+        if (memoryRollout.deferred || migrationDeferredPending)
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune", memoryRollout.legacyFallback, memoryRollout.failure, migrationDeferredPending);
+        if (memoryPruneTraceId !== null && localMemoryWriterMode === "blocked" && !migrationDeferredPending) {
+            throw new Error(memoryRollout.failure === "inspection_failed" ? "local_memory_inspection_failed" : "local_memory_v2_requires_migration");
+        }
         if (memoryPruneTraceId !== null) {
             executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
             promptContext = { ...promptContext, workspace: executionWorkspace };
             baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         }
-        if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
+        if ((localMemoryWriterMode === "v2" && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
                 agentHomePreexisted: workspace.agentHomePreexisted === true,
                 memorySeedCreated: executionWorkspace.memorySeedCreated === true && (localMemoryV2Initialized || workspace.localMemoryV2Initialized !== false),
                 localMemoryV2Initialized,
                 memoryPrune: true,
-            })) {
+            })) || migrationDeferredPending) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
         const memoryPrompt = await prepareLocalMemoryPrompt({
             agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
             enabled: input.localMemoryV2Enabled === true, query: baseWakePrompt,
             resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
-            strictRollout: !isolatedMaintenance && localMemoryV2Environment(input.launch.serverUrl) === "dev",
+            storageVersion: detectLocalMemoryStorageVersion(executionWorkspace.memory),
+            strictRollout: !isolatedMaintenance && !memoryRollout.legacyFallback && (localMemoryV2Environment(input.launch.serverUrl) === "dev"
+                || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
             deferred: memoryRollout.deferred,
+            ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
+            ...(migrationDeferredPending ? { migrationDeferred: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -528,6 +522,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             localMemoryTelemetry?.contextPrepared({
                 systemPrompt: effectiveSystemPrompt,
                 memory: executionWorkspace.memory,
+                memoryQuery: baseWakePrompt,
                 resumed: resuming,
                 ...(executionWorkspace.memorySeedCreated === undefined
                     ? {}
@@ -909,6 +904,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
                 expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
+                ...(localMemoryWriterMode === "v2" ? {
+                    writerCapabilities: [MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY],
+                    requiredStorageVersion: 2,
+                } : {}),
+                ...(migrationDeferredPending ? { migrationDeferredPending: true } : {}),
             });
             const committed = exitCode !== 0 ? await commit() : await withWorkLogCommit(workLogExecutionKey(input.launch.agentsRoot, input.handle, input.taskKey), commit, dependencies.cancellation);
             if (committed.status === "failed" || committed.status === "missing") {
@@ -922,6 +922,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 });
                 throw new Error(`local_memory_commit_failed: ${reason}`);
             }
+            if (committed.status === "applied") {
+                if (localMemoryWriterMode === "v2" && (committed.storageVersionBefore !== 2 || committed.storageVersionAfter !== 2
+                    || committed.committedState !== true)) {
+                    throw new Error("local_memory_commit_failed: local_memory_v2_commit_state_invalid");
+                }
+                logLocalMemoryCommitApplied({ executionId: input.executionId, agentHandle: input.handle,
+                    pruneTraceId: memoryPruneTraceId, committed });
+            }
             memoryPruneFailurePhase = "runtime_finalize";
         }
         const errorTail = [
@@ -1052,6 +1060,23 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                         after_incomplete_file_count: noteDiff.after_manifest.incomplete_file_count,
                         changes: serializedChanges.json,
                     });
+                    const pendingDiff = diffMemoryPruneNotes(memoryPruneBeforeSnapshot.pending_manifest
+                        ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }, snapshot.pending_manifest
+                        ?? { files: [], total_count: 0, omitted_count: 0, truncated: false });
+                    const serializedPendingChanges = boundedDiagnosticJsonArray(pendingDiff.changes);
+                    const pendingChangesTruncated = pendingDiff.truncated || serializedPendingChanges.truncated;
+                    dslog("memory_prune.pending_changed", "长期记忆 pending 候选变化已评估", {
+                        execution_id: input.executionId,
+                        agent_handle: input.handle,
+                        task_key: input.taskKey,
+                        prune_trace_id: memoryPruneTraceId,
+                        change_count: pendingDiff.change_count,
+                        changes_truncated: pendingChangesTruncated,
+                        evidence_complete: pendingDiff.evidence_complete && !pendingChangesTruncated,
+                        before_total_count: pendingDiff.before_manifest.total_count,
+                        after_total_count: pendingDiff.after_manifest.total_count,
+                        changes: serializedPendingChanges.json,
+                    });
                     const postcondition = evaluateMemoryPrunePostcondition(memoryPruneBeforeSnapshot, snapshot, {
                         executorCompleted: memoryPruneExecutorCompleted,
                         ...(memoryPruneRuntimeExitCode === undefined

package/dist/local-memory/commit-telemetry.js

@@ -0,0 +1,30 @@
+import { dslog } from "../slog.js";
+function boundedIds(ids) {
+    return {
+        value: (ids ?? []).slice(0, 100).join(","),
+        count: ids?.length ?? 0,
+        truncated: (ids?.length ?? 0) > 100,
+    };
+}
+export function logLocalMemoryCommitApplied(input) {
+    const { committed } = input;
+    const created = boundedIds(committed.createdIds);
+    const updated = boundedIds(committed.updatedIds);
+    const statusChanged = boundedIds(committed.statusChangedIds);
+    const pending = boundedIds(committed.pendingIds);
+    dslog("local_memory.commit_applied", "结构化本地记忆提交已验证", {
+        execution_id: input.executionId, agent_handle: input.agentHandle, prune_trace_id: input.pruneTraceId,
+        storage_version_before: committed.storageVersionBefore,
+        storage_version_after: committed.storageVersionAfter,
+        committed_state: committed.committedState,
+        writer_mode: committed.pendingReason === "legacy_requires_migration"
+            ? "pending_only"
+            : committed.storageVersionAfter === 2 && committed.committedState ? "v2" : "legacy",
+        created_id_count: created.count, created_ids: created.value, created_ids_truncated: created.truncated,
+        updated_id_count: updated.count, updated_ids: updated.value, updated_ids_truncated: updated.truncated,
+        status_changed_id_count: statusChanged.count, status_changed_ids: statusChanged.value,
+        status_changed_ids_truncated: statusChanged.truncated,
+        pending_id_count: pending.count, pending_ids: pending.value, pending_ids_truncated: pending.truncated,
+        pending_reason: committed.pendingReason,
+    });
+}

package/dist/local-memory/execution-workspace.js

@@ -0,0 +1,62 @@
+import { prepareWorkspace } from "../workspace.js";
+import { awaitWithCancellation } from "../runtime-cancellation.js";
+import { logLocalMemoryContextPrepareFailure } from "../local-memory-telemetry.js";
+import { resolveLocalMemoryV2Rollout } from "./rollout.js";
+import { initializeLocalMemoryV2ForWorkspace } from "./runtime.js";
+import { withMemoryAccess } from "./migration-access.js";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+// A fresh Agent may receive the daemon's full ten-wide execution burst.  The
+// first turn publishes schema2 durably; the remaining turns must wait to reuse
+// that committed fact instead of timing out on the generic short IO window.
+const EXECUTION_MEMORY_ACCESS_WAIT_MS = 30_000;
+export async function prepareExecutionMemoryWorkspace(input, isolated, cancellation) {
+    try {
+        const prepare = async (context) => {
+            const prepared = await prepareWorkspace({
+                agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
+                executionId: input.executionId,
+                ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+                ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
+                ...(input.launch.description ? { description: input.launch.description } : {}),
+                ...(isolated ? { skipLocalMemory: true } : {}),
+            });
+            const workspace = context?.created ? { ...prepared, agentHomePreexisted: false } : prepared;
+            const initialMode = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle, serverUrl: input.launch.serverUrl,
+                agentId: input.launch.agentId, requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
+                ...(input.launch.description ? { description: input.launch.description } : {}) });
+            const initializationBinding = input.launch.workspaceId !== undefined && input.launch.machineId !== undefined
+                ? { workspaceId: input.launch.workspaceId, machineId: input.launch.machineId }
+                : undefined;
+            const initialized = await initializeLocalMemoryV2ForWorkspace(workspace, initialMode.enabled, input.launch.agentId, initializationBinding);
+            const memory = initialized && !workspace.localMemoryV2Initialized
+                ? await readFile(join(workspace.dir, "MEMORY.md"), "utf8")
+                : workspace.memory;
+            const currentWorkspace = { ...workspace, memory };
+            const mode = initialized && !workspace.localMemoryV2Initialized
+                ? await resolveLocalMemoryV2Rollout({ workspace: currentWorkspace, handle: input.handle,
+                    serverUrl: input.launch.serverUrl, agentId: input.launch.agentId,
+                    requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
+                    ...(input.launch.description ? { description: input.launch.description } : {}) })
+                : initialMode;
+            return { workspace: { ...currentWorkspace, localMemoryV2Enabled: mode.enabled }, mode, initialized };
+        };
+        return await awaitWithCancellation(isolated ? prepare()
+            : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, {
+                create: true,
+                waitMs: EXECUTION_MEMORY_ACCESS_WAIT_MS,
+                initializedRecoveryIdentity: {
+                    agentId: input.launch.agentId,
+                    ...(input.launch.workspaceId === undefined ? {} : { workspaceId: input.launch.workspaceId }),
+                    ...(input.launch.machineId === undefined ? {} : { machineId: input.launch.machineId }),
+                },
+            }), cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", error);
+        throw error;
+    }
+}

package/dist/local-memory/full-index-search.js

@@ -0,0 +1,47 @@
+import { parseFullMemoryIndex, LOCAL_MEMORY_GENERATED_INDEX_PATTERN } from "./storage-format.js";
+const excerpt = (text, size) => Array.from(text).slice(0, size).join("");
+/** 查询完整元数据；只在明确的历史入口返回非有效记录。正文仍按引用和哈希分页读取。 */
+export function searchFullMemoryIndex(memory, sha256, input, outputBytes) {
+    const records = parseFullMemoryIndex(memory);
+    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory);
+    const prefix = memory.slice(0, block.index);
+    let line = (prefix.match(/\n/gu) ?? []).length + 1;
+    let offset = Array.from(prefix).length;
+    const positions = new Map();
+    for (const part of block[0].matchAll(/[^\n]*(?:\n|$)/gu)) {
+        const id = /^- id: ([A-Za-z0-9_-]+)\r?\n?$/u.exec(part[0])?.[1];
+        if (id)
+            positions.set(id, { line, offset });
+        line += 1;
+        offset += Array.from(part[0]).length;
+    }
+    const terms = input.query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+    const candidates = records.filter(entry => {
+        const active = entry.status === "active" || entry.status === "pinned";
+        const content = `${entry.id} ${entry.title} ${entry.summary} ${entry.triggers.join(" ")}`.normalize("NFKC").toLowerCase();
+        return active !== input.history && terms.every(term => content.includes(term));
+    });
+    const matches = [];
+    let bytes = 512, hasMore = false;
+    for (const entry of candidates) {
+        const position = positions.get(entry.id);
+        if (!position)
+            throw new Error("memory_storage_position_invalid");
+        if (position.line <= input.afterLine)
+            continue;
+        const item = { ...position, id: entry.id, status: entry.status, revision: entry.revision,
+            file: entry.file, anchor: entry.anchor, heading: excerpt(entry.title, 96),
+            title: excerpt(entry.title, 120), summary: excerpt(entry.summary, 240), text: excerpt(entry.summary, 240) };
+        const size = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+        if (matches.length >= input.limit || bytes + size > outputBytes) {
+            hasMore = true;
+            break;
+        }
+        matches.push(item);
+        bytes += size;
+    }
+    if (hasMore && matches.length === 0)
+        throw new Error("memory_output_too_large");
+    return { file: "MEMORY.md", storageVersion: 2, sha256, matches, matchCount: candidates.length,
+        hasMore, complete: !hasMore, nextAfterLine: hasMore ? matches.at(-1).line : null };
+}

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

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

package/dist/local-memory/initialization-identity.js

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+import { lstat, realpath } from "node:fs/promises";
+export const LEGACY_LOCAL_INITIALIZATION_IDENTITY = "local-initialized";
+export async function localMemoryInitializationIdentity(agentDir, agentId, binding) {
+    const root = await realpath(agentDir);
+    const rootFingerprint = createHash("sha256").update(root).digest("hex");
+    const workspaceId = binding?.workspaceId ?? LEGACY_LOCAL_INITIALIZATION_IDENTITY;
+    const machineId = binding?.machineId ?? LEGACY_LOCAL_INITIALIZATION_IDENTITY;
+    // Keep the legacy digest byte-for-byte stable so an interrupted pre-upgrade
+    // initialization can still be inspected. Every newly authenticated daemon
+    // initialization includes both control-plane identities in its operation id.
+    const operationSeed = workspaceId === LEGACY_LOCAL_INITIALIZATION_IDENTITY
+        && machineId === LEGACY_LOCAL_INITIALIZATION_IDENTITY
+        ? `${agentId}\0${root}`
+        : `${workspaceId}\0${machineId}\0${agentId}\0${root}`;
+    const operation = createHash("sha256").update(operationSeed, "utf8").digest("hex").slice(0, 24);
+    return {
+        workspaceId,
+        agentId,
+        migrationId: `initialize-${operation}`,
+        sourceStorageVersion: 0,
+        targetStorageVersion: 2,
+        rootFingerprint,
+        ownerIdentity: String((await lstat(root)).uid),
+        machineId,
+        executionId: `initialize-${operation}`,
+    };
+}
+export function isLegacyLocalMemoryInitializationIdentity(identity) {
+    return identity.workspaceId === LEGACY_LOCAL_INITIALIZATION_IDENTITY
+        && identity.machineId === LEGACY_LOCAL_INITIALIZATION_IDENTITY;
+}
+export function isLocalMemoryInitializationIdentity(actual, expected) {
+    return Object.keys(expected)
+        .every(key => actual[key] === expected[key]);
+}

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

@@ -2,9 +2,9 @@ const CommandSchema = z.object({
     "agent-dir": z.string().min(1).refine(isAbsolute),
     "dry-run": z.literal(true),
 }).strict();
-const USAGE = "只读记忆盘点与转换预演，不写文件，不支持 --apply。\n"
+const USAGE = "只读记忆盘点、schema0/1 转换预演与 schema2 完整性校验，不写文件，不支持 --apply。\n"
     + "pnpm --filter @nowcrew/daemon exec tsx src/local-memory/inventory-cli.ts --agent-dir <单个Agent绝对路径> --dry-run\n"
-    + "报告包含原始记忆，需作为敏感本地资料保存；退出码0仅代表盘点及格式预演无阻塞，不代表批准迁移。\n";
+    + "报告包含原始记忆，需作为敏感本地资料保存；退出码0仅代表盘点、格式预演或完整性校验无阻塞，不代表批准迁移。\n";
 export async function runMemoryInventoryCommand(args, io) {
     if (args.length === 1 && args[0] === "--help") {
         io.out(USAGE);
@@ -24,19 +24,60 @@ export async function runMemoryInventoryCommand(args, io) {
     try {
         const scan = await scanMemorySources(command["agent-dir"]);
         const scanComplete = scan.issues.length === 0;
-        const analysis = previewMemoryInventory(scan.sources, scanComplete);
+        const memory = scan.sources.find((source) => source.path === "MEMORY.md")?.content ?? "";
+        let storageVersion = null;
+        let detectionIssue = null;
+        try {
+            storageVersion = detectLocalMemoryStorageVersion(memory);
+        }
+        catch (error) {
+            detectionIssue = {
+                code: error instanceof Error && /^[a-z0-9_]+$/u.test(error.message)
+                    ? error.message
+                    : "local_memory_storage_version_invalid",
+                path: "MEMORY.md",
+            };
+        }
+        const v2 = storageVersion === 2
+            ? await inspectV2MemoryInventory(scan.root, scan.sources, scanComplete)
+            : null;
+        const analysis = detectionIssue
+            ? { entries: [], issues: [detectionIssue], preview: null, rawMemory: memory }
+            : v2?.analysis ?? previewMemoryInventory(scan.sources, scanComplete);
         const complete = scanComplete && !analysis.issues.some((issue) => issue.code === "missing_detail");
         const issues = [...scan.issues, ...analysis.issues];
-        const referenced = new Set(analysis.entries.map((entry) => entry.sourceFields.file));
-        const files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const referenced = new Set([
+            ...analysis.entries.map((entry) => entry.sourceFields.file),
+            ...(v2?.preservedSourcePaths ?? []),
+        ]);
+        const reportSources = v2?.stateSource ? [...scan.sources, v2.stateSource] : scan.sources;
+        const files = reportSources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
+        const deferredFiles = files.filter((file) => isDeferredMemoryArtifactPath(file.path)).map((file) => file.path);
+        const orphanNotes = files.filter((file) => file.path.startsWith("notes/") && !isDeferredMemoryArtifactPath(file.path) && !referenced.has(file.path)).map((file) => file.path);
+        const indexedEntries = analysis.entries.filter((entry) => entry.format === "managed").length;
+        const legacyEntries = analysis.entries.length - indexedEntries;
         const report = {
             schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
             complete, scanComplete, requiresHumanReview: true,
-            coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
+            // 只读派生观测，不改变资格判断，也不新增持久化状态。
+            // A dry-run does not create a shadow index or server state. Existing
+            // schema1 cards therefore remain legacy; indexedEntries is only coverage
+            // information, not proof that the Agent entered shadow mode.
+            storageMode: storageVersion === 2 ? (v2?.writeReady ? "v2_write" : "repair_required")
+                : detectionIssue ? "repair_required" : "legacy",
+            contextMode: storageVersion === 2 ? (v2?.writeReady ? "bounded_preview" : "blocked")
+                : detectionIssue ? "blocked" : "legacy_context",
+            readerMode: storageVersion === 2 ? "v2" : detectionIssue ? "blocked" : "legacy",
+            detectedIndexVersion: storageVersion,
+            migrationCoverage: { detectedIndexVersion: storageVersion, storageVersion, indexedEntries, legacyEntries, unindexedFiles: orphanNotes.length,
+                totalEntries: analysis.entries.length, complete },
+            coverage: ["MEMORY.md", "notes/**", ...(storageVersion === 2 ? [".crew/memory/migration.v1.json"] : []),
+                ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
             limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
-            limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
+            limits: inventoryLimits, totalBytes: reportSources.reduce((total, source) => total + source.bytes, 0), files, ...analysis, issues,
             pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
-            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
+            deferredFiles,
+            orphanNotes,
             resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
         };
         io.out(JSON.stringify(report, null, 2) + "\n");
@@ -59,3 +100,6 @@ import { parseArgs } from "node:util";
 import { z } from "zod";
 import { inventoryLimits, scanMemorySources } from "./inventory-source.js";
 import { previewMemoryInventory } from "./inventory-preview.js";
+import { inspectV2MemoryInventory } from "./inventory-v2.js";
+import { detectLocalMemoryStorageVersion } from "./storage-format.js";
+import { isDeferredMemoryArtifactPath } from "./source-path.js";

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

@@ -73,7 +73,8 @@ export async function readMemoryInventorySource(root, file, budget) {
         await handle.close();
     }
 }
-export async function scanMemorySources(agentDir) {
+export async function scanMemorySources(agentDir, options = {}) {
+    const includeOperationalFiles = options.includeOperationalFiles ?? true;
     const root = await realpath(agentDir);
     if ((await lstat(agentDir)).isSymbolicLink())
         throw new Error("agent_root_symlink");
@@ -124,10 +125,14 @@ export async function scanMemorySources(agentDir) {
     }
     await visit("MEMORY.md");
     await visit("notes", true);
-    await visit(".crew/memory/pending", true);
-    const resultNames = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
-    for (const name of resultNames)
-        await visit(name);
+    const resultNames = includeOperationalFiles
+        ? (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort()
+        : [];
+    if (includeOperationalFiles) {
+        await visit(".crew/memory/pending", true);
+        for (const name of resultNames)
+            await visit(name);
+    }
     // 第二遍比对摘要和目录清单，发现扫描期间的变化就拒绝完整性结论；这不是跨文件事务锁。
     for (const source of sources) {
         try {
@@ -150,9 +155,11 @@ export async function scanMemorySources(agentDir) {
                 addIssue("source_changed", file);
         }
     }
-    const currentResults = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
-    if (JSON.stringify(currentResults) !== JSON.stringify(resultNames))
-        addIssue("source_changed", ".memory-result.v1-*.json");
+    if (includeOperationalFiles) {
+        const currentResults = (await readdir(root)).filter((name) => /^\.memory-result\.v1-.*\.json$/u.test(name)).sort();
+        if (JSON.stringify(currentResults) !== JSON.stringify(resultNames))
+            addIssue("source_changed", ".memory-result.v1-*.json");
+    }
     if (await realpath(agentDir) !== root)
         addIssue("source_changed", "agent_root");
     return { root, sources: sources.sort((a, b) => a.path.localeCompare(b.path)), issues, totalBytes };