@co0ontty/wand 4.94.0 → 4.95.0

package/dist/web-ui/react/workspaces/sidebar-manage.d.ts

@@ -1,4 +1,5 @@
 import type { TaskDirectoryGroup } from "./types.js";
+import type { ConversationOrganizationResult } from "../../../conversation-organize-contract.js";
 export interface SidebarManageSelection {
     readonly directoryIds?: readonly string[];
     readonly taskIds: readonly string[];
@@ -20,6 +21,10 @@ export declare function pruneManagedSelection(selection: SidebarManageSelection,
  */
 export declare function describeManagedAction(selection: SidebarManageSelection): string;
 export declare function describeManagedResult(selection: SidebarManageSelection): string;
+export declare function describeConversationOrganizationOutcome(result: ConversationOrganizationResult): {
+    label: string;
+    reason: string;
+};
 export declare function describeOrganizeOutcome(result: {
     movedSessions: readonly unknown[];
     categorizedTasks: readonly unknown[];

package/dist/web-ui/react/workspaces/sidebar-manage.js

@@ -106,13 +106,37 @@ export function describeManagedResult(selection) {
         parts.push(`归档 ${selection.sessionIds.length} 个终端`);
     return parts.join("、") || "处理所选项目";
 }
+export function describeConversationOrganizationOutcome(result) {
+    const changes = [];
+    if (result.createdTasks.length)
+        changes.push(`新建 ${result.createdTasks.length} 个任务`);
+    if (result.updatedTasks.length)
+        changes.push(`更新 ${result.updatedTasks.length} 个系统任务标题`);
+    if (result.reusedTasks.length)
+        changes.push(`复用 ${new Set(result.reusedTasks.map(task => task.taskId)).size} 个任务`);
+    if (result.movedSessions.length)
+        changes.push(`归入 ${result.movedSessions.length} 个会话`);
+    const label = result.unchanged ? "会话内容和归属未变化，没有重复建任务或调用模型"
+        : changes.length ? `${result.cancelled || result.error ? "部分完成：" : "已"}${changes.join("、")}`
+            : result.cancelled ? "已取消后续会话归类" : result.error ? "会话归类未完成" : result.eligibleSessions ? "会话尚未得到明确工作分组，本次未作调整" : "没有符合范围且有正文的工作会话";
+    const details = [`已检查 ${result.analyzedSessions}/${result.eligibleSessions} 个工作会话`,
+        result.skippedManualSessions ? `跳过 ${result.skippedManualSessions} 个人工任务中的会话` : "",
+        result.skippedSessions ? `排除 ${result.skippedSessions} 个归档/私聊/自动化/系统日志或无正文会话` : "",
+        result.unassignedSessions.length ? `${result.unassignedSessions.length} 个会话尚未确定主题` : "",
+        result.refused.length ? `${result.refused.length} 项未处理：${result.refused[0]?.reason}` : "", result.error ?? ""].filter(Boolean);
+    return { label, reason: details.join("；") };
+}
 export function describeOrganizeOutcome(result) {
     const moved = result.movedSessions.length;
     const categorized = result.categorizedTasks.length;
     const reason = result.refused[0]?.reason ?? "";
+    const details = [
+        result.eligibleTasks === undefined ? "" : `已检查 ${result.eligibleTasks} 个任务`,
+        result.skippedTasks ? `已跳过 ${result.skippedTasks} 个用户自定标题的任务` : "",
+    ].filter(Boolean);
     if (!moved && !categorized) {
-        return { label: reason || (result.eligibleTasks === 0 ? "没有符合归类范围的任务" : "所选标题已归类"),
-            reason: reason || (result.skippedTasks ? `已跳过 ${result.skippedTasks} 个用户自定标题的任务` : "") };
+        return { label: reason ? "未调整任何任务或会话" : (result.eligibleTasks === 0 ? "没有符合归类范围的任务" : "未发现可安全归类的项"),
+            reason: [...details, reason].filter(Boolean).join("；") };
     }
     const parts = [];
     if (categorized)
@@ -121,7 +145,7 @@ export function describeOrganizeOutcome(result) {
         parts.push(`归属 ${moved} 个会话`);
     return {
         label: `已${parts.join("、")}`,
-        reason: result.refused.length ? `另有 ${result.refused.length} 项未处理：${reason}` : "",
+        reason: [...details, result.refused.length ? `另有 ${result.refused.length} 项未处理：${reason}` : ""].filter(Boolean).join("；"),
     };
 }
 export function standaloneManagedSessionIds(selection, groups) {

package/dist/web-ui/running-activity.d.ts

@@ -1,9 +1,13 @@
+import type { ConversationTurn } from "../types.js";
 /**
  * 「正在执行」的客户端推导：只允许对服务端下发的运行事实与锚点时刻做展示差分。
  * 锚点（turnStartedAt / lastActivityAt）缺失时一律不显示时长，前端不本地起表伪造运行中。
  */
 /** 服务端会话快照里本模块关心的字段（structured 与 PTY 共用同一形状）。 */
 export interface RunningActivityShape {
+    readonly id?: string;
+    /** Must be the transcript for this source session, never a team's merged feed. */
+    readonly messages?: readonly ConversationTurn[];
     readonly status?: string;
     readonly archived?: boolean;
     readonly permissionBlocked?: boolean;
@@ -16,6 +20,7 @@ export interface RunningActivityShape {
     readonly ptyRunning?: boolean;
     readonly structuredState?: {
         readonly inFlight?: boolean;
+        readonly activeRequestId?: string | null;
         readonly phase?: string;
         readonly turnStartedAt?: string | null;
         readonly lastActivityAt?: string | null;
@@ -41,23 +46,31 @@ export declare function isRunningNow(source: RunningActivityShape | RunningRunSh
 /** 会话侧运行事实：structured 看本轮 inFlight，PTY 看 ptyRunning，两者都不看本地计时。 */
 export declare function sessionRunning(source: RunningActivityShape | null | undefined): boolean;
 /**
- * 分阶段：等待审批/输入 > 已接收排队 > 正在执行 > 结束。
- * 非运行中一律 idle，调用方必须据此立即收敛状态条，不留残留。
+ * 分阶段：终态/归档 > 等待审批/输入 > 正在执行 > 已接收排队 > 结束。
+ * 队列是下一项工作，不能掩盖本轮执行或待答。终态保留在完整投影中，
  * `runMode` 给团队 run：那里的 status 就是运行事实本身。会话侧不行——裸 shell 的
  * status 恒为 running，必须走 sessionRunning（structured inFlight / PTY ptyRunning）。
  */
 export declare function computeRunningPhase(source: RunningActivityShape | null | undefined, runMode?: boolean): RunningPhase;
 /** 距最近一次活动已静默多久；锚点缺失或不在运行中时为 0。 */
-export declare function silenceDurationMs(source: RunningActivityShape | RunningRunShape | null | undefined, nowMs: number): number;
+export declare function silenceDurationMs(source: RunningActivityShape | RunningRunShape | null | undefined, nowMs: number, runMode?: boolean): number;
 /** 静默超阈值时的提示文案；不满足条件返回 null。 */
-export declare function silenceNotice(source: RunningActivityShape | RunningRunShape | null | undefined, nowMs: number, thresholdMs?: number): string | null;
+export declare function silenceNotice(source: RunningActivityShape | RunningRunShape | null | undefined, nowMs: number, thresholdMs?: number, runMode?: boolean): string | null;
 /** 与 formatElapsedShort 不同：面向「已 N 分钟」这类自然语言读数。 */
 export declare function formatMinutes(ms: number): string;
 export declare const PHASE_LABELS: Readonly<Record<RunningPhase, string>>;
-/**
- * 状态条的完整文案。运行中恒有文字（阶段 + 已运行时长），静默超阈值时追加无新消息提示，
- * 这样「还在跑」和「已经停了」在界面上一眼可分。
- */
+/** Distinct display stages; computeRunningPhase remains compatible with avatar consumers. */
+export type RunningStatusStage = RunningPhase | "tool" | "output" | "thinking" | "background" | "failed" | "stopped";
+export interface RunningStatusProjection {
+    readonly phase: RunningPhase;
+    readonly stage: RunningStatusStage;
+    readonly label: string;
+    readonly action: string | null;
+    readonly toolId?: string;
+    readonly active: boolean;
+}
+export declare function projectRunningStatus(source: RunningActivityShape | null | undefined, runMode?: boolean): RunningStatusProjection;
+/** One authoritative label, with server-anchored elapsed/silence reads. */
 export declare function runningStatusText(source: RunningActivityShape | null | undefined, nowMs: number, runMode?: boolean): string;
-/** 团队侧文案：run 级锚点，语义与会话侧一致。 */
+/** 团队只投影 run 自身，不借用任何成员会话的工具或输出。 */
 export declare function runStatusText(source: RunningRunShape | null | undefined, nowMs: number): string;

package/dist/web-ui/running-activity.js

@@ -1,9 +1,8 @@
-/**
- * 「正在执行」的客户端推导：只允许对服务端下发的运行事实与锚点时刻做展示差分。
- * 锚点（turnStartedAt / lastActivityAt）缺失时一律不显示时长，前端不本地起表伪造运行中。
- */
+import { currentRunningAction } from "./running-current-action.js";
 /** 静默起显阈值：超过后从「正在执行」升级为「仍在运行 · 已 N 分钟无新消息」。 */
 export const SILENCE_NOTICE_MS = 60_000;
+const TERMINAL_STATUSES = new Set(["failed", "stopped", "exited", "done"]);
+const WAITING_STATUSES = new Set(["waiting-input", "waiting_input", "waiting_user", "awaiting_approval"]);
 const RUNNING_STATUSES = new Set([
     "running", "thinking", "waiting-input", "waiting_input",
     // 团队 run 的等待相位仍是「这一轮没结束」，收敛只发生在 done/failed/stopped。
@@ -36,6 +35,8 @@ export function isRunningNow(source) {
     if (source.archived)
         return false;
     const activity = source;
+    if (activity.archived || TERMINAL_STATUSES.has(activity.status ?? ""))
+        return false;
     if (activity.permissionBlocked || activity.pendingEscalation)
         return true;
     if (activity.structuredState?.inFlight)
@@ -45,31 +46,34 @@ export function isRunningNow(source) {
 }
 /** 会话侧运行事实：structured 看本轮 inFlight，PTY 看 ptyRunning，两者都不看本地计时。 */
 export function sessionRunning(source) {
-    if (!source || source.archived)
+    if (!source || source.archived || TERMINAL_STATUSES.has(source.status ?? ""))
         return false;
     return Boolean(source.structuredState?.inFlight) || source.ptyRunning === true;
 }
 /**
- * 分阶段：等待审批/输入 > 已接收排队 > 正在执行 > 结束。
- * 非运行中一律 idle，调用方必须据此立即收敛状态条，不留残留。
+ * 分阶段：终态/归档 > 等待审批/输入 > 正在执行 > 已接收排队 > 结束。
+ * 队列是下一项工作，不能掩盖本轮执行或待答。终态保留在完整投影中，
  * `runMode` 给团队 run：那里的 status 就是运行事实本身。会话侧不行——裸 shell 的
  * status 恒为 running，必须走 sessionRunning（structured inFlight / PTY ptyRunning）。
  */
 export function computeRunningPhase(source, runMode = false) {
-    if (!source)
+    if (!source || source.archived || TERMINAL_STATUSES.has(source.status ?? ""))
         return "idle";
-    // 排队未空 = 服务端还欠这一轮回复，属于「已接收」；不能被会话级 idle 吞掉。
-    if ((source.queuedMessages?.length ?? 0) > 0)
-        return "received";
-    if (!(runMode ? isRunningNow(source) : sessionRunning(source)))
-        return "idle";
-    if (source.permissionBlocked || source.pendingEscalation)
+    if (source.permissionBlocked || source.pendingEscalation || WAITING_STATUSES.has(source.status ?? ""))
         return "waiting";
-    return "executing";
+    if (runMode ? isRunningNow(source) : sessionRunning(source)) {
+        if (!runMode && currentRunningAction(source)?.kind === "waiting")
+            return "waiting";
+        return "executing";
+    }
+    if ((source.queuedMessages?.length ?? 0) > 0 || (runMode && source.status === "starting"))
+        return "received";
+    return "idle";
 }
 /** 距最近一次活动已静默多久；锚点缺失或不在运行中时为 0。 */
-export function silenceDurationMs(source, nowMs) {
-    if (!isRunningNow(source) && !sessionRunning(source))
+export function silenceDurationMs(source, nowMs, runMode = false) {
+    // Session status=running alone is only a live shell, not an active turn.
+    if (!(runMode ? isRunningNow(source) : sessionRunning(source)))
         return 0;
     const last = lastActivityAtMs(source);
     if (last === null)
@@ -77,8 +81,8 @@ export function silenceDurationMs(source, nowMs) {
     return Math.max(0, nowMs - last);
 }
 /** 静默超阈值时的提示文案；不满足条件返回 null。 */
-export function silenceNotice(source, nowMs, thresholdMs = SILENCE_NOTICE_MS) {
-    const silence = silenceDurationMs(source, nowMs);
+export function silenceNotice(source, nowMs, thresholdMs = SILENCE_NOTICE_MS, runMode = false) {
+    const silence = silenceDurationMs(source, nowMs, runMode);
     if (silence < thresholdMs)
         return null;
     return `仍在运行 · 已 ${formatMinutes(silence)}无新消息`;
@@ -101,34 +105,46 @@ export const PHASE_LABELS = {
     waiting: "等待你的输入",
     idle: "",
 };
-/**
- * 状态条的完整文案。运行中恒有文字（阶段 + 已运行时长），静默超阈值时追加无新消息提示，
- * 这样「还在跑」和「已经停了」在界面上一眼可分。
- */
-export function runningStatusText(source, nowMs, runMode = false) {
+export function projectRunningStatus(source, runMode = false) {
     const phase = computeRunningPhase(source, runMode);
-    if (phase === "idle")
+    const base = { phase, stage: phase, label: PHASE_LABELS[phase], action: null, active: phase !== "idle" };
+    if (!source || source.archived)
+        return base;
+    if (source.status === "failed" || source.status === "stopped") {
+        return { ...base, stage: source.status, label: source.status === "failed" ? "执行失败" : "已停止", active: false };
+    }
+    if (phase === "received")
+        return { ...base, label: "已接收 · 排队中" };
+    if (phase === "waiting")
+        return { ...base, label: source.permissionBlocked || source.pendingEscalation || source.status === "awaiting_approval" ? "等待你确认操作" : PHASE_LABELS.waiting };
+    if (phase !== "executing" || runMode)
+        return base;
+    if (source.structuredState?.phase === "background")
+        return { ...base, stage: "background", label: "等待后台任务" };
+    const action = currentRunningAction(source);
+    return action ? { ...base, stage: action.kind, label: action.kind === "tool" ? "正在使用工具" : action.label, action: action.kind === "tool" ? action.label : null, toolId: action.toolId } : base;
+}
+/** One authoritative label, with server-anchored elapsed/silence reads. */
+export function runningStatusText(source, nowMs, runMode = false) {
+    const projection = projectRunningStatus(source, runMode);
+    if (!projection.label)
         return "";
-    const parts = [PHASE_LABELS[phase]];
-    const started = turnStartedAtMs(source);
+    const parts = [projection.label];
+    if (projection.action)
+        parts.push(projection.action);
+    if (!projection.active || projection.phase === "received")
+        return parts.join(" · ");
+    const started = runMode
+        ? parseTime(source?.turnStartedAt) ?? parseTime(source?.startedAt)
+        : turnStartedAtMs(source);
     if (started !== null)
         parts.push(`已运行 ${formatMinutes(Math.max(0, nowMs - started))}`);
-    const silence = silenceNotice(source, nowMs);
-    if (silence)
-        parts.push(silence);
+    const silence = silenceDurationMs(source, nowMs, runMode);
+    if (silence >= SILENCE_NOTICE_MS)
+        parts.push(`已 ${formatMinutes(silence)}无新消息`);
     return parts.join(" · ");
 }
-/** 团队侧文案：run 级锚点，语义与会话侧一致。 */
+/** 团队只投影 run 自身，不借用任何成员会话的工具或输出。 */
 export function runStatusText(source, nowMs) {
-    if (!isRunningNow(source))
-        return "";
-    const waiting = source?.status === "awaiting_approval" || source?.status === "waiting_user";
-    const parts = [waiting ? PHASE_LABELS.waiting : PHASE_LABELS.executing];
-    const started = parseTime(source?.turnStartedAt) ?? parseTime(source?.startedAt);
-    if (started !== null)
-        parts.push(`已运行 ${formatMinutes(Math.max(0, nowMs - started))}`);
-    const silence = silenceNotice(source, nowMs);
-    if (silence)
-        parts.push(silence);
-    return parts.join(" · ");
+    return runningStatusText(source, nowMs, true);
 }

package/dist/web-ui/running-current-action.d.ts

@@ -0,0 +1,12 @@
+import type { RunningActivityShape } from "./running-activity.js";
+export interface CurrentRunningAction {
+    readonly kind: "tool" | "output" | "thinking" | "waiting";
+    readonly label: string;
+    readonly toolId?: string;
+}
+/**
+ * Only inspect one source session's current request. Missing request/time evidence
+ * falls back to generic execution; an old unfinished tool is not current activity.
+ * Text contents and tool arguments never participate in phase classification.
+ */
+export declare function currentRunningAction(source: RunningActivityShape): CurrentRunningAction | null;

package/dist/web-ui/running-current-action.js

@@ -0,0 +1,74 @@
+/** A tool name is an identifier, never a command/input/description excerpt. */
+function toolLabel(tool) {
+    const name = /^[\p{L}\p{N}_.:-]{1,64}$/u.test(tool.name) ? tool.name : "工具调用";
+    switch (tool.activity?.kind) {
+        case "read_file": return `读取文件 · ${name}`;
+        case "edit_file": return `修改文件 · ${name}`;
+        case "run_command": return `运行命令 · ${name}`;
+        default: return name;
+    }
+}
+/**
+ * Only inspect one source session's current request. Missing request/time evidence
+ * falls back to generic execution; an old unfinished tool is not current activity.
+ * Text contents and tool arguments never participate in phase classification.
+ */
+export function currentRunningAction(source) {
+    if (source.archived || ["failed", "stopped", "done", "exited"].includes(source.status ?? "")
+        || !(source.structuredState?.inFlight || source.ptyRunning))
+        return null;
+    const messages = source.messages ?? [];
+    const request = source.structuredState?.activeRequestId;
+    const started = Date.parse(source.structuredState?.turnStartedAt ?? source.turnStartedAt ?? "");
+    let start = messages.length - 1;
+    while (start >= 0 && !(messages[start].role === "user"
+        && messages[start].content.some(block => block.type === "text" && !block.__subagent && block.text.trim())))
+        start--;
+    const user = messages[start];
+    if (request && user?.requestId && user.requestId !== request)
+        return null;
+    const sameRequest = Boolean(request && user?.requestId === request);
+    const isCurrent = (turn) => {
+        if (turn.author?.sessionId && turn.author.sessionId !== source.id)
+            return false;
+        if (request && turn.requestId)
+            return turn.requestId === request;
+        if (sameRequest)
+            return true;
+        const created = Date.parse(turn.createdAt ?? "");
+        return Number.isFinite(started) && Number.isFinite(created) && created >= started;
+    };
+    const pending = new Map();
+    const completed = new Set();
+    let latest = null;
+    for (let index = start + 1; index < messages.length; index++) {
+        const turn = messages[index];
+        if (!isCurrent(turn))
+            continue;
+        for (const block of turn.content) {
+            if (block.__subagent)
+                continue;
+            if (block.type === "tool_result") {
+                completed.add(block.tool_use_id);
+                latest = null;
+            }
+            if (turn.role !== "assistant")
+                continue;
+            // completedAt ends the message stream, not the invoked tool. Only its
+            // paired result retires a tool or a question awaiting the user.
+            if (block.type === "tool_use") {
+                pending.set(block.id, block);
+                latest = null;
+            }
+            else if (!turn.completedAt && block.type === "text" && block.text.trim())
+                latest = { kind: "output", label: "正在输出" };
+            else if (!turn.completedAt && block.type === "thinking")
+                latest = { kind: "thinking", label: "正在思考" };
+        }
+    }
+    const tool = [...pending.values()].reverse().find(block => !completed.has(block.id));
+    if (tool?.semantic?.kind === "question_request" || tool?.name === "AskUserQuestion") {
+        return { kind: "waiting", toolId: tool.id, label: "等待你的输入" };
+    }
+    return tool ? { kind: "tool", toolId: tool.id, label: toolLabel(tool) } : latest;
+}

package/dist/web-ui/scripts.d.ts

@@ -17,6 +17,10 @@ export declare function getPlushAvatarChunk(requestedHash?: string): {
 /** Blocking, content-versioned device preference bootstrap. */
 export declare function getThemePreloadAsset(): VersionedWebAsset;
 export interface BrowserModuleManifest {
+    buildId?: string;
+    imports?: Record<string, string>;
+    dependencies?: Record<string, readonly string[]>;
+    integrity?: Record<string, string>;
     entry: string;
     eager: readonly string[];
     files: readonly string[];

package/dist/web-ui/scripts.js

@@ -24,32 +24,33 @@ function readScriptCache() {
         // Retain the last disk read, or fall back to the embedded copy.
     }
 }
-function injectRuntimeValues(source, configPath, chunkHash, plushHash, entry) {
+function injectRuntimeValues(source, configPath, chunkHash, plushHash, manifest) {
     return source
         // This is a JS string literal, not HTML text. JSON escaping also handles
         // quotes, backslashes and newlines in nonstandard configuration paths.
         .replace('"${wandConfigPath}"', JSON.stringify(configPath))
         .replace("${aiTeamsChunkSrc}", `/assets/ai-teams.js?v=${chunkHash}`)
         .replace("${plushAvatarChunkSrc}", `/assets/plush-avatar.js?v=${plushHash}`)
-        .replace("${browserModuleSrc}", `/assets/${entry}`);
+        .replace("${browserModuleSrc}", `/assets/${manifest.entry}`)
+        .replace('"${browserModuleImports}"', JSON.stringify(manifest.imports ?? {}));
 }
 export function getScriptAsset(configPath, requestedHash) {
     readScriptCache();
     const teamHash = getAiTeamsChunk().hash;
     const plushHash = getPlushAvatarChunk().hash;
-    const entry = getBrowserModuleManifest().entry;
-    const chunkHash = `${teamHash}:${plushHash}:${entry}`;
+    const manifest = getBrowserModuleManifest();
+    const chunkHash = `${teamHash}:${plushHash}:${manifest.buildId ?? manifest.entry}`;
     if (!_scriptAsset || _scriptAsset.source !== _scriptCache
         || _scriptAsset.configPath !== configPath || _scriptAsset.chunkHash !== chunkHash) {
         _scriptAsset = {
-            ...versionWebAsset(injectRuntimeValues(_scriptCache, configPath, teamHash, plushHash, entry)),
+            ...versionWebAsset(injectRuntimeValues(_scriptCache, configPath, teamHash, plushHash, manifest)),
             source: _scriptCache, configPath, chunkHash,
         };
     }
     if (requestedHash && requestedHash !== _scriptAsset.hash) {
         if (!_embeddedScriptAsset || _embeddedScriptAsset.configPath !== configPath) {
             _embeddedScriptAsset = {
-                ...versionWebAsset(injectRuntimeValues(EMBEDDED_WEB_ASSETS.scriptsJs, configPath, embeddedAiTeamsChunk.hash, embeddedPlushAvatarChunk.hash, EMBEDDED_WEB_ASSETS.browserModuleManifest.entry)),
+                ...versionWebAsset(injectRuntimeValues(EMBEDDED_WEB_ASSETS.scriptsJs, configPath, embeddedAiTeamsChunk.hash, embeddedPlushAvatarChunk.hash, EMBEDDED_WEB_ASSETS.browserModuleManifest)),
                 configPath,
             };
         }
@@ -123,10 +124,18 @@ export function getBrowserModuleManifest() {
         if (key !== browserManifestKey) {
             const next = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
             if (!next.files.every(file => /^modules\/[a-f0-9]{16}\/[A-Za-z0-9_-]+\.js$/.test(file))
-                || !next.files.includes(next.entry) || !next.eager.every(file => next.files.includes(file))) {
+                || !next.files.includes(next.entry) || !next.eager.every(file => next.files.includes(file))
+                || !Object.values(next.imports ?? {}).every(file => next.files.includes(file))
+                || !Object.entries(next.dependencies ?? {}).every(([file, deps]) => next.files.includes(file) && deps.every(dep => next.files.includes(dep)))) {
                 throw new Error("Invalid browser module manifest");
             }
-            const files = new Map(next.files.map(file => [file, fs.readFileSync(path.join(__dirname, "content", file), "utf8")]));
+            const files = new Map(next.files.map(file => {
+                const content = fs.readFileSync(path.join(__dirname, "content", file), "utf8");
+                if (next.integrity && createHash("sha256").update(content).digest("hex") !== next.integrity[file]) {
+                    throw new Error("Browser module integrity mismatch");
+                }
+                return [file, content];
+            }));
             browserBuilds.unshift(files);
             browserBuilds.splice(2);
             browserManifest = next;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "4.94.0",
+  "version": "4.95.0",
   "description": "A web console for Claude Code, Codex, OpenCode, and other local CLI tools.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   "files": [
     "dist",
     "skills/wand-decision",
+    "skills/wand-system",
     "browser-extension",
     "scripts/install-render-binary.js",
     "scripts/recover-web-update.sh",
@@ -40,6 +41,7 @@
     "check:body": "node scripts/check-node-version.js && node scripts/bundle-tailwind.js && node scripts/bundle-xterm.js && node scripts/bundle-qrcode.js && node scripts/bundle-browser.js && npm run generate:web-assets && tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json && tsc --noEmit -p tsconfig.react.json",
     "test": "node scripts/check-node-version.js && node scripts/run-tests.js",
     "check:bundle-budget": "node scripts/check-node-version.js && node scripts/check-bundle-budget.js",
+    "budget:accept": "node scripts/check-node-version.js && node scripts/check-bundle-budget.js --accept-baseline",
     "sync:brand-assets": "node scripts/sync-brand-assets.js",
     "check:brand-assets": "node scripts/sync-brand-assets.js --check",
     "audit:remnants": "node scripts/audit-legacy-remnants.js",
@@ -57,7 +59,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=24.21.0"
+    "node": ">=22.19.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.81.0",

package/scripts/recover-web-update.mjs

@@ -1,5 +1,4 @@
 import { accessSync, constants, chmodSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -57,23 +56,28 @@ export function chooseInstallPrefix(defaultPrefix, home, configPath) {
   return writable ? defaultPrefix : path.join(home, ".wand/runtime/npm");
 }
 
-function acquireRecoveryLock(root) {
-  const lockPath = path.join(root, ".wand-update-lock");
-  mkdirSync(root, { recursive: true });
-  const token = randomUUID();
-  try { mkdirSync(lockPath, { mode: 0o700 }); }
-  catch (error) {
-    if (error.code === "EEXIST") throw new Error("另一个更新仍持有安装锁，旧安装未修改。");
-    throw error;
+/** Same protocol as Web updates/start.sh, including a live parent's lease.
+ * Acquire before draining: a competing install must not close task admission.
+ * The module is copied into the independent recovery runtime, never loaded
+ * from the installation that this transaction is about to replace.
+ */
+export async function withRecoveryLock(root, guardPath, action) {
+  const directory = path.dirname(guardPath);
+  const lockModule = path.join(directory, existsSync(path.join(directory, "deployment-lock.js"))
+    ? "deployment-lock.js" : "deployment-lock.ts");
+  const { acquireDeploymentLock, releaseDeploymentLock } = await import(pathToFileURL(lockModule).href);
+  const previous = process.env.WAND_DEPLOYMENT_LOCKS;
+  const inherited = previous ? JSON.parse(previous) : [];
+  if (!Array.isArray(inherited)) throw new Error("无效的部署锁回执。");
+  const lock = acquireDeploymentLock(path.join(root, ".wand-update-lock"), { inherited });
+  try {
+    process.env.WAND_DEPLOYMENT_LOCKS = JSON.stringify([...inherited, lock]);
+    return await action();
+  } finally {
+    if (previous === undefined) delete process.env.WAND_DEPLOYMENT_LOCKS;
+    else process.env.WAND_DEPLOYMENT_LOCKS = previous;
+    releaseDeploymentLock(lock);
   }
-  try { writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, token, createdAt: Date.now() }), { mode: 0o600 }); }
-  catch (error) { rmSync(lockPath, { recursive: true, force: true }); throw error; }
-  return () => {
-    try {
-      const owner = JSON.parse(readFileSync(path.join(lockPath, "owner.json"), "utf8"));
-      if (owner.pid === process.pid && owner.token === token) rmSync(lockPath, { recursive: true, force: true });
-    } catch { /* Never remove a changed or unknown lock. */ }
-  };
 }
 
 function copyEntry(source, destination) {
@@ -109,6 +113,10 @@ function stopManagedService(platform, scope, serviceFile) {
 }
 
 export async function recoverPreparedInstallation(options) {
+  return withRecoveryLock(options.root, options.guardPath, () => applyPreparedInstallation(options));
+}
+
+async function applyPreparedInstallation(options) {
   const { prepared, root, bin, configPath, scope, platform, healthPath, guardPath } = options;
   const health = await import(pathToFileURL(healthPath).href);
   const guard = await import(pathToFileURL(guardPath).href);
@@ -118,7 +126,6 @@ export async function recoverPreparedInstallation(options) {
   try { originalPid = JSON.parse(readFileSync(path.join(configDir, "wand.pid"), "utf8")).pid; }
   catch (error) { if (error.code !== "ENOENT") throw error; }
   const wasRunning = alive(originalPid);
-  const unlock = acquireRecoveryLock(root);
   let stageRoot, backupRoot, backup, oldBin, previousService;
   let movedOld = false, promoted = false, registered = false;
   const serviceFile = scope === "standalone" ? null : platform === "Darwin"
@@ -244,7 +251,7 @@ export async function recoverPreparedInstallation(options) {
         [...(privileged ? ["systemctl"] : []), ...(scope === "user" ? ["--user"] : []), "start", "wand.service"], { stdio: "inherit" });
     } else if (wasRunning && !alive(originalPid) && savedBin) await startStandalone();
     throw error;
-  } finally { unlock(); }
+  }
 }
 
 let main = false;

package/scripts/recover-web-update.sh

@@ -13,7 +13,7 @@ copy_or_fetch_script update-node.sh
 copy_or_fetch_script update-target.js
 copy_or_fetch_script recover-web-update.mjs
 . "$RECOVERY_DIR/update-node.sh"
-wand_ensure_update_node 24.21.0 || { echo "需要 Node.js >=24.21.0；旧服务与安装未修改。" >&2; exit 1; }
+wand_ensure_update_node "$WAND_MINIMUM_NODE_VERSION" || { echo "需要 Node.js >=$WAND_MINIMUM_NODE_VERSION；旧服务与安装未修改。" >&2; exit 1; }
 
 PLATFORM="$(uname -s)"
 SYSTEM=0
@@ -83,8 +83,9 @@ GLOBAL_BIN="$INSTALL_PREFIX/bin/wand"
 echo "[wand-recovery] preparing $VERSION ($CHANNEL subscription); current service stays online"
 npm install -g --engine-strict --prefix "$RECOVERY_DIR/prepared" "@co0ontty/wand@$VERSION"
 PREPARED="$RECOVERY_DIR/prepared/lib/node_modules/@co0ontty/wand"
-for name in core-status-cli update-health update-legacy; do
-  if [ -f "$SCRIPT_DIR/../dist/$name.js" ]; then
+for name in core-status-cli update-health update-legacy deployment-lock; do
+  # A checkout may contain an older dist; use the matching source protocol there.
+  if [ ! -f "$SCRIPT_DIR/../src/$name.ts" ] && [ -f "$SCRIPT_DIR/../dist/$name.js" ]; then
     cp "$SCRIPT_DIR/../dist/$name.js" "$RECOVERY_DIR/$name.js"
     case "$name" in core-status-cli) GUARD_PATH="$RECOVERY_DIR/$name.js" ;; update-health) HEALTH_PATH="$RECOVERY_DIR/$name.js" ;; update-legacy) LEGACY_PATH="$RECOVERY_DIR/$name.js" ;; esac
   else
@@ -114,10 +115,12 @@ else
 fi
 # No sudo around the transaction: package, DB and WAL stay owned by the caller.
 # Only system-service registration prompts for its existing required privilege.
-"$NODE_BIN" --input-type=module - "$GUARD_PATH" "$LEGACY_PATH" "$CONFIG_PATH" "$ALLOW_STOPPED" "$NODE_BIN" "$RECOVERY_DIR/recover-web-update.mjs" apply "$PREPARED" "$GLOBAL_ROOT" "$GLOBAL_BIN" "$CONFIG_PATH" "$SCOPE" "$PLATFORM" "$HEALTH_PATH" "$GUARD_PATH" <<'NODE'
+"$NODE_BIN" --input-type=module - "$GUARD_PATH" "$LEGACY_PATH" "$CONFIG_PATH" "$ALLOW_STOPPED" "$GLOBAL_ROOT" "$NODE_BIN" "$RECOVERY_DIR/recover-web-update.mjs" apply "$PREPARED" "$GLOBAL_ROOT" "$GLOBAL_BIN" "$CONFIG_PATH" "$SCOPE" "$PLATFORM" "$HEALTH_PATH" "$GUARD_PATH" <<'NODE'
 import { pathToFileURL } from "node:url";
-const [guardPath, legacyPath, configPath, stopped, ...command] = process.argv.slice(2);
+const [guardPath, legacyPath, configPath, stopped, root, ...command] = process.argv.slice(2);
 const guard = await import(pathToFileURL(guardPath).href);
 const { waitForCompatibleUpdate } = await import(pathToFileURL(legacyPath).href);
-process.exitCode = await waitForCompatibleUpdate(configPath, 300, command, stopped === "1", guard);
+const { withRecoveryLock } = await import(pathToFileURL(command[1]).href);
+process.exitCode = await withRecoveryLock(root, guardPath,
+  () => waitForCompatibleUpdate(configPath, 300, command, stopped === "1", guard));
 NODE

package/scripts/update-node.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 # Sourced by install/recovery. Changes only this process's PATH; never removes an old Node runtime.
+# Keep in sync with package.json engines; .nvmrc is only the CI/build pin.
+WAND_MINIMUM_NODE_VERSION="22.19.0"
 wand_node_satisfies() {
   local executable="$1"
   local required="$2"
@@ -25,7 +27,7 @@ wand_use_existing_node() {
   # nvm installs and Homebrew's versioned prefixes are user-selected runtimes.
   # Do not run arbitrary executables discovered in the project or rewrite nvm aliases.
   for candidate in "${NVM_DIR:-$HOME/.nvm}"/versions/node/v*/bin/node \
-    /opt/homebrew/opt/node@24/bin/node /usr/local/opt/node@24/bin/node \
+    /opt/homebrew/opt/node@{22,24,26}/bin/node /usr/local/opt/node@{22,24,26}/bin/node \
     /opt/homebrew/bin/node /usr/local/bin/node; do
     [ -x "$candidate" ] || continue
     wand_node_satisfies "$candidate" "$required" || continue