@nowcrew/daemon 0.6.101-beta.1 → 0.6.101-beta.3

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

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

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

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

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

@@ -1,362 +0,0 @@
-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";
-import { isDeferredMemoryArtifactPath } from "./source-path.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/") && !isDeferredMemoryArtifactPath(source.path)).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

@@ -1,233 +0,0 @@
-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,
-    };
-}