chatccc 0.2.266 → 0.2.268

package/dist/src/index.js

@@ -47,7 +47,7 @@ import { loadSessionRegistryForBinding, rebuildBindingsFromRegistry, resetState,
 import { startChromeDevtoolsGuard, stopChromeDevtoolsGuard } from "./chrome-devtools-guard.js";
 import { rebuildSessionChatsFromRegistry, setQueueConsumer, } from "./session-chat-binding.js";
 import { fixStaleStreamStates } from "./stream-state.js";
-import { handleCommand } from "./orchestrator.js";
+import { configureSafeMaintenanceRuntime, handleCommand, recoverSafeMaintenanceAfterStartup, } from "./orchestrator.js";
 import { createWechatAdapter, startWechatPlatform } from "./wechat-platform.js";
 import { handleCodexResetCardAction } from "./codex-reset-actions.js";
 import { resolveFeishuCardActionChatType } from "./card-action-routing.js";
@@ -103,11 +103,12 @@ function createFeishuAdapter() {
 }
 const feishuPlatform = createFeishuAdapter();
 const wechatPlatform = createWechatAdapter();
+configureSafeMaintenanceRuntime([feishuPlatform, wechatPlatform]);
 setSessionPlatform(feishuPlatform);
 configureAgentTeamMainAgent(feishuPlatform);
 // 注册队列消费回调：session 生成完成后自动处理缓存消息
 setQueueConsumer((platform, msg) => {
-    handleCommand(platform, msg.text, msg.chatId, msg.openId, msg.msgTimestamp, msg.chatType, msg.traceId).catch(err => console.error(`[${ts()}] Queue consume failed: ${err.message}`));
+    handleCommand(platform, msg.text, msg.chatId, msg.openId, msg.msgTimestamp, msg.chatType, msg.traceId, undefined, true).catch(err => console.error(`[${ts()}] Queue consume failed: ${err.message}`));
 });
 function getInnerEvent(data) {
     return (data.event ?? data);
@@ -596,6 +597,7 @@ async function main() {
             appendStartupTrace(opened ? "web-ui: opening simulate browser" : "web-ui: simulate browser unavailable", { url });
         }
         installShutdownHandlers(simServer, serviceLifecycle);
+        await recoverSafeMaintenanceAfterStartup();
         return;
     }
     if (Number.isNaN(CHATCCC_PORT) || CHATCCC_PORT < 1 || CHATCCC_PORT > 65535) {
@@ -647,6 +649,7 @@ async function main() {
                     });
                     try {
                         await startConfiguredPlatforms(httpServer, { failOnFeishuError: true });
+                        await recoverSafeMaintenanceAfterStartup();
                         return { ok: true };
                     }
                     catch (err) {
@@ -714,6 +717,7 @@ async function main() {
         });
     }
     await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
