@nowcrew/daemon 0.6.101-beta.2 → 0.6.101-beta.4

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

@@ -7,25 +7,10 @@ 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;
 }
-/**
- * Release evidence is a task artifact, not a durable memory note.  Keep this
- * deliberately narrow: only conventional delivery-artifact filename families
- * are blocked; unrelated note names are still handled by the normal candidate
- * protocol instead of being deleted or rewritten.
- */
-const RELEASE_ARTIFACT_NOTE_PATTERN = /^(?:release|publish|build|deploy|artifact)(?:[-_.].*)?\.md$/iu;
-export function isReleaseArtifactNotePath(relativePath) {
-    const basename = relativePath.split("/").pop() ?? relativePath;
-    return RELEASE_ARTIFACT_NOTE_PATTERN.test(basename);
-}
-export function releaseArtifactNoteChanges(diff) {
-    return diff.changes.filter((change) => isReleaseArtifactNotePath(change.relative_path));
-}
 export function parseMemoryPruneTraceId(wakePrompt) {
     return TRACE_PATTERN.exec(wakePrompt)?.[1] ?? null;
 }
@@ -207,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([
@@ -269,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);
     }
@@ -292,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();
@@ -428,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)
@@ -456,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 };
@@ -478,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, selectLegacyMemoryPreview, selectLocalMemoryPreview, } from "./local-memory/storage-format.js";
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
@@ -68,14 +67,23 @@ 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;
-    }
-    if (memory.length > cap || Buffer.byteLength(memory, "utf8") > maxBytes) {
-        return selectLegacyMemoryPreview(memory, query, { maxCodePoints: cap, maxBytes });
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP, maxBytes = Number.POSITIVE_INFINITY) {
+    if (memory.length <= cap && Buffer.byteLength(memory, "utf8") <= maxBytes)
+        return memory;
+    const notice = "[MEMORY.md preview truncated; use crew-memory search/read for more.]\n";
+    const noticeBytes = Buffer.byteLength(notice, "utf8");
+    if (notice.length > cap || noticeBytes > maxBytes)
+        return "";
+    let end = 0;
+    let bytes = noticeBytes;
+    for (const character of memory) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (notice.length + end + character.length > cap || bytes + size > maxBytes)
+            break;
+        end += character.length;
+        bytes += size;
     }
