@nowcrew/daemon 0.6.96 → 0.6.97-beta.2

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

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

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

@@ -0,0 +1,361 @@
+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 { 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;
+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 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;
+    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;
+}
+/**
+ * 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];
+        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) {
+    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();
+        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
+            && !(preserved.has(path) && analysis.coverageIssue === "unindexed_text_requires_mapping")) {
+            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, preservedSourcePaths };
+}
+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,
+            state: 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, state: null, issue: { code: "source_changed", path: STATE_PATH } };
+        }
+        return { valid: true, source, state, issue: null };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            source,
+            state: null,
+            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 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) {
+        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,
+        preservedSourcePaths: detailInspection.preservedSourcePaths,
+        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,
+        },
+    };
+}

package/dist/local-memory/legacy-adapter.js

@@ -0,0 +1,233 @@
+import { Buffer } from "node:buffer";
+import { realpath } from "node:fs/promises";
+import { inventoryLimits, readMemoryInventorySource, scanMemorySources } from "./inventory-source.js";
+import { detectLocalMemoryStorageVersion, LOCAL_MEMORY_GENERATED_INDEX_PATTERN } from "./storage-format.js";
+const CURSOR_VERSION = 1;
+const MAX_METADATA_PATH_BYTES = 4 * 1024;
+const MAX_METADATA_WARNING_BYTES = 2 * 1024;
+const excerpt = (text, size) => {
+    const characters = Array.from(text);
+    return characters.length > size ? `${characters.slice(0, size).join("")}...` : text;
+};
+function originalLowercaseIndex(text, index) {
+    let originalIndex = 0;
+    let lowerIndex = 0;
+    for (const character of text) {
+        lowerIndex += character.toLowerCase().length;
+        if (index < lowerIndex)
+            return originalIndex;
+        originalIndex += character.length;
+    }
+    return text.length;
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("memory_cursor_invalid");
+    }
+    if (!parsed || typeof parsed !== "object")
+        throw new Error("memory_cursor_invalid");
+    const record = parsed;
+    if (record.version !== CURSOR_VERSION || typeof record.file !== "string"
+        || !/^[a-f0-9]{64}$/u.test(String(record.sha256))
+        || typeof record.afterLine !== "number" || !Number.isSafeInteger(record.afterLine) || record.afterLine < 0) {
+        throw new Error("memory_cursor_invalid");
+    }
+    return { version: 1, file: record.file, sha256: String(record.sha256), afterLine: record.afterLine };
+}
+function boundStringList(values, maxBytes) {
+    const bounded = [];
+    for (const value of values) {
+        const candidate = [...bounded, value];
+        if (Buffer.byteLength(JSON.stringify(candidate), "utf8") > maxBytes)
+            break;
+        bounded.push(value);
+    }
+    return { values: bounded, truncated: bounded.length < values.length };
+}
+function sourceMatches(source, query, afterLine, limit, outputBytes) {
+    const terms = query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+    const matches = [];
+    let line = 0;
+    let offset = 0;
+    let heading = "";
+    let matchCount = 0;
+    let hasMore = false;
+    let outputTooLarge = false;
+    let firstMatchLine = null;
+    let remaining = outputBytes;
+    const generatedIndex = source.path === "MEMORY.md"
+        ? LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(source.content)
+        : null;
+    const generatedStart = generatedIndex === null ? -1 : Array.from(source.content.slice(0, generatedIndex.index)).length;
+    const generatedEnd = generatedIndex === null ? -1 : generatedStart + Array.from(generatedIndex[0]).length;
+    for (const match of source.content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+        if (match[0] === "")
+            break;
+        line += 1;
+        const raw = match[0];
+        const lineStart = offset;
+        const lineEnd = offset + Array.from(raw).length;
+        const content = raw.replace(/\r?\n$/u, "");
+        const title = /^#{1,6}\s+(.+?)\s*$/u.exec(content)?.[1];
+        if (title !== undefined)
+            heading = excerpt(title, 96);
+        const lower = content.normalize("NFKC").toLowerCase();
+        const insideGeneratedIndex = generatedStart >= 0 && lineStart < generatedEnd && lineEnd > generatedStart;
+        if (!insideGeneratedIndex && terms.every(term => lower.includes(term))) {
+            matchCount += 1;
+            if (line > afterLine) {
+                firstMatchLine ??= line;
+                const matchIndex = lower.indexOf(terms[0] ?? "");
+                let start = Math.max(0, originalLowercaseIndex(content, matchIndex) - 60);
+                if (start > 0 && /[\uDC00-\uDFFF]/u.test(content[start]))
+                    start -= 1;
+                const item = { file: source.path, sourceSha256: source.sha256, legacy: true, opaque: true,
+                    line, offset, heading, text: `${start > 0 ? "..." : ""}${excerpt(content.slice(start), 240)}` };
+                const bytes = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
+                if (matches.length >= limit)
+                    hasMore = true;
+                else if (bytes > remaining) {
+                    hasMore = true;
+                    outputTooLarge = matches.length === 0;
+                }
+                else {
+                    matches.push(item);
+                    remaining -= bytes;
+                }
+            }
+        }
+        offset += Array.from(raw).length;
+    }
+    return { matches, matchCount, hasMore, outputTooLarge, firstMatchLine,
+        bytesUsed: outputBytes - remaining,
+        nextAfterLine: hasMore ? matches.at(-1)?.line ?? null : null };
+}
+function issueCode(error) {
+    if (error instanceof TypeError)
+        return "invalid_utf8";
+    if (error instanceof Error)
+        return error.code ?? error.message;
+    return "read_failed";
+}
+async function readRequestedSources(agentDir, files, excludeFiles) {
+    const root = await realpath(agentDir);
+    const sources = [];
+    const issues = [];
+    let remaining = inventoryLimits.totalBytes;
+    for (const file of [...new Set(files)].sort((left, right) => left.localeCompare(right))) {
+        if (excludeFiles?.has(file))
+            continue;
+        try {
+            const source = await readMemoryInventorySource(root, file, remaining);
+            remaining -= source.bytes;
+            sources.push(source);
+        }
+        catch (error) {
+            issues.push({ code: issueCode(error), path: file });
+        }
+    }
+    return { sources, issues };
+}
+/**
+ * Read-only adapter for old MEMORY.md/notes content. It is only called from
+ * explicit search commands; prompt preparation never invokes it.
+ */
+export async function searchLegacyMemorySources(input) {
+    const scan = input.files === undefined
+        ? await scanMemorySources(input.agentDir, { includeOperationalFiles: false })
+        : null;
+    const requestedResult = input.files === undefined
+        ? null
+        : await readRequestedSources(input.agentDir, input.files, input.excludeFiles);
+    const requested = input.files === undefined
+        ? scan.sources.filter(source => source.path === "MEMORY.md" || source.path.startsWith("notes/"))
+        : requestedResult.sources;
+    const sources = input.files === undefined
+        ? requested.filter(source => !(input.excludeFiles?.has(source.path) ?? false))
+        : requested;
+    const detectedIndexVersion = await (async () => {
+        try {
+            const memory = sources.find(source => source.path === "MEMORY.md")
+                ?? await readMemoryInventorySource(await realpath(input.agentDir), "MEMORY.md", inventoryLimits.fileBytes);
+            return detectLocalMemoryStorageVersion(memory.content);
+        }
+        catch {
+            return null;
+        }
+    })();
+    const relevantIssues = input.files === undefined
+        ? scan.issues.filter(issue => issue.path === "MEMORY.md" || issue.path.startsWith("notes/"))
+        : requestedResult.issues;
+    const cursor = input.cursor === undefined ? null : decodeCursor(input.cursor);
+    if (cursor !== null && !sources.some(source => source.path === cursor.file))
+        throw new Error("memory_cursor_invalid");
+    const ordered = [...sources].sort((left, right) => left.path.localeCompare(right.path));
+    const matches = [];
+    let matchCount = 0;
+    let hasMore = false;
+    let nextCursor = null;
+    let started = cursor === null;
+    let pageFull = false;
+    const allUnindexedFiles = ordered.map(source => source.path);
+    const boundedFiles = boundStringList(allUnindexedFiles, MAX_METADATA_PATH_BYTES);
+    const allWarnings = relevantIssues.map(issue => ({ code: issue.code, path: issue.path }));
+    const boundedWarnings = boundStringList(allWarnings.map(warning => `${warning.code}\u0000${warning.path}`), MAX_METADATA_WARNING_BYTES);
+    const warnings = boundedWarnings.values.map(value => {
+        const separator = value.indexOf("\u0000");
+        return { code: separator < 0 ? value : value.slice(0, separator), path: separator < 0 ? "" : value.slice(separator + 1) };
+    });
+    const outputReservation = Buffer.byteLength(JSON.stringify({
+        source: "legacy", legacy: true, opaque: true, readerMode: "legacy", storageVersion: detectedIndexVersion,
+        detectedIndexVersion,
+        ...(ordered.length === 1 ? { file: ordered[0].path, sha256: ordered[0].sha256 } : {}),
+        matches: [], matchCount: 0, hasMore: false, complete: false, nextAfterLine: null,
+        unindexedFiles: boundedFiles.values, unindexedFileCount: allUnindexedFiles.length,
+        unindexedFilesTruncated: boundedFiles.truncated, nextCursor: null,
+        warnings, warningCount: allWarnings.length, warningsTruncated: boundedWarnings.truncated,
+    }), "utf8") + 256;
+    let remainingOutputBytes = Math.max(0, input.outputBytes - outputReservation);
+    for (const source of ordered) {
+        if (!started) {
+            if (source.path !== cursor.file)
+                continue;
+            if (source.sha256 !== cursor.sha256)
+                throw new Error("memory_file_changed");
+            started = true;
+        }
+        const afterLine = source.path === cursor?.file ? cursor.afterLine
+            : cursor === null && source.path === ordered[0]?.path ? input.afterLine ?? 0 : 0;
+        const result = sourceMatches(source, input.query, afterLine, pageFull ? 0 : Math.max(0, input.limit - matches.length), remainingOutputBytes);
+        matches.push(...result.matches);
+        matchCount += result.matchCount;
+        remainingOutputBytes -= result.bytesUsed;
+        if (result.hasMore) {
+            hasMore = true;
+            pageFull = true;
+            if (result.outputTooLarge && matches.length === 0)
+                throw new Error("memory_output_too_large");
+            if (nextCursor === null) {
+                const last = result.matches.at(-1);
+                nextCursor = encodeCursor({ version: 1, file: source.path, sha256: source.sha256,
+                    afterLine: Number(last?.line ?? Math.max(0, result.firstMatchLine ?? 1) - 1) });
+            }
+        }
+    }
+    const complete = !hasMore && relevantIssues.length === 0;
+    return {
+        source: "legacy", legacy: true, opaque: true, readerMode: "legacy",
+        storageVersion: detectedIndexVersion, detectedIndexVersion,
+        ...(ordered.length === 1 ? { file: ordered[0].path, sha256: ordered[0].sha256 } : {}),
+        matches, matchCount, hasMore, complete, nextAfterLine: hasMore && ordered.length === 1
+            ? Number(matches.at(-1)?.line ?? 0) : null,
+        unindexedFiles: boundedFiles.values, unindexedFileCount: allUnindexedFiles.length,
+        unindexedFilesTruncated: boundedFiles.truncated, nextCursor, warnings,
+        warningCount: allWarnings.length, warningsTruncated: boundedWarnings.truncated,
+    };
+}