@nowcrew/daemon 0.6.98 → 0.6.99-beta.1

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/memory-prune-diagnostics.js

@@ -7,6 +7,7 @@ import { dslog } from "./slog.js";
 const TRACE_PATTERN = /\[memory-prune trace_id=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]/i;
 export const MEMORY_PRUNE_HASH_LIMIT_BYTES = 10 * 1024 * 1024;
 export const MEMORY_PRUNE_NOTES_MANIFEST_LIMIT = 128;
+export const MEMORY_PRUNE_PENDING_MANIFEST_LIMIT = 128;
 export const MEMORY_PRUNE_NOTE_CHANGE_LIMIT = 128;
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
@@ -192,6 +193,50 @@ export async function inspectMemoryPruneNotes(homeDir, signal) {
         ...(signal?.aborted ? { error: "ABORT_ERR" } : {}),
     };
 }
+export async function inspectMemoryPrunePending(homeDir, signal) {
+    const pendingDir = join(homeDir, ".crew", "memory", "pending");
+    try {
+        const metadata = await lstat(pendingDir);
+        if (metadata.isSymbolicLink())
+            return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: "symbolic_link" };
+        if (!metadata.isDirectory())
+            return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: "ENOTDIR" };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { files: [], total_count: 0, omitted_count: 0, truncated: false };
+        return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
+    }
+    let names;
+    try {
+        names = (await readdir(pendingDir, { withFileTypes: true }))
+            .filter(entry => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".json"))
+            .map(entry => entry.name).sort(compareCodeUnits);
+    }
+    catch (error) {
+        return { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
+    }
+    const selected = names.slice(0, MEMORY_PRUNE_PENDING_MANIFEST_LIMIT);
+    const files = [];
+    for (const name of selected) {
+        if (signal?.aborted)
+            break;
+        const path = join(pendingDir, name);
+        try {
+            if ((await lstat(path)).isSymbolicLink()) {
+                files.push({ relative_path: `.crew/memory/pending/${name}`, exists: false, error: "symbolic_link" });
+                continue;
+            }
+        }
+        catch (error) {
+            files.push({ relative_path: `.crew/memory/pending/${name}`, exists: false, error: diagnosticError(error) });
+            continue;
+        }
+        files.push({ relative_path: `.crew/memory/pending/${name}`, ...await inspectFile(path, false, undefined, signal) });
+    }
+    return { files, total_count: names.length, omitted_count: Math.max(0, names.length - selected.length),
+        truncated: names.length > selected.length, ...(signal?.aborted ? { error: "ABORT_ERR" } : {}) };
+}
 async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal) {
     const cwdIsHome = runDir === homeDir;
     const [memory, lessons, cwdMemory, cwdLessons, workLog] = await Promise.all([
@@ -210,15 +255,17 @@ async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal
     };
 }
 export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal) {
-    const [fixedFiles, notesManifest] = await Promise.all([
+    const [fixedFiles, notesManifest, pendingManifest] = await Promise.all([
         inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal),
         inspectMemoryPruneNotes(homeDir, signal),
+        inspectMemoryPrunePending(homeDir, signal),
     ]);
-    return { ...fixedFiles, notes_manifest: notesManifest };
+    return { ...fixedFiles, notes_manifest: notesManifest, pending_manifest: pendingManifest };
 }
 export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, workLogPath, timeoutMs) {
     const fixedFiles = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal), timeoutMs);
     let notesManifest;
+    let pendingManifest;
     try {
         notesManifest = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneNotes(homeDir, signal), timeoutMs);
     }
@@ -231,7 +278,13 @@ export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, wor
             error: diagnosticError(error),
         };
     }
-    return { ...fixedFiles, notes_manifest: notesManifest };
+    try {
+        pendingManifest = await withinMemoryPruneDiagnosticsDeadline(signal => inspectMemoryPrunePending(homeDir, signal), timeoutMs);
+    }
+    catch (error) {
+        pendingManifest = { files: [], total_count: 0, omitted_count: 0, truncated: false, error: diagnosticError(error) };
+    }
+    return { ...fixedFiles, notes_manifest: notesManifest, pending_manifest: pendingManifest };
 }
 export async function withinMemoryPruneDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
