@nowcrew/daemon 0.6.97-beta.2 → 0.6.97-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/storage-format.js

@@ -1,152 +0,0 @@
-import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderGeneratedIndex, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
-export const LOCAL_MEMORY_STORAGE_BYTE_CAP = 16 * 1024 * 1024;
-export const LOCAL_MEMORY_STORAGE_ENTRY_CAP = 10_000;
-export const LOCAL_MEMORY_NOTE_BYTE_CAP = 32 * 1024 * 1024;
-export const LOCAL_MEMORY_READ_BYTE_CAP = 64 * 1024 * 1024;
-export const LOCAL_MEMORY_GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=[12]\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
-const length = (text) => {
-    let count = 0;
-    for (const _character of text)
-        count += 1;
-    return count;
-};
-const TYPES = new Set(["procedural", "semantic", "episodic", "preference"]);
-const STATUSES = new Set(["candidate", "active", "pinned", "stale", "superseded", "archived"]);
-const PRIORITIES = new Set(["high", "medium", "low"]);
-const FIELDS = new Set(["id", "file", "type", "status", "summary", "triggers", "priority", "revision", "anchor", "updated", "review_after"]);
-/** A malformed/unknown marker is never treated as an unmarked legacy file. */
-export function detectLocalMemoryStorageVersion(memory) {
-    const markerCount = (memory.match(/NOWWORK:MEMORY_INDEX:/gu) ?? []).length;
-    if (markerCount === 0)
-        return 0;
-    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory);
-    if (markerCount !== 2 || block?.index === undefined)
-        throw new Error("local_memory_storage_version_invalid");
-    const headings = [...memory.matchAll(/^##[\t ]+Knowledge Index[\t ]*\r?$/gmu)];
-    const heading = headings[0];
-    if (headings.length !== 1 || heading?.index === undefined)
-        throw new Error("local_memory_storage_index_invalid");
-    const sectionStart = heading.index + heading[0].length;
-    const nextSection = /^##[\t ]+(?!#)/mu.exec(memory.slice(sectionStart));
-    const sectionEnd = nextSection?.index === undefined ? memory.length : sectionStart + nextSection.index;
-    if (block.index < sectionStart || block.index + block[0].length > sectionEnd) {
-        throw new Error("local_memory_storage_index_invalid");
-    }
-    return /schema=2\s*-->/u.test(block[0].slice(0, block[0].indexOf("\n") + 1) || block[0]) ? 2 : 1;
-}
-function validateEntry(entry) {
-    const singleLine = (value) => !/[\r\n\u0000-\u001f\u007f]/u.test(value)
-        && !/<!--/u.test(value);
-    if (!entry.title.trim() || !entry.summary.trim()
-        || ![entry.title, entry.summary, entry.updated, ...entry.triggers].every(singleLine)
-        || !/^[A-Za-z0-9_-]+$/u.test(entry.id) || entry.anchor !== entry.id
-        || !/^notes\/(?:preferences|project-rules|testing|debugging|git|incidents|lessons)\.md$/u.test(entry.file)
-        || !TYPES.has(entry.type) || !STATUSES.has(entry.status) || !PRIORITIES.has(entry.priority)
-        || !Number.isSafeInteger(entry.revision) || entry.revision < 1
-        || !entry.updated.trim()
-        || (entry.reviewAfter !== null && !singleLine(entry.reviewAfter))) {
-        throw new Error("local_memory_storage_entry_invalid");
-    }
-}
-function validateEntries(entries) {
-    if (entries.length > LOCAL_MEMORY_STORAGE_ENTRY_CAP)
-        throw new Error("local_memory_storage_entry_limit");
-    const ids = new Set();
-    for (const entry of entries) {
-        validateEntry(entry);
-        if (ids.has(entry.id))
-            throw new Error("local_memory_storage_duplicate_id");
-        ids.add(entry.id);
-    }
-}
-export function assertLocalMemoryStorageSize(memory) {
-    if (Buffer.byteLength(memory, "utf8") > LOCAL_MEMORY_STORAGE_BYTE_CAP)
-        throw new Error("local_memory_storage_byte_limit");
-}
-/** schema=2 stores every lifecycle state, unlike the schema=1 prompt projection. */
-export function parseFullMemoryIndex(memory) {
-    assertLocalMemoryStorageSize(memory);
-    if (detectLocalMemoryStorageVersion(memory) !== 2)
-        throw new Error("local_memory_storage_version_invalid");
-    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory)[0];
-    const body = block.replace(/^<!--[^>]*-->\s*/u, "").replace(/<!--[^>]*-->$/u, "");
-    const headings = [...body.matchAll(/^###[\t ]+(.+?)[\t ]*\r?$/gmu)];
-    if (headings.length > LOCAL_MEMORY_STORAGE_ENTRY_CAP)
-        throw new Error("local_memory_storage_entry_limit");
-    if (body.slice(0, headings[0]?.index ?? body.length).trim())
-        throw new Error("local_memory_storage_entry_invalid");
-    const entries = headings.map((heading, index) => {
-        const fields = {};
-        const tail = body.slice(heading.index + heading[0].length, headings[index + 1]?.index ?? body.length);
-        for (const line of tail.split(/\r?\n/u)) {
-            if (!line.trim())
-                continue;
-            const field = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/u.exec(line);
-            if (!field || !FIELDS.has(field[1]) || fields[field[1]] !== undefined)
-                throw new Error("local_memory_storage_entry_invalid");
-            fields[field[1]] = field[2];
-        }
-        if ([...FIELDS].filter(field => field !== "review_after").some(field => fields[field] === undefined)) {
-            throw new Error("local_memory_storage_entry_invalid");
-        }
-        if (!/^[1-9][0-9]*$/u.test(fields.revision))
-            throw new Error("local_memory_storage_entry_invalid");
-        return {
-            id: fields.id, title: heading[1], file: fields.file, type: fields.type,
-            status: fields.status, summary: fields.summary,
-            triggers: fields.triggers.split(/[,，、]/u).map(value => value.trim()).filter(Boolean),
-            priority: fields.priority, revision: Number(fields.revision),
-            anchor: fields.anchor, updated: fields.updated, reviewAfter: fields.review_after ?? null,
-        };
-    });
-    validateEntries(entries);
-    const section = memory.slice(memory.indexOf("## Knowledge Index") + "## Knowledge Index".length);
-    const remaining = section.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, "").split(/^##[\t ]+(?!#)/mu)[0] ?? "";
-    if (/^###[\t ]+/mu.test(remaining.replace(/<!--[\s\S]*?-->/gu, "")))
-        throw new Error("local_memory_legacy_index_requires_migration");
-    return entries;
-}
-export function renderFullMemoryIndex(entries) {
-    validateEntries(entries);
-    const block = `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=2 -->\n${entries.map(renderLocalMemoryIndexCard).join("\n")}<!-- NOWWORK:MEMORY_INDEX:END -->`;
-    assertLocalMemoryStorageSize(block);
-    return block;
-}
-export function replaceFullMemoryIndex(memory, entries) {
-    if (detectLocalMemoryStorageVersion(memory) !== 2)
-        throw new Error("local_memory_storage_version_invalid");
-    const updated = memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => renderFullMemoryIndex(entries));
-    assertLocalMemoryStorageSize(updated);
-    return updated;
-}
-export function selectLocalMemoryPreview(memory, query = "", options = {}) {
-    const entries = parseFullMemoryIndex(memory);
-    const totalActiveEntries = entries.filter(entry => entry.status === "active" || entry.status === "pinned").length;
-    const emptyIndex = renderGeneratedIndex([]);
-    // Reserve the largest count label before selecting; all discovery text counts toward the same cap.
-    const hint = (shown) => `\nMemory preview: ${shown}/${totalActiveEntries} active entries. Use crew-memory search --query <text> and crew-memory read --file <file> for more.\n`;
-    const base = memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => `${emptyIndex}${hint(totalActiveEntries)}`);
-    const remaining = Math.min(LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, options.maxCodePoints ?? Infinity) - length(base);
-    const remainingBytes = (options.maxBytes ?? Infinity) - Buffer.byteLength(base, "utf8");
-    if (remaining < 0 || remainingBytes < 0 || Number.isNaN(remaining) || Number.isNaN(remainingBytes)) {
-        throw new Error("local_memory_identity_budget_exceeded");
-    }
-    const terms = query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
-    const selection = selectLocalMemoryIndexEntries(entries, {
-        entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP,
-        indexCodePointCap: Math.min(LOCAL_MEMORY_INDEX_CODE_POINT_CAP - length(emptyIndex), remaining),
-        indexByteCap: remainingBytes,
-    }, {
-        protectedIds: new Set(entries.filter(entry => entry.status === "pinned").map(entry => entry.id)),
-        relevance: entry => {
-            const searchable = `${entry.title} ${entry.summary} ${entry.triggers.join(" ")}`.normalize("NFKC").toLowerCase();
-            return terms.filter(term => searchable.includes(term)).length;
-        },
-    });
-    if (selection.reason === "index_over_budget_pinned")
-        throw new Error("local_memory_pinned_budget_exceeded");
-    return {
-        ...selection, totalActiveEntries,
-        memory: memory.replace(LOCAL_MEMORY_GENERATED_INDEX_PATTERN, () => `${renderGeneratedIndex(selection.entries)}${hint(selection.entries.length)}`),
-    };
-}

package/dist/local-memory/writer-mode.js

@@ -1,13 +0,0 @@
-import { detectLocalMemoryStorageVersion } from "./storage-format.js";
-/** Resolve format and rollout into one writer decision before a prune result is requested. */
-export function resolveLocalMemoryWriterMode(workspace, rollout) {
-    if (rollout.legacyFallback)
-        return "legacy";
-    if (!rollout.enabled)
-        return rollout.deferred ? "blocked" : "legacy";
-    // Production workspaces always report this fact. Historical partial unit
-    // callers retain their already-resolved rollout witness.
-    if (workspace.localMemoryV2Initialized === undefined)
-        return "v2";
-    return detectLocalMemoryStorageVersion(workspace.memory) === 2 ? "v2" : "blocked";
-}