@nowcrew/daemon 0.6.99-beta.3 → 0.6.99-beta.4

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

@@ -1,414 +0,0 @@
-import { statfs, rm, readdir, opendir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { z } from 'zod';
-import { atomicBytes, digest, inventory, readBytes, safePath, STATE_PATH, syncDirectory, validateMigrationRoot } from './migration-io.js';
-import { initializeExactWorkspaceSeed, planMemoryMigration, validateMigrationTarget } from './migration-plan.js';
-import { MigrationError, MigrationHistorySchema, MigrationProcessStoppedReceiptSchema, MigrationStateSchema } from './migration-schema.js';
-import { inspectManagedDetailFilesWithMappings } from './inventory-v2.js';
-import { assertMigrationStateIntegrity as assertIdentity, encodeMigrationData as encode, migrationOperationRoot as opRoot, migrationPlanDigest as planDigest, sameMigrationData as same, verifyMigrationIntent as verifyIntent, } from './migration-state-invariants.js';
-import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from './storage-format.js';
-import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from './initialization-identity.js';
-async function immutable(root, path, data) {
-    const previous = await readBytes(root, path, 64 * 1024 * 1024);
-    if (previous) {
-        if (digest(previous) !== digest(data))
-            throw new MigrationError('migration_immutable_hash_mismatch', [{ path, reason: 'hash_mismatch' }]);
-        return;
-    }
-    await atomicBytes(root, path, data);
-}
-async function save(root, state) {
-    const parsed = MigrationStateSchema.parse(state);
-    assertIdentity(parsed, parsed.identity);
-    if (parsed.phase === 'committed' || parsed.phase === 'rolled_back') {
-        const previous = await readBytes(root, `${opRoot(parsed.identity)}/terminal.json`, 32 * 1024 * 1024);
-        if (previous && !same(JSON.parse(previous.toString('utf8')), parsed)) {
-            throw new MigrationError('migration_terminal_conflict');
-        }
-    }
-    await atomicBytes(root, STATE_PATH, encode(parsed));
-    // State is the commit point. Retain the same terminal fact separately so accidental state loss cannot replay a completed plan.
-    if (parsed.phase === 'committed' || parsed.phase === 'rolled_back')
-        await immutable(root, `${opRoot(parsed.identity)}/terminal.json`, encode(parsed));
-    return parsed;
-}
-async function readState(root) {
-    const bytes = await readBytes(root, STATE_PATH, 32 * 1024 * 1024);
-    if (!bytes)
-        return null;
-    let state;
-    try {
-        state = MigrationStateSchema.parse(JSON.parse(bytes.toString('utf8')));
-    }
-    catch {
-        throw new MigrationError('migration_state_invalid');
-    }
-    return state;
-}
-async function load(input) {
-    const state = await readState(input.agentDir);
-    if (state)
-        assertIdentity(state, input.identity);
-    return state;
-}
-export async function statusMemoryMigration(input) {
-    const identity = await validateMigrationRoot(input.agentDir, input.identity);
-    return load({ ...input, identity });
-}
-export async function prepareMemoryMigration(input, hooks = {}) {
-    const identity = await validateMigrationRoot(input.agentDir, input.identity);
-    const history = MigrationHistorySchema.parse(input.serverHistory);
-    const existing = await readState(input.agentDir);
-    if (existing?.migrationId === identity.migrationId) {
-        assertIdentity(existing, identity);
-        return existing;
-    }
-    if (history.kind !== 'none' || history.writeIntentConfirmed === true)
-        throw new MigrationError(history.kind === 'existing' ? 'migration_recovery_required' : 'migration_server_history_unavailable');
-    const operations = await readdir(await safePath(input.agentDir, '.crew/memory/migrations')).catch((error) => {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    });
-    await verifyRolledBackPredecessors(input.agentDir, identity, history, operations, existing);
-    const leftovers = await readBytes(input.agentDir, `${opRoot(identity)}/manifest.json`, 32 * 1024 * 1024);
-    if (leftovers) {
-        const prepared = MigrationStateSchema.parse(JSON.parse(leftovers.toString('utf8')));
-        assertIdentity(prepared, identity);
-        const intent = await readBytes(input.agentDir, `${opRoot(identity)}/intent.json`);
-        const current = await classify(input.agentDir, prepared);
-        if (intent || current.unknown.length || current.classes.some(value => value !== 'B' && value !== 'AB'))
-            throw new MigrationError('migration_recovery_required');
-        if (!await copies(input.agentDir, prepared, 'before') || !await copies(input.agentDir, prepared, 'after'))
-            throw new MigrationError('migration_copy_invalid');
-        return save(input.agentDir, prepared);
-    }
-    const before = await inventory(input.agentDir);
-    const sourceMemory = before.files.get('MEMORY.md');
-    if (history.isNewAgent === true && identity.sourceStorageVersion === 0 && before.files.size === 0 && before.directories.length === 0)
-        throw new MigrationError('migration_workspace_seed_required');
-    const previousSeed = existing?.origin === 'initialized' && existing.phase === 'rolled_back'
-        ? existing.manifest.files.find(file => file.path === 'MEMORY.md')?.before : undefined;
-    const retryingOriginalSeed = previousSeed?.exists === true && sourceMemory !== undefined && digest(sourceMemory) === previousSeed.sha256;
-    const expectedInitializationIdentity = await localMemoryInitializationIdentity(input.agentDir, identity.agentId, {
-        workspaceId: identity.workspaceId,
-        machineId: identity.machineId,
-    });
-    const onlyCurrentOperationResidue = isLocalMemoryInitializationIdentity(identity, expectedInitializationIdentity)
-        && existing === null && operations.length === 1
-        && operations[0] === identity.migrationId;
-    const pristineSeed = (history.isNewAgent === true && (operations.length === 0 || onlyCurrentOperationResidue) || retryingOriginalSeed) && identity.sourceStorageVersion === 0
-        && before.files.size === 1 && sourceMemory !== undefined && before.directories.every(path => path === 'notes' || path === '.crew/memory/pending')
-        ? initializeExactWorkspaceSeed(sourceMemory) : null;
-    const initialized = history.isNewAgent === true && identity.sourceStorageVersion === 0
-        && pristineSeed !== null;
-    const after = pristineSeed !== null ? { files: new Map([['MEMORY.md', pristineSeed]]), recordMappings: [] } : planMemoryMigration(identity, before.files, input.recordMappings);
-    if (pristineSeed !== null)
-        validateMigrationTarget(after.files);
-    const paths = [...new Set([...before.files.keys(), ...after.files.keys()])].sort();
-    const manifest = { directories: before.directories, recordMappings: after.recordMappings, files: paths.map(path => {
-            const b = before.files.get(path);
-            const a = after.files.get(path);
-            return { path, before: b ? { exists: true, sha256: digest(b), ref: `${opRoot(identity)}/backup/${digest(b)}`, bytes: b.length } : { exists: false },
-                after: a ? { exists: true, sha256: digest(a), ref: `${opRoot(identity)}/staged/${digest(a)}`, bytes: a.length } : { exists: false } };
-        }) };
-    const sourceDigest = digest(encode({ directories: before.directories, files: manifest.files.map(file => ({ path: file.path, before: file.before.exists ? { exists: true, sha256: file.before.sha256 } : { exists: false } })) }));
-    const state = { schemaVersion: 1, identity, storageVersion: identity.sourceStorageVersion, targetStorageVersion: 2, origin: initialized ? 'initialized' : 'migrated', migrationId: identity.migrationId, phase: 'prepared', sourceDigest,
-        planDigest: planDigest(identity, sourceDigest, manifest), manifest, issues: [] };
-    MigrationStateSchema.parse(state);
-    const beforeBytes = [...before.files.values()].reduce((sum, value) => sum + value.length, 0);
-    const afterBytes = [...after.files.values()].reduce((sum, value) => sum + value.length, 0);
-    const max = Math.max(0, ...[...before.files.values(), ...after.files.values()].map(value => value.length));
-    const available = hooks.availableBytes ? await hooks.availableBytes() : await statfs(input.agentDir).then(value => value.bavail * value.bsize);
-    if (available < beforeBytes + afterBytes + max + encode(state).length * 3)
-        throw new MigrationError('migration_insufficient_disk_space');
-    for (const file of manifest.files) {
-        if (file.before.exists)
-            await immutable(input.agentDir, file.before.ref, before.files.get(file.path));
-        if (file.after.exists)
-            await immutable(input.agentDir, file.after.ref, after.files.get(file.path));
-    }
-    const current = await inventory(input.agentDir);
-    if (!same([...current.files].map(([path, bytes]) => [path, digest(bytes)]), [...before.files].map(([path, bytes]) => [path, digest(bytes)])) || !same(current.directories, before.directories))
-        throw new MigrationError('migration_source_changed');
-    await immutable(input.agentDir, `${opRoot(identity)}/manifest.json`, encode(state));
-    return save(input.agentDir, state);
-}
-/** 新操作只接纳服务端明确授权、摘要相符的回退终态；旧备份和历史保持不可变。 */
-async function verifyRolledBackPredecessors(root, identity, history, operations, existing) {
-    const authorized = history.rolledBackOperations ?? [];
-    const allowed = new Map(authorized.map(operation => [operation.migrationId, operation]));
-    if (allowed.size !== authorized.length || allowed.has(identity.migrationId)
-        || authorized.length > 0 && history.migrationId !== identity.migrationId
-        || operations.some(name => name !== identity.migrationId && !allowed.has(name))
-        || authorized.some(operation => !operations.includes(operation.migrationId))
-        || existing && !allowed.has(existing.migrationId))
-        throw new MigrationError('migration_operation_residue');
-    for (const previous of authorized) {
-        const bytes = await readBytes(root, `.crew/memory/migrations/${previous.migrationId}/terminal.json`, 32 * 1024 * 1024);
-        if (!bytes)
-            throw new MigrationError('migration_rollback_history_invalid');
-        const terminal = MigrationStateSchema.parse(JSON.parse(bytes.toString('utf8')));
-        assertIdentity(terminal, terminal.identity);
-        if (terminal.phase !== 'rolled_back' || terminal.migrationId !== previous.migrationId
-            || terminal.sourceDigest !== previous.sourceDigest || terminal.planDigest !== previous.planDigest
-            || terminal.storageVersion !== terminal.identity.sourceStorageVersion
-            || ['workspaceId', 'agentId', 'rootFingerprint', 'ownerIdentity', 'machineId'].some(key => terminal.identity[key] !== identity[key])
-            || existing?.migrationId === terminal.migrationId && !same(existing, terminal))
-            throw new MigrationError('migration_rollback_history_invalid');
-        const manifest = await readBytes(root, `${opRoot(terminal.identity)}/manifest.json`, 32 * 1024 * 1024);
-        if (!manifest)
-            throw new MigrationError('migration_rollback_history_invalid');
-        const prepared = MigrationStateSchema.parse(JSON.parse(manifest.toString('utf8')));
-        assertIdentity(prepared, terminal.identity);
-        if (prepared.planDigest !== terminal.planDigest || !await copies(root, terminal, 'before'))
-            throw new MigrationError('migration_rollback_history_invalid');
-    }
-}
-function matches(bytes, image) { return image.exists ? bytes !== undefined && digest(bytes) === image.sha256 : bytes === undefined; }
-function publicationPath(state, path, sha256) {
-    return `${opRoot(state.identity)}/publish/${digest(path)}-${sha256}.tmp`;
-}
-async function validatePublicationCopies(root, state) {
-    const directory = `${opRoot(state.identity)}/publish`;
-    const allowed = new Map();
-    for (const file of state.manifest.files)
-        for (const image of [file.before, file.after]) {
-            if (image.exists)
-                allowed.set(publicationPath(state, file.path, image.sha256), image.sha256);
-        }
-    const stream = await opendir(await safePath(root, directory)).catch((error) => {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    });
-    if (!stream)
-        return;
-    for await (const entry of stream) {
-        const path = `${directory}/${entry.name}`;
-        const expected = allowed.get(path);
-        if (!expected || !entry.isFile())
-            throw new MigrationError('migration_publication_copy_unknown', [{ path, reason: 'unrecognized_publication_copy' }]);
-        const content = await readBytes(root, path);
-        if (!content || digest(content) !== expected)
-            throw new MigrationError('migration_publication_copy_unknown', [{ path, reason: 'publication_hash_mismatch' }]);
-    }
-}
-async function classify(root, state) {
-    await validatePublicationCopies(root, state);
-    const current = await inventory(root);
-    const known = new Set(state.manifest.files.map(file => file.path));
-    const allowedDirs = new Set(state.manifest.directories);
-    for (const file of state.manifest.files)
-        if (file.after.exists) {
-            let dir = dirname(file.path);
-            while (dir !== '.' && dir !== '.crew' && dir !== '.crew/memory') {
-                allowedDirs.add(dir);
-                dir = dirname(dir);
-            }
-        }
-    const unknown = [...current.files.keys()].filter(path => !known.has(path));
-    unknown.push(...current.directories.filter(path => !allowedDirs.has(path)), ...state.manifest.directories.filter(path => !current.directories.includes(path)));
-    return { files: current.files, unknown, classes: state.manifest.files.map(file => { const b = matches(current.files.get(file.path), file.before), a = matches(current.files.get(file.path), file.after); return a && b ? 'AB' : a ? 'A' : b ? 'B' : 'X'; }) };
-}
-async function copies(root, state, side) {
-    const files = new Map();
-    try {
-        for (const file of state.manifest.files) {
-            const image = file[side];
-            if (image.exists) {
-                const bytes = await readBytes(root, image.ref);
-                if (!bytes || bytes.length !== image.bytes || digest(bytes) !== image.sha256)
-                    return null;
-                files.set(file.path, bytes);
-            }
-        }
-    }
-    catch {
-        return null;
-    }
-    return files;
-}
-async function repair(root, state, paths, reason) { return save(root, { ...state, phase: 'repair_required', issues: paths.map(path => ({ path, reason })) }); }
-async function publish(root, state, side, hooks) {
-    let index = 0;
-    for (const file of state.manifest.files) {
-        const current = await readBytes(root, file.path);
-        const bytes = current ?? undefined;
-        if (matches(bytes, file[side]))
-            continue;
-        const opposite = file[side === 'after' ? 'before' : 'after'];
-        if (!matches(bytes, opposite))
-            throw new MigrationError('migration_unknown_change', [{ path: file.path, reason: 'changed_before_replace' }]);
-        const image = file[side];
-        if (image.exists) {
-            const data = await readBytes(root, image.ref);
-            if (!data || digest(data) !== image.sha256)
-                throw new MigrationError('migration_copy_invalid');
-            const temporaryPath = publicationPath(state, file.path, image.sha256);
-            await atomicBytes(root, file.path, data, { temporaryPath, beforeRename: () => hooks.beforeReplace?.(file.path, temporaryPath, index),
-                afterWriteChunk: (writtenPath, written, total) => hooks.afterPublicationWrite?.(file.path, writtenPath, written, total) });
-        }
-        else {
-            const target = await safePath(root, file.path);
-            await rm(target);
-            await syncDirectory(dirname(target));
-        }
-        await hooks.afterReplace?.(file.path, index++);
-    }
-}
-function validTarget(files, mappings = [], sourceHashes = new Map()) {
-    try {
-        validateMigrationTarget(files);
-        const memory = files.get('MEMORY.md');
-        if (memory === undefined)
-            return false;
-        const entries = [...parseFullMemoryIndex(memory.toString('utf8'))];
-        const sources = [...files]
-            .filter(([path]) => path === 'MEMORY.md' || path.startsWith('notes/'))
-            .map(([path, bytes]) => ({ path, bytes: bytes.length, sha256: digest(bytes), content: bytes.toString('utf8') }));
-        const inspection = inspectManagedDetailFilesWithMappings(entries, sources, mappings, sourceHashes);
-        return inspection.fileIssues.length === 0 && inspection.entryIssues.size === 0;
-    }
-    catch {
-        return false;
-    }
-}
-function manifestSourceHashes(manifest) {
-    return new Map(manifest.files
-        .flatMap(file => file.before.exists ? [[file.path, file.before.sha256]] : []));
-}
-async function finalState(input, state) {
-    const terminalPath = `${opRoot(state.identity)}/terminal.json`;
-    const bytes = await readBytes(input.agentDir, terminalPath, 32 * 1024 * 1024);
-    let terminal = null;
-    if (bytes) {
-        terminal = MigrationStateSchema.parse(JSON.parse(bytes.toString('utf8')));
-        assertIdentity(terminal, input.identity);
-        if ((terminal.phase !== 'committed' && terminal.phase !== 'rolled_back') || terminal.planDigest !== state.planDigest)
-            throw new MigrationError('migration_terminal_invalid');
-    }
-    else if (state.phase === 'committed' || state.phase === 'rolled_back') {
-        // Persist the already-published commit point before any content-health update can replace the mutable state.
-        await immutable(input.agentDir, terminalPath, encode(state));
-        terminal = state;
-    }
-    if (terminal?.phase === 'committed') {
-        let valid = false;
-        try {
-            valid = validTarget((await inventory(input.agentDir)).files, state.manifest.recordMappings, manifestSourceHashes(state.manifest));
-        }
-        catch { /* Protect damaged content without erasing commit history. */ }
-        if (!valid)
-            return repair(input.agentDir, terminal, ['MEMORY.md'], 'committed_target_invalid');
-        return same(state, terminal) ? terminal : save(input.agentDir, terminal);
-    }
-    if (terminal?.phase === 'rolled_back')
-        return same(state, terminal) ? terminal : save(input.agentDir, terminal);
-    return null;
-}
-export async function applyMemoryMigration(input, hooks = {}) {
-    await validateMigrationRoot(input.agentDir, input.identity);
-    let state = await load(input);
-    if (!state)
-        throw new MigrationError('migration_state_missing');
-    const done = await finalState(input, state);
-    if (done)
-        return done;
-    if (state.phase !== 'prepared')
-        throw new MigrationError('migration_recovery_required');
-    const receipt = verifyIntent(input.intentReceipt, state);
-    const classification = await classify(input.agentDir, state);
-    if (classification.unknown.length || classification.classes.some(value => value !== 'B' && value !== 'AB'))
-        return repair(input.agentDir, state, classification.unknown.length ? classification.unknown : ['MEMORY.md'], 'source_changed');
-    const backup = await copies(input.agentDir, state, 'before'), staged = await copies(input.agentDir, state, 'after');
-    if (!backup || !staged || !validTarget(staged, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
-        throw new MigrationError('migration_copy_invalid');
-    await immutable(input.agentDir, `${opRoot(state.identity)}/intent.json`, encode(receipt));
-    state = await save(input.agentDir, { ...state, phase: 'applying', intentReceipt: receipt });
-    await publish(input.agentDir, state, 'after', hooks);
-    const current = await classify(input.agentDir, state);
-    if (current.unknown.length || current.classes.some(value => value === 'X' || value === 'B') || !validTarget(current.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
-        return repair(input.agentDir, state, ['MEMORY.md'], 'target_validation_failed');
-    return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2 });
-}
-export async function recoverMemoryMigration(input, hooks = {}) {
-    await validateMigrationRoot(input.agentDir, input.identity);
-    let state = await readState(input.agentDir);
-    if (state && state.migrationId !== input.identity.migrationId) {
-        const history = MigrationHistorySchema.parse(input.serverHistory);
-        if (history.kind !== 'existing' || history.migrationId !== input.identity.migrationId)
-            throw new MigrationError('migration_history_missing_or_mismatch');
-        const operations = await readdir(await safePath(input.agentDir, '.crew/memory/migrations'));
-        await verifyRolledBackPredecessors(input.agentDir, input.identity, history, operations, state);
-        state = null;
-    }
-    if (state)
-        assertIdentity(state, input.identity);
-    if (!state) {
-        const history = MigrationHistorySchema.parse(input.serverHistory);
-        if (history.kind !== 'existing' || history.migrationId !== input.identity.migrationId)
-            throw new MigrationError('migration_history_missing_or_mismatch');
-        const terminal = await readBytes(input.agentDir, `${opRoot(input.identity)}/terminal.json`, 32 * 1024 * 1024);
-        if (terminal) {
-            const terminalState = MigrationStateSchema.parse(JSON.parse(terminal.toString('utf8')));
-            assertIdentity(terminalState, input.identity);
-            if (terminalState.phase !== 'committed' && terminalState.phase !== 'rolled_back')
-                throw new MigrationError('migration_terminal_invalid');
-            const final = await finalState(input, terminalState);
-            if (final)
-                return save(input.agentDir, final);
-        }
-        const bytes = await readBytes(input.agentDir, `${opRoot(input.identity)}/manifest.json`, 32 * 1024 * 1024);
-        if (!bytes)
-            throw new MigrationError('migration_manifest_missing_repair_required');
-        state = MigrationStateSchema.parse(JSON.parse(bytes.toString('utf8')));
-        assertIdentity(state, input.identity);
-        const receipt = await readBytes(input.agentDir, `${opRoot(input.identity)}/intent.json`);
-        if (receipt)
-            state = { ...state, phase: 'applying', intentReceipt: verifyIntent(JSON.parse(receipt.toString('utf8')), state) };
-        else if (history.writeIntentConfirmed && !input.intentReceipt)
-            throw new MigrationError('migration_intent_receipt_required');
-    }
-    const done = await finalState(input, state);
-    if (done)
-        return done;
-    const stopped = MigrationProcessStoppedReceiptSchema.parse(input.stoppedReceipt);
-    if (stopped.migrationId !== state.migrationId || stopped.machineId !== state.identity.machineId || stopped.executionId !== state.identity.executionId || stopped.ownerIdentity !== state.identity.ownerIdentity
-        || (stopped.proof === 'not_started' && (state.phase !== 'prepared' || state.intentReceipt || input.intentReceipt)))
-        throw new MigrationError('migration_stop_proof_invalid');
-    const cancelled = z.boolean().parse(input.cancelled);
-    let receipt = state.intentReceipt;
-    if (input.intentReceipt)
-        receipt = verifyIntent(input.intentReceipt, state);
-    let current;
-    try {
-        current = await classify(input.agentDir, state);
-    }
-    catch {
-        return repair(input.agentDir, state, ['MEMORY.md'], 'unsafe_or_unreadable_source');
-    }
-    if (current.unknown.length || current.classes.includes('X'))
-        return repair(input.agentDir, state, [...current.unknown, ...state.manifest.files.filter((_, index) => current.classes[index] === 'X').map(file => file.path)], 'unknown_change');
-    const allA = current.classes.every(value => value === 'A' || value === 'AB'), allB = current.classes.every(value => value === 'B' || value === 'AB');
-    if (allA && !cancelled && validTarget(current.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
-        return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2, ...(receipt ? { intentReceipt: receipt } : {}) });
-    if (allB && (!receipt || cancelled))
-        return save(input.agentDir, { ...state, phase: 'rolled_back', storageVersion: state.identity.sourceStorageVersion });
-    const staged = await copies(input.agentDir, state, 'after');
-    if (receipt && !cancelled && staged && validTarget(staged, state.manifest.recordMappings, manifestSourceHashes(state.manifest))) {
-        state = await save(input.agentDir, { ...state, phase: 'applying', intentReceipt: receipt });
-        await publish(input.agentDir, state, 'after', hooks);
-        const target = await classify(input.agentDir, state);
-        if (!target.unknown.length && target.classes.every(value => value === 'A' || value === 'AB') && validTarget(target.files, state.manifest.recordMappings, manifestSourceHashes(state.manifest)))
-            return save(input.agentDir, { ...state, phase: 'committed', storageVersion: 2 });
-    }
-    const backup = await copies(input.agentDir, state, 'before');
-    if (!backup || detectLocalMemoryStorageVersion(backup.get('MEMORY.md')?.toString('utf8') ?? '') !== state.identity.sourceStorageVersion)
-        return repair(input.agentDir, state, ['MEMORY.md'], 'backup_unverifiable');
-    await publish(input.agentDir, state, 'before', hooks);
-    const restored = await classify(input.agentDir, state);
-    if (restored.unknown.length || !restored.classes.every(value => value === 'B' || value === 'AB'))
-        return repair(input.agentDir, state, ['MEMORY.md'], 'rollback_validation_failed');
-    return save(input.agentDir, { ...state, phase: 'rolled_back', storageVersion: state.identity.sourceStorageVersion });
-}

package/dist/local-memory/migration-tool-entry.js

@@ -1,21 +0,0 @@
-import { runMemoryMigrationCommand, MigrationCommandSchema } from "./migration-cli.js";
-import { withMemoryAccess } from "./migration-access.js";
-async function main() {
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of process.stdin) {
-        const part = Buffer.from(chunk);
-        bytes += part.length;
-        if (bytes > 8 * 1024 * 1024)
-            throw new Error("migration_input_limit");
-        chunks.push(part);
-    }
-    const input = MigrationCommandSchema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-    const result = await withMemoryAccess(input.agentDir, () => runMemoryMigrationCommand(input), { maintenance: true });
-    process.stdout.write(JSON.stringify(result) + "\n");
-    process.exitCode = result.result === "success" || result.result === "missing" ? 0 : 1;
-}
-void main().catch(() => {
-    process.stdout.write(JSON.stringify({ result: "failed", issues: [{ path: "", reason: "migration_tool_failed" }] }) + "\n");
-    process.exitCode = 1;
-});

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

@@ -1,13 +0,0 @@
-/**
- * Files retained for audit/rollback but excluded from current memory coverage.
- * The patterns are deliberately conservative and only recognize obvious
- * backup/previous-version names.
- */
-export function isDeferredMemoryArtifactPath(path) {
-    if (!path.startsWith("notes/"))
-        return false;
-    const name = path.slice("notes/".length);
-    return name === "MEMORY.md"
-        || /^MEMORY\.md(?:\.bak(?:[-_.].*)?|[-_.]20\d{2}[-_]\d{2}[-_]\d{2}.*)$/iu.test(name)
-        || /^(?!bak(?:[-_.]|$)|backup(?:[-_.]|$)|prev(?:[-_.]|$)).*(?:[-_.](?:bak|backup|prev))(?:[-_.]|$).*$/iu.test(name);
-}