-    return memory;
+    return notice + memory.slice(0, end);
 }
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
@@ -334,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/runtime-tool-update-bridge.js

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { RuntimeToolResponseSchema } from "./runtime-tool-update-protocol.js";
+export function runtimeToolEnvironment(env) {
+    // Keep only machine identity and lookup settings. Never pass runtime/control-plane credentials or Node injection flags.
+    return Object.fromEntries(Object.entries(env).filter(([key]) => /^(PATH|HOME|USER|LOGNAME|SHELL|TMPDIR|TMP|TEMP|LANG|LC_[A-Z_]+|XDG_CONFIG_HOME|XDG_CACHE_HOME)$/u.test(key)));
+}
+async function readReport(dir) {
+    const file = join(dir, "report.json");
+    if ((await stat(file)).size > 256_000)
+        throw new Error("invalid_report");
+    return RuntimeToolResponseSchema.parse(JSON.parse(await readFile(file, "utf8")));
+}
+async function stopGroup(pid) {
+    if (!pid)
+        return true;
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+    const deadline = Date.now() + 3000;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(-pid, 0);
+        }
+        catch (error) {
+            return error.code === "ESRCH";
+        }
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    return false;
+}
+export function createRuntimeToolProgressPoller(read, progress, intervalMs = 250) {
+    let active = true;
+    let pending = null;
+    const interval = setInterval(() => {
+        if (!active || pending || !progress)
+            return;
+        pending = read().then(async (data) => { if (active)
+            await progress(data); })
+            .catch(() => { }).finally(() => { pending = null; });
+    }, intervalMs);
+    return { async stop() { active = false; clearInterval(interval); await pending; } };
+}
+async function supervise(dir, env, start, progress, protectProcessGroup) {
+    const child = spawn(process.execPath, [join(dir, "runner.mjs"), "--managed-worker"], { cwd: dir, env, detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"] });
+    const closed = new Promise(resolve => { child.once("error", () => resolve(null)); child.once("close", resolve); });
+    const polling = createRuntimeToolProgressPoller(() => readReport(dir), progress);
+    let expired = false;
+    const timer = setTimeout(() => { expired = true; void stopGroup(child.pid); }, start ? 12 * 60_000 : 120_000);
+    let launchFailed = false;
+    try {
+        if (start) {
+            if (!protectProcessGroup || !child.pid)
+                throw new Error("lease_protection_unavailable");
+            await protectProcessGroup(child.pid);
+        }
+        await new Promise((resolve, reject) => child.send({ type: "runtime-tools:go" }, error => error ? reject(error) : resolve()));
+    }
+    catch {
+        launchFailed = true;
+        await stopGroup(child.pid);
+    }
+    const code = await closed;
+    clearTimeout(timer);
+    await polling.stop();
+    // A successful parent exit does not prove its package-manager descendants stopped.
+    const stopped = await stopGroup(child.pid);
+    return { stopped, success: stopped && !expired && !launchFailed && code === 0 };
+}
+export async function runRuntimeToolBridge(config, request, acquireEnv, progress, deps = {}) {
+    let dir;
+    let started = false;
+    let processStopped = true;
+    const failure = (errorCode) => ({ processStopped, data: request.action === "start" ? { operation: {
+                operationId: request.operationId, state: started ? "unknown" : "failed", currentIndex: 0, targets: request.targets,
+                items: request.targets.map(t => ({ runtime: t.installation.runtime, state: started ? "unknown" : "failed", errorCode })),
+                updatedAt: new Date().toISOString(), errorCode,
+            } } : {} });
+    try {
+        const response = await (deps.fetch ?? fetch)(`${config.serverUrl.replace(/\/+$/, "")}/machine/runtime-tool-updates/runner/${request.runner.releaseId}`, {
+            headers: { authorization: `Bearer ${config.machineToken}` }, redirect: "error", signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok || !response.body)
+            return failure("runner_unavailable");
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of response.body) {
+            bytes += chunk.length;
+            if (bytes > 512_000)
+                return failure("runner_unavailable");
+            chunks.push(chunk);
+        }
+        const content = Buffer.concat(chunks);
+        if (createHash("sha256").update(content).digest("hex") !== request.runner.sha256)
+            return failure("runner_unavailable");
+        const env = runtimeToolEnvironment(await acquireEnv());
+        dir = await mkdtemp(join(tmpdir(), "nowwork-runtime-update-"));
+        await writeFile(join(dir, "runner.mjs"), content, { mode: 0o600 });
+        await writeFile(join(dir, "request.json"), JSON.stringify(request), { mode: 0o600 });
+        started = true;
+        processStopped = false;
+        const outcome = await supervise(dir, env, request.action === "start", progress, deps.protectProcessGroup);
+        processStopped = outcome.stopped;
+        if (!outcome.success)
+            return failure("operation_unknown");
+        const data = await readReport(dir);
+        if (request.action === "start" && data.operation?.operationId !== request.operationId)
+            return failure("operation_unknown");
+        if (request.action === "inspect" && !data.snapshot)
+            return failure("inspection_failed");
+        return { data, processStopped };
+    }
+    catch {
+        return failure(started ? "operation_unknown" : "runner_unavailable");
+    }
+    finally {
+        if (dir && processStopped)
+            await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/runtime-tool-update-controller.js

@@ -0,0 +1,151 @@
+import { RuntimeToolRequestSchema, RuntimeToolResponseSchema } from "./runtime-tool-update-protocol.js";
+const finalStates = new Set(["completed", "failed", "unknown", "cancelled"]);
+const phaseRank = (state) => ({ queued: 0, preflight: 1, installing: 2, verifying: 3, completed: 4, failed: 4, unknown: 4, cancelled: 4 })[state];
+function advancesProgress(previous, next) {
+    if (finalStates.has(previous.state) || finalStates.has(next.state)
+        || next.operationId !== previous.operationId || JSON.stringify(next.targets) !== JSON.stringify(previous.targets)
+        || next.currentIndex < previous.currentIndex || next.currentIndex >= previous.targets.length
+        || (next.currentIndex === previous.currentIndex && phaseRank(next.state) < phaseRank(previous.state)))
+        return false;
+    return previous.items.every((item, index) => {
+        const candidate = next.items[index];
+        if (!candidate || candidate.runtime !== item.runtime)
+            return false;
+        return finalStates.has(item.state) ? candidate.state === item.state && candidate.errorCode === item.errorCode
+            : phaseRank(candidate.state) >= phaseRank(item.state);
+    });
+}
+export function createRuntimeToolUpdateController(deps) {
+    const entries = new Map();
+    let current = null;
+    let stopped = false;
+    let orphaned = false;
+    const now = deps.now ?? Date.now;
+    const date = () => new Date(now()).toISOString();
+    const wait = deps.wait ?? (() => new Promise(resolve => setTimeout(resolve, 500)));
+    const fail = (error) => ({ ok: false, error });
+    const result = (data) => ({ ok: true, data });
+    const set = (entry, patch) => { entry.operation = { ...entry.operation, ...patch, updatedAt: date() }; };
+    async function execute(entry) {
+        const deadline = now() + 10 * 60_000;
+        let acceptingProgress = false;
+        let lease = null;
+        try {
+            while (!stopped && entry.operation.state === "queued" && now() < deadline && !lease) {
+                lease = await deps.acquire();
+                if (!lease)
+                    await wait();
+            }
+            if (entry.operation.state === "cancelled")
+                return;
+            if (!lease || stopped || now() >= deadline) {
+                set(entry, { state: "failed", errorCode: "runtime_busy" });
+                return;
+            }
+            set(entry, { state: "preflight" });
+            // Mark unsafe before spawning: an exception or lost response cannot authorize another writer.
+            entry.processStopped = false;
+            acceptingProgress = true;
+            const output = await deps.run(entry.request, raw => {
+                if (!acceptingProgress)
+                    return;
+                const parsed = RuntimeToolResponseSchema.safeParse(raw);
+                if (parsed.success && parsed.data.operation && advancesProgress(entry.operation, parsed.data.operation))
+                    entry.operation = parsed.data.operation;
+            }, lease.protectProcessGroup);
+            acceptingProgress = false;
+            const data = RuntimeToolResponseSchema.parse(output.data);
+            entry.processStopped = output.processStopped;
+            if (!data.operation || data.operation.operationId !== entry.operation.operationId
+                || JSON.stringify(data.operation.targets) !== JSON.stringify(entry.request.targets)
+                || data.operation.currentIndex < entry.operation.currentIndex || !finalStates.has(data.operation.state))
+                throw new Error("operation_mismatch");
+            entry.operation = data.operation;
+            if (!entry.processStopped)
+                set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        catch {
+            acceptingProgress = false;
+            set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        finally {
+            acceptingProgress = false;
+            // Retain the barrier if process-group termination could not be proved.
+            if (entry.processStopped) {
+                try {
+                    await lease?.release();
+                }
+                catch {
+                    entry.processStopped = false;
+                    set(entry, { state: "unknown", errorCode: "operation_unknown" });
+                }
+            }
+        }
+    }
+    return {
+        async handle(raw) {
+            const parsed = RuntimeToolRequestSchema.safeParse(raw);
+            if (!parsed.success || stopped)
+                return fail("invalid_request");
+            const request = parsed.data;
+            if (request.action === "inspect") {
+                try {
+                    const data = RuntimeToolResponseSchema.parse((await deps.run(request)).data);
+                    return data.snapshot ? result(data) : fail("inspection_failed");
+                }
+                catch {
+                    return fail("inspection_failed");
+                }
+            }
+            const entry = entries.get(request.operationId);
+            if (request.action === "start") {
+                if (entry)
+                    return result({ operation: entry.operation });
+                if (orphaned || [...entries.values()].some(x => x.operation.state === "unknown"))
+                    return fail("operation_unknown");
+                if (current)
+                    return fail("runtime_busy");
+                if (entries.size >= 100)
+                    return fail("operation_limit");
+                if (new Set(request.targets.map(t => t.installation.runtime)).size !== request.targets.length)
+                    return fail("invalid_request");
+                const operation = { operationId: request.operationId, state: "queued", currentIndex: 0, targets: request.targets,
+                    items: request.targets.map(t => ({ runtime: t.installation.runtime, state: "queued", errorCode: null })), updatedAt: date(), errorCode: null };
+                const next = { operation, request, processStopped: true };
+                entries.set(request.operationId, next);
+                current = execute(next).finally(() => { current = null; });
+                return result({ operation });
+            }
+            if (!entry) {
+                orphaned = true;
+                return fail("operation_unknown");
+            }
+            if (request.action === "status")
+                return result({ operation: entry.operation });
+            if (request.action === "cancel") {
+                if (entry.operation.state !== "queued")
+                    return fail("already_started");
+                set(entry, { state: "cancelled", items: entry.operation.items.map(x => ({ ...x, state: "cancelled" })) });
+                return result({ operation: entry.operation });
+            }
+            if (!entry.processStopped || current)
+                return fail("operation_unknown");
+            try {
+                const output = await deps.run({ action: "inspect", runner: entry.request.runner });
+                const snapshot = RuntimeToolResponseSchema.parse(output.data).snapshot;
+                if (!snapshot || !output.processStopped)
+                    return fail("operation_unknown");
+                const matches = entry.operation.targets.every(target => snapshot.tools.some(tool => tool.runtime === target.installation.runtime
+                    && tool.version === target.targetVersion && tool.path === target.installation.path && tool.source === target.installation.source
+                    && tool.prefix === target.installation.prefix && tool.brewPath === target.installation.brewPath && tool.automatic));
+                set(entry, { state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed", snapshot,
+                    items: entry.operation.items.map(x => ({ ...x, state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed" })) });
+                return result({ operation: entry.operation, snapshot });
+            }
+            catch {
+                return fail("inspection_failed");
+            }
+        },
+        async stop() { stopped = true; await current; },
+    };
+}

package/dist/runtime-tool-update-protocol.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const RUNTIME_TOOL_UPDATES_CAPABILITY = "runtime_tool_updates_v1";
+const boundedPath = z.string().min(1).max(4096);
+export const RuntimeToolRunnerSchema = z.object({ releaseId: z.string().regex(/^[a-f0-9]{64}$/), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+export const RuntimeToolInstallationSchema = z.object({
+    runtime: z.enum(["codex", "claude"]), path: boundedPath, realPath: boundedPath,
+    version: z.string().max(100).nullable(), source: z.enum(["npm", "homebrew", "native", "unknown"]),
+    nodeVersion: z.string().max(100).nullable(), nodePath: boundedPath.nullable(), npmPath: boundedPath.nullable(), prefix: boundedPath.nullable(),
+    brewPath: boundedPath.nullable(), brewKind: z.enum(["formula", "cask"]).nullable(), brewName: z.enum(["codex", "claude-code"]).nullable(),
+    fingerprint: z.string().regex(/^[a-f0-9]{64}$/), alternatives: z.array(boundedPath).max(32), automatic: z.boolean(), reason: z.string().max(100).nullable(),
+}).strict();
+export const RuntimeToolSnapshotSchema = z.object({ checkedAt: z.string().datetime(), tools: z.array(RuntimeToolInstallationSchema).max(2) }).strict();
+export const RuntimeToolTargetSchema = z.object({ installation: RuntimeToolInstallationSchema, targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/).max(100) }).strict();
+export const RuntimeToolStateSchema = z.enum(["queued", "preflight", "installing", "verifying", "completed", "failed", "unknown", "cancelled"]);
+export const RuntimeToolOperationSchema = z.object({ operationId: z.string().uuid(), state: RuntimeToolStateSchema, currentIndex: z.number().int().min(0).max(2),
+    targets: z.array(RuntimeToolTargetSchema).min(1).max(2), items: z.array(z.object({ runtime: z.enum(["codex", "claude"]), state: RuntimeToolStateSchema, errorCode: z.string().max(100).nullable() }).strict()).max(2),
+    updatedAt: z.string().datetime(), errorCode: z.string().max(100).nullable(), snapshot: RuntimeToolSnapshotSchema.optional(),
+}).strict();
+export const RuntimeToolRequestSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("inspect"), runner: RuntimeToolRunnerSchema }).strict(),
+    z.object({ action: z.literal("start"), operationId: z.string().uuid(), targets: z.array(RuntimeToolTargetSchema).min(1).max(2), runner: RuntimeToolRunnerSchema }).strict(),
+    ...["status", "cancel", "verify"].map(action => z.object({ action: z.literal(action), operationId: z.string().uuid() }).strict()),
+]);
+export const RuntimeToolResponseSchema = z.object({ snapshot: RuntimeToolSnapshotSchema.optional(), operation: RuntimeToolOperationSchema.optional() }).strict();

package/dist/runtime-tool-update-serve.js

@@ -0,0 +1,54 @@
+import { prepareDaemonRestart } from "./daemon-updater.js";
+import { createRuntimeToolUpdateController } from "./runtime-tool-update-controller.js";
+import { augmentedPath } from "./runtime-path.js";
+import { runRuntimeToolBridge } from "./runtime-tool-update-bridge.js";
+export async function acquireRuntimeToolLease(localSlots, host) {
+    const local = await prepareDaemonRestart({ localSlots });
+    if (!local.ok)
+        return null;
+    try {
+        const shared = await host.tryAcquireExclusiveExecution();
+        if (!shared) {
+            await local.release();
+            return null;
+        }
+        let released = false;
+        return { protectProcessGroup: async (pid) => {
+                if (!shared.protectProcessGroup)
+                    throw new Error("lease protection unavailable");
+                await shared.protectProcessGroup(pid);
+            }, async release() { if (released)
+                return; await shared.release(); await local.release(); released = true; } };
+    }
+    catch (error) {
+        await local.release();
+        throw error;
+    }
+}
+export function createServeRuntimeToolUpdates(config, localSlots, host, acquireEnv, refresh) {
+    const controller = createRuntimeToolUpdateController({ acquire: () => acquireRuntimeToolLease(localSlots, host),
+        run: async (request, progress, protectProcessGroup) => {
+            const result = await runRuntimeToolBridge(config, request, async () => {
+                const env = await acquireEnv();
+                return { ...env, PATH: augmentedPath(env, {}, process.platform, "append") };
+            }, progress, { ...(protectProcessGroup ? { protectProcessGroup } : {}) });
+            if (request.action === "start" && result.processStopped)
+                refresh();
+            return result;
+        } });
+    return {
+        handle(raw, send) {
+            if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "runtime-tools:operation")
+                return false;
+            const { reqId, type: _type, ...request } = raw;
+            if (typeof reqId === "string") {
+                if (process.platform !== "linux" && process.platform !== "darwin")
+                    send({ type: "fs:result", reqId, ok: false, error: "unsupported_platform" });
+                else
+                    void controller.handle(request).then(result => send({ type: "fs:result", reqId, ...result })).catch(() => send({ type: "fs:result", reqId, ok: false, error: "operation_unknown" }));
+            }
+            return true;
+        },
+        stop: controller.stop,
+    };
+}