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

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

@@ -46,7 +46,10 @@ export async function runMemoryInventoryCommand(args, io) {
             : 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 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 orphanNotes = files.filter((file) => file.path.startsWith("notes/") && !referenced.has(file.path)).map((file) => file.path);

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

@@ -4,6 +4,7 @@ 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 { isHarmlessMigrationRemainder } from "./migration-plan.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;
@@ -28,6 +29,15 @@ function sourceFields(entry) {
         ...(entry.reviewAfter === null ? {} : { review_after: entry.reviewAfter }),
     };
 }
+function exactManagedDetailBodies(detail, targetId) {
+    const escapedId = targetId.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const pattern = new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escapedId}\\s+revision=[1-9][0-9]*\\s*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escapedId}\\s*-->`, "gu");
+    return [...detail.matchAll(pattern)].map(match => {
+        const beginEnd = match[0].indexOf("-->") + 3;
+        const endStart = match[0].lastIndexOf("<!--");
+        return match[0].slice(beginEnd, endStart);
+    });
+}
 function harmlessDetailRemainder(text) {
     let cursor = 0;
     let lineStart = true;
@@ -60,6 +70,63 @@ function harmlessDetailRemainder(text) {
     }
     return true;
 }
+/**
+ * A migrated legacy note can remain on disk for external references.  It is
+ * safe to exclude it from the V2 orphan scan only when the immutable
+ * migration mapping proves that the complete, unchanged source was copied to
+ * the indexed target entry.
+ */
+export function findControlledPreservedSourcePaths(entries, sources, mappings, sourceHashes = new Map()) {
+    const entriesById = new Map(entries.map(entry => [entry.id, entry]));
+    const sourcesByPath = new Map(sources.map(source => [source.path, source]));
+    const grouped = new Map();
+    for (const mapping of mappings) {
+        if (!mapping.sourceFile.startsWith("notes/"))
+            continue;
+        const current = grouped.get(mapping.sourceFile) ?? [];
+        grouped.set(mapping.sourceFile, [...current, mapping]);
+    }
+    const preserved = [];
+    for (const [path, values] of grouped) {
+        const source = sourcesByPath.get(path);
+        if (source === undefined || values.length === 0)
+            continue;
+        const ranges = [...values].sort((left, right) => left.start - right.start);
+        let cursor = 0;
+        let valid = true;
+        for (const mapping of ranges) {
+            const targetFile = `notes/${mapping.category}.md`;
+            const target = mapping.targetId === undefined ? undefined : entriesById.get(mapping.targetId);
+            const targetSource = target === undefined ? undefined : sourcesByPath.get(target.file);
+            const expectedSourceSha256 = mapping.sourceSha256 ?? sourceHashes.get(path);
+            const sourceBody = source.content.slice(mapping.start, mapping.end);
+            const renderedBody = mapping.sourceFile === targetFile
+                ? sourceBody
+                : `\n## ${mapping.title}\n\nScope: ${mapping.scope}\n\n${sourceBody}\n`;
+            const sourceBlockBodies = mapping.targetId === undefined
+                ? []
+                : exactManagedDetailBodies(sourceBody, mapping.targetId);
+            const expectedBody = mapping.sourceFile === targetFile && sourceBlockBodies.length === 1
+                ? sourceBlockBodies[0]
+                : renderedBody;
+            const targetBodies = mapping.targetId === undefined || targetSource === undefined
+                ? []
+                : exactManagedDetailBodies(targetSource.content, mapping.targetId);
+            if (expectedSourceSha256 === undefined || expectedSourceSha256 !== source.sha256
+                || mapping.start < cursor || !isHarmlessMigrationRemainder(source.content.slice(cursor, mapping.start))
+                || mapping.end > source.content.length
+                || target === undefined || target.file !== targetFile || targetSource === undefined
+                || targetBodies.length !== 1 || targetBodies[0] !== expectedBody) {
+                valid = false;
+                break;
+            }
+            cursor = mapping.end;
+        }
+        if (valid && isHarmlessMigrationRemainder(source.content.slice(cursor)))
+            preserved.push(path);
+    }
+    return preserved.sort((left, right) => left.localeCompare(right));
+}
 export function* scanManagedDetailMarkers(detail) {
     for (const marker of detail.matchAll(DETAIL_MARKER_PATTERN)) {
         const beginId = marker[1];
@@ -131,7 +198,12 @@ function inspectDetailEntry(entry, analysis) {
     return revisions[0] > entry.revision ? "managed_revision_invalid" : null;
 }
 export function inspectManagedDetailFiles(entries, sources, analyze = analyzeManagedDetailFile) {
+    return inspectManagedDetailFilesWithMappings(entries, sources, [], new Map(), analyze);
+}
+export function inspectManagedDetailFilesWithMappings(entries, sources, mappings, sourceHashes = new Map(), analyze = analyzeManagedDetailFile) {
     const sourceMap = new Map(sources.map(source => [source.path, source]));
+    const preservedSourcePaths = findControlledPreservedSourcePaths(entries, sources, mappings, sourceHashes);
+    const preserved = new Set(preservedSourcePaths);
     const expectedByFile = new Map();
     for (const entry of entries) {
         const expected = expectedByFile.get(entry.file) ?? new Set();
@@ -150,8 +222,10 @@ export function inspectManagedDetailFiles(entries, sources, analyze = analyzeMan
             continue;
         const analysis = analyze(source.content, expectedByFile.get(path) ?? new Set());
         analyses.set(path, analysis);
-        if (analysis.coverageIssue !== null)
+        if (analysis.coverageIssue !== null
+            && !(preserved.has(path) && analysis.coverageIssue === "unindexed_text_requires_mapping")) {
             fileIssues.push({ code: analysis.coverageIssue, path });
+        }
     }
     const entryIssues = new Map();
     for (const entry of entries) {
@@ -159,7 +233,7 @@ export function inspectManagedDetailFiles(entries, sources, analyze = analyzeMan
         if (issue !== null)
             entryIssues.set(entry.id, issue);
     }
-    return { entryIssues, fileIssues };
+    return { entryIssues, fileIssues, preservedSourcePaths };
 }
 async function inspectCommittedState(root, budget) {
     let source;
@@ -170,6 +244,7 @@ async function inspectCommittedState(root, budget) {
         return {
             valid: false,
             source: null,
+            state: null,
             issue: {
                 code: error.code === "ENOENT"
                     ? "memory_migration_state_missing"
@@ -190,14 +265,15 @@ async function inspectCommittedState(root, budget) {
         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: false, source, state: null, issue: { code: "source_changed", path: STATE_PATH } };
         }
-        return { valid: true, source, issue: null };
+        return { valid: true, source, state, issue: null };
     }
     catch (error) {
         return {
             valid: false,
             source,
+            state: null,
             issue: {
                 code: "memory_migration_state_invalid",
                 path: STATE_PATH,
@@ -225,7 +301,9 @@ export async function inspectV2MemoryInventory(root, sources, readComplete) {
     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);
+    const sourceHashes = new Map((state.state?.manifest.files ?? [])
+        .flatMap(file => file.before.exists ? [[file.path, file.before.sha256]] : []));
+    const detailInspection = inspectManagedDetailFilesWithMappings(entries, sources, state.state?.manifest.recordMappings ?? [], sourceHashes);
     for (const issue of detailInspection.fileIssues)
         addIssue(issue.code, issue.path);
     for (const entry of entries) {
@@ -260,6 +338,7 @@ export async function inspectV2MemoryInventory(root, sources, readComplete) {
         stateValid: state.valid,
         writeReady,
         stateSource: state.source,
+        preservedSourcePaths: detailInspection.preservedSourcePaths,
         analysis: {
             entries: entries.map(entry => {
                 const detail = shownDetails.has(entry.file) ? null : sourceMap.get(entry.file)?.content ?? null;

package/dist/local-memory/migration-access.js

@@ -6,7 +6,8 @@ import { defaultProcessController } from "../execution-journal.js";
 import { createHash } from "node:crypto";
 import { MigrationStateSchema } from "./migration-schema.js";
 import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./storage-format.js";
-import { readMemoryInventorySource, inventoryLimits } from "./inventory-source.js";
+import { inventoryLimits, readMemoryInventorySource, scanMemorySources } from "./inventory-source.js";
+import { inspectV2MemoryInventory } from "./inventory-v2.js";
 import { MEMORY_STATE_GUARD_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY } from "../memory-migration-protocol.js";
 import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from "./initialization-identity.js";
 import { assertMigrationStateIntegrity } from "./migration-state-invariants.js";
@@ -59,6 +60,40 @@ export async function assertMemoryWriterAllowed(agentDir, capabilities = []) {
         throw new Error("memory_v2_writer_capability_missing");
     }
 }
+/**
+ * Check the committed V2 catalog immediately before a write is persisted.
+ * Keep this separate from the boot/state gate so legacy writer-specific
+ * validation (size limits, entry limits, note limits) retains its established
+ * error precedence.
+ */
+export async function assertMemoryInventoryHealth(agentDir) {
+    const root = await realpath(agentDir);
+    let state;
+    try {
+        const source = await readMemoryInventorySource(root, ".crew/memory/migration.v1.json", inventoryLimits.fileBytes);
+        state = StateGate.parse(JSON.parse(source.content));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        if (error instanceof z.ZodError || error instanceof SyntaxError)
+            throw new Error("memory_migration_state_invalid");
+        throw error;
+    }
+    // Legacy/schema1 writers do not need a V2 inventory scan.  In particular,
+    // a large pending directory must keep the old writer's normal latency and
+    // budget behavior.
+    if (state.phase !== "committed" || state.storageVersion !== 2)
+        return;
+    const scan = await scanMemorySources(root, { includeOperationalFiles: false });
+    const health = await inspectV2MemoryInventory(root, scan.sources, scan.issues.length === 0);
+    const blockingNoteIssues = health.analysis.issues.filter(issue => issue.path.startsWith("notes/"));
+    if (scan.issues.length === 0
+        && !health.analysis.issues.some(issue => issue.path === "MEMORY.md")
+        && blockingNoteIssues.length > 0) {
+        throw new Error("memory_migration_inventory_invalid");
+    }
+}
 const StateGate = z.object({
     schemaVersion: z.literal(1), migrationId: z.string().min(1),
     phase: z.enum(["prepared", "applying", "committed", "rolled_back", "repair_required"]),

package/dist/local-memory/migration-plan.js

@@ -25,7 +25,7 @@ export function initializeExactWorkspaceSeed(bytes) {
 const categories = /^(?:preferences|project-rules|testing|debugging|git|incidents|lessons)$/u;
 const blockPattern = /<!--\s*NOWWORK:MEMORY_ENTRY:BEGIN\s+id=([A-Za-z0-9_-]+)\s+revision=([1-9][0-9]*)\s*-->([\s\S]*?)<!--\s*NOWWORK:MEMORY_ENTRY:END\s+id=\1\s*-->/gu;
 const controlMarker = /<!--\s*NOWWORK:MEMORY_/u;
-const harmless = (text) => !text.replace(/<!--[\s\S]*?-->/gu, '').replace(/^#{1,2}[^\n]*$/gmu, '').trim();
+export const isHarmlessMigrationRemainder = (text) => !text.replace(/<!--[\s\S]*?-->/gu, '').replace(/^#{1,2}[^\n]*$/gmu, '').trim();
 function migrationSummary(body, title) {
     const clean = (value) => value.replace(/<!--[\s\S]*?-->/gu, ' ')
         .replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim().slice(0, 180);
@@ -148,7 +148,7 @@ export function planMemoryMigration(identity, files, supplied = []) {
                 cursor = Math.max(cursor, range.end);
             }
             remainder += content.slice(cursor);
-            if (!harmless(remainder))
+            if (!isHarmlessMigrationRemainder(remainder))
                 issues.push({ path, reason: 'unindexed_text_requires_mapping' });
         }
         for (const mapping of additions) {

package/dist/local-memory/migration-store.js

@@ -4,8 +4,9 @@ import { z } from 'zod';
 import { atomicBytes, digest, inventory, readBytes, safePath, STATE_PATH, syncDirectory, validateMigrationRoot } from './migration-io.js';
 import { initializeExactWorkspaceSeed, planMemoryMigration, validateMigrationTarget } from './migration-plan.js';
 import { MigrationError, MigrationHistorySchema, MigrationProcessStoppedReceiptSchema, MigrationStateSchema } from './migration-schema.js';
+import { inspectManagedDetailFilesWithMappings } from './inventory-v2.js';
 import { assertMigrationStateIntegrity as assertIdentity, encodeMigrationData as encode, migrationOperationRoot as opRoot, migrationPlanDigest as planDigest, sameMigrationData as same, verifyMigrationIntent as verifyIntent, } from './migration-state-invariants.js';
-import { detectLocalMemoryStorageVersion } from './storage-format.js';
+import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from './storage-format.js';
 import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from './initialization-identity.js';
 async function immutable(root, path, data) {
     const previous = await readBytes(root, path, 64 * 1024 * 1024);
@@ -256,15 +257,27 @@ async function publish(root, state, side, hooks) {
         await hooks.afterReplace?.(file.path, index++);
     }
 }
-function validTarget(files) {
+function validTarget(files, mappings = [], sourceHashes = new Map()) {
     try {
         validateMigrationTarget(files);
-        return true;
+        const memory = files.get('MEMORY.md');
+        if (memory === undefined)
+            return false;
+        const entries = [...parseFullMemoryIndex(memory.toString('utf8'))];
+        const sources = [...files]
+            .filter(([path]) => path === 'MEMORY.md' || path.startsWith('notes/'))
+            .map(([path, bytes]) => ({ path, bytes: bytes.length, sha256: digest(bytes), content: bytes.toString('utf8') }));
+        const inspection = inspectManagedDetailFilesWithMappings(entries, sources, mappings, sourceHashes);
+        return inspection.fileIssues.length === 0 && inspection.entryIssues.size === 0;
     }
     catch {
         return false;
     }
 }
+function manifestSourceHashes(manifest) {
+    return new Map(manifest.files
+        .flatMap(file => file.before.exists ? [[file.path, file.before.sha256]] : []));
+}
 async function finalState(input, state) {
     const terminalPath = `${opRoot(state.identity)}/terminal.json`;
     const bytes = await readBytes(input.agentDir, terminalPath, 32 * 1024 * 1024);
@@ -283,7 +296,7 @@ async function finalState(input, state) {
     if (terminal?.phase === 'committed') {
         let valid = false;
         try {
-            valid = validTarget((await inventory(input.agentDir)).files);
+            valid = validTarget((await inventory(input.agentDir)).files, state.manifest.recordMappings, manifestSourceHashes(state.manifest));
         }
         catch { /* Protect damaged content without erasing commit history. */ }
         if (!valid)
@@ -309,13 +322,13 @@ export async function applyMemoryMigration(input, hooks = {}) {
     if (classification.unknown.length || classification.classes.some(value => value !== 'B' && value !== 'AB'))
         return repair(input.agentDir, state, classification.unknown.length ? classification.unknown : ['MEMORY.md'], 'source_changed');
     const backup = await copies(input.agentDir, state, 'before'), staged = await copies(input.agentDir, state, 'after');
-    if (!backup || !staged || !validTarget(staged))
+    if (!backup || !staged || !validTarget(staged, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
         throw new MigrationError('migration_copy_invalid');
     await immutable(input.agentDir, `${opRoot(state.identity)}/intent.json`, encode(receipt));
     state = await save(input.agentDir, { ...state, phase: 'applying', intentReceipt: receipt });
     await publish(input.agentDir, state, 'after', hooks);
     const current = await classify(input.agentDir, state);
-    if (current.unknown.length || current.classes.some(value => value === 'X' || value === 'B') || !validTarget(current.files))
+    if (current.unknown.length || current.classes.some(value => value === 'X' || value === 'B') || !validTarget(current.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
         return repair(input.agentDir, state, ['MEMORY.md'], 'target_validation_failed');
     return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2 });
 }
@@ -378,16 +391,16 @@ export async function recoverMemoryMigration(input, hooks = {}) {
     if (current.unknown.length || current.classes.includes('X'))
         return repair(input.agentDir, state, [...current.unknown, ...state.manifest.files.filter((_, index) => current.classes[index] === 'X').map(file => file.path)], 'unknown_change');
     const allA = current.classes.every(value => value === 'A' || value === 'AB'), allB = current.classes.every(value => value === 'B' || value === 'AB');
-    if (allA && !cancelled && validTarget(current.files))
+    if (allA && !cancelled && validTarget(current.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
         return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2, ...(receipt ? { intentReceipt: receipt } : {}) });
     if (allB && (!receipt || cancelled))
         return save(input.agentDir, { ...state, phase: 'rolled_back', storageVersion: state.identity.sourceStorageVersion });
     const staged = await copies(input.agentDir, state, 'after');
-    if (receipt && !cancelled && staged && validTarget(staged)) {
+    if (receipt && !cancelled && staged && validTarget(staged, state.manifest.recordMappings, manifestSourceHashes(state.manifest))) {
         state = await save(input.agentDir, { ...state, phase: 'applying', intentReceipt: receipt });
         await publish(input.agentDir, state, 'after', hooks);
         const target = await classify(input.agentDir, state);
-        if (!target.unknown.length && target.classes.every(value => value === 'A' || value === 'AB') && validTarget(target.files))
+        if (!target.unknown.length && target.classes.every(value => value === 'A' || value === 'AB') && validTarget(target.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
             return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2 });
     }
     const backup = await copies(input.agentDir, state, 'before');

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

@@ -10,6 +10,9 @@ import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./storage
 import { searchFullMemoryIndex } from "./full-index-search.js";
 import { searchLegacyMemorySources } from "./legacy-adapter.js";
 import { withMemoryAccess } from "./migration-access.js";
+import { readMemoryInventorySource, scanMemorySources } from "./inventory-source.js";
+import { MigrationStateSchema } from "./migration-schema.js";
+import { findControlledPreservedSourcePaths } from "./inventory-v2.js";
 const OUTPUT_BYTES = 12 * 1024;
 // A V2 page may carry coverage metadata for legacy sources. Reserve room for
 // that metadata so a mixed result never exceeds the command's output limit.
@@ -125,6 +128,22 @@ async function readSource(home, file) {
         await handle.close();
     }
 }
+async function readControlledPreservedSourcePaths(home, memory) {
+    try {
+        const root = await realpath(home);
+        const stateSource = await readMemoryInventorySource(root, ".crew/memory/migration.v1.json", FILE_BYTES);
+        const state = MigrationStateSchema.parse(JSON.parse(stateSource.content));
+        if (state.phase !== "committed" || state.storageVersion !== 2)
+            return new Set();
+        const scan = await scanMemorySources(root, { includeOperationalFiles: false });
+        const sourceHashes = new Map(state.manifest.files
+            .flatMap(file => file.before.exists ? [[file.path, file.before.sha256]] : []));
+        return new Set(findControlledPreservedSourcePaths(parseFullMemoryIndex(memory), scan.sources, state.manifest.recordMappings, sourceHashes));
+    }
+    catch {
+        return new Set();
+    }
+}
 function normalizeLimit(requestedLimit, max, safe) {
     if (requestedLimit <= max)
         return { limit: requestedLimit };
@@ -256,10 +275,14 @@ async function runMemoryReadUnlocked(argv, io) {
                 ...command, limit: normalized.limit, history: command.command === "search-history",
             }, FULL_INDEX_RESULT_BYTES);
             const indexedFiles = new Set(["MEMORY.md", ...parseFullMemoryIndex(source.text).map((match) => match.file)]);
+            const preservedSourceFiles = await readControlledPreservedSourcePaths(io.env.CREW_HOME, source.text);
+            const legacyExcludedFiles = fileWasExplicit
+                ? indexedFiles
+                : new Set([...indexedFiles, ...preservedSourceFiles]);
             const legacy = await searchLegacyMemorySources({ agentDir: io.env.CREW_HOME, query: command.query,
                 limit: normalized.limit, outputBytes: FULL_INDEX_LEGACY_SCAN_BYTES,
                 ...(command.cursor === undefined ? {} : { cursor: command.cursor }),
-                ...(fileWasExplicit ? { files: [command.file], excludeFiles: indexedFiles } : { excludeFiles: indexedFiles }) });
+                ...(fileWasExplicit ? { files: [command.file], excludeFiles: legacyExcludedFiles } : { excludeFiles: legacyExcludedFiles }) });
             if (result.matches.length === 0 && (command.cursor === undefined || legacy.matchCount > 0)) {
                 if (legacy.unindexedFiles.length > 0 && (legacy.matchCount > 0 || result.matchCount === 0)) {
                     writeResult({ ...legacy, ...(normalized.warning ? { warning: normalized.warning,

package/dist/local-memory/write.js

@@ -7,7 +7,7 @@ import { LocalMemoryChangeSchema, LocalMemorySingleLineText, validateLocalMemory
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, selectLocalMemoryIndexEntries, } from "./index-budget.js";
 import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
 import { assertLocalMemoryStorageSize, detectLocalMemoryStorageVersion, LOCAL_MEMORY_GENERATED_INDEX_PATTERN, LOCAL_MEMORY_NOTE_BYTE_CAP, LOCAL_MEMORY_READ_BYTE_CAP, parseFullMemoryIndex, replaceFullMemoryIndex, selectLocalMemoryPreview, } from "./storage-format.js";
-import { assertMemoryWriterAllowed, withMemoryAccess } from "./migration-access.js";
+import { assertMemoryInventoryHealth, assertMemoryWriterAllowed, withMemoryAccess } from "./migration-access.js";
 const StatusChangeSchema = z.object({
     memoryId: LocalMemorySingleLineText,
     expectedRevision: z.number().int().positive(),
@@ -686,6 +686,7 @@ export async function applyLocalMemoryResult(input) {
             if (Buffer.byteLength(content, "utf8") > LOCAL_MEMORY_NOTE_BYTE_CAP)
                 throw new Error("local_memory_note_byte_limit");
         }
+        await assertMemoryInventoryHealth(input.agentDir);
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.93-beta.10",
+  "version": "0.6.93-beta.12",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",