@nowcrew/daemon 0.6.93-beta.6 → 0.6.93

package/dist/agent-environment-execution.js

@@ -86,8 +86,13 @@ export async function prepareEnvironmentExecutionSnapshot(input) {
             directory,
             prompt: `## Per-directory environment configuration\nThis execution uses environment revision ${parsed.data.revision}. `
                 + `Directory layers are independent: Agent root is inherited by training and each repo; sibling repos do not inherit each other. `
-                + `When running a command in a training or repository directory, use the immutable environment harness: `
-                + `\`node ${JSON.stringify(join(directory, "run.mjs"))} --cwd <absolute-directory> -- <command> [arguments...]\`. `
+                + `The runtime starts in the task directory \`$CREW_TASK_DIR\`, which uses Agent-root variables. `
+                + `Training variables are available only when the harness \`--cwd\` points to \`$QA_RUNTIME_ROOT\` (the training directory); `
+                + `do not pass \`$PWD\` unless it is that directory. For a training command, use: `
+                + `\`node ${JSON.stringify(join(directory, "run.mjs"))} --cwd \"$QA_RUNTIME_ROOT\" -- <command> [arguments...]\`. `
+                + `For a repository command, pass that repository's absolute root to \`--cwd\`. `
+                + `Keep task outputs under \`$CREW_TASK_DIR\` and pass absolute values such as \`$CREW_TASK_DIR/outputs\` to --report-root, --output-dir, and --runtime-dir; `
+                + `do not let changing the harness cwd relocate task outputs. `
                 + `Changing directory alone does not reload process variables. Do not source mutable .env files or print environment values.`,
         };
     }

package/dist/cloud-report-upload.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir, hostname, platform } from "node:os";
+import { join } from "node:path";
 const ALIYUN_MARKER = /alibaba|aliyun|alicloud/iu;
 function readMarker(path) {
     try {
@@ -28,7 +29,15 @@ export function detectCloudProvider(env = process.env, platformName = platform()
 }
 export function findOssUploadScript(env = process.env, exists = existsSync) {
     const explicit = env.CREW_OSS_UPLOAD_SCRIPT?.trim();
-    return explicit && exists(explicit) ? explicit : undefined;
+    if (explicit)
+        return exists(explicit) ? explicit : undefined;
+    const home = env.HOME?.trim() || homedir();
+    const candidates = [
+        join(home, ".claude", "skills", "oss-upload", "scripts", "oss_upload.py"),
+        join(home, ".codex", "skills", "oss-upload", "scripts", "oss_upload.py"),
+        join(home, ".agents", "skills", "oss-upload", "scripts", "oss_upload.py"),
+    ];
+    return candidates.find(exists);
 }
 export function cloudReportUploadFacts(env = process.env, platformName = platform(), hostName = hostname(), readMarkerValue, exists) {
     const provider = detectCloudProvider(env, platformName, hostName, readMarkerValue);

package/dist/execution-journal.js

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

package/dist/execution-protocol.js

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

package/dist/execution-runner.js

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

package/dist/local-execution-prompt.js

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

package/dist/local-executor.js

@@ -6,7 +6,7 @@ import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
-import { rotateAgentSession, safeKey, } from "./workspace.js";
+import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
@@ -39,18 +39,13 @@ 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, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, } from "./local-memory/runtime.js";
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
-import { reportLocalMemoryV2Deferred } from "./local-memory/rollout.js";
-import { prepareExecutionMemoryWorkspace } from "./local-memory/execution-workspace.js";
+import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
 import { localMemoryV2Environment } from "./config.js";
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
-import { MEMORY_STATE_GUARD_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY } from "./memory-migration-protocol.js";
-import { resolveLocalMemoryWriterMode } from "./local-memory/writer-mode.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -64,6 +59,7 @@ 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) {
@@ -215,12 +211,37 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             : "high"
         : runtime.reasoning;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    const preparedMemory = await prepareExecutionMemoryWorkspace(input, isolatedMaintenance, dependencies.cancellation);
-    let workspace = preparedMemory.workspace;
-    const memoryRollout = preparedMemory.mode;
+    let workspace;
+    try {
+        workspace = await awaitWithCancellation(prepareWorkspace({
+            agentsRoot: input.launch.agentsRoot,
+            handle: input.handle,
+            cliPath: input.launch.cliPath,
+            executionId: input.executionId,
+            ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+            ...(input.sessionContextFingerprint === undefined
+                ? {}
+                : { sessionContextFingerprint: input.sessionContextFingerprint }),
+            ...(input.launch.description ? { description: input.launch.description } : {}),
+            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
+        }), dependencies.cancellation);
+    }
+    catch (error) {
+        logLocalMemoryContextPrepareFailure({
+            executionId: input.executionId,
+            agentHandle: input.handle,
+            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        }, "workspace_prepare", error);
+        throw error;
+    }
+    const memoryRollout = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle,
+        serverUrl: input.launch.serverUrl, requested: input.localMemoryV2Enabled === true,
+        selfTraining: isolatedMaintenance, ...(input.launch.description ? { description: input.launch.description } : {}) });
+    workspace = { ...workspace, localMemoryV2Enabled: memoryRollout.enabled };
     input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
-    const localMemoryV2Initialized = preparedMemory.initialized;
-    let localMemoryWriterMode = resolveLocalMemoryWriterMode(workspace, memoryRollout);
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, memoryRollout.enabled);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -370,16 +391,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         let baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = isolatedMaintenance ? null : parseMemoryPruneTraceId(baseWakePrompt);
         if (memoryRollout.deferred)
