@nowcrew/daemon 0.6.99-beta.3 → 0.6.99

package/dist/local-memory/storage-format.js

@@ -1,249 +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 LEGACY_INDEX_HEADING = /^##[\t ]+Knowledge Index[\t ]*\r?\n/mu;
-const LEGACY_NEXT_SECTION = /^##[\t ]+(?!#)/mu;
-const LEGACY_CARD_HEADING = /^###[\t ]+(.+?)[\t ]*\r?$/gmu;
-const MEMORY_PREVIEW_NOTICE = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";
-const length = (text) => {
-    let count = 0;
-    for (const _character of text)
-        count += 1;
-    return count;
-};
-function queryTerms(query) {
-    const normalized = query.normalize("NFKC").toLowerCase();
-    // 空白切词对中文混排请求只会产生一个无法命中的长 token；同时提取英文/数字
-    // 子 token，让 legacy 和 V2 预览共用同一套召回规则。
-    const whitespaceTokens = normalized.split(/\s+/u).filter(Boolean);
-    const alnumTokens = Array.from(normalized.matchAll(/[a-z0-9]{2,}/gu)).map((match) => match[0]);
-    return Array.from(new Set([...whitespaceTokens, ...alnumTokens]));
-}
-function fitsLegacyPreview(text, maxUnits, maxBytes) {
-    return text.length <= maxUnits && Buffer.byteLength(text, "utf8") <= maxBytes;
-}
-function truncateLegacyText(text, maxUnits, maxBytes) {
-    if (maxUnits <= 0 || maxBytes <= 0)
-        return "";
-    let result = "";
-    let units = 0;
-    let bytes = 0;
-    for (const character of text) {
-        const characterBytes = Buffer.byteLength(character, "utf8");
-        if (units + character.length > maxUnits || bytes + characterBytes > maxBytes)
-            break;
-        result += character;
-        units += character.length;
-        bytes += characterBytes;
-    }
-    return result;
-}
-/**
- * Legacy MEMORY.md has no schema-2 generated index, so the old path used to
- * inject only the first 6k UTF-16 units and could hide a matching late card.
- * Keep identity/preamble intact, then select complete legacy cards by query
- * while retaining the same UTF-16 and UTF-8 byte bounds.
- */
-export function selectLegacyMemoryPreview(memory, query = "", options = {}) {
-    // Keep legacy behavior: MEMORY_INJECT_CAP historically counted UTF-16 units.
-    const maxUnits = Math.min(LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, options.maxCodePoints ?? Infinity);
-    const maxBytes = options.maxBytes ?? Infinity;
-    if (fitsLegacyPreview(memory, maxUnits, maxBytes))
-        return memory;
-    if (!fitsLegacyPreview(MEMORY_PREVIEW_NOTICE, maxUnits, maxBytes))
-        return "";
-    const heading = LEGACY_INDEX_HEADING.exec(memory);
-    if (heading?.index === undefined) {
-        const noticeBytes = Buffer.byteLength(MEMORY_PREVIEW_NOTICE, "utf8");
-        return `${MEMORY_PREVIEW_NOTICE}${truncateLegacyText(memory, maxUnits - MEMORY_PREVIEW_NOTICE.length, maxBytes - noticeBytes)}`;
-    }
-    const indexStart = heading.index + heading[0].length;
-    const rest = memory.slice(indexStart);
-    const nextSection = LEGACY_NEXT_SECTION.exec(rest);
-    const indexEnd = nextSection?.index === undefined ? memory.length : indexStart + nextSection.index;
-    const indexContent = memory.slice(indexStart, indexEnd);
-    const masked = indexContent.replace(/<!--[\s\S]*?-->/gu, (comment) => comment.replace(/[^\r\n]/gu, " "));
-    const headings = [...masked.matchAll(LEGACY_CARD_HEADING)];
-    if (headings.length === 0) {
-        const noticeBytes = Buffer.byteLength(MEMORY_PREVIEW_NOTICE, "utf8");
-        return `${MEMORY_PREVIEW_NOTICE}${truncateLegacyText(memory, maxUnits - MEMORY_PREVIEW_NOTICE.length, maxBytes - noticeBytes)}`;
-    }
-    const terms = queryTerms(query);
-    const cards = headings.map((card, index) => {
-        const start = card.index ?? 0;
-        const end = headings[index + 1]?.index ?? indexContent.length;
-        const text = indexContent.slice(start, end);
-        const searchable = text.normalize("NFKC").toLowerCase();
-        return {
-            text,
-            index,
-            relevance: terms.filter((term) => searchable.includes(term)).length,
-        };
-    });
-    const ranked = [...cards].sort((left, right) => right.relevance - left.relevance || left.index - right.index);
-    const firstCard = headings[0]?.index ?? 0;
-    const preamble = indexContent.slice(0, firstCard);
-    const before = memory.slice(0, indexStart);
-    const suffix = memory.slice(indexEnd);
-    const fixed = `${MEMORY_PREVIEW_NOTICE}${before}${preamble}`;
-    if (!fitsLegacyPreview(fixed, maxUnits, maxBytes)) {
-        const noticeBytes = Buffer.byteLength(MEMORY_PREVIEW_NOTICE, "utf8");
-        return `${MEMORY_PREVIEW_NOTICE}${truncateLegacyText(memory, maxUnits - MEMORY_PREVIEW_NOTICE.length, maxBytes - noticeBytes)}`;
-    }
-    let selected = fixed;
-    let selectedCount = 0;
-    for (const card of ranked) {
-        const candidate = `${selected}${card.text}`;
-        if (!fitsLegacyPreview(candidate, maxUnits, maxBytes))
-            continue;
-        selected = candidate;
-        selectedCount += 1;
-    }
-    if (selectedCount === 0)
-        return fixed;
-    const withSuffix = `${selected}${suffix}`;
-    return fitsLegacyPreview(withSuffix, maxUnits, maxBytes) ? withSuffix : selected;
-}
-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 = queryTerms(query);
-    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";
-}

