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

package/dist/memory-prune-diagnostics.js

@@ -7,7 +7,6 @@ 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;
@@ -193,50 +192,6 @@ 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([
@@ -255,17 +210,15 @@ async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal
     };
 }
 export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal) {
-    const [fixedFiles, notesManifest, pendingManifest] = await Promise.all([
+    const [fixedFiles, notesManifest] = await Promise.all([
         inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal),
         inspectMemoryPruneNotes(homeDir, signal),
-        inspectMemoryPrunePending(homeDir, signal),
     ]);
-    return { ...fixedFiles, notes_manifest: notesManifest, pending_manifest: pendingManifest };
+    return { ...fixedFiles, notes_manifest: notesManifest };
 }
 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);
     }
@@ -278,13 +231,7 @@ export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, wor
             error: diagnosticError(error),
         };
     }
-    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 };
+    return { ...fixedFiles, notes_manifest: notesManifest };
 }
 export async function withinMemoryPruneDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
@@ -414,7 +361,6 @@ 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)
@@ -442,8 +388,6 @@ 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 };
@@ -464,7 +408,7 @@ function memoryPruneFileFactFields(fileFacts) {
     }
     return fields;
 }
-export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, pending_manifest: _pendingManifest, ...fileFacts }) {
+export function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
     return memoryPruneFileFactFields(fileFacts);
 }
 export function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {

package/dist/message-file-preview.js

@@ -9,7 +9,6 @@ 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;
@@ -232,16 +231,7 @@ export async function readSharedMessageFile(agentsRoot, rawRequest, registry) {
         throw new SharedFileError("file_preview_busy");
     activeReads++;
     try {
-        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));
+        return await readCandidate(await resolveCandidate(agentsRoot, parsed.data, registry));
     }
     catch (error) {
         if (error instanceof SharedFileError)

package/dist/prompt.js

@@ -5,7 +5,6 @@
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
-import { detectLocalMemoryStorageVersion, selectLocalMemoryPreview } from "./local-memory/storage-format.js";
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
@@ -68,10 +67,7 @@ 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, query = "") {
-    if (detectLocalMemoryStorageVersion(memory) === 2) {
-        return selectLocalMemoryPreview(memory, query, { maxCodePoints: cap, maxBytes }).memory;
-    }
+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";
@@ -346,7 +342,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。旧版索引可能包含 \`scope\`；V2 规范字段为 \`id/file/type/status/summary/triggers/priority/revision/anchor/updated\`(可选 \`review_after\`),不含 \`scope\`。其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 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 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。

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, undefined, undefined, baseWake),
+            memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
             localMemoryV2Enabled: workspace.localMemoryV2Enabled ?? localMemoryV2Enabled,

package/dist/runtimes/claude-thread-runner.js

@@ -12,14 +12,6 @@ const InputSchema = z.object({ bin: z.string().min(1), args: z.array(z.string())
     wakePrompt: z.string().min(1), sessionId: z.string().min(1).optional(), resume: z.boolean() }).strict();
 class PreflightError extends Error {
 }
-// Claude waits for every merged SessionStart hook before acknowledging SDK
-// initialization. Those hooks may legitimately outlive the old 30s adapter
-// deadline. Cap this phase below the daemon's default 120s fail-closed startup
-// window so wrapper failure propagation and supervisor-owned tree cleanup retain
-// margin. The 100s cap leaves a nominal 20s outside this phase; this runner's
-// local TERM/KILL cleanup is itself bounded to 2s.
-// Resume and cold recovery share this one budget; hook activity never extends it.
-export const CLAUDE_INITIALIZE_TIMEOUT_MS = 100_000;
 function hookCommand(path, nonce) {
     const source = import.meta.url.endsWith(".ts");
     const hook = fileURLToPath(new URL(`./claude-session-start-hook.${source ? "ts" : "js"}`, import.meta.url));
@@ -60,9 +52,6 @@ async function bounded(promise, milliseconds, label) {
         clearTimeout(timer);
     }
 }
-export function waitForClaudeInitialize(initialized, timeoutMs = CLAUDE_INITIALIZE_TIMEOUT_MS) {
-    return bounded(initialized, timeoutMs, "claude_initialize_timeout");
-}
 async function attempt(input, sessionId, resume, options) {
     const proofDir = await mkdtemp(join(tmpdir(), "nowwork-claude-session-"));
     const proofPath = join(proofDir, "proof.json");
@@ -199,7 +188,7 @@ async function attempt(input, sessionId, resume, options) {
     try {
         try {
             await send({ type: "control_request", request_id: initId, request: { subtype: "initialize" } });
-            await waitForClaudeInitialize(initialized.promise, options.initializeTimeoutMs);
+            await bounded(initialized.promise, options.initializeTimeoutMs ?? 30_000, "claude_initialize_timeout");
             const proof = JSON.parse(await readFile(proofPath, "utf8"));
             if (proof.nonce !== nonce || proof.sessionId !== sessionId || proof.source !== (resume ? "resume" : "startup")) {
                 throw new Error("claude_session_proof_mismatch");
@@ -249,25 +238,15 @@ async function attempt(input, sessionId, resume, options) {
 }
 export async function runClaudeThread(input, options = {}) {
     const sessionId = input.sessionId ?? randomUUID();
-    const initializeBudgetMs = options.initializeTimeoutMs ?? CLAUDE_INITIALIZE_TIMEOUT_MS;
-    const now = options.now ?? (() => performance.now());
-    const initializeDeadline = now() + Math.max(0, initializeBudgetMs);
-    const runAttempt = (attemptSessionId, resume) => {
-        const remainingMs = Math.max(0, Math.ceil(initializeDeadline - now()));
-        if (remainingMs === 0)
-            return Promise.reject(new PreflightError("claude_native_session_unconfirmed"));
-        return attempt(input, attemptSessionId, resume, { ...options, initializeTimeoutMs: remainingMs });
-    };
     try {
-        return await runAttempt(sessionId, input.resume);
+        return await attempt(input, sessionId, input.resume, options);
     }
     catch (error) {
         // The failed attempt never received a business user turn or entered its
-        // model/tool loop. Native startup hooks may run again on cold recovery,
-        // within the original aggregate initialize deadline.
+        // model/tool loop. Native startup hooks may run again on cold recovery.
         if (!input.resume || !(error instanceof PreflightError || error instanceof ThreadDeliveryColdStartRequired))
             throw error;
-        return runAttempt(randomUUID(), false);
+        return attempt(input, randomUUID(), false, options);
     }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/dist/serve.js

@@ -14,7 +14,6 @@ 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";
@@ -51,8 +50,6 @@ 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 枚举
@@ -78,8 +75,6 @@ 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));
@@ -94,15 +89,6 @@ 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
@@ -284,7 +270,7 @@ export function serve(config, opts = {}) {
         return null;
     };
     const sendSnapshot = async (reqId) => {
-        const entries = (await replayExecutionJournals(executionJournal, migrationExecutionJournal)).map(snapshotEntry).filter((entry) => entry !== null);
+        const entries = (await executionJournal.replay()).map(snapshotEntry).filter((entry) => entry !== null);
         safeExecutionSend(ExecutionSnapshotSchema.parse({
             type: "execution:snapshot", protocolVersion: 1, reqId, entries,
         }));
@@ -366,12 +352,6 @@ 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) {
@@ -451,8 +431,7 @@ export function serve(config, opts = {}) {
                         return;
                     if (frame.type === "execution:completion-ack") {
                         try {
-                            const journal = await executionJournal.get(frame.executionId) ? executionJournal : migrationExecutionJournal;
-                            await journal.acknowledgeCompletion(frame.executionId);
+                            await executionJournal.acknowledgeCompletion(frame.executionId);
                             const attempts = completionRetransmitter.acknowledge(frame.executionId);
                             dslog("execution.completion_acknowledged", "execution completion ACK 已持久化", {
                                 execution_id: frame.executionId,
@@ -478,8 +457,6 @@ 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)
@@ -712,7 +689,6 @@ export function serve(config, opts = {}) {
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
                         machineEnvironment: machineRuntime.provider,
-                        ...(memoryMigrations.getIdentity() === null ? {} : { controlIdentity: memoryMigrations.getIdentity() }),
                         capabilities: capabilities.executionRunner,
                         projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkills,
                         abilityRelease: opts.execution?.dependencies?.abilityRelease ?? agentAbilityRuntime.materializer,
@@ -803,8 +779,6 @@ 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 });
                 // 旧 server 无此字段 → 空集合(daemon 保持全部旧行为)。ackSupported() 依赖它判断是否重试,
                 // 必须在任何 republish() 之前就位;否则本轮 republish 看到空集合→不排重试→整套 ack/重连机制哑火。
                 serverCapabilities = new Set(Array.isArray(r.serverCapabilities)
@@ -873,8 +847,6 @@ 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 复制用户内容
@@ -889,7 +861,7 @@ export function serve(config, opts = {}) {
                 try {
                     const data2 = req.type === "raft:inspect"
                         ? await inspectRaftWorkspace(req.path)
-                        : await withMemoryAccess(join(config.agentsRoot, req.handle), () => importRaftWorkspace(req.path, join(config.agentsRoot, req.handle)), { create: true });
+                        : await importRaftWorkspace(req.path, join(config.agentsRoot, req.handle));
                     if (req.type === "raft:import") {
                         log(`📦 已导入 raft 工作区 → ${req.handle}: 复制 ${data2.copied.length} 项`);
                     }
@@ -1282,7 +1254,6 @@ export function serve(config, opts = {}) {
                 return;
             // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。
             serverCapabilities = new Set();
-            memoryMigrations.clearIdentity();
             completionRetransmitter.pause();
             // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
             // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。
@@ -1335,9 +1306,6 @@ 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 = () => {
@@ -1355,7 +1323,6 @@ export function serve(config, opts = {}) {
             const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
             const pending = [
                 machineRuntime.stop(),
-                memoryMigrations.stop(),
                 webSocketClosed,
                 updateController.drain(),
                 marketplace.stop(),
@@ -1374,8 +1341,6 @@ 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();

package/dist/token.js

@@ -7,7 +7,6 @@ export async function mintAgentToken(serverUrl, machineToken, handle, displayNam
         },
         // 把本轮唤醒的线程根钉到 per-launch 令牌:服务端据此让 task/消息默认绑/回当前线程。
         body: JSON.stringify({
-            memoryStateGuardVersion: 1,
             handle,
             ...(displayName ? { displayName } : {}),
             ...(options.wakeThreadRoot ? { wakeThreadRoot: options.wakeThreadRoot } : {}),

package/dist/workspace-control-handler.js

@@ -1,22 +1,9 @@
 /** 控制面文件/技能查看的按需处理，独立于执行生命周期。 */
-import { lstat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { readSharedMessageFile } from "./message-file-preview.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
 import { listRuntimeModels } from "./list-models.js";
-import { withMemoryAccess } from "./local-memory/migration-access.js";
-async function listProtectedWorkspace(root, path) {
-    try {
-        await lstat(root);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-        return { root: resolve(root), path: path.replace(/^\/+/, ""), entries: [] };
-    }
-    return withMemoryAccess(root, () => listWorkspace(root, path));
-}
 export async function handleWorkspaceControlRequest(raw, agentsRoot, registry, models = listRuntimeModels) {
     if (!raw || typeof raw !== "object")
         return null;
@@ -28,8 +15,8 @@ export async function handleWorkspaceControlRequest(raw, agentsRoot, registry, m
     try {
         const root = join(agentsRoot, request.handle);
         const data = request.type === "fs:read-shared" ? await readSharedMessageFile(agentsRoot, raw, registry)
-            : request.type === "fs:list" ? await listProtectedWorkspace(root, request.path)
-                : request.type === "fs:read" ? await withMemoryAccess(root, () => readWorkspaceFile(root, request.path))
+            : request.type === "fs:list" ? await listWorkspace(root, request.path)
+                : request.type === "fs:read" ? await readWorkspaceFile(root, request.path)
                     : request.type === "skills:list" ? await listSkills(request.runtime)
                         : { models: await models(request.runtime ?? "") };
         return { type: "fs:result", reqId: request.reqId, ok: true, data };

package/dist/workspace.js

@@ -8,15 +8,12 @@
  *
  * spawn runtime 时把 <ws>/.crew 置于 PATH 最前,于是 agent 的 `crew ...` 命中 wrapper。
  */
-import { mkdir, writeFile, readFile, chmod, access, lstat, realpath } from "node:fs/promises";
+import { mkdir, writeFile, readFile, chmod, access, lstat } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { dslog } from "./slog.js";
-import { MigrationStateSchema } from "./local-memory/migration-schema.js";
-import { assertMigrationStateIntegrity } from "./local-memory/migration-state-invariants.js";
-import { detectLocalMemoryStorageVersion } from "./local-memory/storage-format.js";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
     return key.replace(/[^\w.-]+/g, "_").replace(/^[-.]+/, "").slice(0, 80) || "default";
@@ -52,15 +49,7 @@ async function hasLocalMemoryV2Marker(agentDir) {
         const stat = await lstat(markerPath);
         if (!stat.isFile() || stat.isSymbolicLink())
             return false;
-        if ((await readFile(markerPath, "utf8")) !== "1\n")
-            return false;
-        const root = await realpath(agentDir);
-        const state = MigrationStateSchema.parse(JSON.parse(await readFile(join(memoryDir, "migration.v1.json"), "utf8")));
-        assertMigrationStateIntegrity(state, state.identity);
-        return state.phase === "committed" && state.storageVersion === 2
-            && state.identity.rootFingerprint === createHash("sha256").update(root).digest("hex")
-            && state.identity.ownerIdentity === String((await lstat(root)).uid)
-            && detectLocalMemoryStorageVersion(await readFile(join(root, "MEMORY.md"), "utf8")) === 2;
+        return (await readFile(markerPath, "utf8")) === "1\n";
     }
     catch {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.97-beta.2",
+  "version": "0.6.97-beta.3",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",

package/dist/local-memory/commit-telemetry.js

@@ -1,30 +0,0 @@
-import { dslog } from "../slog.js";
-function boundedIds(ids) {
-    return {
-        value: (ids ?? []).slice(0, 100).join(","),
-        count: ids?.length ?? 0,
-        truncated: (ids?.length ?? 0) > 100,
-    };
-}
-export function logLocalMemoryCommitApplied(input) {
-    const { committed } = input;
-    const created = boundedIds(committed.createdIds);
-    const updated = boundedIds(committed.updatedIds);
-    const statusChanged = boundedIds(committed.statusChangedIds);
-    const pending = boundedIds(committed.pendingIds);
-    dslog("local_memory.commit_applied", "结构化本地记忆提交已验证", {
-        execution_id: input.executionId, agent_handle: input.agentHandle, prune_trace_id: input.pruneTraceId,
-        storage_version_before: committed.storageVersionBefore,
-        storage_version_after: committed.storageVersionAfter,
-        committed_state: committed.committedState,
-        writer_mode: committed.pendingReason === "legacy_requires_migration"
-            ? "pending_only"
-            : committed.storageVersionAfter === 2 && committed.committedState ? "v2" : "legacy",
-        created_id_count: created.count, created_ids: created.value, created_ids_truncated: created.truncated,
-        updated_id_count: updated.count, updated_ids: updated.value, updated_ids_truncated: updated.truncated,
-        status_changed_id_count: statusChanged.count, status_changed_ids: statusChanged.value,
-        status_changed_ids_truncated: statusChanged.truncated,
-        pending_id_count: pending.count, pending_ids: pending.value, pending_ids_truncated: pending.truncated,
-        pending_reason: committed.pendingReason,
-    });
-}

package/dist/local-memory/execution-workspace.js

@@ -1,62 +0,0 @@
-import { prepareWorkspace } from "../workspace.js";
-import { awaitWithCancellation } from "../runtime-cancellation.js";
-import { logLocalMemoryContextPrepareFailure } from "../local-memory-telemetry.js";
-import { resolveLocalMemoryV2Rollout } from "./rollout.js";
-import { initializeLocalMemoryV2ForWorkspace } from "./runtime.js";
-import { withMemoryAccess } from "./migration-access.js";
-import { join } from "node:path";
-import { readFile } from "node:fs/promises";
-// A fresh Agent may receive the daemon's full ten-wide execution burst.  The
-// first turn publishes schema2 durably; the remaining turns must wait to reuse
-// that committed fact instead of timing out on the generic short IO window.
-const EXECUTION_MEMORY_ACCESS_WAIT_MS = 30_000;
-export async function prepareExecutionMemoryWorkspace(input, isolated, cancellation) {
-    try {
-        const prepare = async (context) => {
-            const prepared = await prepareWorkspace({
-                agentsRoot: input.launch.agentsRoot, handle: input.handle, cliPath: input.launch.cliPath,
-                executionId: input.executionId,
-                ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
-                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-                ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
-                ...(input.sessionContextFingerprint === undefined ? {} : { sessionContextFingerprint: input.sessionContextFingerprint }),
-                ...(input.launch.description ? { description: input.launch.description } : {}),
-                ...(isolated ? { skipLocalMemory: true } : {}),
-            });
-            const workspace = context?.created ? { ...prepared, agentHomePreexisted: false } : prepared;
-            const initialMode = await resolveLocalMemoryV2Rollout({ workspace, handle: input.handle, serverUrl: input.launch.serverUrl,
-                agentId: input.launch.agentId, requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
-                ...(input.launch.description ? { description: input.launch.description } : {}) });
-            const initializationBinding = input.launch.workspaceId !== undefined && input.launch.machineId !== undefined
-                ? { workspaceId: input.launch.workspaceId, machineId: input.launch.machineId }
-                : undefined;
-            const initialized = await initializeLocalMemoryV2ForWorkspace(workspace, initialMode.enabled, input.launch.agentId, initializationBinding);
-            const memory = initialized && !workspace.localMemoryV2Initialized
-                ? await readFile(join(workspace.dir, "MEMORY.md"), "utf8")
-                : workspace.memory;
-            const currentWorkspace = { ...workspace, memory };
-            const mode = initialized && !workspace.localMemoryV2Initialized
-                ? await resolveLocalMemoryV2Rollout({ workspace: currentWorkspace, handle: input.handle,
-                    serverUrl: input.launch.serverUrl, agentId: input.launch.agentId,
-                    requested: input.localMemoryV2Enabled === true, selfTraining: isolated,
-                    ...(input.launch.description ? { description: input.launch.description } : {}) })
-                : initialMode;
-            return { workspace: { ...currentWorkspace, localMemoryV2Enabled: mode.enabled }, mode, initialized };
-        };
-        return await awaitWithCancellation(isolated ? prepare()
-            : withMemoryAccess(join(input.launch.agentsRoot, input.handle), prepare, {
-                create: true,
-                waitMs: EXECUTION_MEMORY_ACCESS_WAIT_MS,
-                initializedRecoveryIdentity: {
-                    agentId: input.launch.agentId,
-                    ...(input.launch.workspaceId === undefined ? {} : { workspaceId: input.launch.workspaceId }),
-                    ...(input.launch.machineId === undefined ? {} : { machineId: input.launch.machineId }),
-                },
-            }), cancellation);
-    }
-    catch (error) {
-        logLocalMemoryContextPrepareFailure({ executionId: input.executionId, agentHandle: input.handle,
-            ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }) }, "workspace_prepare", error);
-        throw error;
-    }
-}

package/dist/local-memory/full-index-search.js

@@ -1,47 +0,0 @@
-import { parseFullMemoryIndex, LOCAL_MEMORY_GENERATED_INDEX_PATTERN } from "./storage-format.js";
-const excerpt = (text, size) => Array.from(text).slice(0, size).join("");
-/** 查询完整元数据；只在明确的历史入口返回非有效记录。正文仍按引用和哈希分页读取。 */
-export function searchFullMemoryIndex(memory, sha256, input, outputBytes) {
-    const records = parseFullMemoryIndex(memory);
-    const block = LOCAL_MEMORY_GENERATED_INDEX_PATTERN.exec(memory);
-    const prefix = memory.slice(0, block.index);
-    let line = (prefix.match(/\n/gu) ?? []).length + 1;
-    let offset = Array.from(prefix).length;
-    const positions = new Map();
-    for (const part of block[0].matchAll(/[^\n]*(?:\n|$)/gu)) {
-        const id = /^- id: ([A-Za-z0-9_-]+)\r?\n?$/u.exec(part[0])?.[1];
-        if (id)
-            positions.set(id, { line, offset });
-        line += 1;
-        offset += Array.from(part[0]).length;
-    }
-    const terms = input.query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
-    const candidates = records.filter(entry => {
-        const active = entry.status === "active" || entry.status === "pinned";
-        const content = `${entry.id} ${entry.title} ${entry.summary} ${entry.triggers.join(" ")}`.normalize("NFKC").toLowerCase();
-        return active !== input.history && terms.every(term => content.includes(term));
-    });
-    const matches = [];
-    let bytes = 512, hasMore = false;
-    for (const entry of candidates) {
-        const position = positions.get(entry.id);
-        if (!position)
-            throw new Error("memory_storage_position_invalid");
-        if (position.line <= input.afterLine)
-            continue;
-        const item = { ...position, id: entry.id, status: entry.status, revision: entry.revision,
-            file: entry.file, anchor: entry.anchor, heading: excerpt(entry.title, 96),
-            title: excerpt(entry.title, 120), summary: excerpt(entry.summary, 240), text: excerpt(entry.summary, 240) };
-        const size = Buffer.byteLength(JSON.stringify(item), "utf8") + 1;
-        if (matches.length >= input.limit || bytes + size > outputBytes) {
-            hasMore = true;
-            break;
-        }
-        matches.push(item);
-        bytes += size;
-    }
-    if (hasMore && matches.length === 0)
-        throw new Error("memory_output_too_large");
-    return { file: "MEMORY.md", storageVersion: 2, sha256, matches, matchCount: candidates.length,
-        hasMore, complete: !hasMore, nextAfterLine: hasMore ? matches.at(-1).line : null };
-}