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

package/dist/memory-migration-inspect.js

@@ -0,0 +1,74 @@
+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 { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./local-memory/storage-format.js";
+import { resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
+import { readMemoryInventorySource, inventoryLimits } from "./local-memory/inventory-source.js";
+export async function inspectMemoryForMigration(agentsRoot, input, journal) {
+    const parent = await realpath(agentsRoot);
+    const path = join(parent, input.handle);
+    const base = { 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 empty = { ...base, storageVersion: null, classification: "empty", emptyWithoutResidue: true, localState: null, issueCodes: [], stoppedExecutionId };
+    try {
+        await lstat(path);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return empty;
+        throw e;
+    }
+    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));
+                if (state.identity.rootFingerprint !== base.storageRootFingerprint || state.identity.agentId !== input.agentId
+                    || state.identity.workspaceId !== input.workspaceId || state.identity.machineId !== input.machineId)
+                    throw new Error("migration_identity_mismatch");
+                localState = { migrationId: state.migrationId, phase: state.phase, storageVersion: state.storageVersion,
+                    sourceDigest: state.sourceDigest, planDigest: state.planDigest };
+                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();

package/dist/memory-migration-runtime.js

@@ -0,0 +1,305 @@
+import { createHash } from "node:crypto";
+import { mkdir, lstat, realpath, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { ExecutionCompletedSchema } from "./execution-protocol.js";
+import { startDormantSupervisor } from "./execution-supervisor.js";
+import { MemoryMigrationStartSchema } from "./memory-migration-protocol.js";
+import { MigrationHistorySchema, MigrationIdentitySchema, MigrationStateSchema } from "./local-memory/migration-schema.js";
+import { readMemoryInventorySource, inventoryLimits } from "./local-memory/inventory-source.js";
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const protectedWindows = new Map();
+const Operation = z.object({ id: z.string(), revision: z.number().int(), executionId: z.string().nullable(),
+    status: z.string(), sourceDigest: z.string().nullable(), planDigest: z.string().nullable(),
+    writeIntentConfirmedAt: z.string().nullable(), newAgentConfirmed: z.boolean().optional(),
+    cancelRequestedAt: z.string().nullable(),
+}).passthrough();
+const Summary = z.object({ result: z.enum(["success", "failed", "needs_review", "repair_required", "missing"]),
+    phase: z.string().nullable().optional(), issues: z.array(z.object({ path: z.string(), reason: z.string() }).passthrough()) }).passthrough();
+/** 系统维护在普通执行槽之前分流；只有 server 持久确认意图后才运行活动替换。 */
+export async function runMemoryMigration(raw, deps) {
+    const frame = MemoryMigrationStartSchema.parse(raw);
+    const common = { agentId: frame.agentId, migrationId: frame.migrationId, machineId: frame.machineId,
+        executionId: frame.executionId, attemptKey: frame.attemptKey };
+    const protectionKey = `${deps.agentsRoot}:${frame.migrationId}`;
+    const exclusive = protectedWindows.get(protectionKey) ?? await deps.coordinator.tryAcquireExclusiveExecution();
+    if (!exclusive) {
+        await deps.control("busy", { ...common, expectedRevision: frame.expectedRevision });
+        return { kind: "busy" };
+    }
+    let revision = frame.expectedRevision, intentConfirmed = false, acquired = false, acquisitionRequested = false, keepProtection = false;
+    let bound;
+    let identity, state;
+    let serverHistory;
+    let intentReceipt;
+    let lastPid = null, stopped = true, phaseCount = 0;
+    const startedAt = new Date().toISOString();
+    const dir = join(deps.agentsRoot, frame.handle);
+    const timeoutMs = deps.timeoutMs ?? 60_000;
+    const guard = () => ({ ...common, expectedRevision: revision, ...bound });
+    const control = async (step, extra = {}) => {
+        const response = await deps.control(step, { ...guard(), ...extra });
+        const parsed = z.object({ operation: Operation }).parse(response);
+        revision = parsed.operation.revision;
+        return parsed.operation;
+    };
+    const readKnownState = async (path) => {
+        const source = await readMemoryInventorySource(await realpath(dir), path, inventoryLimits.fileBytes);
+        return MigrationStateSchema.parse(JSON.parse(source.content));
+    };
+    const readState = () => readKnownState(".crew/memory/migration.v1.json");
+    const runTool = async (command, extra = {}) => {
+        if (!identity)
+            throw new Error("migration_identity_missing");
+        if (command === "recover" && deps.cancellation?.isRequested())
+            extra = { ...extra, cancelled: true };
+        const rollback = command === "recover" && extra.cancelled === true;
+        if (!rollback && deps.cancellation?.isRequested())
+            throw new Error("migration_cancelled");
+        if (phaseCount++ > 0) {
+            if (!stopped || !deps.journal.retry)
+                throw new Error("migration_stop_unproven");
+            await deps.journal.retry(frame.executionId);
+        }
+        const sourceMode = import.meta.url.endsWith(".ts");
+        const entry = fileURLToPath(new URL(`./local-memory/migration-tool-entry.${sourceMode ? "ts" : "js"}`, import.meta.url));
+        const args = sourceMode ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href, entry] : [entry];
+        let stdout = "";
+        const launched = await deps.journal.startGuarded(frame.executionId, new Date().toISOString(), () => (deps.startSupervisor ?? startDormantSupervisor)({ command: process.execPath, args, cwd: dir,
+            env: { PATH: process.env.PATH ?? "", CREW_SLS_LOG: "off" },
+            stdinText: JSON.stringify({ command, agentDir: dir, identity, ...extra }),
+        }, sourceMode ? {
+            childEntry: fileURLToPath(new URL("./execution-supervisor-child.ts", import.meta.url)),
+            execArgv: ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href],
+        } : {}), { beforeRelease: async ({ handle }) => {
+                lastPid = handle.pid;
+                stopped = false;
+                handle.stdout.on("data", chunk => { stdout += String(chunk); if (stdout.length > 2 * 1024 * 1024)
+                    void handle.cancel(); });
+                handle.stderr.resume();
+            } });
+        if (launched.kind !== "started")
+            throw new Error("migration_execution_already_running");
+        const processHandle = launched.handle;
+        deps.send({ type: "execution:started", protocolVersion: 1, executionId: frame.executionId, at: new Date().toISOString() });
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; void processHandle.cancel(); }, timeoutMs);
+        if (!rollback)
+            deps.cancellation?.register(async () => { if (!stopped)
+                await processHandle.cancel(); });
+        try {
+            await processHandle.exit;
+            await processHandle.cancel();
+            stopped = true;
+            if (timedOut)
+                throw new Error("migration_window_timeout");
+            return Summary.parse(JSON.parse(stdout.trim()));
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    const finish = async (outcome, reason) => {
+        const completion = ExecutionCompletedSchema.parse({ type: "execution:completed", protocolVersion: 1,
+            executionId: frame.executionId, runtime: "memory_migration", resumed: false, outcome,
+            exitCode: outcome === "succeeded" ? 0 : 1, ...(reason ? { errorCode: reason, errorMessage: reason } : {}),
+            startedAt, finishedAt: new Date().toISOString() });
+        await deps.journal.complete(frame.executionId, completion);
+        deps.send(completion);
+    };
+    try {
+        const history = z.object({ operations: z.array(Operation), serverHistory: MigrationHistorySchema }).passthrough().parse(await deps.control("history", {}));
+        serverHistory = history.serverHistory;
+        const operation = history.operations.find(op => op.id === frame.migrationId);
+        if (!operation || operation.revision !== revision || operation.executionId !== frame.executionId)
+            throw new Error("migration_server_identity_mismatch");
+        intentConfirmed = operation.writeIntentConfirmedAt !== null;
+        await mkdir(dir, { recursive: true });
+        const root = await realpath(dir);
+        if ((await lstat(dir)).isSymbolicLink())
+            throw new Error("migration_root_invalid");
+        bound = { storageRootFingerprint: digest(root), ownerIdentity: String((await lstat(root)).uid) };
+        identity = MigrationIdentitySchema.parse({ agentId: frame.agentId, migrationId: frame.migrationId,
+            machineId: frame.machineId, executionId: frame.executionId, workspaceId: frame.workspaceId,
+            rootFingerprint: bound.storageRootFingerprint, ownerIdentity: bound.ownerIdentity,
+            sourceStorageVersion: frame.sourceStorageVersion, targetStorageVersion: 2 });
+        const { reqId: _transportRequest, ...stableFrame } = frame;
+        const accepted = await deps.journal.accept(frame.executionId, digest(JSON.stringify(stableFrame)), { runtime: "memory_migration" });
+        if (accepted.kind === "existing" && accepted.completion) {
+            deps.send(accepted.completion);
+            return { kind: "completed" };
+        }
+        deps.send({ type: "execution:accepted", protocolVersion: 1, executionId: frame.executionId,
+            state: "ready", effectivePermission: "workspace_write", at: new Date().toISOString() });
+        acquisitionRequested = true;
+        await control("acquired");
+        acquired = true;
+        if (frame.action === "recover") {
+            state = await readState().catch(() => undefined);
+            if (state && state.migrationId !== frame.migrationId && state.phase === "rolled_back"
+                && history.serverHistory.rolledBackOperations?.some(previous => previous.migrationId === state.migrationId
+                    && previous.sourceDigest === state.sourceDigest && previous.planDigest === state.planDigest))
+                state = undefined;
+            if (state) {
+                if (state.migrationId !== frame.migrationId || state.identity.rootFingerprint !== bound.storageRootFingerprint
+                    || state.identity.machineId !== frame.machineId || state.identity.agentId !== frame.agentId)
+                    throw new Error("migration_state_identity_mismatch");
+                identity = state.identity;
+            }
+            if (!state) {
+                state = await readKnownState(`.crew/memory/migrations/${frame.migrationId}/terminal.json`).catch((e) => {
+                    if (e.code !== "ENOENT")
+                        throw e;
+                    return readKnownState(`.crew/memory/migrations/${frame.migrationId}/manifest.json`);
+                });
+                identity = state.identity;
+            }
+            if (state.planDigest !== operation.planDigest || state.sourceDigest !== operation.sourceDigest)
+                throw new Error("migration_server_plan_mismatch");
+            const prior = await deps.journal.get(identity.executionId);
+            if (state.phase !== "committed" && (!prior || (prior.state !== "completed" && prior.state !== "interrupted"))) {
+                throw new Error("migration_stop_unproven");
+            }
+            const result = await runTool("recover", { serverHistory: history.serverHistory, cancelled: !intentConfirmed || operation.cancelRequestedAt !== null,
+                stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
+                    executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: null,
+                    stoppedAt: new Date().toISOString(), proof: "journal_reconciled" } });
+            if (result.result !== "success")
+                throw new Error("migration_recovery_failed");
+        }
+        else {
+            const prepared = await runTool("prepare", { serverHistory: history.serverHistory,
+                ...(frame.recordMappings ? { recordMappings: frame.recordMappings } : {}) });
+            if (prepared.result === "needs_review") {
+                await control("needs-review", { issues: prepared.issues });
+                await finish("failed", "migration_needs_review");
+                return { kind: "needs_review" };
+            }
+            if (prepared.result !== "success")
+                throw new Error("migration_prepare_failed");
+            state = await readState();
+            const confirmed = await control("intent", { sourceDigest: state.sourceDigest, planDigest: state.planDigest,
+                minReaderCapabilities: ["memory_storage_v2", "memory_state_guard_v1"], minWriterCapabilities: ["memory_storage_v2", "memory_state_guard_v1"] });
+            intentConfirmed = true;
+            intentReceipt = { ...identity, kind: "server_write_intent", sourceDigest: state.sourceDigest,
+                planDigest: state.planDigest, intentVersion: confirmed.revision, confirmedAt: confirmed.writeIntentConfirmedAt };
+            const result = await runTool("apply", { intentReceipt });
+            if (result.result !== "success")
+                throw new Error("migration_apply_failed");
+        }
+        state = await readState();
+        if (state.phase !== "committed" && state.phase !== "rolled_back")
+            throw new Error("migration_terminal_unverified");
+        if (!intentConfirmed) {
+            if (state.phase !== "rolled_back")
+                throw new Error("migration_commit_without_intent");
+            await control("no-write", { sourceDigest: state.sourceDigest, planDigest: state.planDigest, verified: true });
+        }
+        else
+            await control("result", { outcome: state.phase, storageVersion: state.storageVersion,
+                sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin, verified: true });
+        await finish("succeeded");
+        return { kind: "completed", phase: state.phase };
+    }
+    catch (error) {
+        const reason = error instanceof Error && /^[a-z_]+$/u.test(error.message) ? error.message : "migration_execution_failed";
+        if (acquisitionRequested) {
+            try {
+                const latest = z.object({ operations: z.array(Operation) }).passthrough().parse(await deps.control("history", {}))
+                    .operations.find(op => op.id === frame.migrationId);
+                if (!latest || latest.executionId !== frame.executionId)
+                    throw new Error("migration_control_owner_changed");
+                revision = latest.revision;
+                intentConfirmed = latest.writeIntentConfirmedAt !== null;
+                acquired = !["needs_review", "rolled_back"].includes(latest.status);
+                if (intentConfirmed && identity && state && latest.sourceDigest === state.sourceDigest && latest.planDigest === state.planDigest) {
+                    intentReceipt = { ...identity, kind: "server_write_intent", sourceDigest: state.sourceDigest, planDigest: state.planDigest,
+                        intentVersion: latest.revision, confirmedAt: latest.writeIntentConfirmedAt };
+                }
+            }
+            catch {
+                keepProtection = true;
+            }
+        }
+        if (acquired) {
+            if (intentConfirmed) {
+                keepProtection = true;
+                if (stopped && identity && lastPid !== null) {
+                    try {
+                        const recovered = await runTool("recover", { cancelled: true, ...(intentReceipt ? { intentReceipt } : {}),
+                            stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
+                                executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: lastPid,
+                                stoppedAt: new Date().toISOString(), proof: "supervisor_exit" } });
+                        state = await readState();
+                        if (recovered.result === "success" && (state.phase === "committed" || state.phase === "rolled_back")) {
+                            await control("result", { outcome: state.phase, storageVersion: state.storageVersion,
+                                sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin, verified: true });
+                            keepProtection = false;
+                        }
+                    }
+                    catch { /* 未证明提交或完整回退时保留保护。 */ }
+                }
+                if (keepProtection)
+                    await control("repair", { reason }).catch(() => undefined);
+            }
+            else if (stopped) {
+                let digests;
+                try {
+                    let local = await readState().catch((error) => { if (error.code === "ENOENT")
+                        return undefined; throw error; });
+                    if (local?.migrationId !== frame.migrationId) {
+                        local = await readKnownState(`.crew/memory/migrations/${frame.migrationId}/manifest.json`).catch(async (error) => {
+                            if (error.code !== "ENOENT")
+                                throw error;
+                            const residue = await lstat(join(dir, ".crew/memory/migrations", frame.migrationId)).catch((statError) => {
+                                if (statError.code === "ENOENT")
+                                    return undefined;
+                                throw statError;
+                            });
+                            if (residue)
+                                throw new Error("migration_prepare_residue_unverified");
+                            return undefined;
+                        });
+                    }
+                    if (local?.migrationId === frame.migrationId) {
+                        if (!identity || lastPid === null || Object.keys(local.identity).some(key => local.identity[key] !== identity[key])
+                            || local.intentReceipt || !["prepared", "rolled_back"].includes(local.phase))
+                            throw new Error("migration_no_write_state_unverified");
+                        digests = { sourceDigest: local.sourceDigest, planDigest: local.planDigest };
+                        const recovered = await runTool("recover", { cancelled: true,
+                            serverHistory: { kind: "existing", migrationId: frame.migrationId, writeIntentConfirmed: false,
+                                ...(serverHistory?.rolledBackOperations ? { rolledBackOperations: serverHistory.rolledBackOperations } : {}) },
+                            stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
+                                executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: lastPid,
+                                stoppedAt: new Date().toISOString(), proof: "supervisor_exit" } });
+                        state = await readState();
+                        if (recovered.result !== "success" || state.phase !== "rolled_back")
+                            throw new Error("migration_no_write_rollback_unverified");
+                        digests = { sourceDigest: state.sourceDigest, planDigest: state.planDigest };
+                    }
+                    await control("no-write", { verified: true, ...digests });
+                    keepProtection = false;
+                }
+                catch {
+                    keepProtection = true;
+                    await control("repair", { reason: "migration_no_write_rollback_unverified", ...digests }).catch(() => undefined);
+                }
+            }
+            else
+                keepProtection = true;
+        }
+        if (stopped)
+            await finish("failed", reason).catch(() => undefined);
+        return { kind: "failed", reason, processStopped: stopped, lastPid };
+    }
+    finally {
+        if (!keepProtection && stopped) {
+            protectedWindows.delete(protectionKey);
+            await exclusive.release();
+        }
+        else
+            protectedWindows.set(protectionKey, exclusive);
+    }
+}