package/dist/memory-migration-controller.js

@@ -1,89 +0,0 @@
-import { z } from "zod";
-import { createRuntimeCancellation } from "./runtime-cancellation.js";
-import { MemoryMigrationStartSchema } from "./memory-migration-protocol.js";
-import { runMemoryMigration } from "./memory-migration-runtime.js";
-import { inspectMemoryForMigration } from "./memory-migration-inspect.js";
-const Inspect = MemoryMigrationStartSchema.pick({ reqId: true, protocolVersion: true, workspaceId: true,
-    agentId: true, handle: true, machineId: true }).extend({ type: z.literal("memory:migration:inspect"), executionId: z.string().uuid().optional() }).strict();
-export function createMemoryMigrationController(input) {
-    let identity = null;
-    const runs = new Map();
-    return {
-        setIdentity(value) { identity = value; },
-        clearIdentity() { identity = null; },
-        getIdentity() { return identity === null ? null : { ...identity }; },
-        cancel(executionId) { const run = runs.get(executionId); if (!run)
-            return false; run.cancel(); return true; },
-        async handle(raw) {
-            const type = raw?.type;
-            if (type !== "memory:migration:start" && type !== "memory:migration:inspect")
-                return false;
-            const parsed = type === "memory:migration:start" ? MemoryMigrationStartSchema.safeParse(raw) : Inspect.safeParse(raw);
-            if (!parsed.success) {
-                const reqId = raw.reqId;
-                if (typeof reqId === "string" && reqId.length <= 200)
-                    input.send({ type: "fs:result", reqId, ok: false, error: "memory_migration_invalid_request" });
-                return true;
-            }
-            const request = parsed.data;
-            if (!identity || request.workspaceId !== identity.workspaceId || request.machineId !== identity.machineId) {
-                input.send({ type: "fs:result", reqId: request.reqId, ok: false, error: "memory_migration_identity_mismatch" });
-                return true;
-            }
-            let journal;
-            try {
-                journal = input.journal();
-            }
-            catch {
-                input.send({ type: "fs:result", reqId: request.reqId, ok: false, error: "memory_migration_journal_unavailable" });
-                return true;
-            }
-            if (request.type === "memory:migration:inspect") {
-                try {
-                    const data = await inspectMemoryForMigration(input.config.agentsRoot, {
-                        ...request,
-                        serverUrl: input.config.serverUrl,
-                    }, journal);
-                    input.send({ type: "fs:result", reqId: request.reqId, ok: true, data });
-                }
-                catch {
-                    input.send({ type: "fs:result", reqId: request.reqId, ok: false, error: "memory_migration_inspection_failed" });
-                }
-                return true;
-            }
-            const existing = runs.get(request.executionId);
-            if (existing) {
-                input.send({ type: "fs:result", reqId: request.reqId, ok: true, data: { kind: "running" } });
-                return true;
-            }
-            if (input.isAdmissionClosed?.()) {
-                input.send({ type: "fs:result", reqId: request.reqId, ok: false, error: "memory_migration_storage_busy" });
-                return true;
-            }
-            const cancellation = createRuntimeCancellation();
-            const promise = runMemoryMigration(request, {
-                agentsRoot: input.config.agentsRoot, coordinator: input.coordinator, journal,
-                cancellation: cancellation.cancellation, send: input.send,
-                control: async (step, body) => {
-                    const base = `/daemon/memory-migrations/${encodeURIComponent(request.agentId)}`;
-                    const path = step === "history" ? `${base}/history` : `${base}/${request.migrationId}/${step === "needs-review" ? "review" : step}`;
-                    const response = await fetch(new URL(path, input.config.serverUrl), {
-                        method: step === "history" ? "GET" : "POST", signal: AbortSignal.timeout(10_000),
-                        headers: { authorization: `Bearer ${input.config.machineToken}`, "content-type": "application/json" },
-                        ...(step === "history" ? {} : { body: JSON.stringify(body) }),
-                    });
-                    const result = await response.json();
-                    if (!response.ok || result.success !== true)
-                        throw new Error("migration_control_unconfirmed");
-                    return result.data;
-                },
-            }).then(data => input.send({ type: "fs:result", reqId: request.reqId, ok: true, data }))
-                .catch(() => input.send({ type: "fs:result", reqId: request.reqId, ok: false, error: "memory_migration_failed" }))
-                .finally(() => runs.delete(request.executionId));
-            runs.set(request.executionId, { promise, cancel: cancellation.request });
-            return true;
-        },
-        async stop() { for (const run of runs.values())
-            run.cancel(); await Promise.allSettled([...runs.values()].map(run => run.promise)); },
-    };
-}

