chatccc 0.2.279 → 0.2.281

package/README.md

@@ -430,7 +430,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/cd` | 查看或设置后续新建会话的默认工作目录，不改变当前会话；飞书私聊自身始终使用系统用户目录 |
 | `/sessions` | 查看所有会话状态 |
 | `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话；飞书私聊不支持切换 |
-| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，主动重置次数查询失败时会明确展示上次成功快照及其查询时间（缓存结果不提供重置按钮）；Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
 | `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
 | `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
@@ -446,6 +446,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 `/update`、`/update safe` 与短别名 `/updatesf` 会把飞书消息或按钮事件 ID 原子写入 `~/.chatccc/state/update-command-guard.json`。同一 ID 跨重启重投时会静默忽略；用户主动发送的新更新指令因事件 ID 不同，仍可执行。该保护不改变普通消息与重启指令的处理方式。
 
 `/restart safe`（短别名 `/restartsf`）与 `/update safe`（短别名 `/updatesf`）会先建立全局准入门禁：指令到达前已经运行或进入单会话缓存队列的工作会继续完成，之后到达的新普通任务会被提示在维护完成后重发。维护任务持久化到 `~/.chatccc/state/safe-maintenance.json`，进程意外退出后可继续排空；依赖安装、会话收尾、自动恢复和 Agent Teams 执行也计入等待条件。内存缓存随重启自然重建，磁盘会话、看板、图片等持久数据不会被清理。
+
+ChatCCC 的内部重启和更新使用跨平台父子进程握手：替代进程完成启动预检后通知父进程退出，再等待旧监听端口实际释放并接管 PID；替代进程未就绪或握手超时时，父进程会保留并继续服务。
 
 > **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
 

package/dist/src/codex-reset-credits-cache.js

