@nowcrew/daemon 0.6.97-beta.1 → 0.6.97-beta.2

package/dist/local-memory-diagnostics.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { lstat, readFile, readdir, stat } from "node:fs/promises";
 import { isAbsolute, join, normalize, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
@@ -8,6 +8,7 @@ const INJECTION_MARKERS = [
     "## [注入] 你的 MEMORY.md(索引,只读参考)\n",
 ];
 const LOCAL_MEMORY_HASH_CAP_BYTES = 10 * 1024 * 1024;
+export const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 function errorCode(error) {
     const code = error?.code;
     return typeof code === "string" ? code : error instanceof Error ? error.name : "unknown";
@@ -39,30 +40,75 @@ async function inspectFile(path, signal) {
         return { ...base, error_code: errorCode(error) };
     }
 }
-export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+async function inspectPendingDirectory(path, signal) {
+    let metadata;
+    try {
+        metadata = await lstat(path);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        return code === "ENOENT" ? { exists: false, entry_count: 0 } : { exists: false, error_code: code };
+    }
+    const base = { exists: true, mtime_ms: metadata.mtimeMs };
+    if (metadata.isSymbolicLink() || !metadata.isDirectory())
+        return { ...base, hash_skipped_reason: "not_regular_file" };
+    try {
+        const names = (await readdir(path, { withFileTypes: true }))
+            .filter(entry => entry.name.endsWith(".json"))
+            .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+        if (names.length > 128)
+            return { ...base, entry_count: names.length, error_code: "entry_limit" };
+        const hash = createHash("sha256");
+        let size = 0;
+        for (const entry of names) {
+            if (signal.aborted)
+                throw signal.reason;
+            if (!entry.isFile() || entry.isSymbolicLink())
+                return { ...base, entry_count: names.length, error_code: "invalid_entry" };
+            const fact = await inspectFile(join(path, entry.name), signal);
+            if (!fact.exists || fact.sha256 === undefined || fact.error_code !== undefined
+                || fact.hash_skipped_reason !== undefined)
+                return { ...base, entry_count: names.length, error_code: "incomplete_entry" };
+            size += fact.size_bytes ?? 0;
+            hash.update(entry.name).update("\0").update(fact.sha256).update("\0");
+        }
+        return { ...base, size_bytes: size, entry_count: names.length, sha256: hash.digest("hex") };
+    }
+    catch (error) {
+        return { ...base, error_code: errorCode(error) };
+    }
+}
+export async function withinLocalMemoryDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
     let timer;
-    const inspection = Promise.all([
-        inspectFile(join(homeDir, "MEMORY.md"), controller.signal),
-        inspectFile(join(homeDir, "notes", "lessons.md"), controller.signal),
-    ]).then(([memory, lessons]) => ({ memory, lessons }));
     const timeout = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            controller.abort();
-            reject(Object.assign(new Error("local memory diagnostics timed out"), {
+            const error = Object.assign(new Error("local memory diagnostics timed out"), {
                 code: "diagnostics_timeout",
-            }));
+            });
+            controller.abort(error);
+            reject(error);
         }, Math.max(1, timeoutMs));
         timer.unref?.();
     });
     try {
-        return await Promise.race([inspection, timeout]);
+        return await Promise.race([operation(controller.signal), timeout]);
     }
     finally {
         if (timer !== undefined)
             clearTimeout(timer);
     }
 }
