@nowcrew/daemon 0.6.93-beta.1 → 0.6.93-beta.10

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,6 +1,5 @@
 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 {
@@ -29,15 +28,7 @@ export function detectCloudProvider(env = process.env, platformName = platform()
 }
 export function findOssUploadScript(env = process.env, exists = existsSync) {
     const explicit = env.CREW_OSS_UPLOAD_SCRIPT?.trim();
-    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);
+    return explicit && exists(explicit) ? explicit : undefined;
 }
 export function cloudReportUploadFacts(env = process.env, platformName = platform(), hostName = hostname(), readMarkerValue, exists) {
     const provider = detectCloudProvider(env, platformName, hostName, readMarkerValue);

package/dist/execution-runner.js

@@ -881,6 +881,7 @@ 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-executor.js

@@ -39,6 +39,7 @@ 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";
@@ -49,6 +50,9 @@ import { prepareExecutionMemoryWorkspace } from "./local-memory/execution-worksp
 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`);
@@ -62,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) {
@@ -219,6 +222,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     const memoryRollout = preparedMemory.mode;
     input = { ...input, localMemoryV2Enabled: memoryRollout.enabled };
     const localMemoryV2Initialized = preparedMemory.initialized;
+    let localMemoryWriterMode = resolveLocalMemoryWriterMode(workspace, memoryRollout);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -229,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;
@@ -367,21 +372,29 @@ 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", memoryRollout.legacyFallback);
+        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({
@@ -393,6 +406,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 || detectLocalMemoryStorageVersion(executionWorkspace.memory) === 2),
             deferred: memoryRollout.deferred,
             ...(memoryRollout.legacyFallback ? { legacyFallback: true } : {}),
+            ...(migrationDeferredPending ? { migrationDeferred: true } : {}),
             renderBase: (reservedPromptBytes) => resolvePrompt(input.systemPrompt, { ...promptContext, reservedPromptBytes }),
         });
         localMemoryResultPath = memoryPrompt.resultPath;
@@ -894,10 +908,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 exitCode,
                 workLogPath: executionWorkspace.workLogPath,
                 expectedWorkLogSha256: workLogSha256(executionWorkspace.workLog),
-                ...(input.localMemoryV2Enabled === true ? {
+                ...(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") {
@@ -912,32 +927,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 throw new Error(`local_memory_commit_failed: ${reason}`);
             }
             if (committed.status === "applied") {
-                if (input.localMemoryV2Enabled === true
-                    && (committed.storageVersionBefore !== 2 || committed.storageVersionAfter !== 2
-                        || committed.committedState !== true)) {
+                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,
-                });
+                logLocalMemoryCommitApplied({ executionId: input.executionId, agentHandle: input.handle,
+                    pruneTraceId: memoryPruneTraceId, committed });
             }
             memoryPruneFailurePhase = "runtime_finalize";
         }

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

@@ -27,7 +27,10 @@ export async function prepareExecutionMemoryWorkspace(input, isolated, cancellat
             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 initialized = await initializeLocalMemoryV2ForWorkspace(workspace, initialMode.enabled, input.launch.agentId);
+            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;
@@ -44,7 +47,11 @@ export async function prepareExecutionMemoryWorkspace(input, isolated, cancellat
             : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, {
                 create: true,
                 waitMs: EXECUTION_MEMORY_ACCESS_WAIT_MS,
-                initializedRecoveryAgentId: input.launch.agentId,
+                initializedRecoveryIdentity: {
+                    agentId: input.launch.agentId,
+                    ...(input.launch.workspaceId === undefined ? {} : { workspaceId: input.launch.workspaceId }),
+                    ...(input.launch.machineId === undefined ? {} : { machineId: input.launch.machineId }),
+                },
             }), cancellation);
     }
     catch (error) {

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

@@ -1,22 +1,35 @@
 import { createHash } from "node:crypto";
 import { lstat, realpath } from "node:fs/promises";
-const INITIALIZED_IDENTITY = "local-initialized";
-export async function localMemoryInitializationIdentity(agentDir, agentId) {
+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 operation = createHash("sha256").update(`${agentId}\0${root}`, "utf8").digest("hex").slice(0, 24);
+    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: INITIALIZED_IDENTITY,
+        workspaceId,
         agentId,
         migrationId: `initialize-${operation}`,
         sourceStorageVersion: 0,
         targetStorageVersion: 2,
         rootFingerprint,
         ownerIdentity: String((await lstat(root)).uid),
-        machineId: INITIALIZED_IDENTITY,
+        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,20 +24,32 @@ 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 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 storageVersion = (() => {
-            try {
-                return detectLocalMemoryStorageVersion(scan.sources.find((source) => source.path === "MEMORY.md")?.content ?? "");
-            }
-            catch {
-                return null;
-            }
-        })();
         const indexedEntries = analysis.entries.filter((entry) => entry.format === "managed").length;
         const legacyEntries = analysis.entries.length - indexedEntries;
         const report = {
@@ -47,15 +59,18 @@ export async function runMemoryInventoryCommand(args, io) {
             // 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_write" : "legacy",
-            contextMode: storageVersion === 2 ? "bounded_preview" : "legacy_context",
-            readerMode: storageVersion === 2 ? "v2" : "legacy",
+            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/**", ".crew/memory/pending/**", "根目录的 .memory-result.v1-*.json"],
+            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,
             resultFiles: files.filter((file) => file.path.startsWith(".memory-result.v1-")).map((file) => file.path),
@@ -80,4 +95,5 @@ 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-v2.js

@@ -0,0 +1,282 @@
+import { createHash } from "node:crypto";
+import { lstat, realpath } from "node:fs/promises";
+import { renderLocalMemoryIndexCard } from "./index-budget.js";
+import { inventoryLimits, readMemoryInventorySource } from "./inventory-source.js";
+import { MigrationStateSchema } from "./migration-schema.js";
+import { assertMigrationStateIntegrity } from "./migration-state-invariants.js";
+import { parseFullMemoryIndex, selectLocalMemoryPreview } from "./storage-format.js";
+const STATE_PATH = ".crew/memory/migration.v1.json";
+const DETAIL_MARKER_PATTERN = /<!--\s*NOWWORK:MEMORY_ENTRY:(?:BEGIN\s+id=([A-Za-z0-9_-]+)\s+revision=([1-9][0-9]*)|END\s+id=([A-Za-z0-9_-]+))\s*-->/gu;
+const CONTROL_MARKER_PATTERN = /NOWWORK:MEMORY_(?:ENTRY|INDEX):/u;
+function errorCode(error, fallback) {
+    if (error instanceof Error && /^[a-z0-9_]+$/u.test(error.message))
+        return error.message;
+    return fallback;
+}
+function sourceFields(entry) {
+    return {
+        id: entry.id,
+        file: entry.file,
+        type: entry.type,
+        status: entry.status,
+        summary: entry.summary,
+        triggers: entry.triggers.join(", "),
+        priority: entry.priority,
+        revision: String(entry.revision),
+        anchor: entry.anchor ?? "",
+        updated: entry.updated,
+        ...(entry.reviewAfter === null ? {} : { review_after: entry.reviewAfter }),
+    };
+}
+function harmlessDetailRemainder(text) {
+    let cursor = 0;
+    let lineStart = true;
+    const whitespace = /\s+/uy;
+    while (cursor < text.length) {
+        whitespace.lastIndex = cursor;
+        const spacing = whitespace.exec(text);
+        if (spacing !== null) {
+            const lastNewline = spacing[0].lastIndexOf("\n");
+            lineStart = lastNewline === spacing[0].length - 1;
+            cursor = whitespace.lastIndex;
+            continue;
+        }
+        if (text.startsWith("<!--", cursor)) {
+            const end = text.indexOf("-->", cursor + 4);
+            if (end === -1)
+                return false;
+            cursor = end + 3;
+            continue;
+        }
+        if (lineStart && text[cursor] === "#") {
+            const end = text.indexOf("\n", cursor + 1);
+            if (end === -1)
+                return true;
+            cursor = end + 1;
+            lineStart = true;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+export function* scanManagedDetailMarkers(detail) {
+    for (const marker of detail.matchAll(DETAIL_MARKER_PATTERN)) {
+        const beginId = marker[1];
+        yield {
+            start: marker.index,
+            end: marker.index + marker[0].length,
+            kind: beginId === undefined ? "end" : "begin",
+            id: beginId ?? marker[3],
+            revision: beginId === undefined ? null : Number(marker[2]),
+        };
+    }
+}
+/** Parse one note once, then let every index entry use constant-time lookups. */
+export function analyzeManagedDetailFile(detail, expectedIds, scan = scanManagedDetailMarkers) {
+    const revisionsById = new Map();
+    const remainder = [];
+    let cursor = 0;
+    let markerInvalid = false;
+    let unindexed = false;
+    let open = null;
+    for (const marker of scan(detail)) {
+        const between = detail.slice(cursor, marker.start);
+        if (CONTROL_MARKER_PATTERN.test(between))
+            markerInvalid = true;
+        if (open === null)
+            remainder.push(between);
+        cursor = marker.end;
+        if (marker.kind === "begin") {
+            if (open !== null || marker.revision === null)
+                markerInvalid = true;
+            else
+                open = { id: marker.id, revision: marker.revision };
+            continue;
+        }
+        if (open === null || marker.id !== open.id) {
+            markerInvalid = true;
+            continue;
+        }
+        const revisions = revisionsById.get(open.id) ?? [];
+        revisions.push(open.revision);
+        revisionsById.set(open.id, revisions);
+        if (!expectedIds.has(open.id))
+            unindexed = true;
+        open = null;
+    }
+    const tail = detail.slice(cursor);
+    if (CONTROL_MARKER_PATTERN.test(tail) || open !== null)
+        markerInvalid = true;
+    if (open === null)
+        remainder.push(tail);
+    const uncovered = remainder.join("");
+    const coverageIssue = markerInvalid
+        ? "managed_anchor_invalid"
+        : unindexed
+            ? "unindexed_detail"
+            : harmlessDetailRemainder(uncovered)
+                ? null
+                : "unindexed_text_requires_mapping";
+    return { revisionsById, coverageIssue };
+}
+function inspectDetailEntry(entry, analysis) {
+    if (analysis === undefined)
+        return "missing_detail";
+    if (analysis.coverageIssue === "managed_anchor_invalid")
+        return "managed_anchor_invalid";
+    const revisions = analysis.revisionsById.get(entry.id) ?? [];
+    if (revisions.length !== 1)
+        return "managed_anchor_invalid";
+    return revisions[0] > entry.revision ? "managed_revision_invalid" : null;
+}
+export function inspectManagedDetailFiles(entries, sources, analyze = analyzeManagedDetailFile) {
+    const sourceMap = new Map(sources.map(source => [source.path, source]));
+    const expectedByFile = new Map();
+    for (const entry of entries) {
+        const expected = expectedByFile.get(entry.file) ?? new Set();
+        expected.add(entry.id);
+        expectedByFile.set(entry.file, expected);
+    }
+    const paths = new Set([
+        ...expectedByFile.keys(),
+        ...sources.filter(source => source.path.startsWith("notes/")).map(source => source.path),
+    ]);
+    const analyses = new Map();
+    const fileIssues = [];
+    for (const path of paths) {
+        const source = sourceMap.get(path);
+        if (source === undefined)
+            continue;
+        const analysis = analyze(source.content, expectedByFile.get(path) ?? new Set());
+        analyses.set(path, analysis);
+        if (analysis.coverageIssue !== null)
+            fileIssues.push({ code: analysis.coverageIssue, path });
+    }
+    const entryIssues = new Map();
+    for (const entry of entries) {
+        const issue = inspectDetailEntry(entry, analyses.get(entry.file));
+        if (issue !== null)
+            entryIssues.set(entry.id, issue);
+    }
+    return { entryIssues, fileIssues };
+}
+async function inspectCommittedState(root, budget) {
+    let source;
+    try {
+        source = await readMemoryInventorySource(root, STATE_PATH, Math.min(inventoryLimits.fileBytes, budget));
+    }
+    catch (error) {
+        return {
+            valid: false,
+            source: null,
+            issue: {
+                code: error.code === "ENOENT"
+                    ? "memory_migration_state_missing"
+                    : errorCode(error, "memory_migration_state_invalid"),
+                path: STATE_PATH,
+            },
+        };
+    }
+    try {
+        const state = MigrationStateSchema.parse(JSON.parse(source.content));
+        const fingerprint = createHash("sha256").update(await realpath(root)).digest("hex");
+        const ownerIdentity = String((await lstat(root)).uid);
+        if (state.phase !== "committed" || state.storageVersion !== 2
+            || state.identity.rootFingerprint !== fingerprint
+            || state.identity.ownerIdentity !== ownerIdentity) {
+            throw new Error("memory_migration_state_invalid");
+        }
+        assertMigrationStateIntegrity(state, state.identity);
+        const confirmed = await readMemoryInventorySource(root, STATE_PATH, Math.min(inventoryLimits.fileBytes, budget));
+        if (confirmed.sha256 !== source.sha256) {
+            return { valid: false, source, issue: { code: "source_changed", path: STATE_PATH } };
+        }
+        return { valid: true, source, issue: null };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            source,
+            issue: {
+                code: "memory_migration_state_invalid",
+                path: STATE_PATH,
+            },
+        };
+    }
+}
+/** Validate an already-committed schema2 store without sending it through the schema1 migration preview. */
+export async function inspectV2MemoryInventory(root, sources, readComplete) {
+    const sourceMap = new Map(sources.map(source => [source.path, source]));
+    const memory = sourceMap.get("MEMORY.md")?.content ?? "";
+    const issues = [];
+    const addIssue = (code, path) => {
+        if (!issues.some(issue => issue.code === code && issue.path === path))
+            issues.push({ code, path });
+    };
+    let entries = [];
+    try {
+        entries = parseFullMemoryIndex(memory);
+    }
+    catch (error) {
+        addIssue(errorCode(error, "local_memory_storage_entry_invalid"), "MEMORY.md");
+    }
+    const scannedBytes = sources.reduce((total, source) => total + source.bytes, 0);
+    const state = await inspectCommittedState(root, Math.max(0, inventoryLimits.totalBytes - scannedBytes));
+    if (state.issue)
+        addIssue(state.issue.code, state.issue.path);
+    const detailInspection = inspectManagedDetailFiles(entries, sources);
+    for (const issue of detailInspection.fileIssues)
+        addIssue(issue.code, issue.path);
+    for (const entry of entries) {
+        const issue = detailInspection.entryIssues.get(entry.id);
+        if (issue !== undefined)
+            addIssue(issue, entry.file);
+    }
+    let preview = null;
+    if (readComplete && !issues.some(issue => issue.path === "MEMORY.md")) {
+        try {
+            const selected = selectLocalMemoryPreview(memory);
+            preview = {
+                memory: selected.memory,
+                budget: {
+                    entries: selected.entries.length,
+                    omittedEntries: selected.omittedIds.length,
+                    // The bounded projection itself fits; reason records normal long-tail omission.
+                    fits: true,
+                    reason: selected.reason,
+                },
+                writerCompatible: state.valid && issues.length === 0,
+                notes: [],
+            };
+        }
+        catch (error) {
+            addIssue(errorCode(error, "local_memory_preview_invalid"), "MEMORY.md");
+        }
+    }
+    const shownDetails = new Set();
+    const writeReady = readComplete && state.valid && issues.length === 0;
+    return {
+        stateValid: state.valid,
+        writeReady,
+        stateSource: state.source,
+        analysis: {
+            entries: entries.map(entry => {
+                const detail = shownDetails.has(entry.file) ? null : sourceMap.get(entry.file)?.content ?? null;
+                shownDetails.add(entry.file);
+                return {
+                    title: entry.title,
+                    format: "managed",
+                    disposition: detailInspection.entryIssues.has(entry.id) || !writeReady ? "blocked" : "review_required",
+                    sourceFields: sourceFields(entry),
+                    rawCard: renderLocalMemoryIndexCard(entry),
+                    detail,
+                    proposed: entry,
+                };
+            }),
+            issues,
+            preview,
+            rawMemory: memory,
+        },
+    };
+}