+    await recoverSafeMaintenanceAfterStartup();
 }
 /**
  * 生命周期健康检查发现 HTTP Server 已停止监听时，优先原地恢复同一个 Server。

package/dist/src/orchestrator.js

@@ -17,7 +17,7 @@ import { CLAUDE_MODEL, GIT_TIMEOUT_MS, PROJECT_ROOT, anthropicConfigDisplay, con
 import { buildHelpCard, buildEffortCard, buildFastModeCard, buildModelCard, buildStatusCard, buildCdContent, buildCdCard, buildSessionsCard, buildQueuedCard, buildQueueFullCard, buildCodexUsageCard, } from "./cards.js";
 import { formatGitResult, gitResultHeaderTemplate, runGitCommand, } from "./git-command.js";
 import { clearSessionModelOverride, clearSessionEffortOverride, getSessionStatus, getAllSessionsStatus, initClaudeSession, lastMsgTimestamps, resumeAndPrompt, sessionInfoMap, setSessionModelOverride, setSessionEffortOverride, switchChatBinding, recordSessionRegistry, getAdapterForTool, getEffectiveModelForTool, getEffectiveEffortForTool, getEffectiveFastModeForTool, setSessionFastModeOverride, stopSession, loadSessionRegistryForBinding, removeSessionRegistryRecord, saveSessionTool, recordChatPlatform, } from "./session.js";
-import { bindChatToSession, unbindChatFromSession, isSessionRunning, displayCards, enqueueMessage, cancelQueuedMessage, } from "./session-chat-binding.js";
+import { bindChatToSession, unbindChatFromSession, isSessionRunning, displayCards, enqueueMessage, cancelQueuedMessage, getSessionDrainSnapshot, } from "./session-chat-binding.js";
 import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.js";
 import { getCursorUsageSummary } from "./cursor-usage.js";
 import { getChatGptSubscriptionStatus } from "./chatgpt-subscription.js";
@@ -25,8 +25,10 @@ import { applySharedPrefix } from "./shared-prefix.js";
 import { sessionChatName } from "./session-name.js";
 import { reloadRuntimeConfig } from "./runtime-reload.js";
 import { acquireUpdateCommandGuard } from "./update-command-guard.js";
-import { createInternalRestartEnv } from "./startup-lifecycle.js";
+import { createInternalRestartEnv, INTERNAL_RESTART_ENV_VAR } from "./startup-lifecycle.js";
 import { resolveChatCccRuntimeSpawnSpec } from "./runtime-entry.js";
+import { engineManager } from "./engines/engine-specs.js";
+import { beginSafeMaintenanceTrackedWork, isSafeMaintenanceAdmissionClosed, safeMaintenanceCoordinator, } from "./safe-maintenance.js";
 import { feishuP2pContactStore, isValidFeishuOpenId, } from "./agent-team/repositories/feishu-p2p-contact-store.js";
 // ---------------------------------------------------------------------------
 // 辅助函数
@@ -577,10 +579,11 @@ function updLog(msg) {
     catch { }
 }
 /** 同步更新 npm 全局包并 spawn 新进程重启。不依赖 systemd 或任何服务管理器。 */
