chatccc 0.2.237 → 0.2.239

package/package.json

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

package/src/__tests__/builtin-chat-session.test.ts

@@ -56,6 +56,42 @@ afterEach(() => {
 });
 
 describe("ChatSession context management", () => {
+  it("keeps the generalized evidence gate in the stable system prompt prefix", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "deepccc-session-evidence-gate-"));
+    await writeFile(join(dir, "AGENTS.md"), "PROJECT GUIDANCE MARKER", "utf-8");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "evidence-gate",
+        systemPrompt: "CUSTOM PROMPT MARKER",
+      },
+    );
+    await collect(session.chat("diagnose a consequential problem"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).toContain("## Evidence-Gated Conclusions");
+    expect(system).toContain("source of truth");
+    expect(system).toContain("direct observations from inferences");
+    expect(system).toContain("plausible alternative explanations");
+    expect(system).toContain("runtime behavior for runtime claims");
+    expect(system).toContain("state uncertainty");
+    expect(system).toContain("Do not repeat checks once decisive evidence exists");
+    expect(system).not.toContain("CodesForUnity");
+    expect(system.indexOf("## Evidence-Gated Conclusions")).toBeLessThan(
+      system.indexOf("PROJECT GUIDANCE MARKER"),
+    );
+    expect(system.indexOf("## Evidence-Gated Conclusions")).toBeLessThan(
+      system.indexOf("Current working directory"),
+    );
+    expect(system.indexOf("## Evidence-Gated Conclusions")).toBeLessThan(
+      system.indexOf("CUSTOM PROMPT MARKER"),
+    );
+  });
+
   it("injects cwd project instruction files before runtime workspace details", async () => {
     const { ChatSession } = await import("../builtin/index.ts");
     const dir = await mkdtemp(join(tmpdir(), "deepccc-session-instructions-"));

package/src/__tests__/session.test.ts

@@ -131,9 +131,11 @@ import {
   stopUnifiedDisplayLoop,
   _setProcessAliveForTest,
   _resetProcessAliveForTest,
-  _setProcessMonitorIntervalForTest,
-  _resetProcessMonitorIntervalForTest,
-  _setResponseStallTimeoutForTest,
+  _setProcessMonitorIntervalForTest,
+  _resetProcessMonitorIntervalForTest,
+  _setAvatarRefreshIntervalForTest,
+  _resetAvatarRefreshIntervalForTest,
+  _setResponseStallTimeoutForTest,
   _resetResponseStallTimeoutForTest,
   _setResponseStallCheckIntervalForTest,
   _resetResponseStallCheckIntervalForTest,
@@ -436,7 +438,7 @@ describe("runAgentSession previous final delivery guard", () => {
   });
 });
 
-describe("runAgentSession process monitor", () => {
+describe("runAgentSession process monitor", () => {
   let registryFile = "";
   let toolsFile = "";
 
@@ -804,7 +806,99 @@ describe("runAgentSession process monitor", () => {
     expect(sentTexts[0]).toContain("first prompt");
     expect(sentTexts[1]).toContain("second prompt");
   });
-});
+});
+
+describe("runAgentSession periodic avatar refresh", () => {
+  let registryFile = "";
+  let toolsFile = "";
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-avatar-refresh-"));
+    registryFile = join(dir, "session-registry.json");
+    toolsFile = join(dir, "session-tools.json");
+    _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(toolsFile);
+    _setAvatarRefreshIntervalForTest(50);
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    _resetAvatarRefreshIntervalForTest();
+    _clearAdapterCacheForTest();
+    resetState();
+    resetBindingState();
+    vi.useRealTimers();
+    if (registryFile) await rm(dirname(registryFile), { recursive: true, force: true });
+  });
+
+  it.each(["codex", "cursor", "claude", "ccc"])(
+    "refreshes the busy avatar for %s every interval and stops after completion",
+    async (tool) => {
+      const sessionId = `sid-avatar-${tool}`;
+      const chatId = `chat-avatar-${tool}`;
+      const platform = mockPlatform("feishu");
+      setSessionPlatform(platform);
+      bindChatToSession(sessionId, chatId);
+      recordLastActiveChat(sessionId, chatId);
+
+      let finishPrompt: (() => void) | undefined;
+      const adapter: ToolAdapter = {
+        displayName: tool,
+        sessionDescPrefix: `${tool} Session:`,
+        createSession: async () => ({ sessionId }),
+        getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "/tmp" }),
+        closeSession: async () => {},
+        prompt: async function* () {
+          yield { type: "assistant", blocks: [{ type: "text", text: "working" }] };
+          await new Promise<void>((resolve) => {
+            finishPrompt = resolve;
+          });
+          yield { type: "assistant", blocks: [{ type: "text", text: "done" }] };
+        },
+      };
+      _setAdapterForToolForTest(tool, adapter);
+
+      const runPromise = runAgentSession(
+        sessionId,
+        "prompt",
+        platform,
+        chatId,
+        Date.now(),
+        tool,
+      );
+
+      await vi.waitFor(() => {
+        expect(vi.mocked(platform.setChatAvatar).mock.calls.some(
+          ([calledChatId, calledTool, status]) =>
+            calledChatId === chatId && calledTool === tool && status === "busy",
+        )).toBe(true);
+        expect(finishPrompt).toBeTypeOf("function");
+      });
+      const initialBusyCalls = vi.mocked(platform.setChatAvatar).mock.calls.filter(
+        ([calledChatId, calledTool, status]) =>
+          calledChatId === chatId && calledTool === tool && status === "busy",
+      ).length;
+
+      await vi.advanceTimersByTimeAsync(51);
+      expect(vi.mocked(platform.setChatAvatar).mock.calls.filter(
+        ([calledChatId, calledTool, status]) =>
+          calledChatId === chatId && calledTool === tool && status === "busy",
+      )).toHaveLength(initialBusyCalls + 1);
+
+      finishPrompt?.();
+      await runPromise;
+      const callsAfterCompletion = vi.mocked(platform.setChatAvatar).mock.calls.length;
+
+      await vi.advanceTimersByTimeAsync(100);
+      expect(platform.setChatAvatar).toHaveBeenCalledTimes(callsAfterCompletion);
+    },
+  );
+});
 
 describe("runAgentSession response stall watchdog", () => {
   let tempDir = "";

package/src/builtin/index.ts

@@ -42,9 +42,17 @@ const SYSTEM_PROMPT = [
   "- Respond in the user's language unless they ask otherwise.",
   "- Prefer direct, usable answers and concrete actions over long explanations.",
   "- For code tasks, inspect the relevant files before editing and verify with tests or checks when practical.",
-  "- Preserve user work. Do not overwrite concurrent changes unless the user explicitly asks.",
-  "- Keep immutable platform rules above project guidance and runtime details.",
-].join("\n");
+  "- Preserve user work. Do not overwrite concurrent changes unless the user explicitly asks.",
+  "- Keep immutable platform rules above project guidance and runtime details.",
+  "",
+  "## Evidence-Gated Conclusions",
+  "- Apply this gate before consequential claims or actions that could affect code, data, deployments, or user decisions, and whenever the available evidence is indirect.",
+  "- Identify the claim and its authoritative source of truth. Separate direct observations from inferences, and test plausible alternative explanations before choosing one.",
+  "- Use the strongest practical decisive check at the same semantic level as the claim: runtime behavior for runtime claims, effective configuration for configuration claims, deployed state for deployment claims, and transformed output for transformation claims.",
+  "- Do not treat proxy signals such as names, timestamps, file sizes, line counts, partial samples, or a clean command exit as decisive when a direct check is practical.",
+  "- Use definitive language only after the evidence closes the loop. Otherwise state uncertainty, identify the missing evidence, and name the next check.",
+  "- Do not repeat checks once decisive evidence exists.",
+].join("\n");
 
 const SUMMARY_SYSTEM_PROMPT = [
   "You are DeepCCC's context compactor.",

package/src/session-chat-binding.ts

@@ -111,6 +111,7 @@ export interface ActivePrompt {
   processPid?: number;
   processMonitor?: ReturnType<typeof setInterval>;
   responseStallMonitor?: ReturnType<typeof setInterval>;
+  avatarRefreshTimer?: ReturnType<typeof setInterval>;
   /** Grace timer that force-closes a stream which stays open after its authoritative final event. */
   finalResponseCloseTimer?: ReturnType<typeof setTimeout>;
   /** Character-count progress observed only while the activity is "responding". */

package/src/session.ts

@@ -174,8 +174,9 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
-const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
-const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
+const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
+const DEFAULT_AVATAR_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+const DEFAULT_RESPONSE_STALL_TIMEOUT_MS = 3 * 60 * 1000;
 const DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS = 5000;
 const DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS = 10_000;
 export const RESPONSE_STALL_RECOVERY_PROMPT = "完成了吗？如果没完成继续";
@@ -184,8 +185,9 @@ export const RESPONSE_STALL_RECOVERY_NOTICE =
 export const RESPONSE_STALL_RECOVERY_EXHAUSTED_NOTICE =
   "⚠️ 自动续跑仍连续 3 分钟没有生成新回复，本次不再自动继续。";
 const RESPONSE_STALL_RECOVERY_DELAY_MS = 200;
-let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_INTERVAL_MS;
+let responseStallTimeoutMs = DEFAULT_RESPONSE_STALL_TIMEOUT_MS;
 let responseStallCheckIntervalMs = DEFAULT_RESPONSE_STALL_CHECK_INTERVAL_MS;
 let finalResponseCloseTimeoutMs = DEFAULT_FINAL_RESPONSE_CLOSE_TIMEOUT_MS;
 let isProcessAliveImpl = (pid: number): boolean => {
@@ -216,9 +218,17 @@ export function _setProcessMonitorIntervalForTest(ms: number): void {
   processMonitorIntervalMs = ms;
 }
 
-export function _resetProcessMonitorIntervalForTest(): void {
-  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
-}
+export function _resetProcessMonitorIntervalForTest(): void {
+  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+}
+
+export function _setAvatarRefreshIntervalForTest(ms: number): void {
+  avatarRefreshIntervalMs = ms;
+}
+
+export function _resetAvatarRefreshIntervalForTest(): void {
+  avatarRefreshIntervalMs = DEFAULT_AVATAR_REFRESH_INTERVAL_MS;
+}
 
 export function _setResponseStallTimeoutForTest(ms: number): void {
   responseStallTimeoutMs = ms;
@@ -251,14 +261,21 @@ function clearPromptProcessMonitor(sessionId: string): void {
   prompt.processMonitor = undefined;
 }
 
-function clearPromptResponseStallMonitor(sessionId: string): void {
-  const prompt = activePrompts.get(sessionId);
-  if (!prompt?.responseStallMonitor) return;
-  clearInterval(prompt.responseStallMonitor);
-  prompt.responseStallMonitor = undefined;
-}
-
-function clearPromptFinalResponseCloseTimer(sessionId: string): void {
+function clearPromptResponseStallMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.responseStallMonitor) return;
+  clearInterval(prompt.responseStallMonitor);
+  prompt.responseStallMonitor = undefined;
+}
+
+function clearPromptAvatarRefreshTimer(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.avatarRefreshTimer) return;
+  clearInterval(prompt.avatarRefreshTimer);
+  prompt.avatarRefreshTimer = undefined;
+}
+
+function clearPromptFinalResponseCloseTimer(sessionId: string): void {
   const prompt = activePrompts.get(sessionId);
   if (!prompt?.finalResponseCloseTimer) return;
   clearTimeout(prompt.finalResponseCloseTimer);
@@ -513,10 +530,11 @@ export function resetState(): void {
   clearFeishuMessageLedgerMemory();
   lastMsgTimestamps.clear();
   chatPlatformMap.clear();
-  for (const prompt of activePrompts.values()) {
-    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
-    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
-    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+    if (prompt.avatarRefreshTimer) clearInterval(prompt.avatarRefreshTimer);
+    if (prompt.finalResponseCloseTimer) clearTimeout(prompt.finalResponseCloseTimer);
   }
   activePrompts.clear();
   displayCards.clear();
@@ -582,7 +600,7 @@ export function getEffectiveFastModeForTool(tool: string, sessionId?: string): b
   return config.codex.fastMode;
 }
 
-function setSessionChatAvatar(
+function setSessionChatAvatar(
   platform: PlatformAdapter,
   chatId: string,
   tool: string,
@@ -591,8 +609,59 @@ function setSessionChatAvatar(
 ): Promise<void> {
   return getEffectiveFastModeForTool(tool, sessionId)
     ? platform.setChatAvatar(chatId, tool, status, { fastMode: true })
-    : platform.setChatAvatar(chatId, tool, status);
-}
+    : platform.setChatAvatar(chatId, tool, status);
+}
+
+async function refreshBusySessionAvatar(
+  sessionId: string,
+  tool: string,
+  fallbackPlatform: PlatformAdapter,
+): Promise<void> {
+  const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+  if (!chatId) return;
+  const platform = platformForChat(chatId) ?? fallbackPlatform;
+  await setSessionChatAvatar(platform, chatId, tool, "busy", sessionId);
+}
+
+function startPromptAvatarRefresh(
+  sessionId: string,
+  tool: string,
+  fallbackPlatform: PlatformAdapter,
+  runningPrompt: NonNullable<ReturnType<typeof activePrompts.get>>,
+): void {
+  let refreshInFlight = false;
+  const timer = setInterval(() => {
+    const current = activePrompts.get(sessionId);
+    if (!current || current !== runningPrompt) {
+      clearInterval(timer);
+      if (runningPrompt.avatarRefreshTimer === timer) {
+        runningPrompt.avatarRefreshTimer = undefined;
+      }
+      return;
+    }
+    if (
+      refreshInFlight
+      || current.stopped
+      || current.abnormalExit
+      || current.resourceStuck
+      || current.autoEnded
+      || current.finalResponseObserved
+    ) {
+      return;
+    }
+
+    refreshInFlight = true;
+    void refreshBusySessionAvatar(sessionId, tool, fallbackPlatform)
+      .catch((err) => {
+        console.warn(`[${ts()}] [AVATAR] Periodic refresh failed for ${sessionId}: ${(err as Error).message}`);
+      })
+      .finally(() => {
+        refreshInFlight = false;
+      });
+  }, avatarRefreshIntervalMs);
+  timer.unref?.();
+  runningPrompt.avatarRefreshTimer = timer;
+}
 
 /** 为指定 session 设置模型覆盖（/model <name>） */
 export function setSessionModelOverride(sessionId: string, model: string): void {
@@ -1435,10 +1504,7 @@ export async function runAgentSession(
   }
 
   // 设置最后活跃群头像为 busy
-  const activeCid = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
-  if (activeCid) {
-    setSessionChatAvatar(platform, activeCid, tool, "busy", sessionId).catch(() => {});
-  }
+  refreshBusySessionAvatar(sessionId, tool, platform).catch(() => {});
 
   const state: AccumulatorState = {
     accumulatedContent: "",
@@ -1456,6 +1522,8 @@ export async function runAgentSession(
 
   const runningPrompt = activePrompts.get(sessionId);
   if (runningPrompt) {
+    startPromptAvatarRefresh(sessionId, tool, platform, runningPrompt);
+
     // 在消费第一个事件前建立阶段感知的零字符基线；启动阶段不计时，只有后续
     // 收到明确的 responding 状态后才会启动三分钟回复停滞保护。
     runningPrompt.responseProgress = observeResponseProgress(
@@ -1642,9 +1710,10 @@ export async function runAgentSession(
     const wasAutoEnded = timeoutTriggered && !completedAtTimeoutBoundary;
     const wasAutoRecovery = prompt?.autoRecovery ?? false;
     const autoEndedAt = wasAutoEnded ? prompt?.autoEndedAt : undefined;
-    clearPromptResponseStallMonitor(sessionId);
-    clearPromptProcessMonitor(sessionId);
-    clearPromptFinalResponseCloseTimer(sessionId);
+    clearPromptResponseStallMonitor(sessionId);
+    clearPromptProcessMonitor(sessionId);
+    clearPromptAvatarRefreshTimer(sessionId);
+    clearPromptFinalResponseCloseTimer(sessionId);
     markSessionFinalizing(sessionId);
     activePrompts.delete(sessionId);
 
@@ -2351,10 +2420,11 @@ export function stopSession(sessionId: string): boolean {
     }
     return false;
   }
-  prompt.stopped = true;
-  clearPromptResponseStallMonitor(sessionId);
-  clearPromptProcessMonitor(sessionId);
-  clearPromptFinalResponseCloseTimer(sessionId);
+  prompt.stopped = true;
+  clearPromptResponseStallMonitor(sessionId);
+  clearPromptProcessMonitor(sessionId);
+  clearPromptAvatarRefreshTimer(sessionId);
+  clearPromptFinalResponseCloseTimer(sessionId);
   cancelQueuedMessage(sessionId);
 
   // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由