-            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune", memoryRollout.legacyFallback, memoryRollout.failure);
-        localMemoryWriterMode = resolveLocalMemoryWriterMode(executionWorkspace, memoryRollout);
-        if (memoryPruneTraceId !== null && localMemoryWriterMode === "blocked")
-            throw new Error(memoryRollout.failure === "inspection_failed" ? "local_memory_inspection_failed" : "local_memory_v2_requires_migration");
+            reportLocalMemoryV2Deferred(input.executionId, input.handle, memoryPruneTraceId !== null || input.maintenancePurpose === "memory_prune");
         if (memoryPruneTraceId !== null) {
             executionWorkspace = await resolveMemoryPruneWorkLog(executionWorkspace, input);
             promptContext = { ...promptContext, workspace: executionWorkspace };
             baseWakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         }
-        if (localMemoryWriterMode === "v2" && memoryPruneTraceId !== null
+        if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
                 enabledForHandle: true,
                 agentHomePreexisted: workspace.agentHomePreexisted === true,
@@ -393,11 +411,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             agentDir: executionWorkspace.dir, executionId: input.executionId, agentHandle: input.handle,
             enabled: input.localMemoryV2Enabled === true, query: baseWakePrompt,
             resultPath: localMemoryResultPath, maxBytes: input.maxSystemPromptBytes,
-            storageVersion: detectLocalMemoryStorageVersion(executionWorkspace.memory),
-            strictRollout: !isolatedMaintenance && !memoryRollout.legacyFallback && (localMemoryV2Environment(input.launch.serverUrl) === "dev"
-                || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
+            strictRollout: !isolatedMaintenance && localMemoryV2Environment(input.launch.serverUrl) === "dev",
             deferred: memoryRollout.deferred,
-            ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -899,10 +914,6 @@ 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,
-                } : {}),
             });
             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") {
@@ -916,33 +927,6 @@ 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");
-                }
-                const boundedIds = (ids) => ({
-                    value: (ids ?? []).slice(0, 100).join(","),
-                    count: ids?.length ?? 0,
-                    truncated: (ids?.length ?? 0) > 100,
-                });
-                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.handle, prune_trace_id: memoryPruneTraceId,
-                    storage_version_before: committed.storageVersionBefore,
-                    storage_version_after: committed.storageVersionAfter,
-                    committed_state: committed.committedState,
-                    writer_mode: 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,
-                });
-            }
             memoryPruneFailurePhase = "runtime_finalize";
         }
         const errorTail = [
@@ -1066,23 +1050,6 @@ 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/index-budget.js

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

package/dist/local-memory/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 = "只读记忆盘点、schema0/1 转换预演与 schema2 完整性校验，不写文件，不支持 --apply。\n"
+const USAGE = "只读记忆盘点与转换预演，不写文件，不支持 --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,55 +24,19 @@ export async function runMemoryInventoryCommand(args, io) {
     try {
         const scan = await scanMemorySources(command["agent-dir"]);
         const scanComplete = scan.issues.length === 0;
-        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 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 reportSources = v2?.stateSource ? [...scan.sources, v2.stateSource] : scan.sources;
-        const files = reportSources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
-        const orphanNotes = files.filter((file) => file.path.startsWith("notes/") && !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 files = scan.sources.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 }));
         const report = {
             schemaVersion: 1, mode: "dry-run", agentDir: scan.root, applySupported: false,
             complete, scanComplete, requiresHumanReview: true,
-            // 只读派生观测，不改变资格判断，也不新增持久化状态。
-            // 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"],
+            coverage: ["MEMORY.md", "notes/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
             limitations: ["不扫描历史执行目录；result清单仅覆盖Agent根目录。", "两遍摘要比对不等同跨文件原子快照，正式迁移仍需停止写入并重新核对。"],
-            limits: inventoryLimits, totalBytes: reportSources.reduce((total, source) => total + source.bytes, 0), files, ...analysis, issues,
+            limits: inventoryLimits, totalBytes: scan.totalBytes, files, ...analysis, issues,
             pending: files.filter((file) => file.path.startsWith(".crew/memory/pending/")).map((file) => file.path),
-            orphanNotes,
+            orphanNotes: files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path),
             resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
         };
         io.out(JSON.stringify(report, null, 2) + "\n");
@@ -95,5 +59,3 @@ 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";

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

@@ -73,8 +73,7 @@ export async function readMemoryInventorySource(root, file, budget) {
         await handle.close();
     }
 }
-export async function scanMemorySources(agentDir, options = {}) {
-    const includeOperationalFiles = options.includeOperationalFiles ?? true;
+export async function scanMemorySources(agentDir) {
     const root = await realpath(agentDir);
     if ((await lstat(agentDir)).isSymbolicLink())
         throw new Error("agent_root_symlink");
@@ -125,14 +124,10 @@ export async function scanMemorySources(agentDir, options = {}) {
     }
     await visit("MEMORY.md");
     await visit("notes", true);
-    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);
-    }
+    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);
     // 第二遍比对摘要和目录清单，发现扫描期间的变化就拒绝完整性结论；这不是跨文件事务锁。
     for (const source of sources) {
         try {
@@ -155,11 +150,9 @@ export async function scanMemorySources(agentDir, options = {}) {
                 addIssue("source_changed", file);
         }
     }
-    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");
-    }
+    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 };

package/dist/local-memory/prompt.js

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