package/dist/message-file-preview.js

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { isInternalEnvironmentPath } from "./workspace-fs.js";
 import { opaqueKey, safeKey } from "./workspace.js";
 import { AgentHandleSchema } from "./execution-protocol.js";
+import { withMemoryAccess } from "./local-memory/migration-access.js";
 const MAX_BYTES = 256 * 1024;
 const MAX_BINARY_BYTES = 8 * 1024 * 1024;
 const MAX_CONCURRENT_READS = 4;
@@ -231,7 +232,16 @@ export async function readSharedMessageFile(agentsRoot, rawRequest, registry) {
         throw new SharedFileError("file_preview_busy");
     activeReads++;
     try {
-        return await readCandidate(await resolveCandidate(agentsRoot, parsed.data, registry));
+        const candidate = await resolveCandidate(agentsRoot, parsed.data, registry);
+        const agentRoot = await realpath(resolve(agentsRoot, parsed.data.handle)).catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        // 记忆保护只用于该Agent根内资料，独立项目文件仍按原执行授权读取。
+        return await (agentRoot && inside(agentRoot, candidate.path)
+            ? withMemoryAccess(agentRoot, () => readCandidate(candidate))
+            : readCandidate(candidate));
     }
     catch (error) {
         if (error instanceof SharedFileError)

package/dist/pre-admission-rejection.js

@@ -2,7 +2,7 @@ import { ExecutionCompletedSchema, ExecutionRejectedSchema } from "./execution-p
 import { hashExecutionSpec } from "./execution-runner.js";
 import { dslog } from "./slog.js";
 /** Queue rejection is admission work too: own the ID before any asynchronous journal write. */
-export async function rejectQueuedAdmission(context, spec, executionClass, facts) {
+export async function rejectQueuedAdmission(context, spec, executionClass, facts, rejectionReason = "machine_queue_full") {
     const id = spec.executionId;
     const hash = hashExecutionSpec(spec);
     if (context.knownExecutionHashes.has(id) || context.executionRuns.has(id)) {
@@ -16,10 +16,11 @@ export async function rejectQueuedAdmission(context, spec, executionClass, facts
     context.knownExecutionHashes.set(id, hash);
     const rejected = ExecutionRejectedSchema.parse({
         type: "execution:rejected", protocolVersion: 1, executionId: id,
-        reason: "resource_limit", message: "Local machine execution queue is full", at: new Date().toISOString(),
+        reason: "resource_limit", message: rejectionReason === "maintenance" ? "Local machine is temporarily unavailable for maintenance"
+            : rejectionReason === "agent_queue_full" ? "Local agent execution queue is full" : "Local machine execution queue is full", at: new Date().toISOString(),
     });
-    dslog("execution.machine_queue_rejected", "机器执行队列已满", {
-        level: "WARN", execution_id: id, agent_handle: spec.agent.handle, execution_class: executionClass, ...facts,
+    dslog("execution.machine_queue_rejected", rejectionReason === "maintenance" ? "机器维护期间暂停接收执行" : "执行等待队列已满", {
+        level: "WARN", execution_id: id, agent_handle: spec.agent.handle, execution_class: executionClass, admission_reason: rejectionReason, ...facts,
     });
     const rejecting = persistPreAdmissionRejection(context.journal, spec, rejected)
         .then(async (entry) => {

package/dist/prompt.js

@@ -5,6 +5,7 @@
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
+import { detectLocalMemoryStorageVersion, selectLocalMemoryPreview } from "./local-memory/storage-format.js";
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
@@ -67,7 +68,10 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     const tail = workLog.slice(-WORKLOG_TAIL);
     return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
 }
-export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY) {
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY, query = "") {
+    if (detectLocalMemoryStorageVersion(memory) === 2) {
+        return selectLocalMemoryPreview(memory, query, { maxCodePoints: cap, maxBytes }).memory;
+    }
     if (memory.length <= cap && Buffer.byteLength(memory, "utf8") <= maxBytes)
         return memory;
     const notice = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";

package/dist/runner.js

@@ -80,7 +80,7 @@ async function runAgentWithMachineEnvironment(config, input, onActivity = defaul
                 ? { scheduledExternalNotificationPolicy: input.scheduled.externalNotificationPolicy }
                 : {}),
             ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
-            memory: capMemoryForInject(workspace.memory),
+            memory: capMemoryForInject(workspace.memory, undefined, undefined, baseWake),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
             localMemoryV2Enabled: workspace.localMemoryV2Enabled ?? localMemoryV2Enabled,

package/dist/serve.js

@@ -14,6 +14,7 @@ import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { initReleaseSlog, reportDaemonConnectionClose, reportReleaseError } from "./release-channel-guard.js";
 import { handleWorkspaceControlRequest } from "./workspace-control-handler.js";
 import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
+import { withMemoryAccess } from "./local-memory/migration-access.js";
 import { normalizeScheduledContext } from "./scheduled-report.js";
 import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
@@ -50,6 +51,8 @@ import { probeRuntimeHealth } from "./runtime-health.js";
 import { createServeMarketplace } from "./marketplace-serve.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
+import { createMemoryMigrationController } from "./memory-migration-controller.js";
+import { createMemoryMigrationJournal, replayExecutionJournals } from "./memory-migration-journal.js";
 import { bindStorageServerIdentity, createStorageIdentityAdmission, } from "./storage-serve-adapter.js";
 export { buildControlPlaneUrl } from "./control-plane-url.js";
 // normalize.ts 的活动种类 → activity 枚举
@@ -71,6 +74,8 @@ export function serve(config, opts = {}) {
     let reconnectTimer = null;
     let stopPromise = null;
     let executionJournal;
+    let migrationExecutionJournal;
+    let migrationJournalReady = false;
     const injectedExecutionJournal = opts.execution?.journal;
     const agentMemory = opts.execution?.dependencies?.agentMemory
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
@@ -85,6 +90,15 @@ export function serve(config, opts = {}) {
             startupGapMs: config.executionLimits.startupGapMs,
         });
     const localSlots = createSharedSlotManager(config.executionLimits);
+    const memoryMigrations = createMemoryMigrationController({ config, coordinator: hostCoordinator,
+        isAdmissionClosed: () => stopped || storageIdentityAdmission.isAdmissionClosed(),
+        journal: () => { if (!migrationJournalReady)
+            throw new Error("memory_migration_journal_unavailable"); return migrationExecutionJournal; }, send: frame => {
+            if (frame.type === "execution:completed")
+                completionRetransmitter.track(frame);
+            else if (ws?.readyState === WebSocket.OPEN)
+                ws.send(JSON.stringify(frame));
+        } });
     const sharedSlots = hostCoordinatedSlotManager(localSlots, hostCoordinator);
     const concurrencyTelemetry = createExecutionConcurrencyTelemetry(sharedSlots, {
         ...(opts.execution?.concurrencySnapshotIntervalMs === undefined
@@ -232,7 +246,7 @@ export function serve(config, opts = {}) {
         return null;
     };
     const sendSnapshot = async (reqId) => {
-        const entries = (await executionJournal.replay()).map(snapshotEntry).filter((entry) => entry !== null);
+        const entries = (await replayExecutionJournals(executionJournal, migrationExecutionJournal)).map(snapshotEntry).filter((entry) => entry !== null);
         safeExecutionSend(ExecutionSnapshotSchema.parse({
             type: "execution:snapshot", protocolVersion: 1, reqId, entries,
         }));
@@ -313,6 +327,12 @@ export function serve(config, opts = {}) {
             machineRuntime.open(openedSocket, { capabilities: capabilities.machineHello, beforePublish: Promise.resolve(), connectionId });
             opts.onOpen?.(ws);
             void sendSnapshot(`reconnect-${randomUUID()}`);
+            // 普通回执不等待维护日志IO；两类记录分别重放到同一发送器。
+            void migrationExecutionJournal.replay().then(entries => {
+                for (const entry of entries)
+                    if (entry.completion && !entry.completionAcknowledged)
+                        completionRetransmitter.track(entry.completion);
+            }).catch(() => dslog("memory_migration.journal_unavailable", "维护回执重放失败，普通回执继续", { level: "ERROR" }));
             void executionJournal.replay()
                 .then((entries) => {
                 for (const entry of entries) {
@@ -387,7 +407,8 @@ export function serve(config, opts = {}) {
                         return;
                     if (frame.type === "execution:completion-ack") {
                         try {
-                            await executionJournal.acknowledgeCompletion(frame.executionId);
+                            const journal = await executionJournal.get(frame.executionId) ? executionJournal : migrationExecutionJournal;
+                            await journal.acknowledgeCompletion(frame.executionId);
                             const attempts = completionRetransmitter.acknowledge(frame.executionId);
                             dslog("execution.completion_acknowledged", "execution completion ACK 已持久化", {
                                 execution_id: frame.executionId,
@@ -413,6 +434,8 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     if (frame.type === "execution:cancel") {
+                        if (memoryMigrations.cancel(frame.executionId))
+                            return;
                         if (!knownExecutionHashes.has(frame.executionId)
                             && !executionRuns.has(frame.executionId)
                             && await executionJournal.get(frame.executionId) === null)
@@ -488,7 +511,7 @@ export function serve(config, opts = {}) {
                     let reservation = sharedSlots.reserve(spec.agent.handle, "execution", executionClass);
                     if (!reservation.accepted) {
                         await rejectQueuedAdmission({ journal: executionJournal, knownExecutionHashes, executionRuns,
-                            report: reportExecutionFrame, replay: sendJournalStatus }, spec, executionClass, reservation.facts);
+                            report: reportExecutionFrame, replay: sendJournalStatus }, spec, executionClass, reservation.facts, reservation.rejectionReason);
                         return;
                     }
                     knownExecutionHashes.set(spec.executionId, hash);
@@ -735,6 +758,8 @@ export function serve(config, opts = {}) {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
                 setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                if (r.workspaceId && r.machineId)
+                    memoryMigrations.setIdentity({ workspaceId: r.workspaceId, machineId: r.machineId });
                 if (opts.storageRuntime !== undefined && typeof r.workspaceId === "string" && typeof r.machineId === "string") {
                     const bindingSocket = ws;
                     bindStorageServerIdentity(opts.storageRuntime, { workspaceId: r.workspaceId, machineId: r.machineId }, {
@@ -801,6 +826,8 @@ export function serve(config, opts = {}) {
             }
             catch { /* server 会按请求超时处理 */ } }))
                 return;
+            if (await memoryMigrations.handle(msg))
+                return;
             if (await agentAbilityRuntime.tryHandleControlMessage(msg, serverCapabilities, (frame) => ws?.send(JSON.stringify(frame))))
                 return;
             // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
@@ -815,7 +842,7 @@ export function serve(config, opts = {}) {
                 try {
                     const data2 = req.type === "raft:inspect"
                         ? await inspectRaftWorkspace(req.path)
-                        : await importRaftWorkspace(req.path, join(config.agentsRoot, req.handle));
+                        : await withMemoryAccess(join(config.agentsRoot, req.handle), () => importRaftWorkspace(req.path, join(config.agentsRoot, req.handle)), { create: true });
                     if (req.type === "raft:import") {
                         log(`📦 已导入 raft 工作区 → ${req.handle}: 复制 ${data2.copied.length} 项`);
                     }
@@ -1259,6 +1286,9 @@ export function serve(config, opts = {}) {
             writeStderr: (line) => process.stderr.write(line),
         });
         await runProjectSkillStartupCleanup(config.agentsRoot, executionJournal, dslog);
+        migrationExecutionJournal = createMemoryMigrationJournal(config.agentsRoot);
+        await migrationExecutionJournal.reconcileAfterRestart().then(() => { migrationJournalReady = true; })
+            .catch(() => dslog("memory_migration.journal_unavailable", "迁移日志恢复失败，普通执行继续，迁移请求单独报错", { level: "ERROR" }));
         await connect();
     })();
     const stop = () => {
@@ -1276,6 +1306,7 @@ export function serve(config, opts = {}) {
             const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
             const pending = [
                 machineRuntime.stop(),
+                memoryMigrations.stop(),
                 webSocketClosed,
                 updateController.drain(),
                 marketplace.stop(),
@@ -1294,6 +1325,8 @@ export function serve(config, opts = {}) {
                 if (executionJournal !== undefined) {
                     await executionJournal.close({ signal: deadline.signal });
                 }
+                if (migrationExecutionJournal !== undefined)
+                    await migrationExecutionJournal.close({ signal: deadline.signal });
             }
             finally {
                 deadline.dispose();