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

package/dist/local-memory/write.js

@@ -209,6 +209,25 @@ function stableId(executionId, index, change) {
     const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
     return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
 }
+function migrationPendingId(change) {
+    // Keep the digest independent of object insertion order for callers that
+    // reach applyLocalMemoryResult directly instead of the JSON/Zod boundary.
+    const canonicalChange = {
+        operation: change.operation,
+        memoryId: change.memoryId,
+        baseRevision: change.baseRevision,
+        supersedesMemoryId: change.supersedesMemoryId,
+        title: change.title,
+        kind: change.kind,
+        summary: change.summary,
+        triggers: change.triggers,
+        priority: change.priority,
+        detailCategory: change.detailCategory,
+        detailBody: change.detailBody,
+        reviewAfter: change.reviewAfter,
+    };
+    return `pending-migration-${createHash("sha256").update(JSON.stringify(canonicalChange), "utf8").digest("hex").slice(0, 12)}`;
+}
 function normalize(value) {
     return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
 }
@@ -259,6 +278,34 @@ function archivedChange(entry, detailBody) {
 function emptyResult() {
     return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
 }
+async function stageMigrationDeferredPending(input) {
+    if (input.result.outcome !== "proposed")
+        return emptyResult();
+    if (input.result.statusChanges.length > 0 || input.result.changes.some((change) => change.operation !== "create")) {
+        throw new Error("local_memory_migration_pending_create_only");
+    }
+    const executionId = input.executionId ?? "unknown";
+    const pending = input.result.changes.map((change) => ({
+        schemaVersion: 1,
+        pendingId: migrationPendingId(change),
+        createdAt: new Date().toISOString(),
+        reason: "legacy_requires_migration",
+        source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+        candidate: change,
+    }));
+    await assertMemoryAccessDirectory(input.agentDir);
+    await withMemoryAccess(input.agentDir, async () => {
+        const memory = await readFile(join(input.agentDir, "MEMORY.md"), "utf8").catch(() => null);
+        if (memory === null || detectLocalMemoryStorageVersion(memory) !== 1) {
+            throw new Error("local_memory_migration_pending_storage_invalid");
+        }
+        for (const candidate of pending) {
+            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
+        }
+    }, { pendingOnly: true });
+    const pendingIds = [...new Set(pending.map((candidate) => candidate.pendingId))];
+    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: pendingIds, pendingIds };
+}
 function isWithin(root, candidate) {
     const path = relative(root, candidate);
     return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
@@ -357,10 +404,13 @@ async function withApplyLease(agentDir, operation) {
 }
 export async function applyLocalMemoryResult(input) {
     validateCandidate(input.result);
-    if (input.result.outcome !== "proposed")
+    if (input.migrationDeferredPending)
+        return stageMigrationDeferredPending(input);
+    if (input.result.outcome !== "proposed" && input.requiredStorageVersion !== 2)
         return emptyResult();
     const memoryPath = join(input.agentDir, "MEMORY.md");
-    await assertWritablePaths(input.agentDir, memoryPath);
+    if (input.result.outcome === "proposed")
+        await assertWritablePaths(input.agentDir, memoryPath);
     await assertMemoryAccessDirectory(input.agentDir);
     return withApplyLease(input.agentDir, async () => withMemoryAccess(input.agentDir, async () => {
         await assertMemoryWriterAllowed(input.agentDir, input.writerCapabilities ?? []);
@@ -370,6 +420,13 @@ export async function applyLocalMemoryResult(input) {
         const memory = await readFile(memoryPath, "utf8");
         assertLocalMemoryStorageSize(memory);
         const fullStorage = detectLocalMemoryStorageVersion(memory) === 2;
+        if (input.requiredStorageVersion === 2 && !fullStorage) {
+            throw new Error("local_memory_v2_state_invalid_before_commit");
+        }
+        // A V2 no-op is still a commit decision.  Return only after the access
+        // lock and committed-state writer gate have validated the same snapshot.
+        if (input.result.outcome !== "proposed")
+            return emptyResult();
         if (parseUnmarkedMemoryIndex(memory).length > 0)
             throw new Error("local_memory_legacy_index_requires_migration");
         let entries = [...parseLocalMemoryIndex(memory)];
@@ -535,6 +592,10 @@ export async function applyLocalMemoryResult(input) {
             return [];
         });
         for (const pending of pendingCandidatesOnDisk) {
+            // Migration-deferred candidates require reviewed import; only capacity
+            // overflow is eligible for the existing automatic promotion path.
+            if (pending.reason !== "index_over_budget")
+                continue;
             const change = pending.candidate;
             if (change.operation !== "create")
                 continue;

package/dist/local-memory/writer-mode.js

@@ -0,0 +1,13 @@
+import { detectLocalMemoryStorageVersion } from "./storage-format.js";
+/** Resolve format and rollout into one writer decision before a prune result is requested. */
+export function resolveLocalMemoryWriterMode(workspace, rollout) {
+    if (rollout.legacyFallback)
+        return "legacy";
+    if (!rollout.enabled)
+        return rollout.deferred ? "blocked" : "legacy";
+    // Production workspaces always report this fact. Historical partial unit
+    // callers retain their already-resolved rollout witness.
+    if (workspace.localMemoryV2Initialized === undefined)
+        return "v2";
+    return detectLocalMemoryStorageVersion(workspace.memory) === 2 ? "v2" : "blocked";
+}

package/dist/local-memory-diagnostics.js

@@ -8,6 +8,7 @@ const INJECTION_MARKERS = [
     "## [注入] 你的 MEMORY.md(索引,只读参考)\n",
 ];
 const LOCAL_MEMORY_HASH_CAP_BYTES = 10 * 1024 * 1024;
+export const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 function errorCode(error) {
     const code = error?.code;
     return typeof code === "string" ? code : error instanceof Error ? error.name : "unknown";
@@ -77,31 +78,37 @@ async function inspectPendingDirectory(path, signal) {
         return { ...base, error_code: errorCode(error) };
     }
 }
-export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+export async function withinLocalMemoryDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
     let timer;
-    const inspection = Promise.all([
-        inspectFile(join(homeDir, "MEMORY.md"), controller.signal),
-        inspectFile(join(homeDir, "notes", "lessons.md"), controller.signal),
-        inspectPendingDirectory(join(homeDir, ".crew", "memory", "pending"), controller.signal),
-    ]).then(([memory, lessons, pending]) => ({ memory, lessons, pending }));
     const timeout = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            controller.abort();
-            reject(Object.assign(new Error("local memory diagnostics timed out"), {
+            const error = Object.assign(new Error("local memory diagnostics timed out"), {
                 code: "diagnostics_timeout",
-            }));
+            });
+            controller.abort(error);
+            reject(error);
         }, Math.max(1, timeoutMs));
         timer.unref?.();
     });
     try {
-        return await Promise.race([inspection, timeout]);
+        return await Promise.race([operation(controller.signal), timeout]);
     }
     finally {
         if (timer !== undefined)
             clearTimeout(timer);
     }
 }
+export async function inspectLocalMemoryFilesWithinDeadline(homeDir, timeoutMs) {
+    return withinLocalMemoryDiagnosticsDeadline(async (signal) => {
+        const [memory, lessons, pending] = await Promise.all([
+            inspectFile(join(homeDir, "MEMORY.md"), signal),
+            inspectFile(join(homeDir, "notes", "lessons.md"), signal),
+            inspectPendingDirectory(join(homeDir, ".crew", "memory", "pending"), signal),
+        ]);
+        return { memory, lessons, pending };
+    }, timeoutMs);
+}
 export function localMemoryContentFacts(content, maxScanBytes = LOCAL_MEMORY_HASH_CAP_BYTES) {
     const sizeBytes = Buffer.byteLength(content, "utf8");
     if (sizeBytes > Math.max(0, maxScanBytes)) {
@@ -256,15 +263,50 @@ function crewMemoryReadAccess(command, paths) {
         return null;
     }
 }
+/**
+ * Decode only the shell wrapper shape emitted by supported runtimes. The body must be one complete
+ * quoted argument. Double-quoted bodies may escape only a quote or backslash; shell expansion and
+ * concatenated quoting stay unknown so telemetry never guesses what the shell actually executed.
+ */
+function unwrapLiteralShellCommand(command) {
+    const trimmed = command.trim();
+    const wrapper = /^\/bin\/(?:(?:zsh|bash)\s+-lc|sh\s+-c)\s+([\s\S]+)$/u.exec(trimmed);
+    if (wrapper === null)
+        return trimmed;
+    const quoted = wrapper[1];
+    const quote = quoted[0];
+    if ((quote !== "'" && quote !== '"') || quoted.at(-1) !== quote || quoted.length < 2)
+        return null;
+    const body = quoted.slice(1, -1);
+    if (quote === "'")
+        return body.includes("'") ? null : body;
+    let decoded = "";
+    for (let index = 0; index < body.length; index += 1) {
+        const character = body[index];
+        if (character === '"' || character === "$" || character === "`")
+            return null;
+        if (character !== "\\") {
+            decoded += character;
+            continue;
+        }
+        const escaped = body[index + 1];
+        if (escaped !== '"' && escaped !== "\\")
+            return null;
+        decoded += escaped;
+        index += 1;
+    }
+    return decoded;
+}
 function commandAccesses(command, paths) {
-    if (/[;|&\n]/.test(command))
+    const unwrapped = unwrapLiteralShellCommand(command);
+    if (unwrapped === null || /[;|&\n]/.test(unwrapped))
         return [];
     const accesses = new Map();
-    const memoryRead = crewMemoryReadAccess(command, paths);
+    const memoryRead = crewMemoryReadAccess(unwrapped, paths);
     if (memoryRead !== null) {
         accesses.set(`${memoryRead.target}:${memoryRead.relative_path ?? ""}:read`, memoryRead);
     }
-    const expanded = command
+    const expanded = unwrapped
         .replaceAll("${CREW_HOME}", paths.homeDir)
         .replaceAll("$CREW_HOME", paths.homeDir)
         .replace(/["']/g, "");

package/dist/marketplace-protocol.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 // 与另一个进程中的 marketplace-protocol.ts 保持一致；跨进程契约测试校验摘要。
 export const MARKETPLACE_CAPABILITY = "marketplace_update_v1";
 export const MARKETPLACE = "nowwork-pm";
-export const PLUGIN = "AIinterview-plugin";
+export const PLUGIN = "aiinterview-plugin";
 export const MarketplaceModeSchema = z.enum(["inspect", "refresh", "update"]);
 export const MarketplaceStatusSchema = z.enum(["queued", "running", "completed", "partial", "failed", "unknown"]);
 export const MarketplaceTargetSchema = z.object({

package/dist/marketplace-remote.js

@@ -10,7 +10,7 @@ const Target = z.object({
     version: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,79}$/),
     source: z.object({ source: z.literal("git-subdir"),
         url: z.literal("git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git"),
-        path: z.literal("plugins/AIinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
+        path: z.literal("plugins/aiinterview-plugin"), sha: z.string().regex(/^[a-f0-9]{40}$/) }),
 });
 export async function readRemoteMarketplace(runtime, registered, env, command) {
     const source = validateMarketplaceSource(registered.url, registered.ref);

package/dist/marketplace-runner.js

@@ -12,7 +12,7 @@ import { readMarketplaceSource } from "./marketplace-source.js";
 export { MarketplaceFailure, runMarketplaceCommand } from "./marketplace-command.js";
 const SELECTOR = `${PLUGIN}@${MARKETPLACE}`;
 const SOURCE = "git@codeup.aliyun.com:6128d2e757e7cd986dfae5ab/pm/AIinterview-agent-skill.git";
-const SOURCE_PATH = "plugins/AIinterview-plugin";
+const SOURCE_PATH = "plugins/aiinterview-plugin";
 const obj = (x) => x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
 const parse = (text) => { try {
     return JSON.parse(text);

package/dist/memory-migration-controller.js

@@ -10,6 +10,8 @@ export function createMemoryMigrationController(input) {
     const runs = new Map();
     return {
         setIdentity(value) { identity = value; },
+        clearIdentity() { identity = null; },
+        getIdentity() { return identity === null ? null : { ...identity }; },
         cancel(executionId) { const run = runs.get(executionId); if (!run)
             return false; run.cancel(); return true; },
         async handle(raw) {

package/dist/memory-migration-inspect.js

@@ -3,38 +3,71 @@ import { join, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { withMemoryAccess } from "./local-memory/migration-access.js";
 import { MigrationStateSchema } from "./local-memory/migration-schema.js";
+import { assertMigrationStateIntegrity } from "./local-memory/migration-state-invariants.js";
 import { detectLocalMemoryStorageVersion, parseFullMemoryIndex } from "./local-memory/storage-format.js";
 import { resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
 import { readMemoryInventorySource, inventoryLimits } from "./local-memory/inventory-source.js";
+import { isLocalMemoryInitializationIdentity, localMemoryInitializationIdentity } from "./local-memory/initialization-identity.js";
 export async function inspectMemoryForMigration(agentsRoot, input, journal) {
     const parent = await realpath(agentsRoot);
     const path = join(parent, input.handle);
-    const base = { workspaceId: input.workspaceId, agentId: input.agentId, machineId: input.machineId,
+    const missingBase = { workspaceId: input.workspaceId, agentId: input.agentId, machineId: input.machineId,
         storageRootFingerprint: createHash("sha256").update(resolve(path)).digest("hex"),
         ownerIdentity: String((await lstat(parent)).uid) };
     const prior = input.executionId ? await journal?.get(input.executionId) : null;
     const stoppedExecutionId = prior?.requestedRuntime === "memory_migration" && (prior.state === "completed" || prior.state === "interrupted") ? prior.executionId : null;
-    const empty = { ...base, storageVersion: null, classification: "empty", emptyWithoutResidue: true, localState: null, issueCodes: [], stoppedExecutionId };
+    const missing = { ...missingBase, storageVersion: null, classification: "empty", emptyWithoutResidue: true, localState: null, issueCodes: [], stoppedExecutionId };
     try {
         await lstat(path);
     }
     catch (e) {
         if (e.code === "ENOENT")
-            return empty;
+            return missing;
         throw e;
     }
+    const root = await realpath(path);
+    const base = { ...missingBase,
+        storageRootFingerprint: createHash("sha256").update(root).digest("hex"),
+        ownerIdentity: String((await lstat(root)).uid) };
+    const empty = { ...missing, ...base };
     try {
         return await withMemoryAccess(path, async () => {
             let localState = null;
             try {
                 const record = await readMemoryInventorySource(path, ".crew/memory/migration.v1.json", inventoryLimits.fileBytes);
                 const state = MigrationStateSchema.parse(JSON.parse(record.content));
-                if (state.identity.rootFingerprint !== base.storageRootFingerprint || state.identity.agentId !== input.agentId
-                    || state.origin !== "initialized" && (state.identity.workspaceId !== input.workspaceId
-                        || state.identity.machineId !== input.machineId))
+                assertMigrationStateIntegrity(state, state.identity);
+                const expectedInitialization = state.origin === "initialized"
+                    ? await localMemoryInitializationIdentity(path, input.agentId, {
+                        workspaceId: input.workspaceId,
+                        machineId: input.machineId,
+                    })
+                    : null;
+                const expectedLegacyInitialization = state.origin === "initialized"
+                    ? await localMemoryInitializationIdentity(path, input.agentId)
+                    : null;
+                const localInitialization = expectedInitialization !== null
+                    && (isLocalMemoryInitializationIdentity(state.identity, expectedInitialization)
+                        || expectedLegacyInitialization !== null
+                            && isLocalMemoryInitializationIdentity(state.identity, expectedLegacyInitialization));
+                const serverBoundIdentity = state.identity.workspaceId === input.workspaceId
+                    && state.identity.machineId === input.machineId;
+                const operationIdentityValid = state.origin === "initialized" ? localInitialization : serverBoundIdentity;
+                if (state.identity.rootFingerprint !== base.storageRootFingerprint
+                    || state.identity.ownerIdentity !== base.ownerIdentity
+                    || state.identity.agentId !== input.agentId || !operationIdentityValid) {
                     throw new Error("migration_identity_mismatch");
+                }
                 localState = { migrationId: state.migrationId, phase: state.phase, storageVersion: state.storageVersion,
-                    sourceDigest: state.sourceDigest, planDigest: state.planDigest };
+                    sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin,
+                    issues: state.issues.map(issue => issue.reason),
+                    initializationIdentity: localInitialization ? {
+                        agentId: state.identity.agentId, migrationId: state.identity.migrationId,
+                        workspaceId: state.identity.workspaceId, machineId: state.identity.machineId,
+                        executionId: state.identity.executionId, sourceStorageVersion: state.identity.sourceStorageVersion,
+                        targetStorageVersion: state.identity.targetStorageVersion,
+                        rootFingerprint: state.identity.rootFingerprint, ownerIdentity: state.identity.ownerIdentity,
+                    } : null };
                 if (state.phase === "applying" || state.phase === "repair_required")
                     return {
                         ...empty, localState, classification: "repair_required", emptyWithoutResidue: false, issueCodes: ["migration_recovery_required"],

package/dist/prompt.js

@@ -346,7 +346,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
-1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
+1. **MEMORY.md = 常驻索引 + 角色**:提示词末尾可能只有它的有界预览,预算不足时也可能省略。预览未命中不等于没有记忆。旧版索引可能包含 \`scope\`；V2 规范字段为 \`id/file/type/status/summary/triggers/priority/revision/anchor/updated\`(可选 \`review_after\`),不含 \`scope\`。其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`);需要历史约束、经验或偏好时先检索完整索引,再按需分段读取。
 2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。

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

@@ -12,6 +12,14 @@ 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));
@@ -52,6 +60,9 @@ 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");
@@ -188,7 +199,7 @@ async function attempt(input, sessionId, resume, options) {
     try {
         try {
             await send({ type: "control_request", request_id: initId, request: { subtype: "initialize" } });
-            await bounded(initialized.promise, options.initializeTimeoutMs ?? 30_000, "claude_initialize_timeout");
+            await waitForClaudeInitialize(initialized.promise, options.initializeTimeoutMs);
             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");
@@ -238,15 +249,25 @@ 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 attempt(input, sessionId, input.resume, options);
+        return await runAttempt(sessionId, input.resume);
     }
     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.
+        // model/tool loop. Native startup hooks may run again on cold recovery,
+        // within the original aggregate initialize deadline.
         if (!input.resume || !(error instanceof PreflightError || error instanceof ThreadDeliveryColdStartRequired))
             throw error;
-        return attempt(input, randomUUID(), false, options);
+        return runAttempt(randomUUID(), false);
     }
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/dist/serve.js

@@ -668,6 +668,7 @@ 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,
@@ -1234,6 +1235,7 @@ export function serve(config, opts = {}) {
                 return;
             // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。
             serverCapabilities = new Set();
+            memoryMigrations.clearIdentity();
             completionRetransmitter.pause();
             // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
             // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。

package/dist/workspace.js

@@ -15,6 +15,7 @@ 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) {
@@ -55,8 +56,10 @@ async function hasLocalMemoryV2Marker(agentDir) {
             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;
     }
     catch {

package/package.json

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