@nowcrew/daemon 0.6.87-beta.2 → 0.6.87

package/dist/execution-runner.js

@@ -25,6 +25,7 @@ import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
 import { PROJECT_SKILL_PROJECTION_V2_CAPABILITY } from "./project-skills/types.js";
 import { dslog } from "./slog.js";
 import { identityRosterPromptFacts } from "./identity-roster-telemetry.js";
+import { renderLocalMemoryV2WriteGuard } from "./local-memory/runtime.js";
 export { supervisorLaunch } from "./supervised-runtime.js";
 const MAX_LOCAL_EXECUTION_ATTEMPTS = 3;
 const ACTIVITY_KIND = {
@@ -828,7 +829,8 @@ export async function runExecution(config, input, dependencies) {
         const baseSystemPromptBudget = spec.agent.abilityRelease === undefined
             ? systemPromptBudget
             : Math.max(0, Math.min(systemPromptBudget, Math.max(32 * 1024, systemPromptBudget - 168 * 1024)));
-        const systemPromptWithLocalFacts = withLocalExecutionFacts(spec.instructions.systemPrompt, baseSystemPromptBudget, {
+        const localMemoryV2Enabled = config.localMemoryV2Handles?.has(spec.agent.handle) === true;
+        const systemPromptWithLocalFacts = withLocalExecutionFacts(`${spec.instructions.systemPrompt}${localMemoryV2Enabled ? renderLocalMemoryV2WriteGuard() : ""}`, baseSystemPromptBudget, {
             ...(selfTraining ? { isolateLocalMemory: true } : {}),
             collaborationTools: config.codexCollaborationTools && spec.runtime.name === "codex",
         });
@@ -887,7 +889,7 @@ export async function runExecution(config, input, dependencies) {
                 maxTurns: config.sessionMaxTurns,
             },
             ...(selfTraining ? { maintenancePurpose: "self_training" } : {}),
-            localMemoryV2Enabled: config.localMemoryV2Handles?.has(spec.agent.handle) === true,
+            localMemoryV2Enabled,
         };
         const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),

package/dist/external-output.js

@@ -1,15 +1,104 @@
 export const EXTERNAL_ANSWER_OPEN = "<nowwork_external_answer>";
 export const EXTERNAL_ANSWER_CLOSE = "</nowwork_external_answer>";
-function retainedMarkerPrefix(value, marker) {
-    const maximum = Math.min(value.length, marker.length - 1);
-    for (let length = maximum; length > 0; length -= 1) {
-        if (marker.startsWith(value.slice(-length)))
-            return length;
+const MAX_MARKER_TAG_LENGTH = 96;
+const KNOWN_EXTERNAL_ANSWER_TAG = /^now+orkexternalanswer$/u;
+const CANONICAL_EXTERNAL_ANSWER_TAG = "noworkexternalanswer";
+function editDistanceWithin(value, target, maximum) {
+    if (Math.abs(value.length - target.length) > maximum)
+        return false;
+    let previous = Array.from({ length: target.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= value.length; row += 1) {
+        const current = [row];
+        let rowMinimum = row;
+        for (let column = 1; column <= target.length; column += 1) {
+            const cost = value[row - 1] === target[column - 1] ? 0 : 1;
+            const distance = Math.min(previous[column] + 1, current[column - 1] + 1, previous[column - 1] + cost);
+            current.push(distance);
+            rowMinimum = Math.min(rowMinimum, distance);
+        }
+        if (rowMinimum > maximum)
+            return false;
+        previous = current;
+    }
+    return previous[target.length] <= maximum;
+}
+function resemblesExternalAnswerTag(name) {
+    if (name.includes("externalanswer"))
+        return true;
+    const canonicalized = name.replace(/^now+ork/u, "nowork");
+    return editDistanceWithin(canonicalized, CANONICAL_EXTERNAL_ANSWER_TAG, 2);
+}
+function classifyMarkerTag(body) {
+    const trimmed = body.trim();
+    const closing = trimmed.startsWith("/");
+    const name = (closing ? trimmed.slice(1) : trimmed)
+        .trim()
+        .toLowerCase()
+        .replace(/[_\-\s]/gu, "");
+    if (KNOWN_EXTERNAL_ANSWER_TAG.test(name))
+        return { closing, kind: "known" };
+    return {
+        closing,
+        kind: resemblesExternalAnswerTag(name) ? "suspicious" : "other",
+    };
+}
+function nextMarkerTag(value, from) {
+    let cursor = from;
+    while (cursor < value.length) {
+        const start = value.indexOf("<", cursor);
+        if (start < 0)
+            return null;
+        const end = value.indexOf(">", start + 1);
+        if (end < 0)
+            return null;
+        const body = value.slice(start + 1, end);
+        const classified = classifyMarkerTag(body);
+        if (classified.kind === "suspicious"
+            || (classified.kind === "known" && body.length > MAX_MARKER_TAG_LENGTH)) {
+            return { start, end: end + 1, closing: classified.closing, kind: "suspicious" };
+        }
+        if (classified.kind === "known") {
+            return { start, end: end + 1, closing: classified.closing, kind: "known" };
+        }
+        cursor = end + 1;
+    }
+    return null;
+}
+function parseExternalAnswerText(value) {
+    const sections = [];
+    let cursor = 0;
+    let contentStart = 0;
+    let inside = false;
+    let found = false;
+    for (;;) {
+        const tag = nextMarkerTag(value, cursor);
+        if (!tag)
+            break;
+        if (tag.kind === "suspicious")
+            return { kind: "rejected", text: "" };
+        if (tag.closing) {
+            if (!inside)
+                return { kind: "rejected", text: "" };
+            sections.push(value.slice(contentStart, tag.start));
+            inside = false;
+        }
+        else {
+            if (inside)
+                return { kind: "rejected", text: "" };
+            found = true;
+            inside = true;
+            contentStart = tag.end;
+        }
+        cursor = tag.end;
     }
-    return 0;
+    if (inside)
+        sections.push(value.slice(contentStart));
+    if (!found)
+        return { kind: "plain", text: value.trim() };
+    return { kind: "marked", text: sections.join("").trim() };
 }
 /**
- * 跨 chunk 的契约标签流式解码器:push() 逐段返回标签内文本(供 answerStream 实时转发);
+ * 跨 chunk 的契约标签解码器:push() 在合法闭合后返回完整标签块(供 answerStream 转发);
  * 同时记住整轮里**最后一个完整闭合**的标签块(`lastClosedBlock`),供完结时作为契约答案——
  * 只有闭合了的块才算数:半截块(被工具调用拆开的前半段)与叙述里提到的开标签
  * ("我会把结论包在 <marker> 里,先去跑测试")都不会被当成答案(review of a027bf15, C1)。
@@ -40,34 +129,63 @@ export class ExternalAnswerDecoder {
     }
     consume(value, output) {
         this.pending = "";
-        const marker = this.state === "outside" ? EXTERNAL_ANSWER_OPEN : EXTERNAL_ANSWER_CLOSE;
-        const markerAt = value.indexOf(marker);
-        if (markerAt >= 0) {
-            if (this.state === "inside") {
-                const head = value.slice(0, markerAt);
-                if (head)
-                    output.push(head);
-                const completed = `${this.block}${head}`.trim();
-                if (completed)
-                    this.closed = completed;
-                this.block = "";
-                this.state = "outside";
+        const appendInside = (text) => {
+            if (!text)
+                return;
+            this.block += text;
+        };
+        for (const character of value) {
+            if (this.pending) {
+                this.pending += character;
+                if (character === ">") {
+                    const body = this.pending.slice(1, -1);
+                    const tag = classifyMarkerTag(body);
+                    if (tag.kind === "known" && body.length <= MAX_MARKER_TAG_LENGTH) {
+                        if (tag.closing && this.state === "inside") {
+                            const completed = this.block.trim();
+                            if (completed) {
+                                this.closed = completed;
+                                output.push(completed);
+                            }
+                            this.block = "";
+                            this.state = "outside";
+                        }
+                        else if (!tag.closing && this.state === "outside") {
+                            this.block = "";
+                            this.state = "inside";
+                        }
+                        else {
+                            this.block = "";
+                            this.state = tag.closing ? "outside" : "inside";
+                        }
+                    }
+                    else if (tag.kind === "suspicious" || tag.kind === "known") {
+                        this.block = "";
+                        this.state = "outside";
+                    }
+                    else if (this.state === "inside") {
+                        appendInside(this.pending);
+                    }
+                    this.pending = "";
+                }
+                else if (this.pending.length > MAX_MARKER_TAG_LENGTH + 2) {
+                    const tag = classifyMarkerTag(this.pending.slice(1));
+                    if (tag.kind === "suspicious" || tag.kind === "known") {
+                        this.block = "";
+                        this.state = "outside";
+                    }
+                    else if (this.state === "inside") {
+                        appendInside(this.pending);
+                    }
+                    this.pending = "";
+                }
             }
-            else {
-                this.block = "";
-                this.state = "inside";
+            else if (character === "<") {
+                this.pending = character;
+            }
+            else if (this.state === "inside") {
+                appendInside(character);
             }
-            const remaining = value.slice(markerAt + marker.length);
-            if (remaining)
-                this.consume(remaining, output);
-            return;
-        }
-        const retained = retainedMarkerPrefix(value, marker);
-        const safe = retained > 0 ? value.slice(0, -retained) : value;
-        this.pending = retained > 0 ? value.slice(-retained) : "";
-        if (this.state === "inside" && safe) {
-            output.push(safe);
-            this.block += safe;
         }
     }
 }
@@ -104,20 +222,7 @@ export function decodeExternalOutputEvent(runtime, event, decoder) {
         : [];
 }
 export function stripExternalAnswerMarkers(value) {
-    const sections = [];
-    let cursor = 0;
-    while (cursor < value.length) {
-        const openAt = value.indexOf(EXTERNAL_ANSWER_OPEN, cursor);
-        if (openAt < 0)
-            break;
-        const contentAt = openAt + EXTERNAL_ANSWER_OPEN.length;
-        const closeAt = value.indexOf(EXTERNAL_ANSWER_CLOSE, contentAt);
-        if (closeAt < 0)
-            return value.slice(contentAt).trim();
-        sections.push(value.slice(contentAt, closeAt));
-        cursor = closeAt + EXTERNAL_ANSWER_CLOSE.length;
-    }
-    return (sections.length > 0 ? sections.join("") : value).trim();
+    return parseExternalAnswerText(value).text;
 }
 /**
  * 提取 marker 内容:有 marker 返回拼接内容(trim,空→null),无 marker 返回 null。
@@ -125,25 +230,6 @@ export function stripExternalAnswerMarkers(value) {
  * 本函数用于判定"agent 是否给出了频道直接回复"——必须能区分有无 marker。
  */
 export function extractExternalAnswer(value) {
-    const parts = [];
-    let found = false;
-    let rest = value;
-    for (;;) {
-        const open = rest.indexOf(EXTERNAL_ANSWER_OPEN);
-        if (open < 0)
-            break;
-        found = true;
-        const afterOpen = rest.slice(open + EXTERNAL_ANSWER_OPEN.length);
-        const close = afterOpen.indexOf(EXTERNAL_ANSWER_CLOSE);
-        if (close < 0) {
-            parts.push(afterOpen);
-            break;
-        }
-        parts.push(afterOpen.slice(0, close));
-        rest = afterOpen.slice(close + EXTERNAL_ANSWER_CLOSE.length);
-    }
-    if (!found)
-        return null;
-    const answer = parts.join("").trim();
-    return answer.length > 0 ? answer : null;
+    const parsed = parseExternalAnswerText(value);
+    return parsed.kind === "marked" && parsed.text ? parsed.text : null;
 }

package/dist/local-executor.js

@@ -37,6 +37,7 @@ import { formatRuntimeStartupError } from "./runtime-startup-error.js";
 import { machinePackageManagerEnv, packageManagerEnvFacts } from "./package-manager-env.js";
 import { sanitizeEnvVars } from "./runtime-env.js";
 import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
+import { renderPendingMemoryContext, searchPendingMemoryCandidates, } from "./local-memory/pending.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -381,6 +382,26 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
+        let pendingMemoryContext = "";
+        if (input.localMemoryV2Enabled === true) {
+            try {
+                const pendingCandidates = await searchPendingMemoryCandidates({
+                    agentDir: executionWorkspace.dir,
+                    query: wakePrompt,
+                    limit: 5,
+                });
+                pendingMemoryContext = renderPendingMemoryContext(pendingCandidates);
+            }
+            catch (error) {
+                dslog("local_memory.pending_recall_failed", "本地归档记忆召回失败", {
+                    level: "WARN",
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    error_name: error instanceof Error ? error.name : "unknown",
+                    error_code: error?.code,
+                });
+            }
+        }
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
         if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
             && isLocalMemoryV2Eligible({
@@ -392,14 +413,21 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             })) {
             localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
         }
-        const baseSystemPrompt = resolvePrompt(input.systemPrompt, promptContext);
+        const promptWithoutPending = resolvePrompt(input.systemPrompt, promptContext);
+        let baseSystemPrompt = `${promptWithoutPending}${pendingMemoryContext}`;
         const structuredMemoryInstructions = localMemoryResultPath === null
             ? null
             : renderLocalMemoryResultInstructions(localMemoryResultPath);
-        const structuredPromptFits = structuredMemoryInstructions === null
+        const fitsPromptBudget = (prompt) => structuredMemoryInstructions === null
             || input.maxSystemPromptBytes === undefined
-            || Buffer.byteLength(baseSystemPrompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
+            || Buffer.byteLength(prompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
                 <= input.maxSystemPromptBytes;
+        // The structured prune contract is mandatory for V2. Drop optional archived
+        // recall before dropping the daemon result file when the prompt budget is tight.
+        if (!fitsPromptBudget(baseSystemPrompt) && pendingMemoryContext !== "") {
+            baseSystemPrompt = promptWithoutPending;
+        }
+        const structuredPromptFits = fitsPromptBudget(baseSystemPrompt);
         if (!structuredPromptFits)
             localMemoryResultPath = null;
         const systemPrompt = localMemoryResultPath === null

package/dist/local-memory/pending.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
+export const LOCAL_MEMORY_PENDING_SCAN_FILE_CAP = 128;
+export const LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP = 1_000_000;
 const CandidateSchema = z.object({
     operation: z.enum(["create", "update", "supersede"]),
     memoryId: z.string().nullable(),
@@ -59,6 +61,44 @@ async function pendingDirectory(agentDir) {
     }
     return directory;
 }
+async function existingPendingDirectory(agentDir) {
+    const agentRoot = await realpath(agentDir);
+    const memoryRoot = resolve(agentRoot, ".crew", "memory");
+    let memoryStat;
+    try {
+        memoryStat = await lstat(memoryRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink()) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const resolvedMemoryRoot = await realpath(memoryRoot);
+    if (resolvedMemoryRoot !== memoryRoot || !within(agentRoot, resolvedMemoryRoot)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const directory = join(memoryRoot, "pending");
+    let stat;
+    try {
+        stat = await lstat(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const resolvedDirectory = await realpath(directory);
+    if (resolvedDirectory !== directory || !within(agentRoot, resolvedDirectory)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    return directory;
+}
 async function assertRegularFile(path) {
     try {
         const stat = await lstat(path);
@@ -91,15 +131,40 @@ export async function persistPendingMemoryCandidate(input) {
     await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
     return target;
 }
+export async function removePendingMemoryCandidate(input) {
+    const directory = await existingPendingDirectory(input.agentDir);
+    if (directory === null)
+        return;
+    const target = join(directory, `${input.pendingId}.json`);
+    await assertRegularFile(target);
+    await rm(target, { force: true });
+}
 export async function readPendingMemoryCandidates(input) {
-    const directory = await pendingDirectory(input.agentDir);
+    const directory = await existingPendingDirectory(input.agentDir);
+    if (directory === null)
+        return [];
     const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
+    const maxFiles = Math.max(0, input.maxFiles ?? LOCAL_MEMORY_PENDING_SCAN_FILE_CAP);
+    const maxBytes = Math.max(0, input.maxBytes ?? LOCAL_MEMORY_PENDING_SCAN_BYTE_CAP);
     const result = [];
+    let scannedBytes = 0;
     for (const name of names) {
+        if (result.length >= maxFiles || scannedBytes >= maxBytes)
+            break;
         const path = join(directory, name);
         try {
             await assertRegularFile(path);
-            const parsed = PendingSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+            const stat = await lstat(path);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error("local_memory_pending_path_invalid");
+            if (scannedBytes + stat.size > maxBytes)
+                break;
+            const raw = await readFile(path, "utf8");
+            const size = Buffer.byteLength(raw, "utf8");
+            if (scannedBytes + size > maxBytes)
+                break;
+            scannedBytes += size;
+            const parsed = PendingSchema.safeParse(JSON.parse(raw));
             if (parsed.success && `${parsed.data.pendingId}.json` === name)
                 result.push(parsed.data);
         }
@@ -109,3 +174,72 @@ export async function readPendingMemoryCandidates(input) {
     }
     return result;
 }
+function normalize(value) {
+    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
+function priorityRank(priority) {
+    return priority === "high" ? 0 : priority === "medium" ? 1 : 2;
+}
+function candidateText(candidate) {
+    return [
+        candidate.candidate.title,
+        candidate.candidate.summary,
+        ...candidate.candidate.triggers,
+        candidate.candidate.detailCategory,
+        candidate.candidate.detailBody,
+    ].join("\n");
+}
+function recallScore(candidate, query) {
+    const normalizedQuery = normalize(query);
+    if (normalizedQuery === "")
+        return 1;
+    const text = normalize(candidateText(candidate));
+    if (text.includes(normalizedQuery))
+        return 100;
+    const terms = normalizedQuery.split(/[\s,，、。！？；：:()[\]{}"'`]+/u).filter((term) => term.length > 0);
+    return terms.reduce((score, term) => score + (text.includes(term) ? 1 : 0), 0);
+}
+export async function searchPendingMemoryCandidates(input) {
+    const candidates = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+    const limit = Math.max(0, input.limit ?? 5);
+    if (limit === 0)
+        return [];
+    return candidates
+        .map((candidate) => ({ candidate, score: recallScore(candidate, input.query) }))
+        .filter((item) => normalize(input.query) === "" || item.score > 0)
+        .sort((left, right) => right.score - left.score
+        || priorityRank(left.candidate.candidate.priority) - priorityRank(right.candidate.candidate.priority)
+        || right.candidate.createdAt.localeCompare(left.candidate.createdAt)
+        || left.candidate.pendingId.localeCompare(right.candidate.pendingId))
+        .slice(0, limit)
+        .map((item) => item.candidate);
+}
+function truncateCodePoints(value, maxCodePoints) {
+    return Array.from(value).slice(0, Math.max(0, maxCodePoints)).join("");
+}
+export function renderPendingMemoryContext(candidates, maxCodePoints = 2_000) {
+    if (candidates.length === 0 || maxCodePoints <= 0)
+        return "";
+    const header = `\n\n## Archived memory candidates (daemon-managed)\n这些记忆已持久化，但尚未进入常驻热索引；只在当前请求相关时参考，必要时再由 memory-prune 提升。\n`;
+    let remaining = maxCodePoints - Array.from(header).length;
+    if (remaining <= 0)
+        return truncateCodePoints(header, maxCodePoints);
+    const sections = [];
+    for (const item of candidates) {
+        const change = item.candidate;
+        const prefix = `\n### ${change.title}\n`
+            + `- pending_file: .crew/memory/pending/${item.pendingId}.json\n`
+            + `- summary: ${change.summary}\n`
+            + `- triggers: ${change.triggers.join(", ")}\n`
+            + "- detail: ";
+        const prefixLength = Array.from(prefix).length;
+        if (prefixLength + 1 > remaining)
+            break;
+        const detail = truncateCodePoints(change.detailBody, remaining - prefixLength - 1);
+        const section = `${prefix}${detail}\n`;
+        const length = Array.from(section).length;
+        sections.push(section);
+        remaining -= length;
+    }
+    return `${header}${sections.join("")}`;
+}

package/dist/local-memory/runtime.js

@@ -57,9 +57,16 @@ ${resultPath}
 JSON 顶层必须包含：
 {"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[]}
 每个 changes 项使用 operation=create|update|supersede、title、kind、summary、triggers、priority、detailCategory、detailBody、reviewAfter；create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null，update/supersede 按现有索引填写版本和 id。
-只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 中等待后续治理。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 归档中；后续相关任务会按需召回，索引腾出空间后可自动提升。
 `;
 }
+/** Prevent ordinary V2 turns from racing the daemon-managed memory writer. */
+export function renderLocalMemoryV2WriteGuard() {
+    return `
+
+## V2 shared memory write safety
+本节覆盖前文关于普通任务直接更新共享记忆的例外规则。本 Agent 已启用结构化本地记忆 V2。普通任务不得直接编辑共享的 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/ 文件；即使用户明确要求记住内容，也只把候选、用户授权和分类理由记录到本任务的 $CREW_TASK_LOG，留给任务结束后的 memory-prune 结构化收尾应用。只有 memory-prune 收尾提示明确要求写入 daemon 提供的 result 文件时，才按该协议提交候选。`;
+}
 export async function commitLocalMemoryResultAfterExit(input) {
     if (input.exitCode !== 0)
         return { status: "skipped" };

package/dist/local-memory/write.js

@@ -4,7 +4,7 @@ import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
 import { containsLikelySecret } from "../agent-memory/policy.js";
 import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
-import { persistPendingMemoryCandidate } from "./pending.js";
+import { persistPendingMemoryCandidate, readPendingMemoryCandidates, removePendingMemoryCandidate, } from "./pending.js";
 const CategorySchema = z.enum([
     "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
 ]);
@@ -228,6 +228,47 @@ function normalize(value) {
 function activeOrPinnedIds(entries) {
     return new Set(entries.filter((entry) => entry.status === "active" || entry.status === "pinned").map((entry) => entry.id));
 }
+function pinnedIds(entries) {
+    return new Set(entries.filter((entry) => entry.status === "pinned").map((entry) => entry.id));
+}
+const DETAIL_CATEGORIES = new Set([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+function detailCategoryFromFile(file) {
+    if (!file.startsWith("notes/") || !file.endsWith(".md"))
+        return null;
+    const category = file.slice("notes/".length, -".md".length);
+    return DETAIL_CATEGORIES.has(category) ? category : null;
+}
+function readNoteBody(content, id) {
+    const begin = content.indexOf(`<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id}`);
+    if (begin < 0)
+        return null;
+    const bodyStart = content.indexOf("\n\n", begin);
+    const bodyEnd = content.indexOf(`\n<!-- NOWWORK:MEMORY_ENTRY:END id=${id}`, bodyStart + 2);
+    if (bodyStart < 0 || bodyEnd < 0)
+        return null;
+    return content.slice(bodyStart + 2, bodyEnd).trim();
+}
+function archivedChange(entry, detailBody) {
+    const detailCategory = detailCategoryFromFile(entry.file);
+    if (detailCategory === null)
+        return null;
+    return {
+        operation: "create",
+        memoryId: null,
+        baseRevision: null,
+        supersedesMemoryId: null,
+        title: entry.title,
+        kind: entry.type,
+        summary: entry.summary,
+        triggers: entry.triggers,
+        priority: entry.priority,
+        detailCategory,
+        detailBody,
+        reviewAfter: entry.reviewAfter,
+    };
+}
 function emptyResult() {
     return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
 }
@@ -341,7 +382,9 @@ export async function applyLocalMemoryResult(input) {
         const statusChangedIds = input.result.statusChanges.map((change) => change.memoryId);
         const deferredIds = [];
         const pendingCandidates = [];
+        const resolvedPendingIds = new Set();
         const noteUpdates = new Map();
+        let allowActiveEviction = false;
         const randomId = input.randomId ?? randomUUID;
         const executionId = input.executionId ?? "unknown";
         const defer = (change, index) => {
@@ -399,7 +442,10 @@ export async function applyLocalMemoryResult(input) {
                             : item),
                         entry,
                     ];
-            const protectedIds = new Set(activeOrPinnedIds(entries));
+            const allowEvictionForChange = change.operation === "create" && change.priority === "high";
+            const protectedIds = new Set(allowEvictionForChange ? pinnedIds(entries) : activeOrPinnedIds(entries));
+            if (allowEvictionForChange)
+                allowActiveEviction = true;
             if (change.supersedesMemoryId !== null)
                 protectedIds.delete(change.supersedesMemoryId);
             const projection = projectIndex(memory, candidateEntries, protectedIds);
@@ -428,15 +474,91 @@ export async function applyLocalMemoryResult(input) {
             else if (existingCreate === undefined)
                 createdIds.push(id);
         }
-        const finalProjection = projectIndex(memory, entries, activeOrPinnedIds(entries));
-        if (finalProjection.reason !== null)
+        // Pending create candidates are durable overflow, not dead ends. Promote only
+        // when the current catalog has room; supersede/update candidates stay pending
+        // until a fresh revision-aware decision can safely replay them.
+        const pendingCandidatesOnDisk = await readPendingMemoryCandidates({ agentDir: input.agentDir });
+        for (const pending of pendingCandidatesOnDisk) {
+            const change = pending.candidate;
+            if (change.operation !== "create")
+                continue;
+            const id = stableId(`pending:${pending.pendingId}`, 0, change);
+            const existing = entries.find((entry) => entry.id === id);
+            if (existing !== undefined) {
+                resolvedPendingIds.add(pending.pendingId);
+                continue;
+            }
+            const duplicate = entries.find((entry) => (entry.status === "active" || entry.status === "pinned")
+                && (normalize(entry.title) === normalize(change.title)
+                    || normalize(entry.summary) === normalize(change.summary)));
+            if (duplicate !== undefined) {
+                const duplicatePath = resolve(input.agentDir, duplicate.file);
+                const duplicateBody = readNoteBody(noteUpdates.get(duplicatePath) ?? await readNote(duplicatePath), duplicate.id);
+                if (duplicateBody === change.detailBody)
+                    resolvedPendingIds.add(pending.pendingId);
+                continue;
+            }
+            const entry = entryFromChange(change, id, 1, "active");
+            const candidateEntries = [...entries, entry];
+            const allowEvictionForPending = change.priority === "high";
+            const projection = projectIndex(memory, candidateEntries, allowEvictionForPending ? pinnedIds(entries) : activeOrPinnedIds(entries));
+            if (allowEvictionForPending)
+                allowActiveEviction = true;
+            if (projection.omittedIds.includes(id))
+                continue;
+            const notePath = resolve(input.agentDir, entry.file);
+            if (!isWithin(resolve(input.agentDir, "notes"), notePath))
+                throw new Error("local_memory_note_path_invalid");
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const replacement = noteSection(id, 1, change.title, change.detailBody);
+            const existingSection = replaceNote(previous, id, replacement);
+            const next = existingSection ?? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`;
+            noteUpdates.set(notePath, next);
+            entries = candidateEntries;
+            createdIds.push(id);
+            resolvedPendingIds.add(pending.pendingId);
+        }
+        let finalProjection = projectIndex(memory, entries, allowActiveEviction ? pinnedIds(entries) : activeOrPinnedIds(entries));
+        if (finalProjection.reason !== null
+            && (!allowActiveEviction || finalProjection.reason === "index_over_budget_pinned")) {
             throw new Error(finalProjection.reason);
+        }
+        if (allowActiveEviction) {
+            const omittedActiveEntries = finalProjection.omittedIds
+                .map((id) => entries.find((entry) => entry.id === id))
+                .filter((entry) => entry?.status === "active");
+            for (const entry of omittedActiveEntries) {
+                const notePath = resolve(input.agentDir, entry.file);
+                const content = noteUpdates.get(notePath) ?? await readNote(notePath);
+                const detailBody = readNoteBody(content, entry.id);
+                const change = detailBody === null ? null : archivedChange(entry, detailBody);
+                if (change === null)
+                    throw new Error("local_memory_note_anchor_missing");
+                const pendingId = `pending-${stableId(`evicted:${executionId}`, 0, change).slice("mem_".length)}`;
+                pendingCandidates.push({
+                    schemaVersion: 1,
+                    pendingId,
+                    createdAt: new Date().toISOString(),
+                    reason: "index_over_budget",
+                    source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+                    candidate: change,
+                });
+                deferredIds.push(pendingId);
+                entries = entries.map((item) => item.id === entry.id ? { ...item, status: "archived" } : item);
+            }
+            finalProjection = projectIndex(memory, entries, pinnedIds(entries));
+            if (finalProjection.reason !== null)
+                throw new Error(finalProjection.reason);
+        }
         for (const candidate of pendingCandidates)
             await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
         for (const [path, content] of noteUpdates)
             await atomicWrite(path, content);
         if (noteUpdates.size > 0 || statusChangedIds.length > 0)
             await atomicWrite(memoryPath, finalProjection.memory);
+        for (const pendingId of resolvedPendingIds) {
+            await removePendingMemoryCandidate({ agentDir: input.agentDir, pendingId });
+        }
         return {
             createdIds,
             updatedIds,

package/dist/main.js

@@ -24,7 +24,7 @@ import { formatDaemonStartupError } from "./daemon-startup-error.js";
 import { assertManagedServiceStartup } from "./managed-service-startup.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { acquireDaemonInstallationLease, runWithDaemonInstallationLease, } from "./daemon-installation-lease.js";
-import { loadStorageRuntime } from "./storage-runtime.js";
+import { createStorageRuntimeOwnershipBinding, loadStorageRuntime } from "./storage-runtime.js";
 import { readStorageMigrationReceipt } from "./storage-migration-controller.js";
 import { storageMigrationStatusReplay } from "./storage-status-replay.js";
 import { runStorageWorkerCommand } from "./storage-worker-command.js";
@@ -160,6 +160,9 @@ async function main() {
                 ...(process.getuid === undefined ? {} : { uid: process.getuid() }),
                 environment: process.env,
             });
+        const targetStorageBinding = storageRuntime === null
+            ? null
+            : createStorageRuntimeOwnershipBinding(storageRuntime);
         const targetConfirmation = storageRuntime?.identity.storageMigrationId === undefined
             ? null
             : createStorageTargetConfirmationHandler({
@@ -172,7 +175,8 @@ async function main() {
             ? {
                 ready: false,
                 statusOutboxPath: join(storageRuntime.local.stateRoot, "storage-status-outbox.json"),
-                identity: storageRuntime.identity,
+                identity: targetStorageBinding.identity,
+                bindServerIdentity: targetStorageBinding.bind,
                 ...(targetConfirmation === null ? {} : { confirm: targetConfirmation.handle }),
                 ...(storageRuntime.identity.storageMigrationId === undefined ? {} : {
                     replayStatus: async (send) => {

package/dist/prompt.js

@@ -279,6 +279,9 @@ ${newThreadRule}
 
 ## Skill 指定
 - 如果用户输入 \`/xxxx\`、或消息开头/正文中有形如 \`/skill-name\` 的片段,优先判断用户是否在精准指定某个 skill。若该 skill 可用且适合当前任务,按该 skill 的工作流处理;若名称不明确或不可用,先说明不确定并按最接近的可用能力处理。`;
+    const memoryWritePolicy = ctx.localMemoryV2Enabled
+        ? "- **V2 结构化本地记忆**:普通任务不得直接编辑共享 `$CREW_HOME/MEMORY.md` 或 notes/;即使用户明确要求长期记忆,也只记录到 `$CREW_TASK_LOG`,由任务结束时的 memory-prune 结构化提交。只有 memory-prune 收尾提示明确要求写入 daemon result 文件时才提交候选。"
+        : "- **当前请求明确要求更新或记住长期记忆,明确表达需要跨后续任务持续生效的具体规则、偏好或约束,或当前消息是对本线程紧邻记忆方案的无歧义确认时**,可以按最小范围直接写共享记忆。例如“以后所有测试报告统一按五部分写”属于明确长期意图,即使没有使用“记忆”一词。先读取相关索引和 note,语义已存在时不重复追加,不要把 Agent 自己判断值得记住视为用户授权。";
     return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
@@ -293,7 +296,7 @@ ${newThreadRule}
 ## 并行与记忆(CRITICAL — 防冲突 + 防上下文膨胀)
 你**可能同时在处理多个任务**(你自己的多个并行进程)。为避免互相覆盖、并保持上下文精简,严格遵守:
 - **普通任务默认只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。默认不要修改共享 \`$CREW_HOME/MEMORY.md\` 或 notes/;只有当前用户明确要求更新或记住长期记忆,或明确表达具体且跨后续任务持续生效的规则、偏好或约束时,才按下方条件写入相关共享文件。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
-- **当前请求明确要求更新或记住长期记忆,明确表达需要跨后续任务持续生效的具体规则、偏好或约束,或当前消息是对本线程紧邻记忆方案的无歧义确认时**,可以按最小范围直接写共享记忆。例如“以后所有测试报告统一按五部分写”属于明确长期意图,即使没有使用“记忆”一词。先读取相关索引和 note,语义已存在时不重复追加,不要把 Agent 自己判断值得记住视为用户授权。
+${memoryWritePolicy}
 - 本节的直接更新共享记忆和相关 task 流转仅适用于用户消息触发的普通交互执行。memory_prune 和 scheduled 执行只遵守各自唤醒指令,不得依据本节认领、创建、重开或推进 task。
 ${memoryTaskReadRule}
 - 普通交互执行将写共享记忆时,使用当前线程唯一的普通 task:已有非终态 task 时先按归属规则确保当前 Agent 成功认领;当前线程没有 task 时先创建并认领一个普通 task;已有 task 为 done/closed 时不得由 Agent 重开,done 报告当前轻量方案无法安全复用终态 task,closed 保持人工终态。遇到终态或归属问题时报告冲突且不得创建第二个 task 或新的任务类型。完成写入后,只有任务本身的全部工作已完成时才推进终态以触发 prune。

package/dist/runner.js

@@ -30,6 +30,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     }), dependencies.cancellation);
     const providerConfig = credential.config ?? {};
     const runtime = runtimeName(providerConfig.runtime ?? config.runtimeBin);
+    const localMemoryV2Enabled = config.localMemoryV2Handles?.has(input.handle) === true;
     const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
     const baseWake = input.wake ?? buildWakePrompt(input.channelId);
     const executionId = input.runId ?? `legacy-${randomUUID()}`;
@@ -61,6 +62,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
             collaborationToolsEnabled: config.codexCollaborationTools && runtime === "codex",
+            localMemoryV2Enabled,
         }),
         wakePrompt: ({ resuming, rotatedForBudget, nearBudget }) => {
             const distillHint = nearBudget
@@ -111,7 +113,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             softTokens: config.sessionSoftTokens,
             maxTurns: config.sessionMaxTurns,
         },
-        localMemoryV2Enabled: config.localMemoryV2Handles?.has(input.handle) === true,
+        localMemoryV2Enabled,
     }, {
         onActivity,
         onConsole,

package/dist/serve.js

@@ -54,7 +54,7 @@ import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { createServeMigrationController, handleMigrationControlMessage } from "./daemon-migration-wiring.js";
 import { createCodexHomeModeController } from "./codex-home-mode-controller.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
-import { attachStorageMigrationRuntime, createServeStorageStatusDelivery, handleStorageMigrationControl, replayStorageMigrationStatus, storageMigrationCapabilities, } from "./storage-serve-adapter.js";
+import { attachStorageMigrationRuntime, bindStorageMigrationServerIdentity, createServeStorageStatusDelivery, handleStorageMigrationControl, replayStorageMigrationStatus, storageMigrationCapabilities, } from "./storage-serve-adapter.js";
 export { buildControlPlaneUrl } from "./control-plane-url.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
@@ -316,6 +316,7 @@ export function serve(config, opts = {}) {
         let connectionEpochToken;
         ws.on("open", () => {
             connectionEpochToken = projectSkillsController.beginConnectionEpoch();
+            storageMigrationRuntime.beginIdentityBinding();
             const openedSocket = ws;
             backoff = 1000;
             connectedAt = Date.now();
@@ -811,16 +812,21 @@ export function serve(config, opts = {}) {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
                 setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
-                if (opts.storageMigration?.ready === true && typeof r.workspaceId === "string" && typeof r.machineId === "string") {
-                    try {
-                        opts.storageMigration.bindServerIdentity?.({ workspaceId: r.workspaceId, machineId: r.machineId });
-                        machineHelloPublisher.republish();
-                    }
-                    catch (error) {
-                        dslog("daemon.storage_identity_bind_failed", "存储迁移 Workspace 身份绑定失败", {
-                            level: "ERROR", error_message: error.message,
-                        });
-                    }
+                if (opts.storageMigration !== undefined && typeof r.workspaceId === "string" && typeof r.machineId === "string") {
+                    const bindingSocket = ws;
+                    bindStorageMigrationServerIdentity(opts.storageMigration, { workspaceId: r.workspaceId, machineId: r.machineId }, {
+                        onBound: () => {
+                            if (bindingSocket !== ws || bindingSocket?.readyState !== WebSocket.OPEN)
+                                return;
+                            storageMigrationRuntime.completeIdentityBinding();
+                            machineHelloPublisher.republish();
+                        },
+                        onError: (error) => {
+                            dslog("daemon.storage_identity_bind_failed", "存储迁移 Workspace 身份绑定失败", { level: "ERROR", error_message: error.message });
+                            if (bindingSocket === ws && bindingSocket?.readyState === WebSocket.OPEN)
+                                bindingSocket.close(1011, "storage identity binding failed");
+                        },
+                    });
                 }
                 // 旧 server 无此字段 → 空集合(daemon 保持全部旧行为)。
                 serverCapabilities = new Set(Array.isArray(r.serverCapabilities)

package/dist/storage-identity.js

@@ -4,6 +4,9 @@ import { createStorageOwnershipClaim } from "./storage-ownership.js";
 function fingerprint(namespace, value) {
     return `sha256:${createHash("sha256").update(`${namespace}\0${value}`).digest("hex")}`;
 }
+export function storageWorkspaceRootFingerprint(workspaceRoot) {
+    return fingerprint("workspace-root", workspaceRoot);
+}
 export function storageIdFingerprint(storageId) {
     return fingerprint("storage", storageId);
 }
@@ -15,7 +18,7 @@ export function storageHelloIdentity(input) {
         || installation.runtimeRoot !== layout.runtimeRoot) {
         throw new Error("installation storage identity does not match resolved layout");
     }
-    const workspaceRootFingerprint = fingerprint("workspace-root", layout.workspaceRoot);
+    const workspaceRootFingerprint = storageWorkspaceRootFingerprint(layout.workspaceRoot);
     let ownership;
     if (input.ownership !== undefined) {
         const { claimFingerprint: reportedFingerprint, ...claimIdentity } = input.ownership;

package/dist/storage-ownership.js

@@ -1,8 +1,11 @@
-import { createHash } from "node:crypto";
-import { lstat, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { z } from "zod";
+import { atomicRenameNoReplace } from "./atomic-no-replace-rename.js";
+import { durableDirectorySync } from "./atomic-private-write.js";
 const FingerprintSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const UuidSchema = z.string().uuid();
 const StorageOwnershipClaimSchema = z.object({
     version: z.literal(1),
     machineId: z.string().uuid(),
@@ -38,8 +41,10 @@ export function createStorageOwnershipClaim(input) {
 export function storageOwnershipClaimPath(nowworkHome) {
     return join(nowworkHome, "storage-layout.json");
 }
-export async function readStorageOwnershipClaim(nowworkHome) {
-    const path = storageOwnershipClaimPath(nowworkHome);
+export function workspaceStorageOwnershipClaimPath(nowworkHome, workspaceId) {
+    return join(nowworkHome, ".storage-ownership", `${UuidSchema.parse(workspaceId).toLowerCase()}.json`);
+}
+async function readClaim(path) {
     const metadata = await lstat(path);
     if (!metadata.isFile())
         throw new Error("storage ownership claim must be a file");
@@ -53,3 +58,86 @@ export async function readStorageOwnershipClaim(nowworkHome) {
     }
     return expected;
 }
+function missingClaim(message) {
+    return Object.assign(new Error(message), { code: "ENOENT" });
+}
+export async function readStorageOwnershipClaim(nowworkHome, workspaceId) {
+    if (workspaceId !== undefined) {
+        const normalizedWorkspaceId = UuidSchema.parse(workspaceId).toLowerCase();
+        try {
+            return await readClaim(workspaceStorageOwnershipClaimPath(nowworkHome, normalizedWorkspaceId));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const legacy = await readClaim(storageOwnershipClaimPath(nowworkHome));
+        if (legacy.workspaceId !== normalizedWorkspaceId) {
+            throw missingClaim(`storage ownership claim is not provisioned for workspace '${normalizedWorkspaceId}'`);
+        }
+        return legacy;
+    }
+    return readClaim(storageOwnershipClaimPath(nowworkHome));
+}
+export async function resolveWorkspaceStorageOwnershipClaim(input) {
+    const machineId = UuidSchema.parse(input.machineId).toLowerCase();
+    const workspaceId = UuidSchema.parse(input.workspaceId).toLowerCase();
+    try {
+        const existing = await readStorageOwnershipClaim(input.nowworkHome, workspaceId);
+        const expected = createStorageOwnershipClaim({
+            machineId,
+            workspaceId,
+            environment: input.environment,
+            volumeFingerprint: existing.volumeFingerprint,
+            workspaceRootFingerprint: input.workspaceRootFingerprint,
+            ownerEpoch: existing.ownerEpoch,
+        });
+        if (existing.claimFingerprint !== expected.claimFingerprint) {
+            throw new Error("storage ownership claim conflicts with the authenticated workspace identity");
+        }
+        return existing;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const anchor = await readClaim(storageOwnershipClaimPath(input.nowworkHome));
+    if (anchor.environment !== input.environment.toLowerCase()) {
+        throw new Error("storage ownership volume anchor environment does not match");
+    }
+    const claim = createStorageOwnershipClaim({
+        machineId,
+        workspaceId,
+        environment: input.environment,
+        volumeFingerprint: anchor.volumeFingerprint,
+        workspaceRootFingerprint: input.workspaceRootFingerprint,
+        ownerEpoch: 1,
+    });
+    const path = workspaceStorageOwnershipClaimPath(input.nowworkHome, workspaceId);
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    let handle = null;
+    try {
+        handle = await open(temporary, "wx", 0o600);
+        await handle.writeFile(`${JSON.stringify({ version: 1, ...claim })}\n`, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        const published = await atomicRenameNoReplace(temporary, path);
+        if (published === "published") {
+            await durableDirectorySync(directory);
+            return claim;
+        }
+        const raced = await readClaim(path);
+        if (raced.claimFingerprint !== claim.claimFingerprint) {
+            throw new Error("storage ownership claim was concurrently provisioned for another identity");
+        }
+        return raced;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+}

package/dist/storage-runtime-controller.js

@@ -5,12 +5,13 @@ import { buildServiceSpec } from "./computer-service.js";
 import { buildManagedServiceRecord } from "./managed-service-lifecycle.js";
 import { createStorageControlController } from "./storage-control.js";
 import { runStorageDoctor } from "./storage-doctor.js";
-import { storageHelloIdentity } from "./storage-identity.js";
+import { storageHelloIdentity, storageWorkspaceRootFingerprint, } from "./storage-identity.js";
 import { storageLayout, validateStorageEnvironment } from "./storage-layout.js";
 import { StorageMigrationFailure } from "./storage-migration-controller.js";
 import { launchStorageMigrationWorker, writeStorageWorkerHandoff } from "./storage-worker-handoff.js";
 import { writeStorageWorkerOperation } from "./storage-worker-operation.js";
 import { latestSourceStorageMigrationReceipt, monitorStorageMigrationStatus, storageMigrationStatusReplay, } from "./storage-status-replay.js";
+import { resolveWorkspaceStorageOwnershipClaim, } from "./storage-ownership.js";
 const UUID = z.string().uuid();
 function fingerprint(value) {
     return `sha256:${createHash("sha256").update(value).digest("hex")}`;
@@ -22,13 +23,13 @@ function deterministicUuid(value) {
     const hex = chars.join("");
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
-function storageId(input, workspaceId) {
-    if (input.ownership.workspaceId !== workspaceId || input.ownership.environment !== input.environment) {
+function storageId(input, workspaceId, ownership) {
+    if (ownership.workspaceId !== workspaceId || ownership.environment !== input.environment) {
         throw new Error("Storage ownership claim does not match the migration identity");
     }
-    return `storage_${input.ownership.claimFingerprint.slice("sha256:".length)}`;
+    return `storage_${ownership.claimFingerprint.slice("sha256:".length)}`;
 }
-function installationBase(input, workspaceId, migrationId, createdAt) {
+function installationBase(input, workspaceId, migrationId, createdAt, ownership) {
     const layout = storageLayout({
         nowworkHome: input.nowworkHome,
         environment: input.environment,
@@ -43,7 +44,7 @@ function installationBase(input, workspaceId, migrationId, createdAt) {
         serverUrl: input.serverUrl,
         environment: input.environment,
         workspaceId,
-        storageId: storageId(input, workspaceId),
+        storageId: storageId(input, workspaceId, ownership),
         nowworkHome: input.nowworkHome,
         runtimeRoot: layout.runtimeRoot,
         credentialRef: `profile:${input.profile}`,
@@ -99,6 +100,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
         writeHandoff: writeStorageWorkerHandoff,
         launchWorker: launchStorageMigrationWorker,
         monitorWorker: monitorStorageMigrationStatus,
+        resolveOwnership: resolveWorkspaceStorageOwnershipClaim,
         now: () => new Date(),
         ...injected,
     };
@@ -108,6 +110,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
     let gate = null;
     let sendStatus = null;
     let control = null;
+    let ownership = input.ownership;
+    let identityBindTail = Promise.resolve();
     const pendingControlMessages = [];
     let drainingPendingControlMessages = false;
     const drainPendingControlMessages = () => {
@@ -197,8 +201,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
                 backupsRoot: input.local.backupsRoot,
                 backupArtifacts: input.backupArtifacts.map((artifact) => ({ ...artifact })),
                 ownership: {
-                    ownerEpoch: input.ownership.ownerEpoch,
-                    ownershipClaimFingerprint: input.ownership.claimFingerprint,
+                    ownerEpoch: ownership.ownerEpoch,
+                    ownershipClaimFingerprint: ownership.claimFingerprint,
                 },
                 acceptedWarnings: [...input.policy.acceptedWarnings],
             },
@@ -214,7 +218,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             installation: {
                 configRoot: input.local.configRoot,
                 target: {
-                    ...installationBase(input, workspaceId, doctor.manifest.migrationId, createdAt),
+                    ...installationBase(input, workspaceId, doctor.manifest.migrationId, createdAt, ownership),
                     storageMigrationId: doctor.manifest.migrationId,
                 },
             },
@@ -236,8 +240,8 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             sourceStorageFingerprint,
             targetStorageFingerprint: identity.storageIdFingerprint,
             ownership: {
-                ownerEpoch: input.ownership.ownerEpoch,
-                ownershipClaimFingerprint: input.ownership.claimFingerprint,
+                ownerEpoch: ownership.ownerEpoch,
+                ownershipClaimFingerprint: ownership.claimFingerprint,
             },
             runDoctor: async (migrationId) => dependencies.runDoctor(await doctorInput(migrationId)),
             runMigration: async (doctor) => {
@@ -294,7 +298,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             sendStatus,
         });
     };
-    const bindServerIdentity = (server) => {
+    const bindServerIdentityOnce = async (server) => {
         const nextWorkspaceId = UUID.parse(server.workspaceId).toLowerCase();
         const nextMachineId = UUID.parse(server.machineId).toLowerCase();
         if (workspaceId !== null && workspaceId !== nextWorkspaceId) {
@@ -303,13 +307,6 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
         if (machineId !== null && machineId !== nextMachineId) {
             throw new Error("Storage migration server machine identity changed");
         }
-        if (input.ownership.workspaceId !== nextWorkspaceId
-            || input.ownership.machineId !== nextMachineId
-            || input.ownership.environment !== input.environment) {
-            throw new Error("Storage ownership claim does not match authenticated server identity");
-        }
-        const createdAt = dependencies.now().toISOString();
-        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt);
         const layout = storageLayout({
             nowworkHome: input.nowworkHome,
             environment: input.environment,
@@ -317,13 +314,36 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             runtimeBase: input.local.runtimeBase,
             platform: input.platform,
         });
-        const nextIdentity = storageHelloIdentity({ installation, layout, ownership: input.ownership });
+        if (ownership.workspaceId !== nextWorkspaceId
+            || ownership.machineId !== nextMachineId
+            || ownership.environment !== input.environment) {
+            ownership = await dependencies.resolveOwnership({
+                nowworkHome: input.nowworkHome,
+                machineId: nextMachineId,
+                workspaceId: nextWorkspaceId,
+                environment: input.environment,
+                workspaceRootFingerprint: storageWorkspaceRootFingerprint(layout.workspaceRoot),
+            });
+        }
+        if (ownership.workspaceId !== nextWorkspaceId
+            || ownership.machineId !== nextMachineId
+            || ownership.environment !== input.environment) {
+            throw new Error("Storage ownership claim does not match authenticated server identity");
+        }
+        const createdAt = dependencies.now().toISOString();
+        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt, ownership);
+        const nextIdentity = storageHelloIdentity({ installation, layout, ownership });
         workspaceId = nextWorkspaceId;
         machineId = nextMachineId;
         identity = nextIdentity;
         ensureControl();
         drainPendingControlMessages();
     };
+    const bindServerIdentity = (server) => {
+        const current = identityBindTail.then(() => bindServerIdentityOnce(server));
+        identityBindTail = current.catch(() => undefined);
+        return current;
+    };
     const attach = (runtime) => {
         gate = runtime.gate;
         sendStatus = runtime.sendStatus;

package/dist/storage-runtime.js

@@ -1,7 +1,7 @@
 import { findInstallationForProfile, readInstallations, resolveLocalStorageRoots, } from "./storage-config.js";
 import { storageHelloIdentity } from "./storage-identity.js";
 import { storageLayout } from "./storage-layout.js";
-import { readStorageOwnershipClaim } from "./storage-ownership.js";
+import { readStorageOwnershipClaim, resolveWorkspaceStorageOwnershipClaim, } from "./storage-ownership.js";
 const canonicalServerUrl = (value) => value.replace(/\/+$/u, "");
 export function resolveStorageRuntime(input) {
     const installation = findInstallationForProfile(input.records, input.profile);
@@ -45,7 +45,7 @@ export async function loadStorageRuntime(input) {
         return null;
     let ownership;
     try {
-        ownership = await readStorageOwnershipClaim(baseline.layout.persistentRoot);
+        ownership = await readStorageOwnershipClaim(baseline.layout.persistentRoot, baseline.layout.workspaceId);
     }
     catch (error) {
         if (error.code !== "ENOENT")
@@ -53,3 +53,39 @@ export async function loadStorageRuntime(input) {
     }
     return ownership === undefined ? baseline : resolveStorageRuntime({ ...input, records, ownership });
 }
+export async function bindStorageRuntimeOwnership(runtime, server) {
+    const workspaceId = server.workspaceId.toLowerCase();
+    const machineId = server.machineId.toLowerCase();
+    if (runtime.installation.workspaceId !== workspaceId) {
+        throw new Error("Storage runtime server workspace identity changed");
+    }
+    const existing = runtime.identity.storageOwnership;
+    if (existing !== undefined) {
+        if (existing.machineId !== machineId)
+            throw new Error("Storage runtime server machine identity changed");
+        return runtime;
+    }
+    const ownership = await resolveWorkspaceStorageOwnershipClaim({
+        nowworkHome: runtime.layout.persistentRoot,
+        machineId,
+        workspaceId,
+        environment: runtime.installation.environment,
+        workspaceRootFingerprint: runtime.identity.workspaceRootFingerprint,
+    });
+    return Object.freeze({
+        ...runtime,
+        identity: storageHelloIdentity({ installation: runtime.installation, layout: runtime.layout, ownership }),
+    });
+}
+export function createStorageRuntimeOwnershipBinding(initial) {
+    let runtime = initial;
+    let bindTail = Promise.resolve();
+    const bind = (server) => {
+        const current = bindTail.then(async () => {
+            runtime = await bindStorageRuntimeOwnership(runtime, server);
+        });
+        bindTail = current.catch(() => undefined);
+        return current;
+    };
+    return Object.freeze({ identity: () => runtime.identity, bind });
+}

package/dist/storage-serve-adapter.js

@@ -9,6 +9,15 @@ export function storageMigrationCapabilities(configured, options) {
             ...(options.ready ? [STORAGE_MIGRATION_CAPABILITY] : []),
         ])]);
 }
+export function bindStorageMigrationServerIdentity(options, identity, callbacks) {
+    const bind = options?.bindServerIdentity;
+    if (bind === undefined) {
+        if (options?.ready === true)
+            callbacks.onBound();
+        return;
+    }
+    void Promise.resolve().then(() => bind(identity)).then(callbacks.onBound).catch(callbacks.onError);
+}
 export function createServeStorageStatusDelivery(options, dependencies) {
     return createStorageStatusDelivery({
         ...(options?.statusOutboxPath === undefined ? {} : { outboxPath: options.statusOutboxPath }),
@@ -17,28 +26,36 @@ export function createServeStorageStatusDelivery(options, dependencies) {
     });
 }
 export function attachStorageMigrationRuntime(options, dependencies) {
-    let admissionClosed = false;
+    let migrationAdmissionClosed = false;
+    let identityAdmissionClosed = options?.bindServerIdentity !== undefined;
     if (options?.ready === true) {
         options.attach?.({
             gate: {
                 isBusy: dependencies.isBusy,
                 closeAndFlush: async () => {
-                    admissionClosed = true;
+                    migrationAdmissionClosed = true;
                     await dependencies.waitForExecutionFrames();
                     if (dependencies.isBusy()) {
-                        admissionClosed = false;
+                        migrationAdmissionClosed = false;
                         throw Object.assign(new Error("active execution entered before storage migration quiesce"), {
                             code: "runtime_busy",
                         });
                     }
                     await dependencies.flushLocalState();
                 },
-                reopen: () => { admissionClosed = false; },
+                reopen: () => { migrationAdmissionClosed = false; },
             },
             sendStatus: dependencies.sendStatus,
         });
     }
-    return Object.freeze({ isAdmissionClosed: () => admissionClosed });
+    return Object.freeze({
+        isAdmissionClosed: () => migrationAdmissionClosed || identityAdmissionClosed,
+        beginIdentityBinding: () => {
+            if (options?.bindServerIdentity !== undefined)
+                identityAdmissionClosed = true;
+        },
+        completeIdentityBinding: () => { identityAdmissionClosed = false; },
+    });
 }
 export function replayStorageMigrationStatus(options, socket, isCurrent, onError, deliver) {
     return options?.replayStatus?.((frame) => {

package/package.json

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