@@ -361,6 +414,7 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
             && (after.cwd_memory.lessons_reference_count ?? 0) > 0,
         cwd_lessons_changed: !after.cwd_lessons.same_as_shared_path
             && fileChanged(before.cwd_lessons, after.cwd_lessons),
+        pending_changed: diffMemoryPruneNotes(before.pending_manifest ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }, after.pending_manifest ?? { files: [], total_count: 0, omitted_count: 0, truncated: false }).change_count > 0,
     };
     let outcome;
     if (!execution.executorCompleted)
@@ -388,6 +442,8 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
         outcome = "promoted_without_index_change";
     else if (facts.shared_memory_changed)
         outcome = "shared_memory_updated";
+    else if (facts.pending_changed)
+        outcome = "pending_updated";
     else
         outcome = "no_files_changed";
     return { outcome, ...facts };
@@ -408,7 +464,7 @@ function memoryPruneFileFactFields(fileFacts) {
     }
     return fields;
 }
-export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
+export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, pending_manifest: _pendingManifest, ...fileFacts }) {
     return memoryPruneFileFactFields(fileFacts);
 }
 export function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {

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/npm-command.js

@@ -1,9 +1,9 @@
 import { posix, win32 } from "node:path";
-/** Execute POSIX npm through its owning Node binary so service PATH is irrelevant. */
+/** Execute npm through its owning Node binary so PATH and cmd.exe quoting are irrelevant. */
 export function npmInvocation(platform, nodePath = process.execPath) {
     const paths = platform === "win32" ? win32 : posix;
-    const npmPath = paths.join(paths.dirname(nodePath), platform === "win32" ? "npm.cmd" : "npm");
-    return platform === "win32"
-        ? { command: npmPath, argsPrefix: [] }
-        : { command: nodePath, argsPrefix: [npmPath] };
+    const npmPath = platform === "win32"
+        ? paths.join(paths.dirname(nodePath), "node_modules", "npm", "bin", "npm-cli.js")
+        : paths.join(paths.dirname(nodePath), "npm");
+    return { command: nodePath, argsPrefix: [npmPath] };
 }

package/dist/powershell-command.js

@@ -0,0 +1,12 @@
+/**
+ * powershell.exe -Command joins trailing argv into command text, rather than
+ * binding it to $args. Invoke a scriptblock with literal arguments inside one
+ * UTF-16LE encoded command. Encoding is transport, not encryption.
+ */
+export function powershellCommandArgs(script, args = []) {
+    // PowerShell also treats typographic single quotes as string delimiters.
+    const literals = args.map((arg) => `'${arg.replace(/['\u2018-\u201b]/gu, (quote) => quote + quote)}'`).join(" ");
+    const command = "[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false);\n"
+        + `& {\n${script}\n} ${literals}`;
+    return ["-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(command, "utf16le").toString("base64")];
+}

package/dist/project-skills/machine-hello-publisher.js

@@ -1,20 +1,109 @@
 import { WebSocket } from "ws";
+const HELLO_RETRY_DELAYS_MS = [1_000, 2_000, 4_000];
 /** 记住最近一次 hello 与 socket,便于存储身份变化后重发;Project Skills 状态恒为 ready。 */
 export function createMachineHelloPublisher(input) {
     let latest = null;
     let latestSocket = null;
-    const republish = () => {
-        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+    let acknowledged = false;
+    let attempts = 0;
+    // 发送代次:每开一轮新发送(attach/publish/republish)自增,随帧发出并要求 ack 回显。
+    let generation = 0;
+    let retryTimer;
+    const clearRetry = () => {
+        if (retryTimer !== undefined) {
+            clearTimeout(retryTimer);
+            retryTimer = undefined;
+        }
+    };
+    const scheduleRetry = () => {
+        clearRetry();
+        if (acknowledged || latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+            return;
+        // 当前 server 不支持 ack → 不排重试(否则永远等不到确认,白跑满退避)。
+        if (input.ackSupported && !input.ackSupported())
+            return;
+        const delay = HELLO_RETRY_DELAYS_MS[attempts - 1];
+        if (delay === undefined) {
+            // 退避跑满仍未 ack:期待 ack(ackSupported 已声明支持)才升级为断连重连,避免旧行为下反复重连。
+            if (input.ackSupported !== undefined && latestSocket !== null)
+                input.onExhausted?.(latestSocket);
             return;
-        const hello = input.effective({ ...latest, projectSkillsStatus: "ready" });
+        }
+        retryTimer = setTimeout(() => {
+            retryTimer = undefined;
+            sendCurrent();
+        }, delay);
+    };
+    function sendCurrent() {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN || acknowledged)
+            return;
+        // helloSeq 随帧发出;同一代次的多次重试复用同一 seq,ack 回显该 seq 即视为确认。
+        const hello = input.effective({ ...latest, projectSkillsStatus: "ready", helloSeq: generation });
+        const attempt = attempts + 1;
+        attempts = attempt;
         try {
             latestSocket.send(JSON.stringify(hello));
-            input.onSent(hello);
+            input.onSent(hello, attempt);
+        }
+        catch (error) {
+            input.onSendFailed?.(hello, attempt, error);
         }
-        catch { /* 非 OPEN,忽略 */ }
+        scheduleRetry();
+    }
+    const attach = (socket) => {
+        clearRetry();
+        latestSocket = socket;
+        acknowledged = false;
+        attempts = 0;
+        generation += 1;
+        sendCurrent();
+    };
+    const detach = (socket) => {
+        if (latestSocket !== socket)
+            return;
+        clearRetry();
+        latestSocket = null;
+        acknowledged = false;
+        attempts = 0;
+    };
+    const republish = () => {
+        if (latest === null || latestSocket === null)
+            return;
+        clearRetry();
+        acknowledged = false;
+        attempts = 0;
+        generation += 1;
+        sendCurrent();
+    };
+    const acknowledge = (socket, seq) => {
+        // 非当前 socket / 已确认 / 该 socket 已在关闭(close 后迟到的 ack)一律忽略:
+        // 后者会错误触发 onAck→清零强制重连计数,削弱重连上限。
+        if (latestSocket !== socket || latest === null || acknowledged || socket.readyState !== WebSocket.OPEN)
+            return;
+        // 代次校验:只接受回显当前代次的 ack,忽略上一代次迟到的 ack(否则会误停新代次的重试)。
+        // seq 缺省(老 server 不回显)时退回仅按 socket 匹配,保持兼容。
+        if (seq !== undefined && seq !== generation)
+            return;
+        acknowledged = true;
+        clearRetry();
+        input.onAck?.(input.effective({ ...latest, projectSkillsStatus: "ready" }));
     };
     return Object.freeze({
-        publish: (hello, socket) => { latest = hello; latestSocket = socket; republish(); },
+        publish: (hello, socket) => {
+            latest = hello;
+            if (latestSocket !== socket) {
+                attach(socket);
+                return;
+            }
+            acknowledged = false;
+            attempts = 0;
+            generation += 1;
+            clearRetry();
+            sendCurrent();
+        },
+        attach,
+        detach,
         republish,
+        acknowledge,
     });
 }

package/dist/prompt.js

@@ -5,6 +5,7 @@
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
+import { detectLocalMemoryStorageVersion, selectLegacyMemoryPreview, selectLocalMemoryPreview, } from "./local-memory/storage-format.js";
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
@@ -67,23 +68,14 @@ 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) {
-    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";
-    const noticeBytes = Buffer.byteLength(notice, "utf8");
-    if (notice.length > cap || noticeBytes > maxBytes)
-        return "";
-    let end = 0;
-    let bytes = noticeBytes;
-    for (const character of memory) {
-        const size = Buffer.byteLength(character, "utf8");
-        if (notice.length + end + character.length > cap || bytes + size > maxBytes)
-            break;
-        end += character.length;
-        bytes += size;
+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 selectLegacyMemoryPreview(memory, query, { maxCodePoints: cap, maxBytes });
     }
-    return notice + memory.slice(0, end);
+    return memory;
 }
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
@@ -342,7 +334,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。旧版索引可能包含 \`scope\`；V2 规范字段为 \`id/file/type/status/summary/triggers/priority/revision/anchor/updated\`(可选 \`review_after\`),不含 \`scope\`。其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
 2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。