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

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

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

@@ -0,0 +1,242 @@
+import { lstat, mkdir, open, readFile, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { createJournalLease, createJournalLeaseRegistry, JournalLockedError } from "../execution-journal-lock.js";
+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 { 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";
+export const LOCAL_MEMORY_V2_WRITER_CAPABILITIES = [MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY];
+/**
+ * Keep an execution that started before migration from writing a committed V2
+ * catalog with the legacy result writer.  Server-side daemon capability checks
+ * stop new work, but an already-running old process can still reach its local
+ * result commit after the migration has finished.
+ */
+export async function assertMemoryWriterAllowed(agentDir, capabilities = []) {
+    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") {
+            // A missing state file is only compatible with an old, unmarked store.
+            // Once MEMORY.md carries a schema2 index, absence of the state must fail closed.
+            try {
+                const memory = await readMemoryInventorySource(root, "MEMORY.md", inventoryLimits.fileBytes);
+                if (detectLocalMemoryStorageVersion(memory.content) === 2) {
+                    throw new Error("memory_migration_state_missing");
+                }
+            }
+            catch (memoryError) {
+                if (memoryError.code === "ENOENT")
+                    return;
+                throw memoryError;
+            }
+            return;
+        }
+        if (error instanceof z.ZodError || error instanceof SyntaxError)
+            throw new Error("memory_migration_state_invalid");
+        throw error;
+    }
+    if (state.phase === "applying" || state.phase === "repair_required" || state.phase === "prepared") {
+        throw new Error("memory_migration_in_progress");
+    }
+    if (state.phase !== "committed")
+        return;
+    // Reuse the committed-state integrity checks before admitting any writer;
+    // a truncated committed state must fail closed instead of looking legacy.
+    await assertMemoryAccessAllowed(root);
+    if (state.storageVersion !== 2)
+        return;
+    if (LOCAL_MEMORY_V2_WRITER_CAPABILITIES.some((capability) => !capabilities.includes(capability))) {
+        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"]),
+    storageVersion: z.union([z.literal(0), z.literal(1), z.literal(2)]).optional(),
+}).passthrough();
+async function checkedDirectory(parent, name) {
+    const directory = join(parent, name);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory) {
+        throw new Error("memory_migration_path_invalid");
+    }
+    return directory;
+}
+export async function assertMemoryAccessAllowed(agentDir, options = {}) {
+    let state = null;
+    try {
+        const source = await readMemoryInventorySource(agentDir, ".crew/memory/migration.v1.json", inventoryLimits.fileBytes);
+        state = StateGate.parse(JSON.parse(source.content));
+        if (state.phase === "prepared" || state.phase === "applying" || state.phase === "repair_required") {
+            if (options.pendingOnly && (state.phase === "prepared" || state.phase === "applying")) {
+                const fullState = MigrationStateSchema.parse(state);
+                assertMigrationStateIntegrity(fullState, fullState.identity);
+                // The migration inventory owns the pending directory while its journal
+                // is active.  Allowing an execution to append a candidate here would
+                // make the next classify() see an unplanned file and force
+                // repair_required.  Keep the journal fail-closed and let pending-only
+                // apply only to the marker-only legacy state (no active journal).
+                throw new Error("memory_migration_in_progress");
+            }
+            const recovery = options.initializedRecoveryIdentity;
+            if (recovery === undefined)
+                throw new Error("memory_migration_in_progress");
+            const fullState = MigrationStateSchema.parse(state);
+            assertMigrationStateIntegrity(fullState, fullState.identity);
+            const binding = recovery.workspaceId !== undefined && recovery.machineId !== undefined
+                ? { workspaceId: recovery.workspaceId, machineId: recovery.machineId }
+                : undefined;
+            const identity = await localMemoryInitializationIdentity(agentDir, recovery.agentId, binding);
+            const legacyIdentity = binding === undefined
+                ? identity
+                : await localMemoryInitializationIdentity(agentDir, recovery.agentId);
+            if (fullState.origin !== "initialized"
+                || (fullState.phase === "prepared" && fullState.intentReceipt !== undefined)
+                || (!isLocalMemoryInitializationIdentity(fullState.identity, identity)
+                    && !isLocalMemoryInitializationIdentity(fullState.identity, legacyIdentity))) {
+                throw new Error("memory_migration_in_progress");
+            }
+            return;
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "memory_migration_in_progress")
+            throw error;
+        if (error.code !== "ENOENT")
+            throw new Error("memory_migration_state_invalid");
+    }
+    let source;
+    try {
+        source = await readMemoryInventorySource(agentDir, "MEMORY.md", inventoryLimits.fileBytes);
+    }
+    catch (error) {
+        if (error.code === "ENOENT" && state === null)
+            return;
+        if (error instanceof Error && error.message === "read_limit_exceeded")
+            throw new Error("memory_file_too_large");
+        throw error;
+    }
+    const version = detectLocalMemoryStorageVersion(source.content);
+    if (version === 2 || state?.phase === "committed") {
+        if (!state)
+            throw new Error("memory_migration_state_missing");
+        const verified = MigrationStateSchema.parse(state);
+        assertMigrationStateIntegrity(verified, verified.identity);
+        if (verified.phase !== "committed" || verified.storageVersion !== 2 || version !== 2
+            || verified.identity.rootFingerprint !== createHash("sha256").update(await realpath(agentDir)).digest("hex")
+            || verified.identity.ownerIdentity !== String((await lstat(agentDir)).uid)) {
+            throw new Error("memory_migration_state_invalid");
+        }
+        parseFullMemoryIndex(source.content);
+    }
+}
+/** 复用现有进程身份锁；仅保护一次本地IO，不持锁等待模型，避免子CLI自锁。 */
+export async function withMemoryAccess(agentDir, operation, options = {}) {
+    let created = false;
+    if (options.create) {
+        created = await lstat(agentDir).then(() => false, (e) => { if (e.code === "ENOENT")
+            return true; throw e; });
+        await mkdir(agentDir, { recursive: true, mode: 0o700 });
+    }
+    const root = await realpath(agentDir);
+    if ((await lstat(agentDir)).isSymbolicLink())
+        throw new Error("memory_migration_path_invalid");
+    const crew = await checkedDirectory(root, ".crew");
+    const memory = await checkedDirectory(crew, "memory");
+    const directory = await checkedDirectory(memory, "access.lock");
+    const lease = createJournalLease({ directory, currentPid: process.pid,
+        captureCurrentIdentity: async () => {
+            const identity = await defaultProcessController.inspectIdentity(process.pid);
+            if (!identity)
+                throw new Error("memory_migration_process_unknown");
+            return identity;
+        },
+        inspectIdentity: pid => defaultProcessController.inspectIdentity(pid),
+        registry: createJournalLeaseRegistry(),
+        syncDirectory: async (path) => {
+            if (process.platform === "win32")
+                return;
+            const handle = await open(path, "r");
+            try {
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        },
+    });
+    const deadline = Date.now() + (options.waitMs ?? 2000);
+    for (;;) {
+        try {
+            await lease.acquire();
+            break;
+        }
+        catch (error) {
+            if (!(error instanceof JournalLockedError))
+                throw error;
+            if (Date.now() >= deadline)
+                throw new Error("memory_migration_access_busy");
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+    }
+    try {
+        if (!options.maintenance)
+            await assertMemoryAccessAllowed(root, {
+                ...(options.initializedRecoveryIdentity === undefined ? {} : {
+                    initializedRecoveryIdentity: options.initializedRecoveryIdentity,
+                }),
+                ...(options.pendingOnly ? { pendingOnly: true } : {}),
+            });
+        lease.assertUsable();
+        return await operation({ created });
+    }
+    finally {
+        await lease.close();
+    }
+}

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

@@ -0,0 +1,54 @@
+import { isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { applyMemoryMigration, prepareMemoryMigration, recoverMemoryMigration, statusMemoryMigration } from './migration-store.js';
+import { MigrationError, MigrationHistorySchema, MigrationIdentitySchema, MigrationIntentReceiptSchema, MigrationProcessStoppedReceiptSchema, MigrationRecordMappingSchema } from './migration-schema.js';
+const base = z.object({ agentDir: z.string().refine(isAbsolute), identity: MigrationIdentitySchema });
+export const MigrationCommandSchema = z.discriminatedUnion('command', [
+    base.extend({ command: z.literal('prepare'), serverHistory: MigrationHistorySchema, recordMappings: z.array(MigrationRecordMappingSchema).max(10000).optional() }).strict(),
+    base.extend({ command: z.literal('status') }).strict(),
+    base.extend({ command: z.literal('apply'), intentReceipt: MigrationIntentReceiptSchema }).strict(),
+    base.extend({ command: z.literal('recover'), serverHistory: MigrationHistorySchema.optional(), intentReceipt: MigrationIntentReceiptSchema.optional(), stoppedReceipt: MigrationProcessStoppedReceiptSchema.optional(), cancelled: z.boolean() }).strict(),
+]);
+export function summarizeMemoryMigration(state) {
+    return { migrationId: state?.migrationId ?? null, phase: state?.phase ?? null, storageVersion: state?.storageVersion ?? null, sourceDigest: state?.sourceDigest ?? null, planDigest: state?.planDigest ?? null,
+        issues: state?.issues ?? [], result: state === null ? 'missing' : state.phase === 'repair_required' ? 'repair_required' : 'success' };
+}
+/** The caller owns the execution/maintenance lease. This boundary never accepts or reads credentials. */
+export async function runMemoryMigrationCommand(raw) {
+    let migrationId = null;
+    try {
+        const input = MigrationCommandSchema.parse(raw);
+        migrationId = input.identity.migrationId;
+        const state = input.command === 'prepare' ? await prepareMemoryMigration(input) : input.command === 'apply' ? await applyMemoryMigration(input)
+            : input.command === 'recover' ? await recoverMemoryMigration(input) : await statusMemoryMigration(input);
+        return summarizeMemoryMigration(state);
+    }
+    catch (error) {
+        const reason = error instanceof MigrationError ? error.code : error instanceof z.ZodError ? 'migration_input_invalid' : 'migration_operation_failed';
+        return { ...summarizeMemoryMigration(null), migrationId, result: reason === 'migration_needs_review' ? 'needs_review' : reason.includes('repair_required') ? 'repair_required' : 'failed',
+            issues: error instanceof MigrationError && error.issues.length ? error.issues : [{ path: '', reason }] };
+    }
+}
+async function main() {
+    try {
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of process.stdin) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += buffer.length;
+            if (bytes > 8 * 1024 * 1024)
+                throw new Error('input_limit');
+            chunks.push(buffer);
+        }
+        const result = await runMemoryMigrationCommand(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        process.exitCode = result.result === 'success' || result.result === 'missing' ? 0 : 1;
+    }
+    catch {
+        process.stdout.write(`${JSON.stringify({ ...summarizeMemoryMigration(null), result: 'failed', issues: [{ path: '', reason: 'migration_input_invalid' }] })}\n`);
+        process.exitCode = 1;
+    }
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url))
+    void main();