-function syncUpdateAndRestart() {
+function syncUpdateAndRestart(options = {}) {
     updLog(`sync update start, pid=${process.pid}`);
     appendStartupTrace("update: sync update start", { pid: process.pid });
     const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    let updateSucceeded = false;
     // 1. npm update
     updLog(`running: ${npmCmd} update -g chatccc`);
     appendStartupTrace("update: npm update begin", { npmCmd });
@@ -590,6 +593,7 @@ function syncUpdateAndRestart() {
         const elapsed = Date.now() - t0;
         updLog(`npm update OK (${elapsed}ms): ${out.slice(0, 500)}`);
         appendStartupTrace("update: npm update OK", { elapsedMs: elapsed, outputLen: out.length });
+        updateSucceeded = true;
     }
     catch (e) {
         const elapsed = Date.now() - t0;
@@ -605,6 +609,7 @@ function syncUpdateAndRestart() {
             const elapsed2 = Date.now() - t1;
             updLog(`npm install fallback OK (${elapsed2}ms): ${out2.slice(0, 500)}`);
             appendStartupTrace("update: npm install fallback OK", { elapsedMs: elapsed2, outputLen: out2.length });
+            updateSucceeded = true;
         }
         catch (e2) {
             const elapsed2 = Date.now() - t1;
@@ -613,6 +618,11 @@ function syncUpdateAndRestart() {
             appendStartupTrace("update: npm install fallback failed", { elapsedMs: elapsed2, message: err2.message });
         }
     }
+    if (!updateSucceeded && options.spawnOnUpdateFailure === false) {
+        updLog("safe update aborted: both npm update and fallback install failed");
+        appendStartupTrace("update: safe update aborted before restart", {});
+        return undefined;
+    }
     // 2. resolve bin path
     const npmPrefix = process.env.NPM_PREFIX || "";
     const binName = process.platform === "win32" ? "chatccc.cmd" : "chatccc";
@@ -771,15 +781,106 @@ export async function decideRestartParentExit(child, timeoutMs, pollMs = 500, tr
     trace("restart: child alive after window, parent exiting", { childPid: child.pid });
     return true;
 }
+const safeMaintenancePlatforms = new Map();
+export function configureSafeMaintenanceRuntime(platforms) {
+    safeMaintenancePlatforms.clear();
+    for (const platform of platforms) {
+        if (platform.kind)
+            safeMaintenancePlatforms.set(platform.kind, platform);
+    }
+    safeMaintenanceCoordinator.configure({
+        getSnapshot() {
+            const sessions = getSessionDrainSnapshot();
+            return {
+                ...sessions,
+                activeEngineIds: engineManager.getActiveInstallIds(),
+                activeWorkLabels: [],
+            };
+        },
+        execute(kind) {
+            return kind === "update" ? executeSafeUpdate() : executeSafeRestart();
+        },
+        async notify(requester, message) {
+            const platform = safeMaintenancePlatforms.get(requester.platform);
+            if (!platform)
+                throw new Error(`Unavailable platform: ${requester.platform}`);
+            await platform.sendText(requester.chatId, message);
+        },
+    });
+}
+export function recoverSafeMaintenanceAfterStartup() {
+    return safeMaintenanceCoordinator.recoverAfterStartup(process.env[INTERNAL_RESTART_ENV_VAR] === "1");
+}
+async function executeSafeRestart() {
+    fileLog.flush();
+    appendStartupTrace("safe-maintenance: restart spawn begin", { fromPid: process.pid });
+    const child = spawnRestartChild();
+    child.unref();
+    const shouldExit = await decideRestartParentExit(child, RESTART_CHILD_READY_MS);
+    if (!shouldExit)
+        return false;
+    appendStartupTrace("safe-maintenance: restart parent exit", { childPid: child.pid });
+    process.exit(0);
+}
+async function executeSafeUpdate() {
+    fileLog.flush();
+    appendStartupTrace("safe-maintenance: update begin", { fromPid: process.pid });
+    const child = syncUpdateAndRestart({ spawnOnUpdateFailure: false });
+    if (!child)
+        return false;
+    child.unref();
+    const shouldExit = await decideRestartParentExit(child, RESTART_CHILD_READY_MS);
+    if (!shouldExit)
+        return false;
+    appendStartupTrace("safe-maintenance: update parent exit", { childPid: child.pid });
+    process.exit(0);
+}
+function safeMaintenanceRequester(platform, chatId, openId) {
+    return { platform: platform.kind ?? "feishu", chatId, openId };
+}
+function safeMaintenancePhaseLabel(phase) {
+    const labels = {
+        draining: "等待现有任务结束",
+        executing: "正在执行维护",
+        completed: "已完成",
+        failed: "执行失败",
+    };
+    return labels[phase] ?? phase;
+}
+async function safeMaintenanceStatusText() {
+    const status = await safeMaintenanceCoordinator.status();
+    if (!status.job)
+        return "当前没有安全维护预约。";
+    const snapshot = status.snapshot;
+    return [
+        `安全维护：${status.job.kind === "update" ? "更新并重启" : "重启"}`,
+        `状态：${safeMaintenancePhaseLabel(status.job.phase)}`,
+        `执行中/收尾会话：${snapshot.activeSessionIds.length}`,
+        `已接受的缓存消息：${snapshot.queuedSessionIds.length}`,
+        `依赖安装任务：${snapshot.activeEngineIds.length}`,
+        `其他处理中入口：${Math.max(0, snapshot.activeWorkLabels.length - 1)}`,
+        ...(status.job.lastError ? [`错误：${status.job.lastError}`] : []),
+    ].join("\n");
+}
 // ---------------------------------------------------------------------------
 // handleCommand — 平台无关的命令分发
 // ---------------------------------------------------------------------------
-export async function handleCommand(platform, text, chatId, openId, msgTimestamp, chatType = "group", traceId, commandId) {
+export async function handleCommand(platform, text, chatId, openId, msgTimestamp, chatType = "group", traceId, commandId, acceptedBeforeSafeMaintenance = false) {
+    const release = beginSafeMaintenanceTrackedWork(acceptedBeforeSafeMaintenance ? "accepted-queued-message" : "chat-command");
+    try {
+        await handleCommandInternal(platform, text, chatId, openId, msgTimestamp, chatType, traceId, commandId, acceptedBeforeSafeMaintenance);
+    }
+    finally {
+        release();
+    }
+}
+async function handleCommandInternal(platform, text, chatId, openId, msgTimestamp, chatType = "group", traceId, commandId, acceptedBeforeSafeMaintenance = false) {
     const tid = traceId ?? makeTraceId();
     const sharedPrefix = applySharedPrefix(text);
     const promptText = sharedPrefix.text;
     text = sharedPrefix.body;
     const textLower = text.toLowerCase();
+    const normalizedCommandText = textLower.trim().replace(/\s+/g, " ");
     const isCommandText = !sharedPrefix.matched && textLower.startsWith("/");
     recordChatPlatform(chatId, platform);
     if (platform.kind === "feishu" && chatType === "p2p" && isValidFeishuOpenId(openId)) {
@@ -788,6 +889,77 @@ export async function handleCommand(platform, text, chatId, openId, msgTimestamp
             console.error(`[${ts()}] [AGENT-TEAM] Failed to remember Feishu private contact: ${err.message}`);
         });
     }
+    if (isCommandText && normalizedCommandText === "/safestatus") {
+        logTrace(tid, "BRANCH", { cmd: "/safestatus" });
+        await platform.sendText(chatId, await safeMaintenanceStatusText()).catch(() => { });
+        logTrace(tid, "DONE", { outcome: "safe_maintenance_status" });
+        return;
+    }
+    if (isCommandText && normalizedCommandText === "/cancelsf") {
+        logTrace(tid, "BRANCH", { cmd: "/cancelsf" });
+        const canceled = await safeMaintenanceCoordinator.cancel();
+        if (!canceled) {
+            await platform.sendText(chatId, "当前没有可取消的安全维护预约；已经开始执行的维护也不能取消。").catch(() => { });
+        }
+        logTrace(tid, "DONE", { outcome: canceled ? "safe_maintenance_canceled" : "safe_maintenance_cancel_unavailable" });
+        return;
+    }
+    if (isCommandText && normalizedCommandText === "/restart safe") {
+        logTrace(tid, "BRANCH", { cmd: "/restart safe" });
+        try {
+            const job = await safeMaintenanceCoordinator.schedule("restart", safeMaintenanceRequester(platform, chatId, openId));
+            await platform.sendText(chatId, job.phase === "executing"
+                ? "安全维护已经开始执行，无法重复预约。"
+                : job.kind === "update"
+                    ? "已经存在优先级更高的安全更新预约，将继续等待现有任务完成。发送 /safestatus 查看状态，/cancelsf 取消预约。"
+                    : "已预约安全重启。现有会话、缓存消息和依赖安装会先自然完成；现在起不再接受新的普通任务。发送 /safestatus 查看状态，/cancelsf 取消预约。").catch(() => { });
+            logTrace(tid, "DONE", { outcome: "safe_restart_scheduled", jobId: job.jobId });
+        }
+        catch (error) {
+            await platform.sendText(chatId, `安全重启预约失败：${error.message}`).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "safe_restart_schedule_failed", error: error.message });
+        }
+        return;
+    }
+    if (isCommandText && normalizedCommandText === "/update safe") {
+        logTrace(tid, "BRANCH", { cmd: "/update safe" });
+        const isGlobal = isRunningFromGlobalNpm();
+        if (!isGlobal) {
+            await platform.sendText(chatId, "当前进程非 npm 全局安装，无法使用 /update safe。请通过 npm install -g chatccc 安装后使用。").catch(() => { });
+            logTrace(tid, "DONE", { outcome: "safe_update_not_global" });
+            return;
+        }
+        const updateGuard = acquireUpdateCommandGuard({ commandId });
+        if (!updateGuard.allowed) {
+            if (updateGuard.reason !== "duplicate_id") {
+                await platform.sendText(chatId, "无法写入更新保护状态。为避免连续更新和重启，本次 /update safe 未预约。").catch(() => { });
+            }
+            logTrace(tid, "DONE", { outcome: updateGuard.reason === "duplicate_id" ? "safe_update_duplicate_id" : "safe_update_guard_failed" });
+            return;
+        }
+        try {
+            const job = await safeMaintenanceCoordinator.schedule("update", safeMaintenanceRequester(platform, chatId, openId));
+            await platform.sendText(chatId, job.phase === "executing"
+                ? "安全维护已经开始执行，无法重复预约。"
+                : "已预约安全更新。现有会话、缓存消息和依赖安装会先自然完成；现在起不再接受新的普通任务。发送 /safestatus 查看状态，/cancelsf 取消预约。").catch(() => { });
+            logTrace(tid, "DONE", { outcome: "safe_update_scheduled", jobId: job.jobId });
+        }
+        catch (error) {
+            await platform.sendText(chatId, `安全更新预约失败：${error.message}`).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "safe_update_schedule_failed", error: error.message });
+        }
+        return;
+    }
+    const maintenanceAllowedCommands = new Set([
+        "/stop", "/cancel", "/state", "/sessions", "/usage", "/safestatus", "/cancelsf", "/restart", "/update", "/reload", "/help",
+    ]);
+    if (isSafeMaintenanceAdmissionClosed()
+        && !acceptedBeforeSafeMaintenance
+        && (!isCommandText || !maintenanceAllowedCommands.has(normalizedCommandText))) {
+        await platform.sendText(chatId, "ChatCCC 正在等待安全重启或更新，当前不接受新的任务。请在维护完成后重新发送；可用 /safestatus 查看状态。").catch(() => { });
+        logTrace(tid, "DONE", { outcome: "safe_maintenance_admission_closed" });
+        return;
+    }
     if (isCommandText && textLower === "/reload") {
         logTrace(tid, "BRANCH", { cmd: "/reload" });
         try {
@@ -808,6 +980,14 @@ export async function handleCommand(platform, text, chatId, openId, msgTimestamp
     }
     if (isCommandText && textLower === "/restart") {
         logTrace(tid, "BRANCH", { cmd: "/restart" });
+        const safeStatus = await safeMaintenanceCoordinator.status();
+        if (safeStatus.job?.phase === "executing") {
+            await platform.sendText(chatId, "安全维护已经开始执行，请勿重复重启。").catch(() => { });
+            logTrace(tid, "DONE", { outcome: "restart_blocked_by_executing_safe_maintenance" });
+            return;
+        }
+        if (safeStatus.job?.phase === "draining")
+            await safeMaintenanceCoordinator.cancel(false);
         await platform.sendText(chatId, "重启中...请几秒后发消息唤醒我").catch(() => { });
         logTrace(tid, "DONE", { outcome: "restart" });
         appendStartupTrace("restart: spawn begin", { fromPid: process.pid });
@@ -825,6 +1005,12 @@ export async function handleCommand(platform, text, chatId, openId, msgTimestamp
     }
     if (isCommandText && textLower === "/update") {
         logTrace(tid, "BRANCH", { cmd: "/update" });
+        const safeStatus = await safeMaintenanceCoordinator.status();
+        if (safeStatus.job?.phase === "executing") {
+            await platform.sendText(chatId, "安全维护已经开始执行，请勿重复更新。").catch(() => { });
+            logTrace(tid, "DONE", { outcome: "update_blocked_by_executing_safe_maintenance" });
+            return;
+        }
         const isGlobal = isRunningFromGlobalNpm();
         appendStartupTrace("update: command received", { isGlobal, chatId });
         if (!isGlobal) {
@@ -851,6 +1037,8 @@ export async function handleCommand(platform, text, chatId, openId, msgTimestamp
             logTrace(tid, "DONE", { outcome: "update_guard_write_failed" });
             return;
         }
+        if (safeStatus.job?.phase === "draining")
+            await safeMaintenanceCoordinator.cancel(false);
         await platform.sendText(chatId, "正在更新并重启，请稍候...").catch(() => { });
         logTrace(tid, "DONE", { outcome: "update" });
         appendStartupTrace("update: sync update begin", { fromPid: process.pid });

package/dist/src/safe-maintenance.js

@@ -0,0 +1,271 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR } from "./config.js";
+export const SAFE_MAINTENANCE_FILE = join(USER_DATA_DIR, "state", "safe-maintenance.json");
+export const SAFE_MAINTENANCE_STABLE_IDLE_MS = 1_000;
+const EMPTY_SNAPSHOT = {
+    activeSessionIds: [],
+    queuedSessionIds: [],
+    activeEngineIds: [],
+    activeWorkLabels: [],
+};
+export class SafeMaintenanceCoordinator {
+    filePath;
+    now;
+    idFactory;
+    stableIdleMs;
+    pollMs;
+    autoPoll;
+    trackedWork = new Map();
+    runtime = null;
+    job;
+    snapshot = EMPTY_SNAPSHOT;
+    stableSince = null;
+    timer = null;
+    tickRunning = false;
+    constructor(options = {}) {
+        this.filePath = options.filePath ?? SAFE_MAINTENANCE_FILE;
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+        this.stableIdleMs = options.stableIdleMs ?? SAFE_MAINTENANCE_STABLE_IDLE_MS;
+        this.pollMs = options.pollMs ?? 500;
+        this.autoPoll = options.autoPoll ?? true;
+        this.job = readJob(this.filePath);
+    }
+    configure(runtime) {
+        this.runtime = runtime;
+    }
+    isAdmissionClosed() {
+        return this.job?.phase === "draining" || this.job?.phase === "executing";
+    }
+    beginTrackedWork(label) {
+        const id = this.idFactory();
+        this.trackedWork.set(id, label);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.trackedWork.delete(id);
+        };
+    }
+    async schedule(kind, requester) {
+        const now = this.now().toISOString();
+        if (this.job?.phase === "executing")
+            return structuredClone(this.job);
+        const previous = this.job;
+        if (this.job?.phase === "draining") {
+            const requesters = addRequester(this.job.requesters, requester);
+            this.job = {
+                ...this.job,
+                kind: this.job.kind === "update" || kind === "update" ? "update" : "restart",
+                requesters,
+                updatedAt: now,
+            };
+        }
+        else {
+            this.job = {
+                schemaVersion: 1,
+                jobId: this.idFactory(),
+                kind,
+                phase: "draining",
+                requestedAt: now,
+                updatedAt: now,
+                requesters: [requester],
+            };
+        }
+        this.stableSince = null;
+        try {
+            writeJob(this.filePath, this.job);
+        }
+        catch (error) {
+            this.job = previous;
+            throw error;
+        }
+        this.startPolling();
+        return structuredClone(this.job);
+    }
+    async cancel(notify = true) {
+        if (this.job?.phase !== "draining")
+            return false;
+        const requesters = this.job.requesters;
+        removeJob(this.filePath);
+        this.job = null;
+        this.snapshot = EMPTY_SNAPSHOT;
+        this.stableSince = null;
+        this.stopPolling();
+        if (notify)
+            await this.notifyAll(requesters, "已取消安全维护预约，ChatCCC 恢复接受新任务。");
+        return true;
+    }
+    async status() {
+        if (this.runtime && this.isAdmissionClosed())
+            this.snapshot = await this.collectSnapshot();
+        return {
+            job: this.job ? structuredClone(this.job) : null,
+            snapshot: structuredClone(this.snapshot),
+            waitingCount: snapshotCount(this.snapshot),
+        };
+    }
+    async tick() {
+        if (this.tickRunning || this.job?.phase !== "draining" || !this.runtime)
+            return;
+        this.tickRunning = true;
+        try {
+            this.snapshot = await this.collectSnapshot();
+            if (snapshotCount(this.snapshot) > 0) {
+                this.stableSince = null;
+                return;
+            }
+            const nowMs = this.now().getTime();
+            if (this.stableSince === null) {
+                this.stableSince = nowMs;
+                return;
+            }
+            if (nowMs - this.stableSince < this.stableIdleMs)
+                return;
+            await this.executeCurrentJob();
+        }
+        finally {
+            this.tickRunning = false;
+        }
+    }
+    async recoverAfterStartup(internalRestart) {
+        if (!this.job || !this.runtime)
+            return;
+        if (this.job.phase === "draining") {
+            this.startPolling();
+            await this.notifyAll(this.job.requesters, "ChatCCC 已恢复未完成的安全维护预约，继续等待现有任务结束。");
+            return;
+        }
+        if (this.job.phase !== "executing")
+            return;
+        if (internalRestart) {
+            const completed = { ...this.job, phase: "completed", updatedAt: this.now().toISOString() };
+            writeJob(this.filePath, completed);
+            this.job = completed;
+            await this.notifyAll(this.job.requesters, this.job.kind === "update" ? "ChatCCC 已安全更新并重新启动。" : "ChatCCC 已安全重新启动。");
+            return;
+        }
+        const message = "安全维护执行期间进程意外退出；为避免重启循环，未自动重试。";
+        const failed = {
+            ...this.job,
+            phase: "failed",
+            updatedAt: this.now().toISOString(),
+            lastError: message,
+        };
+        writeJob(this.filePath, failed);
+        this.job = failed;
+        await this.notifyAll(this.job.requesters, message);
+    }
+    async collectSnapshot() {
+        const external = await this.runtime.getSnapshot();
+        return {
+            activeSessionIds: [...external.activeSessionIds],
+            queuedSessionIds: [...external.queuedSessionIds],
+            activeEngineIds: [...external.activeEngineIds],
+            activeWorkLabels: [...external.activeWorkLabels, ...this.trackedWork.values()],
+        };
+    }
+    async executeCurrentJob() {
+        if (!this.job || !this.runtime)
+            return;
+        const executing = { ...this.job, phase: "executing", updatedAt: this.now().toISOString() };
+        writeJob(this.filePath, executing);
+        this.job = executing;
+        this.stopPolling();
+        const label = this.job.kind === "update" ? "更新并重启" : "重启";
+        await this.notifyAll(this.job.requesters, `现有任务已全部完成，开始安全${label}。`);
+        const started = await this.runtime.execute(this.job.kind).catch(async (error) => {
+            await this.markFailed(error instanceof Error ? error.message : String(error));
+            return false;
+        });
+        if (!started && this.job?.phase === "executing") {
+            await this.markFailed(`安全${label}未能启动，当前进程将继续提供服务。`);
+        }
+    }
+    async markFailed(message) {
+        if (!this.job)
+            return;
+        const failed = {
+            ...this.job,
+            phase: "failed",
+            updatedAt: this.now().toISOString(),
+            lastError: message,
+        };
+        writeJob(this.filePath, failed);
+        this.job = failed;
+        await this.notifyAll(this.job.requesters, message);
+    }
+    startPolling() {
+        if (!this.autoPoll || this.timer || this.job?.phase !== "draining")
+            return;
+        this.timer = setInterval(() => { void this.tick(); }, this.pollMs);
+        this.timer.unref?.();
+    }
+    stopPolling() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    async notifyAll(requesters, message) {
+        if (!this.runtime)
+            return;
+        await Promise.all(requesters.map((requester) => this.runtime.notify(requester, message).catch(() => { })));
+    }
+}
+function snapshotCount(snapshot) {
+    return snapshot.activeSessionIds.length
+        + snapshot.queuedSessionIds.length
+        + snapshot.activeEngineIds.length
+        + snapshot.activeWorkLabels.length;
+}
+function addRequester(requesters, requester) {
+    if (requesters.some((item) => item.platform === requester.platform && item.chatId === requester.chatId))
+        return requesters;
+    return [...requesters, requester];
+}
+function readJob(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(filePath, "utf8"));
+        if (value.schemaVersion !== 1 || !value.jobId || !Array.isArray(value.requesters))
+            return null;
+        if (!["restart", "update"].includes(value.kind) || !["draining", "executing", "completed", "failed"].includes(value.phase))
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeJob(filePath, job) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(job, null, 2)}\n`, "utf8");
+        renameSync(temporary, filePath);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function removeJob(filePath) {
+    rmSync(filePath, { force: true });
+}
+export let safeMaintenanceCoordinator = new SafeMaintenanceCoordinator();
+export function _setSafeMaintenanceCoordinatorForTest(coordinator) {
+    safeMaintenanceCoordinator = coordinator;
+}
+export function _resetSafeMaintenanceCoordinatorForTest() {
+    safeMaintenanceCoordinator = new SafeMaintenanceCoordinator();
+}
+export function isSafeMaintenanceAdmissionClosed() {
+    return safeMaintenanceCoordinator.isAdmissionClosed();
+}
+export function beginSafeMaintenanceTrackedWork(label) {
+    return safeMaintenanceCoordinator.beginTrackedWork(label);
+}

package/dist/src/session-chat-binding.js

@@ -133,6 +133,18 @@ export function setUnifiedDisplayLoopHandle(h) {
     unifiedDisplayLoopHandle = h;
 }
 export const queuedMessages = new Map();
+/** Includes prompt execution, finalization, auto-recovery reservations, and accepted queues. */
+export function getSessionDrainSnapshot() {
+    const active = new Set([
+        ...activePrompts.keys(),
+        ...finalizingSessions,
+        ...autoRecoveryReservations,
+    ]);
+    return {
+        activeSessionIds: [...active].sort(),
+        queuedSessionIds: [...queuedMessages.keys()].sort(),
+    };
+}
 export function enqueueMessage(sessionId, msg) {
     if (queuedMessages.has(sessionId))
         return false;

package/dist/src/session.js

@@ -6,6 +6,7 @@ import { progressView } from "./progress/view.js";
 import { createAgentActivityTracker, formatAgentActivityTitle, updateAgentActivity, } from "./agent-activity.js";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.js";
 import { logTrace } from "./trace.js";
+import { appendExecutionTranscriptBlock, } from "./execution-transcript.js";
 import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCursorAdapter } from "./adapters/cursor-adapter.js";
 import { createCodexAdapter } from "./adapters/codex-adapter.js";
@@ -698,6 +699,11 @@ export function pickFinalReply(state) {
     return state.finalCompleteText || state.finalText;
 }
 export function accumulateBlockContent(block, state, toolCallMap) {
+    if (state.transcript !== undefined || (block.type !== "agent_progress" && block.type !== "text_reset")) {
+        const transcriptState = { transcript: state.transcript ?? [] };
+        appendExecutionTranscriptBlock(block, transcriptState);
+        state.transcript = transcriptState.transcript;
+    }
     switch (block.type) {
         case "thinking":
             state.chunkCount++;
@@ -1145,6 +1151,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
     refreshBusySessionAvatar(sessionId, tool, platform).catch(() => { });
     const state = {
         accumulatedContent: "",
+        transcript: [],
         finalText: "",
         finalCompleteText: "",
         chunkCount: 0,
@@ -1196,6 +1203,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 status: "auto_ended",
                 accumulatedContent: state.accumulatedContent,
                 finalReply: pickFinalReply(state).trim(),
+                transcript: state.transcript,
                 activity: activityTracker.activity,
                 chunkCount: state.chunkCount,
                 turnCount: nextTurnCount,
@@ -1308,6 +1316,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                     status: "running",
                     accumulatedContent: state.accumulatedContent,
                     finalReply: pickFinalReply(state),
+                    transcript: state.transcript,
                     activity: activityTracker.activity,
                     chunkCount: state.chunkCount,
                     turnCount: nextTurnCount,
@@ -1406,6 +1415,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 status: finalStatus,
                 accumulatedContent: state.accumulatedContent,
                 finalReply: finalReplyToWrite,
+                transcript: state.transcript,
                 activity: activityTracker.activity,
                 chunkCount: state.chunkCount,
                 turnCount: nextTurnCount,