package/dist/memory-migration-inspect.js

@@ -1,108 +0,0 @@
-import { lstat, readFile, realpath, readdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { withMemoryAccess } from "./local-memory/migration-access.js";
-import { MigrationStateSchema } from "./local-memory/migration-schema.js";
-import { assertMigrationStateIntegrity } from "./local-memory/migration-state-invariants.js";
-import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./local-memory/storage-format.js";
-import { resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
-import { readMemoryInventorySource, inventoryLimits } from "./local-memory/inventory-source.js";
-import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from "./local-memory/initialization-identity.js";
-export async function inspectMemoryForMigration(agentsRoot, input, journal) {
-    const parent = await realpath(agentsRoot);
-    const path = join(parent, input.handle);
-    const missingBase = { workspaceId: input.workspaceId, agentId: input.agentId, machineId: input.machineId,
-        storageRootFingerprint: createHash("sha256").update(resolve(path)).digest("hex"),
-        ownerIdentity: String((await lstat(parent)).uid) };
-    const prior = input.executionId ? await journal?.get(input.executionId) : null;
-    const stoppedExecutionId = prior?.requestedRuntime === "memory_migration" && (prior.state === "completed" || prior.state === "interrupted") ? prior.executionId : null;
-    const missing = { ...missingBase, storageVersion: null, classification: "empty", emptyWithoutResidue: true, localState: null, issueCodes: [], stoppedExecutionId };
-    try {
-        await lstat(path);
-    }
-    catch (e) {
-        if (e.code === "ENOENT")
-            return missing;
-        throw e;
-    }
-    const root = await realpath(path);
-    const base = { ...missingBase,
-        storageRootFingerprint: createHash("sha256").update(root).digest("hex"),
-        ownerIdentity: String((await lstat(root)).uid) };
-    const empty = { ...missing, ...base };
-    try {
-        return await withMemoryAccess(path, async () => {
-            let localState = null;
-            try {
-                const record = await readMemoryInventorySource(path, ".crew/memory/migration.v1.json", inventoryLimits.fileBytes);
-                const state = MigrationStateSchema.parse(JSON.parse(record.content));
-                assertMigrationStateIntegrity(state, state.identity);
-                const expectedInitialization = state.origin === "initialized"
-                    ? await localMemoryInitializationIdentity(path, input.agentId, {
-                        workspaceId: input.workspaceId,
-                        machineId: input.machineId,
-                    })
-                    : null;
-                const expectedLegacyInitialization = state.origin === "initialized"
-                    ? await localMemoryInitializationIdentity(path, input.agentId)
-                    : null;
-                const localInitialization = expectedInitialization !== null
-                    && (isLocalMemoryInitializationIdentity(state.identity, expectedInitialization)
-                        || expectedLegacyInitialization !== null
-                            && isLocalMemoryInitializationIdentity(state.identity, expectedLegacyInitialization));
-                const serverBoundIdentity = state.identity.workspaceId === input.workspaceId
-                    && state.identity.machineId === input.machineId;
-                const operationIdentityValid = state.origin === "initialized" ? localInitialization : serverBoundIdentity;
-                if (state.identity.rootFingerprint !== base.storageRootFingerprint
-                    || state.identity.ownerIdentity !== base.ownerIdentity
-                    || state.identity.agentId !== input.agentId || !operationIdentityValid) {
-                    throw new Error("migration_identity_mismatch");
-                }
-                localState = { migrationId: state.migrationId, phase: state.phase, storageVersion: state.storageVersion,
-                    sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin,
-                    issues: state.issues.map(issue => issue.reason),
-                    initializationIdentity: localInitialization ? {
-                        agentId: state.identity.agentId, migrationId: state.identity.migrationId,
-                        workspaceId: state.identity.workspaceId, machineId: state.identity.machineId,
-                        executionId: state.identity.executionId, sourceStorageVersion: state.identity.sourceStorageVersion,
-                        targetStorageVersion: state.identity.targetStorageVersion,
-                        rootFingerprint: state.identity.rootFingerprint, ownerIdentity: state.identity.ownerIdentity,
-                    } : null };
-                if (state.phase === "applying" || state.phase === "repair_required")
-                    return {
-                        ...empty, localState, classification: "repair_required", emptyWithoutResidue: false, issueCodes: ["migration_recovery_required"],
-                    };
-            }
-            catch (e) {
-                if (e.code !== "ENOENT")
-                    throw e;
-            }
-            let source;
-            try {
-                source = await readMemoryInventorySource(path, "MEMORY.md", inventoryLimits.fileBytes);
-            }
-            catch (e) {
-                if (e.code !== "ENOENT")
-                    throw e;
-                const names = await readdir(path);
-                const nonMetadata = names.filter(name => name !== ".crew");
-                return { ...empty, localState, emptyWithoutResidue: nonMetadata.length === 0 && localState === null,
-                    classification: nonMetadata.length === 0 && localState === null ? "empty" : "repair_required", issueCodes: ["memory_source_missing"] };
-            }
-            const storageVersion = detectLocalMemoryStorageVersion(source.content);
-            if (storageVersion === 2) {
-                parseFullMemoryIndex(source.content);
-                return { ...base, storageVersion, classification: "valid_v2", emptyWithoutResidue: false, localState, issueCodes: [], stoppedExecutionId };
-            }
-            const eligibility = await resolveLocalMemoryV2Rollout({ workspace: { dir: path, memory: source.content },
-                serverUrl: input.serverUrl, handle: input.handle, requested: true });
-            return { ...base, storageVersion, classification: storageVersion === 1 && eligibility.enabled ? "valid_v1"
-                    : eligibility.legacyFallback || eligibility.enabled ? "legacy" : "repair_required",
-                emptyWithoutResidue: false, localState, stoppedExecutionId, issueCodes: eligibility.enabled || eligibility.legacyFallback ? [] : ["memory_source_incompatible"] };
-        }, { maintenance: true, waitMs: 0 });
-    }
-    catch (error) {
-        const code = error instanceof Error && /^[a-z_]+$/u.test(error.message) ? error.message : "memory_inspection_failed";
-        return { ...empty, emptyWithoutResidue: false, classification: code === "memory_migration_access_busy" ? "busy" : "repair_required", issueCodes: [code] };
-    }
-}

package/dist/memory-migration-journal.js

@@ -1,14 +0,0 @@
-import { join } from "node:path";
-import { createExecutionJournal } from "./execution-journal.js";
-import { dslog } from "./slog.js";
-/** 复用journal的监管/恢复实现；旧daemon只读普通目录，不会解析维护类型。 */
-export function createMemoryMigrationJournal(agentsRoot) {
-    return createExecutionJournal(join(agentsRoot, ".crew", "memory-migration-runtime"), { retainCompleted: true });
-}
-export async function replayExecutionJournals(normal, maintenance) {
-    const [ordinary, migration] = await Promise.all([normal.replay(), maintenance.replay().catch(() => {
-            dslog("memory_migration.journal_unavailable", "迁移日志暂不可读，保留普通执行能力", { level: "ERROR" });
-            return [];
-        })]);
-    return [...ordinary, ...migration];
-}

package/dist/memory-migration-protocol.js

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { MigrationRecordMappingSchema } from "./local-memory/migration-schema.js";
-export const MEMORY_MIGRATION_CAPABILITY = "memory_migration_v1";
-export const MEMORY_STORAGE_V2_CAPABILITY = "memory_storage_v2";
-export const MEMORY_STATE_GUARD_CAPABILITY = "memory_state_guard_v1";
-export const MemoryMigrationStartSchema = z.object({
-    type: z.literal("memory:migration:start"), reqId: z.string().min(1).max(200), protocolVersion: z.literal(1),
-    workspaceId: z.string().uuid(), agentId: z.string().uuid(), handle: z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-    machineId: z.string().uuid(), executionId: z.string().uuid(), migrationId: z.string().uuid(),
-    expectedRevision: z.number().int().nonnegative(), attemptKey: z.string().min(1).max(200),
-    sourceStorageVersion: z.union([z.literal(0), z.literal(1)]), targetStorageVersion: z.literal(2),
-    action: z.enum(["migrate", "recover"]),
-    recordMappings: z.array(MigrationRecordMappingSchema).max(10_000).optional(),
-}).strict();