@nowcrew/daemon 0.6.91-beta.1 → 0.6.91-beta.10

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";
@@ -39,6 +40,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",
@@ -73,6 +75,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/memory-migration-controller.js

@@ -0,0 +1,84 @@
+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; },
+        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,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/normalize.js

@@ -37,7 +37,8 @@ export function extractFinalText(event) {
     const e = (event ?? {});
     if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
         || e.type === "deepseek-harness.acp.text_delta"
-        || e.type === "opencode.text_delta") && e.text)
+        || e.type === "opencode.text_delta"
+        || e.type === "pi.text_delta") && e.text)
         return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
         return e.result.trim();
@@ -70,15 +71,18 @@ export function normalizeEvent(event) {
     }
     if ((e.type === "kimi.acp.text_delta" || e.type === "hermes.acp.text_delta"
         || e.type === "deepseek-harness.acp.text_delta"
-        || e.type === "opencode.text_delta") && e.text?.trim()) {
+        || e.type === "opencode.text_delta"
+        || e.type === "pi.text_delta") && e.text?.trim()) {
         return [{ kind: "text", label: "思考/说明", detail: e.text }];
     }
     if (e.type === "kimi.acp.tool_call" || e.type === "hermes.acp.tool_call"
-        || e.type === "deepseek-harness.acp.tool_call" || e.type === "opencode.tool_call") {
+        || e.type === "deepseek-harness.acp.tool_call" || e.type === "opencode.tool_call"
+        || e.type === "pi.tool_call") {
         return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
     }
     if (e.type === "kimi.acp.tool_result" || e.type === "hermes.acp.tool_result"
-        || e.type === "deepseek-harness.acp.tool_result" || e.type === "opencode.tool_result") {
+        || e.type === "deepseek-harness.acp.tool_result" || e.type === "opencode.tool_result"
+        || e.type === "pi.tool_result") {
         return [{ kind: "tool_result", label: "工具返回" }];
     }
     if (e.type === "system" && e.subtype === "init") {
@@ -97,7 +101,7 @@ export function normalizeEvent(event) {
     if (e.type === "turn.completed") {
         return [{ kind: "done", label: "本轮结束" }];
     }
-    if (e.type === "opencode.error") {
+    if (e.type === "opencode.error" || e.type === "pi.error") {
         const detail = typeof event.message === "string"
             ? event.message
             : undefined;

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";