+export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+    return withinLocalMemoryDiagnosticsDeadline(async (signal) => {
+        const [memory, lessons, pending] = await Promise.all([
+            inspectFile(join(homeDir, "MEMORY.md"), signal),
+            inspectFile(join(homeDir, "notes", "lessons.md"), signal),
+            inspectPendingDirectory(join(homeDir, ".crew", "memory", "pending"), signal),
+        ]);
+        return { memory, lessons, pending };
+    }, timeoutMs);
+}
 export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HASH_CAP_BYTES) {
     const sizeBytes = Buffer.byteLength(content, "utf8");
     if (sizeBytes > Math.max(0, maxScanBytes)) {
@@ -217,15 +263,50 @@ function crewMemoryReadAccess(command, paths) {
         return null;
     }
 }
+/**
+ * Decode only the shell wrapper shape emitted by supported runtimes. The body must be one complete
+ * quoted argument. Double-quoted bodies may escape only a quote or backslash; shell expansion and
+ * concatenated quoting stay unknown so telemetry never guesses what the shell actually executed.
+ */
+function unwrapLiteralShellCommand(command) {
+    const trimmed = command.trim();
+    const wrapper = /^\/bin\/(?:(?:zsh|bash)\s+-lc|sh\s+-c)\s+([\s\S]+)$/u.exec(trimmed);
+    if (wrapper === null)
+        return trimmed;
+    const quoted = wrapper[1];
+    const quote = quoted[0];
+    if ((quote !== "'" && quote !== '"') || quoted.at(-1) !== quote || quoted.length < 2)
+        return null;
+    const body = quoted.slice(1, -1);
+    if (quote === "'")
+        return body.includes("'") ? null : body;
+    let decoded = "";
+    for (let index = 0; index < body.length; index += 1) {
+        const character = body[index];
+        if (character === '"' || character === "$" || character === "`")
+            return null;
+        if (character !== "\\") {
+            decoded += character;
+            continue;
+        }
+        const escaped = body[index + 1];
+        if (escaped !== '"' && escaped !== "\\")
+            return null;
+        decoded += escaped;
+        index += 1;
+    }
+    return decoded;
+}
 function commandAccesses(command, paths) {
-    if (/[;|&\n]/.test(command))
+    const unwrapped = unwrapLiteralShellCommand(command);
+    if (unwrapped === null || /[;|&\n]/.test(unwrapped))
         return [];
     const accesses = new Map();
-    const memoryRead = crewMemoryReadAccess(command, paths);
+    const memoryRead = crewMemoryReadAccess(unwrapped, paths);
     if (memoryRead !== null) {
         accesses.set(`${memoryRead.target}:${memoryRead.relative_path ?? ""}:read`, memoryRead);
     }
-    const expanded = command
+    const expanded = unwrapped
         .replaceAll("${CREW_HOME}", paths.homeDir)
         .replaceAll("$CREW_HOME", paths.homeDir)
         .replace(/["']/g, "");

package/dist/local-memory-telemetry.js

@@ -38,6 +38,7 @@ export function logLocalMemoryDiagnosticsFailure(identity, phase, error) {
 function snapshotFields(snapshot) {
     if (snapshot === null)
         return {};
+    const pending = snapshot.pending ?? { exists: false, entry_count: 0 };
     return {
         memory_exists: snapshot.memory.exists,
         memory_size_bytes: snapshot.memory.size_bytes,
@@ -54,6 +55,12 @@ function snapshotFields(snapshot) {
         lessons_hash_skipped_reason: snapshot.lessons.hash_skipped_reason,
         lessons_error_code: snapshot.lessons.error_code,
         lessons_markdown_heading_count: snapshot.lessons.markdown_heading_count,
+        pending_exists: pending.exists,
+        pending_size_bytes: pending.size_bytes,
+        pending_mtime_ms: pending.mtime_ms,
+        pending_sha256: pending.sha256,
+        pending_error_code: pending.error_code,
+        pending_entry_count: pending.entry_count,
     };
 }
 function promptDelivery(runtime, stableProtocolRuntime) {
@@ -183,10 +190,13 @@ export function createLocalMemoryTelemetry(options) {
             const lessonsChanged = beforeSnapshot !== null && afterSnapshot !== null
                 ? localMemoryFileChanged(beforeSnapshot.lessons, afterSnapshot.lessons)
                 : undefined;
+            const pendingChanged = beforeSnapshot !== null && afterSnapshot !== null
+                ? localMemoryFileChanged(beforeSnapshot.pending ?? { exists: false }, afterSnapshot.pending ?? { exists: false })
+                : undefined;
             const accessSummary = accessObserver.summary();
-            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
+            const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined || pendingChanged === undefined
                 ? undefined
-                : memoryChanged || lessonsChanged;
+                : memoryChanged || lessonsChanged || pendingChanged;
             safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
                 execution_id: options.executionId,
                 agent_handle: options.agentHandle,
@@ -200,6 +210,7 @@ export function createLocalMemoryTelemetry(options) {
                 executor_outcome: executorCompleted ? "succeeded" : "failed",
                 memory_changed: memoryChanged,
                 lessons_changed: lessonsChanged,
+                pending_changed: pendingChanged,
                 shared_files_changed_during_execution: sharedFilesChanged,
                 unexpected_shared_write: options.isMemoryPrune
                     ? undefined
@@ -224,6 +235,12 @@ export function createLocalMemoryTelemetry(options) {
                     lessons_after_hash_skipped_reason: afterSnapshot.lessons.hash_skipped_reason,
                     lessons_after_error_code: afterSnapshot.lessons.error_code,
                     lessons_after_markdown_heading_count: afterSnapshot.lessons.markdown_heading_count,
+                    pending_after_exists: afterSnapshot.pending?.exists ?? false,
+                    pending_after_size_bytes: afterSnapshot.pending?.size_bytes,
+                    pending_after_mtime_ms: afterSnapshot.pending?.mtime_ms,
+                    pending_after_sha256: afterSnapshot.pending?.sha256,
+                    pending_after_error_code: afterSnapshot.pending?.error_code,
+                    pending_after_entry_count: afterSnapshot.pending?.entry_count ?? 0,
                 }),
             });
         },

package/dist/machine-info.js

@@ -25,6 +25,7 @@ import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
 import { probeDeepSeekHarnessAcp, deepSeekHarnessLauncher } from "./runtimes/deepseek-harness.js";
 import { daemonHome } from "./computer-profile.js";
 import { daemonReleaseProvenance } from "./release-provenance.js";
+import { MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY } from "./memory-migration-protocol.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const PROJECT_WORKSPACES_CAPABILITY = "project_workspaces_v1";
@@ -40,6 +41,7 @@ export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
 });
 export const DAEMON_CAPABILITIES = Object.freeze([
     MARKETPLACE_CAPABILITY,
+    MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY,
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
@@ -75,6 +77,7 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => ((capability !== MARKETPLACE_CAPABILITY || nativeWorkspacePlatform)
         && (capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
         && (capability !== "message_file_preview_v1" || nativeWorkspacePlatform)
+        && (nativeWorkspacePlatform || ![MEMORY_MIGRATION_CAPABILITY, MEMORY_STORAGE_V2_CAPABILITY, MEMORY_STATE_GUARD_CAPABILITY].includes(capability))
         && (nativeWorkspacePlatform
             || (capability !== "project_skills_v1"
                 && capability !== "project_skill_projection_v2"

package/dist/marketplace-protocol.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 // 与另一个进程中的 marketplace-protocol.ts 保持一致；跨进程契约测试校验摘要。
 export const MARKETPLACE_CAPABILITY = "marketplace_update_v1";
 export const MARKETPLACE = "nowwork-pm";
-export const PLUGIN = "AIinterview-plugin";
+export const PLUGIN = "aiinterview-plugin";
 export const MarketplaceModeSchema = z.enum(["inspect", "refresh", "update"]);
 export const MarketplaceStatusSchema = z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]);
 export const MarketplaceTargetSchema = z.object({

package/dist/marketplace-remote.js

@@ -10,7 +10,7 @@ const Target = z.object({
     version: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/),
     source: z.object({ source: z.literal("git-subdir"),
         url: z.literal("git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git"),
-        path: z.literal("plugins/AIinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
+        path: z.literal("plugins/aiinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
 });
 export async function readRemoteMarketplace(runtime, registered, env, command) {
     const source = validateMarketplaceSource(registered.url, registered.ref);

package/dist/marketplace-runner.js

@@ -12,7 +12,7 @@ import { readMarketplaceSource } from "./marketplace-source.js";
 export { MarketplaceFailure, runMarketplaceCommand } from "./marketplace-command.js";
 const SELECTOR = `${PLUGIN}@${MARKETPLACE}`;
 const SOURCE = "git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git";
-const SOURCE_PATH = "plugins/AIinterview-plugin";
+const SOURCE_PATH = "plugins/aiinterview-plugin";
 const obj = (x) => x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
 const parse = (text) => { try {
     return JSON.parse(text);

package/dist/memory-migration-controller.js

@@ -0,0 +1,86 @@
+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, 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

@@ -0,0 +1,108 @@
+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: "https://nowwork-dev.nowcoder.com", 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,14 @@
+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();