@@ -0,0 +1,105 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR } from "./config.js";
+const CACHE_FILE = join(USER_DATA_DIR, "state", "codex-reset-credits.json");
+let mutationQueue = Promise.resolve();
+export function codexResetCreditsAccountKey(accountId, accessToken) {
+    if (accountId?.trim())
+        return `account:${accountId.trim()}`;
+    const digest = createHash("sha256").update(accessToken).digest("hex").slice(0, 24);
+    return `token-sha256:${digest}`;
+}
+function emptyCache() {
+    return { version: 1, accounts: {} };
+}
+function normalizeSnapshot(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const value = raw;
+    const availableCount = Number(value.availableCount);
+    if (!Number.isFinite(availableCount) || typeof value.queriedAt !== "string" || !value.queriedAt.trim())
+        return null;
+    const credits = Array.isArray(value.credits)
+        ? value.credits.flatMap((credit) => {
+            if (!credit || typeof credit !== "object")
+                return [];
+            const item = credit;
+            if (typeof item.expiresAt !== "string" || !item.expiresAt.trim())
+                return [];
+            return [{
+                    grantedAt: typeof item.grantedAt === "string" && item.grantedAt.trim() ? item.grantedAt : null,
+                    expiresAt: item.expiresAt,
+                }];
+        })
+        : [];
+    return {
+        availableCount: Math.max(0, Math.trunc(availableCount)),
+        credits,
+        queriedAt: value.queriedAt,
+        locallyAdjusted: value.locallyAdjusted === true,
+    };
+}
+async function readCache() {
+    try {
+        const parsed = JSON.parse(await readFile(CACHE_FILE, "utf-8"));
+        const accounts = {};
+        if (parsed.accounts && typeof parsed.accounts === "object") {
+            for (const [key, raw] of Object.entries(parsed.accounts)) {
+                const snapshot = normalizeSnapshot(raw);
+                if (snapshot)
+                    accounts[key] = snapshot;
+            }
+        }
+        return { version: 1, accounts };
+    }
+    catch {
+        return emptyCache();
+    }
+}
+async function writeCache(cache) {
+    await mkdir(dirname(CACHE_FILE), { recursive: true });
+    const tempFile = `${CACHE_FILE}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tempFile, JSON.stringify(cache, null, 2), "utf-8");
+    try {
+        await rename(tempFile, CACHE_FILE);
+    }
+    catch {
+        await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+        await rm(tempFile, { force: true }).catch(() => { });
+    }
+}
+async function mutateCache(mutate) {
+    const operation = mutationQueue.then(async () => {
+        const cache = await readCache();
+        mutate(cache);
+        await writeCache(cache);
+    });
+    mutationQueue = operation.catch(() => { });
+    return operation;
+}
+export async function readCodexResetCreditsSnapshot(accountKey) {
+    return (await readCache()).accounts[accountKey] ?? null;
+}
+export async function saveCodexResetCreditsSnapshot(accountKey, snapshot) {
+    await mutateCache((cache) => {
+        cache.accounts[accountKey] = {
+            ...snapshot,
+            availableCount: Math.max(0, Math.trunc(snapshot.availableCount)),
+            locallyAdjusted: false,
+        };
+    });
+}
+export async function decrementCachedCodexResetCredits(accountKey) {
+    await mutateCache((cache) => {
+        const current = cache.accounts[accountKey];
+        if (!current)
+            return;
+        cache.accounts[accountKey] = {
+            ...current,
+            availableCount: Math.max(0, current.availableCount - 1),
+            credits: current.credits.slice(1),
+            locallyAdjusted: true,
+        };
+    });
+}

package/dist/src/feishu-api.js

@@ -6,6 +6,7 @@ import sharp from "sharp";
 import { APP_ID, APP_SECRET, BASE_URL, CHAT_LOGS_DIR, PROJECT_ROOT, USER_DATA_DIR, CLAUDE_SESSION_PREFIX, CURSOR_SESSION_PREFIX, CODEX_SESSION_PREFIX, CCC_SESSION_PREFIX, DSH_SESSION_PREFIX, ts, resolveDefaultAgentTool, toolDisplayName, config, } from "./config.js";
 import { getCursorUsageSummary } from "./cursor-usage.js";
 import { applyPrivacy } from "./privacy.js";
+import { codexResetCreditsAccountKey, decrementCachedCodexResetCredits, readCodexResetCreditsSnapshot, saveCodexResetCreditsSnapshot, } from "./codex-reset-credits-cache.js";
 import { buildHelpCard } from "./cards.js";
 // ---------------------------------------------------------------------------
 // Auth
@@ -366,9 +367,6 @@ async function getCodexAuth() {
         return null;
     }
 }
-async function getCodexAccessToken() {
-    return (await getCodexAuth())?.accessToken ?? null;
-}
 function codexAuthHeaders(auth) {
     const headers = {
         Authorization: `Bearer ${auth.accessToken}`,
@@ -399,26 +397,42 @@ function parseCodexResetCreditDetails(data) {
         }),
     };
 }
+const codexResetCreditsInFlight = new Map();
 async function fetchCodexRateLimitResetCredits(auth) {
-    try {
-        const resp = await fetch(CODEX_RESET_CREDITS_URL, {
-            headers: codexAuthHeaders(auth),
-        });
-        const text = await resp.text();
-        if (!resp.ok)
-            throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-        return parseCodexResetCreditDetails(JSON.parse(text));
-    }
-    catch (err) {
-        console.warn(`[Codex] reset credits lookup failed: ${err.message}`);
-        return null;
-    }
+    const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+    const existing = codexResetCreditsInFlight.get(accountKey);
+    if (existing)
+        return existing;
+    const lookup = (async () => {
+        try {
+            const resp = await fetch(CODEX_RESET_CREDITS_URL, {
+                headers: codexAuthHeaders(auth),
+            });
+            const text = await resp.text();
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+            return {
+                details: parseCodexResetCreditDetails(JSON.parse(text)),
+                error: null,
+            };
+        }
+        catch (err) {
+            const error = err.message;
+            console.warn(`[Codex] reset credits lookup failed: ${error}`);
+            return { details: null, error };
+        }
+    })().finally(() => {
+        codexResetCreditsInFlight.delete(accountKey);
+    });
+    codexResetCreditsInFlight.set(accountKey, lookup);
+    return lookup;
 }
-export async function getCodexUsageSummary() {
+export async function getCodexUsageSummary(options = {}) {
     const auth = await getCodexAuth();
     if (!auth)
         throw new Error("missing ~/.codex/auth.json access token");
-    const resetCreditsPromise = fetchCodexRateLimitResetCredits(auth);
+    const includeResetCredits = options.includeResetCredits !== false;
+    const resetCreditsPromise = includeResetCredits ? fetchCodexRateLimitResetCredits(auth) : null;
     const resp = await fetch(CODEX_USAGE_URL, {
         headers: { Authorization: `Bearer ${auth.accessToken}` },
     });
@@ -443,24 +457,77 @@ export async function getCodexUsageSummary() {
         ?? (primaryWindow?.limitWindowSeconds === undefined ? primaryWindow : null);
     const weekly = windows.find((window) => isUsageWindowDuration(window, SEVEN_DAY_WINDOW_SECONDS))
         ?? (secondaryWindow?.limitWindowSeconds === undefined ? secondaryWindow : null);
-    const resetCredits = await resetCreditsPromise;
+    if (!includeResetCredits) {
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: null,
+            rateLimitResetCredits: null,
+            rateLimitResetCreditsSource: "not_requested",
+            rateLimitResetCreditsQueriedAt: null,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: null,
+        };
+    }
+    const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+    const resetLookup = await resetCreditsPromise;
+    const embeddedAvailableCount = parseRateLimitResetCredits(data);
+    const liveAvailableCount = resetLookup.details?.availableCount ?? embeddedAvailableCount;
+    if (liveAvailableCount !== null) {
+        const queriedAt = new Date().toISOString();
+        const liveCredits = resetLookup.details?.availableCredits ?? [];
+        await saveCodexResetCreditsSnapshot(accountKey, {
+            availableCount: liveAvailableCount,
+            credits: liveCredits,
+            queriedAt,
+        }).catch((err) => {
+            console.warn(`[Codex] reset credits snapshot write failed: ${err.message}`);
+        });
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: liveAvailableCount,
+            rateLimitResetCredits: liveCredits,
+            rateLimitResetCreditsSource: "live",
+            rateLimitResetCreditsQueriedAt: queriedAt,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: null,
+        };
+    }
+    const cached = await readCodexResetCreditsSnapshot(accountKey);
+    if (cached) {
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: cached.availableCount,
+            rateLimitResetCredits: cached.credits,
+            rateLimitResetCreditsSource: "cache",
+            rateLimitResetCreditsQueriedAt: cached.queriedAt,
+            rateLimitResetCreditsLocallyAdjusted: cached.locallyAdjusted,
+            rateLimitResetCreditsError: resetLookup.error ?? "OpenAI returned no reset-credit data",
+        };
+    }
     return {
         fiveHour,
         weekly,
-        rateLimitResetCreditsAvailable: resetCredits?.availableCount ?? parseRateLimitResetCredits(data),
-        rateLimitResetCredits: resetCredits?.availableCredits ?? null,
+        rateLimitResetCreditsAvailable: null,
+        rateLimitResetCredits: null,
+        rateLimitResetCreditsSource: "unavailable",
+        rateLimitResetCreditsQueriedAt: null,
+        rateLimitResetCreditsLocallyAdjusted: false,
+        rateLimitResetCreditsError: resetLookup.error ?? "OpenAI returned no reset-credit data",
     };
 }
 export async function consumeCodexRateLimitResetCredit(redeemRequestId) {
     if (!redeemRequestId.trim())
         throw new Error("missing redeem_request_id");
-    const token = await getCodexAccessToken();
-    if (!token)
+    const auth = await getCodexAuth();
+    if (!auth)
         throw new Error("missing ~/.codex/auth.json access token");
     const resp = await fetch(CODEX_RESET_CONSUME_URL, {
         method: "POST",
         headers: {
-            Authorization: `Bearer ${token}`,
+            Authorization: `Bearer ${auth.accessToken}`,
             "Content-Type": "application/json",
         },
         body: JSON.stringify({ redeem_request_id: redeemRequestId }),
@@ -477,10 +544,17 @@ export async function consumeCodexRateLimitResetCredit(redeemRequestId) {
         throw new Error("missing or unknown reset result code");
     }
     const windowsReset = Number(data.windows_reset);
-    return {
+    const result = {
         code,
         windowsReset: Number.isFinite(windowsReset) ? Math.max(0, Math.trunc(windowsReset)) : 0,
     };
+    if (result.code === "reset") {
+        const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+        await decrementCachedCodexResetCredits(accountKey).catch((err) => {
+            console.warn(`[Codex] reset credits snapshot update failed: ${err.message}`);
+        });
+    }
+    return result;
 }
 async function resolveCodexAvatarUsage(usageHint) {
     if (usageHint !== undefined) {
@@ -489,7 +563,7 @@ async function resolveCodexAvatarUsage(usageHint) {
         return usageHint;
     }
     try {
-        const summary = await getCodexUsageSummary();
+        const summary = await getCodexUsageSummary({ includeResetCredits: false });
         if (!summary.weekly)
             throw new Error("missing weekly usage window");
         return summary;

package/dist/src/index.js

@@ -27,7 +27,7 @@ import WebSocket from "ws";
 import { appendStartupTrace, attachRelayWebSocket, ensureSingleInstance, freeRelayListenPort, installCrashLogging, installEpipeGuard, waitForPortFree } from "./shared.js";
 import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.js";
 import { configureAgentTeamMainAgent } from "./agent-team/main-agent-bootstrap.js";
-import { buildWebUiUrl, createServiceLifecycleGuard, INTERNAL_RESTART_ENV_VAR, openWebUiInDefaultBrowser, shouldAutoOpenWebUi, } from "./startup-lifecycle.js";
+import { buildWebUiUrl, createServiceLifecycleGuard, announceInternalRestartReady, INTERNAL_RESTART_ENV_VAR, openWebUiInDefaultBrowser, shouldAutoOpenWebUi, } from "./startup-lifecycle.js";
 import { buildPlatformStartupPlan } from "./platform-startup.js";
 import { makeTraceId, logTrace } from "./trace.js";
 import { CHATCCC_PORT, config, APP_ID, APP_SECRET, FEISHU_ENABLED, FEISHU_PLATFORM_TYPE, ILINK_ENABLED, ILINK_REUSE_TOKEN_ON_START, BASE_URL, LOCAL_RELAY_URL, PID_FILE, PROJECT_ROOT, USE_LOCAL, USE_SIMULATE, appendChatLog, fileLog, reportEnvironmentVariableReadout, maskAppId, resolveDefaultAgentTool, toolDisplayName, ts, } from "./config.js";
@@ -609,6 +609,23 @@ async function main() {
         printServiceDidNotStart("config.json 的 port 字段配置无效（须为 1–65535 的整数）");
         process.exit(1);
     }
+    const isInternalRestart = process.env[INTERNAL_RESTART_ENV_VAR] === "1";
+    if (isInternalRestart) {
+        const announced = await announceInternalRestartReady();
+        appendStartupTrace("restart-handoff: replacement preflight ready", {
+            announced,
+            port: CHATCCC_PORT,
+        });
+        const portReleased = await waitForPortFree(CHATCCC_PORT, 30_000);
+        appendStartupTrace("restart-handoff: parent port wait finished", {
+            port: CHATCCC_PORT,
+            portReleased,
+        });
+        if (!portReleased) {
+            printServiceDidNotStart(`内部重启交接超时：端口 ${CHATCCC_PORT} 在 30 秒内未释放`);
+            process.exit(1);
+        }
+    }
     console.log(`\n[启动 1/7] 单实例：按 PID 文件清理旧 ChatCCC 进程`);
     console.log(`  PID 文件: ${PID_FILE}`);
     appendStartupTrace("main: before ensureSingleInstance", { PID_FILE, CHATCCC_PORT });
@@ -680,14 +697,15 @@ async function main() {
     // 启动 HTTP server（同时挂 UI router，供 dashboard / setup / agent image/file 使用）
     appendStartupTrace("main: before freeRelayListenPort", { CHATCCC_PORT });
     const killed = freeRelayListenPort(CHATCCC_PORT);
-    const isInternalRestart = process.env[INTERNAL_RESTART_ENV_VAR] === "1";
     appendStartupTrace("main: after freeRelayListenPort", { CHATCCC_PORT, killed, isInternalRestart });
-    // 内部自重启（/restart、/update）时父进程还占着端口（祖先链 PID 不会被杀）：
-    // 无条件等待端口释放再 listen，避免子进程一上来就 EADDRINUSE 秒退
-    // （Windows 端口释放有额外延迟，重试窗口容易不够）。
-    if (killed > 0 || isInternalRestart) {
-        await waitForPortFree(CHATCCC_PORT, isInternalRestart ? 5000 : undefined);
-        appendStartupTrace("main: port free confirmed", { CHATCCC_PORT, isInternalRestart });
+    // 普通启动清理过旧实例后，也必须确认端口真正释放再继续监听。
+    if (killed > 0) {
+        const portReleased = await waitForPortFree(CHATCCC_PORT, 5_000);
+        appendStartupTrace("main: post-kill port wait finished", { CHATCCC_PORT, portReleased });
+        if (!portReleased) {
+            printServiceDidNotStart(`旧进程退出后端口 ${CHATCCC_PORT} 在 5 秒内仍未释放`);
+            process.exit(1);
+        }
     }
     const httpServer = createServer(createUiRouter());
     await listenWithRetry(httpServer, CHATCCC_PORT, "127.0.0.1").catch((err) => {

package/dist/src/orchestrator.js

@@ -6,7 +6,7 @@
  */
 import { execSync, spawn } from "node:child_process";
 import { readdir, stat } from "node:fs/promises";
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
+import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
 import { join, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
 import { config as deepCccConfig } from "../deepccc-agent/src/config.js";
@@ -25,7 +25,7 @@ import { applySharedPrefix } from "./shared-prefix.js";
 import { normalizeSessionDisplayTitle, sessionChatName, sessionDisplayTitleFromPrompt, } from "./session-name.js";
 import { reloadRuntimeConfig } from "./runtime-reload.js";
 import { acquireUpdateCommandGuard } from "./update-command-guard.js";
-import { createInternalRestartEnv, INTERNAL_RESTART_ENV_VAR } from "./startup-lifecycle.js";
+import { createInternalRestartEnv, INTERNAL_RESTART_ENV_VAR, INTERNAL_RESTART_READY_MESSAGE, } 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";
@@ -100,33 +100,69 @@ function formatCodexUsageSummary(usage, chatGptSubscription = null) {
         ].join("\n");
     };
     const formatResetCredits = () => {
+        const formatDateTime = (value) => {
+            const date = new Date(value);
+            if (!Number.isFinite(date.getTime()))
+                return value;
+            const pad = (part) => String(part).padStart(2, "0");
+            return [
+                date.getFullYear(),
+                "-",
+                pad(date.getMonth() + 1),
+                "-",
+                pad(date.getDate()),
+                " ",
+                pad(date.getHours()),
+                ":",
+                pad(date.getMinutes()),
+                ":",
+                pad(date.getSeconds()),
+            ].join("");
+        };
+        const failureReason = () => {
+            const raw = usage.rateLimitResetCreditsError?.replace(/\s+/g, " ").trim();
+            if (!raw)
+                return "OpenAI 未返回主动重置数据";
+            if (/HTTP 429/i.test(raw))
+                return "OpenAI 返回 HTTP 429（请求受限）";
+            if (/HTTP 404/i.test(raw))
+                return "OpenAI 返回 HTTP 404（接口暂不可用）";
+            return raw.length > 180 ? `${raw.slice(0, 180)}...` : raw;
+        };
+        const source = usage.rateLimitResetCreditsSource ?? "live";
+        if (source === "unavailable") {
+            return [
+                `**主动重置:** 本次查询失败（${failureReason()}）`,
+                "- 没有可用的历史缓存结果",
+            ].join("\n");
+        }
+        if (source === "cache") {
+            const lines = [
+                `**主动重置:** 本次查询失败（${failureReason()}）`,
+                `**上次缓存结果:** 剩余 ${usage.rateLimitResetCreditsAvailable ?? 0} 次`,
+            ];
+            if (usage.rateLimitResetCreditsQueriedAt) {
+                lines.push(`- 查询时间: ${formatDateTime(usage.rateLimitResetCreditsQueriedAt)}`);
+            }
+            if (usage.rateLimitResetCreditsLocallyAdjusted) {
+                lines.push("- 状态: 本地推算，待下次查询确认");
+            }
+            const credits = usage.rateLimitResetCredits ?? [];
+            if (credits.length > 0) {
+                lines.push("**缓存中的过期时间:**");
+                for (const credit of credits)
+                    lines.push(`- ${formatDateTime(credit.expiresAt)}`);
+            }
+            return lines.join("\n");
+        }
         if (usage.rateLimitResetCreditsAvailable === null)
             return "**主动重置:** 暂无数据";
         const lines = [`**主动重置:** 剩余 ${usage.rateLimitResetCreditsAvailable} 次`];
         const credits = usage.rateLimitResetCredits ?? [];
         if (credits.length > 0) {
-            const pad = (value) => String(value).padStart(2, "0");
-            const formatExpiresAt = (value) => {
-                const date = new Date(value);
-                if (!Number.isFinite(date.getTime()))
-                    return value;
-                return [
-                    date.getFullYear(),
-                    "-",
-                    pad(date.getMonth() + 1),
-                    "-",
-                    pad(date.getDate()),
-                    " ",
-                    pad(date.getHours()),
-                    ":",
-                    pad(date.getMinutes()),
-                    ":",
-                    pad(date.getSeconds()),
-                ].join("");
-            };
             lines.push("**过期时间:**");
             for (const credit of credits) {
-                lines.push(`- ${formatExpiresAt(credit.expiresAt)}`);
+                lines.push(`- ${formatDateTime(credit.expiresAt)}`);
             }
         }
         return lines.join("\n");
@@ -397,7 +433,11 @@ async function sendUsageSummary(platform, chatId, tool, avatarStatus = "idle", s
         await platform.sendText(chatId, content).catch(() => { });
     }
     else if (platform.kind === "feishu") {
-        await platform.sendRawCard(chatId, buildCodexUsageCard(content, usage.rateLimitResetCreditsAvailable));
+        const liveResetCredits = usage.rateLimitResetCreditsSource === undefined
+            || usage.rateLimitResetCreditsSource === "live"
+            ? usage.rateLimitResetCreditsAvailable
+            : null;
+        await platform.sendRawCard(chatId, buildCodexUsageCard(content, liveResetCredits));
     }
     else {
         await platform.sendCard(chatId, "Codex Usage", content, "blue");
@@ -638,41 +678,18 @@ function syncUpdateAndRestart(options = {}) {
         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";
-    const binPath = npmPrefix ? join(npmPrefix, binName) : "chatccc";
-    updLog(`bin path: npmPrefix=${npmPrefix || "(empty)"}, binPath=${binPath}`);
-    appendStartupTrace("update: spawn begin", { npmPrefix: npmPrefix || "(empty)", binPath });
-    // 3. spawn new chatccc：优先 node + 全局包入口绝对路径（不依赖 PATH/shell），
-    //    避免继承环境 PATH 异常时秒退；失败时回退到 binPath（走 shell）。
+    // 2. Spawn the updated runtime directly through Node. Reusing the restart
+    // launcher guarantees an IPC handoff channel and avoids shell/PATH variance.
+    const spawnSpec = buildRestartSpawnSpec(PROJECT_ROOT);
+    updLog(`runtime path: ${spawnSpec.command} ${spawnSpec.args.join(" ")}`);
+    appendStartupTrace("update: spawn begin", { runtimeEntry: spawnSpec.args[0] });
     try {
-        let spawnSpec = null;
-        if (npmPrefix) {
-            const entry = join(npmPrefix, "node_modules", "chatccc", "bin", "chatccc.mjs");
-            if (existsSync(entry)) {
-                spawnSpec = { command: process.execPath, args: [entry] };
-            }
-        }
-        const child = spawnSpec
-            ? spawn(spawnSpec.command, spawnSpec.args, {
-                detached: true,
-                stdio: "ignore",
-                shell: false,
-                env: createInternalRestartEnv(),
-            })
-            : spawn(binPath, [], {
-                detached: true,
-                stdio: "ignore",
-                shell: true,
-                env: createInternalRestartEnv(),
-            });
+        const child = spawnRestartChild({ projectRoot: PROJECT_ROOT });
         child.unref();
-        const spawnedAs = spawnSpec ? `${spawnSpec.command} ${spawnSpec.args.join(" ")}` : binPath;
-        updLog(`spawn new chatccc OK, childPid=${child.pid}, bin=${spawnedAs}`);
+        updLog(`spawn new chatccc OK, childPid=${child.pid}, bin=${spawnSpec.command} ${spawnSpec.args.join(" ")}`);
         appendStartupTrace("update: spawn OK", {
             childPid: child.pid,
-            binPath: spawnSpec ? spawnSpec.args[0] : binPath,
+            binPath: spawnSpec.args[0],
         });
         return child;
     }
@@ -686,8 +703,8 @@ function syncUpdateAndRestart(options = {}) {
 // ---------------------------------------------------------------------------
 // /restart — 自重启子进程（不经过 npx/npm，避免 PATH 注入秒退；防空窗兜底）
 // ---------------------------------------------------------------------------
-/** 父进程等待子进程稳定启动的时间窗口（毫秒）。 */
-export const RESTART_CHILD_READY_MS = 3000;
+/** 父进程等待替代进程通过 IPC 完成启动预检的最长时间（毫秒）。 */
+export const RESTART_CHILD_READY_MS = 15_000;
 /**
  * 构建自重启的 spawn 参数：发布包直接运行编译后的 JavaScript；只有尚未
  * build 的开发工作区才使用本地 tsx CLI。两种情况都不经过 npx/npm。
@@ -695,12 +712,64 @@ export const RESTART_CHILD_READY_MS = 3000;
 export function buildRestartSpawnSpec(projectRoot = PROJECT_ROOT) {
     return resolveChatCccRuntimeSpawnSpec(projectRoot);
 }
+const restartHandoffMonitors = new WeakMap();
+function getOrCreateRestartHandoffMonitor(child) {
+    const existing = restartHandoffMonitors.get(child);
+    if (existing)
+        return existing;
+    if (typeof child.on !== "function") {
+        const unavailable = { promise: Promise.resolve({ kind: "no_ipc" }), cancel() { } };
+        restartHandoffMonitors.set(child, unavailable);
+        return unavailable;
+    }
+    const addListener = child.on.bind(child);
+    const removeListener = typeof child.off === "function"
+        ? child.off.bind(child)
+        : undefined;
+    let resolveOutcome = () => { };
+    let settled = false;
+    const cleanup = () => {
+        removeListener?.("message", onMessage);
+        removeListener?.("exit", onExit);
+        removeListener?.("error", onError);
+    };
+    const settle = (outcome) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        resolveOutcome(outcome);
+    };
+    const onMessage = (message) => {
+        const ready = message;
+        if (!ready || ready.type !== INTERNAL_RESTART_READY_MESSAGE)
+            return;
+        if (typeof ready.pid === "number" && child.pid !== undefined && ready.pid !== child.pid)
+            return;
+        if (ready.parentPid !== process.pid)
+            return;
+        settle({ kind: "ready" });
+    };
+    const onExit = () => settle({ kind: "exit" });
+    const onError = (error) => settle({ kind: "error", error });
+    const promise = new Promise((resolve) => {
+        resolveOutcome = resolve;
+    });
+    const monitor = { promise, cancel: cleanup };
+    restartHandoffMonitors.set(child, monitor);
+    addListener("message", onMessage);
+    addListener("exit", onExit);
+    addListener("error", onError);
+    if (child.exitCode !== null || child.signalCode !== null)
+        settle({ kind: "exit" });
+    return monitor;
+}
 /**
  * spawn 自重启子进程。
  *
  * stdout/stderr 按启动方式分流：
  * - **终端（TTY）场景**（用户从 cmd/PowerShell/node.exe 窗口启动）：stdio 用
- *   ["ignore", "inherit", "inherit"] 直接继承终端句柄，restart 后窗口日志不中断。
+ *   前三个 stdio 直接继承终端句柄，第四个通道保留给 IPC 握手；restart 后窗口日志不中断。
  *   终端句柄的生命周期不随父进程退出而关闭，因此不存在 EPIPE 风险。
  * - **非终端场景**（守护进程/黑匣子等管道或文件启动）：stderr 重定向到磁盘日志
  *   文件（restart-*.log），子进程继承文件句柄，父进程退出不影响写入。
@@ -716,7 +785,7 @@ export function spawnRestartChild(deps = {}) {
     const isTty = deps.isTty ?? (() => process.stdout.isTTY === true || process.stderr.isTTY === true);
     const { command, args } = buildRestartSpawnSpec(projectRoot);
     let stderrFd;
-    const stdio = ["ignore", "ignore", "pipe"];
+    const stdio = ["ignore", "ignore", "pipe", "ipc"];
     const tty = isTty();
     if (tty) {
         // 终端场景：全部 inherit（含 stdin）。注意 stdin 不能是 "ignore"：
@@ -753,8 +822,11 @@ export function spawnRestartChild(deps = {}) {
         detached: true,
         stdio,
         shell: false,
-        env: createInternalRestartEnv(),
+        env: createInternalRestartEnv(process.env, process.pid),
     });
+    // Attach before returning so an extremely fast replacement cannot emit its
+    // IPC readiness message between spawnRestartChild() and the caller's wait.
+    getOrCreateRestartHandoffMonitor(child);
     // 子进程已继承 stderr 文件句柄；父进程关闭自己的副本，避免"子进程早退、
     // 父进程留下继续服务"时 fd 泄漏。
     if (stderrFd !== undefined) {
@@ -777,24 +849,61 @@ export function spawnRestartChild(deps = {}) {
 }
 /**
  * 决定父进程是否应退出（防空窗兜底）：
- * - 窗口内子进程已退出（死亡或信号终止）→ 返回 false，父进程留下继续服务；
- * - 子进程存活满整个窗口 → 返回 true，父进程退出并把端口让给新进程。
+ * - 替代进程通过 IPC 明确完成预检 → 返回 true，父进程退出并交出端口；
+ * - 替代进程退出、报错或握手超时 → 返回 false，父进程继续服务。
  */
-export async function decideRestartParentExit(child, timeoutMs, pollMs = 500, trace = appendStartupTrace) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (child.exitCode !== null || child.signalCode !== null) {
-            trace("restart: child died during window, keeping parent", {
-                childPid: child.pid,
-                exitCode: child.exitCode,
-                signalCode: child.signalCode,
-            });
-            return false;
+export async function decideRestartParentExit(child, timeoutMs, _pollMs = 500, trace = appendStartupTrace) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        trace("restart: child died during window, keeping parent", {
+            childPid: child.pid,
+            exitCode: child.exitCode,
+            signalCode: child.signalCode,
+        });
+        return false;
+    }
+    const monitor = getOrCreateRestartHandoffMonitor(child);
+    let timeout;
+    const timeoutOutcome = new Promise((resolve) => {
+        timeout = setTimeout(() => resolve({ kind: "no_ipc" }), timeoutMs);
+        timeout.unref?.();
+    });
+    const outcome = await Promise.race([monitor.promise, timeoutOutcome]);
+    if (timeout)
+        clearTimeout(timeout);
+    monitor.cancel();
+    if (outcome.kind === "ready") {
+        if (child.connected && typeof child.disconnect === "function") {
+            try {
+                child.disconnect();
+            }
+            catch { /* child may disconnect first */ }
+        }
+        trace("restart: child handoff ready, parent exiting", { childPid: child.pid });
+        return true;
+    }
+    if (outcome.kind === "exit") {
+        trace("restart: child died during window, keeping parent", {
+            childPid: child.pid,
+            exitCode: child.exitCode,
+            signalCode: child.signalCode,
+        });
+        return false;
+    }
+    if (outcome.kind === "error") {
+        trace("restart: child handoff error, keeping parent", {
+            childPid: child.pid,
+            error: outcome.error.message,
+        });
+        return false;
+    }
+    if (typeof child.kill === "function") {
+        try {
+            child.kill();
         }
-        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        catch { /* best effort */ }
     }
-    trace("restart: child alive after window, parent exiting", { childPid: child.pid });
-    return true;
+    trace("restart: child handoff timeout, keeping parent", { childPid: child.pid });
+    return false;
 }
 const safeMaintenancePlatforms = new Map();
 export function configureSafeMaintenanceRuntime(platforms) {
@@ -1011,8 +1120,8 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         appendStartupTrace("restart: spawn begin", { fromPid: process.pid });
         const child = spawnRestartChild();
         child.unref();
-        // 子进程存活满窗口才退出父进程；若子进程在窗口内死亡，父进程留下继续
-        // 服务（防空窗），并已把子进程 stderr 写入 startup-trace 供排查。
+        // 只有替代进程通过 IPC 明确完成预检才退出父进程；超时或早退时父进程
+        // 继续服务，并保留替代进程 stderr 日志供排查。
         void decideRestartParentExit(child, RESTART_CHILD_READY_MS).then((shouldExit) => {
             if (!shouldExit)
                 return;
@@ -1060,10 +1169,9 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         await platform.sendText(chatId, "正在更新并重启，请稍候...").catch(() => { });
         logTrace(tid, "DONE", { outcome: "update" });
         appendStartupTrace("update: sync update begin", { fromPid: process.pid });
-        const child = syncUpdateAndRestart();
+        const child = syncUpdateAndRestart({ spawnOnUpdateFailure: false });
         if (child) {
-            // 子进程存活满窗口才退出父进程；若子进程在窗口内死亡，父进程留下继续
-            // 服务（防空窗）。
+            // 只有替代进程通过 IPC 明确完成预检才退出父进程；否则父进程继续服务。
             void decideRestartParentExit(child, RESTART_CHILD_READY_MS).then((shouldExit) => {
                 if (!shouldExit)
                     return;
@@ -1072,8 +1180,7 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
             });
         }
         else {
-            // spawn 失败：没有子进程可等，给残留日志写入时间后退出
-            setTimeout(() => process.exit(0), 2000);
+            appendStartupTrace("update: replacement unavailable, parent stays alive", {});
         }
         return;
     }

package/dist/src/shared.js

@@ -164,25 +164,42 @@ export function freeRelayListenPort(port) {
     return killed;
 }
 /**
- * 轮询等待端口释放（Windows 下 taskkill 后端口可能不会立即释放）。
- * 在 freeRelayListenPort kill 了进程后调用，确认端口真正空闲再 listen。
+ * 跨平台轮询等待端口释放。既用于 Windows taskkill 后的延迟释放，也用于
+ * Linux/macOS 内部重启时等待父进程交出监听端口。
  */
-export async function waitForPortFree(port, timeoutMs = 3000) {
-    if (process.platform !== "win32")
-        return;
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        try {
-            const out = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", windowsHide: true });
-            const pids = collectListeningPidsOnPortWindows(port, out);
-            if (pids.length === 0)
+async function canBindLoopbackPort(port) {
+    const probe = createServer();
+    probe.unref();
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (available) => {
+            if (settled)
                 return;
-        }
-        catch {
-            return;
-        }
-        await new Promise((r) => setTimeout(r, 200));
-    }
+            settled = true;
+            probe.removeAllListeners();
+            if (probe.listening) {
+                probe.close(() => resolve(available));
+            }
+            else {
+                resolve(available);
+            }
+        };
+        probe.once("error", () => finish(false));
+        probe.once("listening", () => finish(true));
+        probe.listen(port, "127.0.0.1");
+    });
+}
+/** Wait until the loopback port can actually be bound on every supported OS. */
+export async function waitForPortFree(port, timeoutMs = 3000, pollMs = 200) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        if (await canBindLoopbackPort(port))
+            return true;
+        if (Date.now() >= deadline)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    } while (Date.now() <= deadline);
+    return false;
 }
 // ---------------------------------------------------------------------------
 // 单实例保证：PID 文件互斥（端口占用在 freeRelayListenPort + 监听前处理）

package/dist/src/sim-platform.js

@@ -105,6 +105,10 @@ export const SimulatedPlatform = {
             weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
             rateLimitResetCreditsAvailable: null,
             rateLimitResetCredits: null,
+            rateLimitResetCreditsSource: "unavailable",
+            rateLimitResetCreditsQueriedAt: null,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: "Simulated platform has no reset-credit data",
         };
     },
     async consumeCodexRateLimitResetCredit(_redeemRequestId) {

package/dist/src/startup-lifecycle.js

@@ -147,12 +147,54 @@ export function createServiceLifecycleGuard(options = {}) {
  * 会自然穿过 cmd/bash/npx 这几层启动器，因此也适用于 Windows 与 Linux。
  */
 export const INTERNAL_RESTART_ENV_VAR = "CHATCCC_INTERNAL_RESTART";
-export function createInternalRestartEnv(inherited = process.env) {
+export const INTERNAL_RESTART_PARENT_PID_ENV_VAR = "CHATCCC_RESTART_PARENT_PID";
+export const INTERNAL_RESTART_READY_MESSAGE = "chatccc:restart-handoff-ready";
+export function createInternalRestartEnv(inherited = process.env, parentPid = process.pid) {
     return {
         ...inherited,
         [INTERNAL_RESTART_ENV_VAR]: "1",
+        [INTERNAL_RESTART_PARENT_PID_ENV_VAR]: String(parentPid),
     };
 }
+/**
+ * Tell the current parent that the replacement runtime loaded successfully and
+ * is ready to wait for the listening port. Older parents do not provide IPC;
+ * returning false preserves the port-wait fallback used during an upgrade from
+ * a pre-handoff ChatCCC version.
+ */
+export async function announceInternalRestartReady(options = {}) {
+    const env = options.env ?? process.env;
+    if (env[INTERNAL_RESTART_ENV_VAR] !== "1")
+        return false;
+    const send = options.send ?? (typeof process.send === "function"
+        ? process.send.bind(process)
+        : undefined);
+    if (!send)
+        return false;
+    const pid = options.pid ?? process.pid;
+    const parentPid = Number(env[INTERNAL_RESTART_PARENT_PID_ENV_VAR]);
+    if (!Number.isInteger(parentPid) || parentPid <= 0)
+        return false;
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(ok);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref?.();
+        try {
+            send({ type: INTERNAL_RESTART_READY_MESSAGE, pid, parentPid }, (error) => finish(!error));
+        }
+        catch {
+            finish(false);
+        }
+    });
+}
 export function shouldAutoOpenWebUi(options = {}) {
     const env = options.env ?? process.env;
     return options.openOnStart !== false && env[INTERNAL_RESTART_ENV_VAR] !== "1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.279",
+  "version": "0.2.281",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",