@nowcrew/daemon 0.6.101-beta.5 → 0.6.101-beta.7

package/dist/local-memory/execution-workspace.js

@@ -1,117 +0,0 @@
-import { LocalMemoryWorkspacePrepareError, prepareWorkspace } from "../workspace.js";
-import { awaitWithCancellation } from "../runtime-cancellation.js";
-import { logLocalMemoryContextDegraded, logLocalMemoryContextPrepareFailure } from "../local-memory-telemetry.js";
-import { resolveLocalMemoryV2Rollout } from "./rollout.js";
-import { initializeLocalMemoryV2ForWorkspace } from "./runtime.js";
-import { withMemoryAccess } from "./migration-access.js";
-import { join } from "node:path";
-import { readFile } from "node:fs/promises";
-// A fresh Agent may receive the daemon's full ten-wide execution burst.  The
-// first turn publishes schema2 durably; the remaining turns must wait to reuse
-// that committed fact instead of timing out on the generic short IO window.
-const EXECUTION_MEMORY_ACCESS_WAIT_MS = 30_000;
-function errorCode(error) {
-    const code = error?.code;
-    return typeof code === "string" ? code : error instanceof Error ? error.message : undefined;
-}
-function canSafelyDisableLocalMemory(error) {
-    if (error instanceof Error && error.name === "RuntimeCancelledError")
-        return false;
-    const code = errorCode(error);
-    if (code === undefined)
-        return false;
-    if (code === "memory_migration_access_busy"
-        || code === "memory_migration_in_progress"
-        || code === "memory_migration_path_invalid"
-        || code === "memory_migration_process_unknown"
-        || code === "local_memory_v2_initialization_residue_invalid")
-        return false;
-    return error instanceof LocalMemoryWorkspacePrepareError
-        || code.startsWith("local_memory_v2_initialization_")
-        || code.startsWith("memory_migration_")
-        || code.startsWith("migration_");
-}
-async function prepareWithoutLocalMemory(input, cancellation) {
-    const workspace = await awaitWithCancellation(prepareWorkspace({
-        agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
-        executionId: input.executionId,
-        ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-        ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-        ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-        ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
-        ...(input.launch.description ? { description: input.launch.description } : {}),
-        skipLocalMemory: true,
-    }), cancellation);
-    return {
-        workspace: {
-            ...workspace,
-            memory: "",
-            localMemoryV2Initialized: false,
-            localMemoryV2Enabled: false,
-        },
-        mode: { enabled: false, deferred: true, failure: "inspection_failed" },
-        initialized: false,
-    };
-}
-export async function prepareExecutionMemoryWorkspace(input, isolated, cancellation) {
-    try {
-        const prepare = async (context) => {
-            const prepared = await prepareWorkspace({
-                agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
-                executionId: input.executionId,
-                ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-                ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-                ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
-                ...(input.launch.description ? { description: input.launch.description } : {}),
-                ...(isolated ? { skipLocalMemory: true } : {}),
-            });
-            const workspace = context?.created ? { ...prepared, agentHomePreexisted: false } : prepared;
-            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 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;
-            const currentWorkspace = { ...workspace, memory };
-            const mode = initialized && !workspace.localMemoryV2Initialized
-                ? await resolveLocalMemoryV2Rollout({ workspace: currentWorkspace, handle: input.handle,
-                    serverUrl: input.launch.serverUrl, agentId: input.launch.agentId,
-                    requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
-                    ...(input.launch.description ? { description: input.launch.description } : {}) })
-                : initialMode;
-            return { workspace: { ...currentWorkspace, localMemoryV2Enabled: mode.enabled }, mode, initialized };
-        };
-        return await awaitWithCancellation(isolated ? prepare()
-            : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, {
-                create: true,
-                waitMs: EXECUTION_MEMORY_ACCESS_WAIT_MS,
-                initializedRecoveryIdentity: {
-                    agentId: input.launch.agentId,
-                    ...(input.launch.workspaceId === undefined ? {} : { workspaceId: input.launch.workspaceId }),
-                    ...(input.launch.machineId === undefined ? {} : { machineId: input.launch.machineId }),
-                },
-            }), cancellation);
-    }
-    catch (error) {
-        logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", error);
-        if (!isolated && canSafelyDisableLocalMemory(error)) {
-            try {
-                const degraded = await prepareWithoutLocalMemory(input, cancellation);
-                logLocalMemoryContextDegraded({ executionId: input.executionId, agentHandle: input.handle,
-                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, error);
-                return degraded;
-            }
-            catch (fallbackError) {
-                logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
-                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", fallbackError);
-            }
-        }
-        throw error;
-    }
-}

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,
-        },
-    };
-}