chatccc 0.2.45 → 0.2.46

package/src/agent-image-rpc.ts

@@ -1,123 +1,30 @@
-import { randomBytes } from "node:crypto";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { extname, isAbsolute, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 
 import { getTenantAccessToken, sendImageReply, sendTextReply } from "./feishu-platform.ts";
 import { ts } from "./config.ts";
-import { logTrace } from "./trace.ts";
 import { readUtf8JsonBody } from "./agent-rpc-body.ts";
+import { getAdapterForTool } from "./session.ts";
+import { getChatsForSession } from "./session-chat-binding.ts";
 
 export const AGENT_SEND_IMAGE_PATH = "/api/agent/send-image";
 
-const DEFAULT_GRANT_TTL_MS = 30 * 60 * 1000;
 const MAX_REQUEST_BYTES = 64 * 1024;
 const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
 const ALLOWED_IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"]);
 
-export interface AgentImageGrant {
-  token: string;
-  url: string;
-  chatId: string;
-  sessionId: string;
-  cwd: string;
-  expiresAt: number;
-  traceId: string;
-}
-
-interface CreateAgentImageGrantInput {
-  chatId: string;
-  sessionId: string;
-  cwd: string;
-  port: number;
-  traceId?: string;
-  nowMs?: number;
-  ttlMs?: number;
-}
-
-const imageGrants = new Map<string, AgentImageGrant>();
-
-function createToken(): string {
-  return randomBytes(24).toString("base64url");
-}
-
-export function createAgentImageGrant(input: CreateAgentImageGrantInput): AgentImageGrant {
-  const now = input.nowMs ?? Date.now();
-  const token = createToken();
-  const grant: AgentImageGrant = {
-    token,
-    url: `http://127.0.0.1:${input.port}${AGENT_SEND_IMAGE_PATH}`,
-    chatId: input.chatId,
-    sessionId: input.sessionId,
-    cwd: input.cwd,
-    expiresAt: now + (input.ttlMs ?? DEFAULT_GRANT_TTL_MS),
-    traceId: input.traceId ?? "",
-  };
-  imageGrants.set(token, grant);
-  if (grant.traceId) logTrace(grant.traceId, "IMAGE_GRANT_CREATED", { sessionId: grant.sessionId, ttlMs: input.ttlMs ?? DEFAULT_GRANT_TTL_MS });
-  return grant;
-}
-
-export function revokeAgentImageGrant(token: string): void {
-  const grant = imageGrants.get(token);
-  if (grant?.traceId) logTrace(grant.traceId, "IMAGE_GRANT_REVOKED", {});
-  imageGrants.delete(token);
-}
-
-export function getAgentImageGrantFromAuthorization(
-  authorization: string | undefined,
-  nowMs = Date.now(),
-): AgentImageGrant | null {
-  const match = (authorization ?? "").match(/^Bearer\s+(.+)$/i);
-  if (!match) return null;
-  const grant = imageGrants.get(match[1]);
-  if (!grant) return null;
-  if (grant.expiresAt <= nowMs) {
-    imageGrants.delete(match[1]);
-    return null;
-  }
-  return grant;
-}
-
-export function buildAgentImageCapabilityPrompt(input: {
-  url: string;
-  token: string;
-  cwd?: string;
-}): string {
-  const lines = [
-    "[ChatCCC local capability: send image]",
-    "You can send an image to the current Feishu chat in real time by calling this local endpoint.",
-    "",
-    `POST ${input.url}`,
-    `Authorization: Bearer ${input.token}`,
-    "Content-Type: application/json; charset=utf-8",
-    "",
-    'Body: {"path":"absolute image file path","caption":"optional caption"}',
-    "",
-    "Rules:",
-    "- Save or choose a local image file first, then call the endpoint.",
-    "- Use an absolute local file path. Do not call Feishu Open Platform directly.",
-    "- Request body must be UTF-8 encoded JSON bytes; caption supports Unicode text, including Chinese.",
-    "- Only call this endpoint when the user asked for an image or when an image is useful to the answer.",
-    "[/ChatCCC local capability: send image]",
-  ];
-  if (input.cwd) {
-    lines.splice(2, 0, `Current working directory: ${input.cwd}`);
-  }
-  return lines.join("\n");
-}
-
 function jsonReply(res: ServerResponse, status: number, data: unknown): void {
   res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(data));
 }
 
-async function resolveAndValidateImagePath(grant: AgentImageGrant, rawPath: unknown): Promise<string> {
+async function resolveAndValidateImagePath(cwd: string, rawPath: unknown): Promise<string> {
   if (typeof rawPath !== "string" || rawPath.trim() === "") {
     throw new Error("path must be a non-empty string");
   }
 
-  const sessionRoot = resolve(grant.cwd);
+  const sessionRoot = resolve(cwd);
   const imagePath = isAbsolute(rawPath)
     ? resolve(rawPath)
     : resolve(sessionRoot, rawPath);
@@ -146,43 +53,101 @@ export async function handleAgentImageRequest(
     return true;
   }
 
-  const grant = getAgentImageGrantFromAuthorization(req.headers.authorization);
-  if (!grant) {
-    jsonReply(res, 401, { ok: false, error: "Invalid or expired image-send token" });
+  let payload: { session_id?: unknown; path?: unknown; caption?: unknown };
+  try {
+    payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+  } catch (err) {
+    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" });
+    return true;
+  }
+
+  const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
+  if (!sessionId) {
+    jsonReply(res, 400, { ok: false, error: "Missing session_id" });
     return true;
   }
-  const tid = grant.traceId;
 
-  let payload: { path?: unknown; caption?: unknown };
+  // 获取 cwd 以校验路径
+  let cwd: string;
   try {
-    payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    const { getSessionTool } = await import("./session.ts");
+    const tool = await getSessionTool(sessionId);
+    const adapter = getAdapterForTool(tool ?? "claude");
+    const info = await adapter.getSessionInfo(sessionId);
+    if (!info?.cwd) {
+      jsonReply(res, 400, { ok: false, error: "Cannot determine cwd for session" });
+      return true;
+    }
+    cwd = info.cwd;
   } catch (err) {
-    if (tid) logTrace(tid, "IMAGE_REQ", { outcome: "invalid_json", error: (err as Error).message });
-    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" });
+    jsonReply(res, 500, { ok: false, error: `Failed to get session info: ${(err as Error).message}` });
     return true;
   }
 
   let imagePath: string;
   try {
-    imagePath = await resolveAndValidateImagePath(grant, payload.path);
+    imagePath = await resolveAndValidateImagePath(cwd, payload.path);
   } catch (err) {
-    if (tid) logTrace(tid, "IMAGE_REQ", { outcome: "invalid_path", path: String(payload.path), error: (err as Error).message });
     jsonReply(res, 400, { ok: false, error: (err as Error).message });
     return true;
   }
 
+  // 发送到所有绑定该 session 的群
+  const chatIds = getChatsForSession(sessionId);
+  if (chatIds.length === 0) {
+    jsonReply(res, 404, { ok: false, error: "No chats bound to this session" });
+    return true;
+  }
+
   try {
     const token = await getTenantAccessToken();
     const caption = typeof payload.caption === "string" ? payload.caption.trim() : "";
-    await sendImageReply(token, grant.chatId, imagePath);
-    if (caption) await sendTextReply(token, grant.chatId, caption);
-    if (tid) logTrace(tid, "IMAGE_REQ", { outcome: "sent", path: imagePath, hasCaption: !!caption });
-    console.log(`[${ts()}] [AGENT-IMAGE] sent image chat=${grant.chatId} session=${grant.sessionId} path=${imagePath}`);
-    jsonReply(res, 200, { ok: true });
+    let sentCount = 0;
+    for (const cid of chatIds) {
+      try {
+        await sendImageReply(token, cid, imagePath);
+        if (caption) await sendTextReply(token, cid, caption);
+        sentCount++;
+      } catch (err) {
+        console.error(`[${ts()}] [AGENT-IMAGE] send to ${cid} failed: ${(err as Error).message}`);
+      }
+    }
+    console.log(`[${ts()}] [AGENT-IMAGE] sent image to ${sentCount}/${chatIds.length} chats, session=${sessionId} path=${imagePath}`);
+    jsonReply(res, 200, { ok: true, sentTo: sentCount, total: chatIds.length });
   } catch (err) {
-    if (tid) logTrace(tid, "IMAGE_REQ", { outcome: "send_failed", path: imagePath!, error: (err as Error).message });
     console.error(`[${ts()}] [AGENT-IMAGE] send failed: ${(err as Error).message}`);
     jsonReply(res, 500, { ok: false, error: (err as Error).message });
   }
   return true;
 }
+
+// ---------------------------------------------------------------------------
+// 兼容旧版 buildAgentImageCapabilityPrompt（供 im-skills 使用）
+// ---------------------------------------------------------------------------
+
+export function buildAgentImageCapabilityPrompt(input: {
+  url: string;
+  sessionId?: string;
+  cwd?: string;
+}): string {
+  const lines = [
+    "[ChatCCC local capability: send image]",
+    "You can send an image to all chats bound to this session by calling this local endpoint.",
+    "",
+    `POST ${input.url}`,
+    "Content-Type: application/json; charset=utf-8",
+    "",
+    `Body: {"session_id":"${input.sessionId ?? "YOUR_SESSION_ID"}","path":"absolute image file path","caption":"optional caption"}`,
+    "",
+    "Rules:",
+    "- Save or choose a local image file first, then call the endpoint.",
+    "- Use an absolute local file path. Do not call Feishu Open Platform directly.",
+    "- Request body must be UTF-8 encoded JSON bytes; caption supports Unicode text, including Chinese.",
+    "- Only call this endpoint when the user asked for an image or when an image is useful to the answer.",
+    "[/ChatCCC local capability: send image]",
+  ];
+  if (input.cwd) {
+    lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+  }
+  return lines.join("\n");
+}

package/src/index.ts

@@ -41,7 +41,6 @@ import {
   CLAUDE_EFFORT,
   CLAUDE_MODEL,
   GIT_TIMEOUT_MS,
-  ALLOW_INTERRUPT,
   reloadConfigFromDisk,
   anthropicConfigDisplay,
   LOCAL_RELAY_URL,
@@ -84,17 +83,14 @@ import {
   reportPermissionResults,
   setPlatform,
 } from "./feishu-platform.ts";
-import { buildHelpCard, buildStatusCard, buildProgressCard, buildCdContent, buildCdCard, buildSessionsCard } from "./cards.ts";
-import { updateCardKitCard } from "./cardkit.ts";
+import { buildHelpCard, buildStatusCard, buildCdContent, buildCdCard, buildSessionsCard } from "./cards.ts";
 import { handleAgentImageRequest } from "./agent-image-rpc.ts";
 import { handleAgentFileRequest } from "./agent-file-rpc.ts";
-import { handleAgentGrantsRequest } from "./agent-grants-rpc.ts";
 import { SimulatedPlatform, SIM_DEFAULT_CHAT_ID } from "./sim-platform.ts";
 import { setMessageHandler } from "./sim-store.ts";
 import { formatGitResult, gitResultHeaderTemplate, runGitCommand } from "./git-command.ts";
 import {
   MAX_PROCESSED,
-  chatSessionMap,
   getSessionStatus,
   getAllSessionsStatus,
   initClaudeSession,
@@ -105,7 +101,18 @@ import {
   sessionInfoMap,
   recordSessionRegistry,
   getAdapterForTool,
+  stopSession,
+  loadSessionRegistryForBinding,
 } from "./session.ts";
+import {
+  bindChatToSession,
+  unbindChatFromSession,
+  getChatsForSession,
+  isSessionRunning,
+  activePrompts,
+  rebuildSessionChatsFromRegistry,
+} from "./session-chat-binding.ts";
+import { fixStaleStreamStates } from "./stream-state.ts";
 
 export function cwdDisplayName(cwd: string): string {
   const trimmed = cwd.trim().replace(/[\\/]+$/, "");
@@ -462,6 +469,41 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     const cwd = sessionCwd;
     const initialName = sessionChatName("新会话", cwd);
 
+    // 私聊：不创建群，直接绑定 session 到当前私聊
+    if (chatType === "p2p") {
+      bindChatToSession(sessionId, chatId);
+      sessionInfoMap.set(chatId, {
+        sessionId,
+        turnCount: 0,
+        lastContextTokens: 0,
+        startTime: Date.now(),
+        tool,
+      });
+      await setDefaultCwd(cwd, chatId);
+      await recordSessionRegistry({
+        chatId,
+        sessionId,
+        tool,
+        chatName: initialName,
+        turnCount: 0,
+        startTime: Date.now(),
+        running: false,
+      });
+      await sendCardReply(
+        freshToken, chatId, `${toolLabel} Session Ready`,
+        `这是你的 **${toolLabel}** 私聊会话。\n\n` +
+          `**Session ID:** ${sessionId}\n` +
+          `**工作目录:** \`${cwd}\`\n\n` +
+          `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
+          `发送 **/sessions** 查看所有会话状态。\n` +
+          `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
+        "green"
+      );
+      console.log(`[${ts()}] [NEW] P2P session created: ${sessionId} (${toolLabel})`);
+      logTrace(tid, "DONE", { outcome: "session_ready_p2p", chatId, sessionId, tool });
+      return;
+    }
+
     let newChatId: string;
     try {
       newChatId = await createGroupChat(freshToken, initialName, [openId]);
@@ -515,24 +557,62 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     return;
   }
 
-  // 私聊没有群 description，无法存储/获取 session ID，跳过群聊检测直接发 help card
+  // 检测会话上下文：群聊从 description 获取，私聊从 session-registry 获取
+  let sessionId: string | null = null;
+  let descriptionTool: string | null = null;
+  let toolLabel: string | null = null;
+  let chatInfo: Awaited<ReturnType<typeof getChatInfo>> | undefined;
+  let description: string | undefined;
+
   if (chatType !== "p2p") {
-  try {
-    const token = await getTenantAccessToken();
-    const chatInfo = await getChatInfo(token, chatId);
-    const description = chatInfo.description;
-    const sessionInfo = extractSessionInfo(description);
-
-    if (sessionInfo) {
-      const sessionId = sessionInfo.sessionId;
-      const descriptionTool = sessionInfo.tool;
-      const toolLabel = toolDisplayName(descriptionTool);
-      logTrace(tid, "BRANCH", { sessionId, tool: descriptionTool });
-      console.log(`[${ts()}] [RESUME] ${toolLabel} session group detected, session=${sessionId} tool=${descriptionTool}`);
+    try {
+      const token = await getTenantAccessToken();
+      chatInfo = await getChatInfo(token, chatId);
+      description = chatInfo.description;
+      const sessionInfo = extractSessionInfo(description);
+      if (sessionInfo) {
+        sessionId = sessionInfo.sessionId;
+        descriptionTool = sessionInfo.tool;
+        toolLabel = toolDisplayName(descriptionTool);
+      }
+    } catch (err) {
+      logTrace(tid, "BRANCH", { reason: "get_chat_info_failed", error: (err as Error).message });
+      console.log(`[${ts()}] [INFO] Cannot get chat info for ${chatId}: ${(err as Error).message}`);
+    }
+  } else {
+    // 私聊：从 session-registry.json 获取绑定的 session
+    try {
+      const registry = await loadSessionRegistryForBinding();
+      const record = registry[chatId];
+      if (record && record.sessionId && record.tool) {
+        sessionId = record.sessionId;
+        descriptionTool = record.tool;
+        toolLabel = toolDisplayName(descriptionTool);
+        // 确保 sessionInfoMap 中有该私聊的信息
+        if (!sessionInfoMap.has(chatId)) {
+          sessionInfoMap.set(chatId, {
+            sessionId,
+            turnCount: record.turnCount ?? 0,
+            lastContextTokens: record.lastContextTokens ?? 0,
+            startTime: record.startTime ?? Date.now(),
+            tool: descriptionTool,
+          });
+        }
+        bindChatToSession(sessionId, chatId);
+      }
+    } catch (err) {
+      console.log(`[${ts()}] [INFO] Cannot load registry for p2p ${chatId}: ${(err as Error).message}`);
+    }
+  }
+
+  if (sessionId && descriptionTool && toolLabel) {
+    // 有会话上下文 — 路由到命令处理或 prompt
+    logTrace(tid, "BRANCH", { sessionId, tool: descriptionTool });
+    console.log(`[${ts()}] [RESUME] ${toolLabel} session group detected, session=${sessionId} tool=${descriptionTool}`);
 
       const freshToken = await getTenantAccessToken();
 
-      if (isUntitledSessionChatName(chatInfo.name)) {
+      if (chatType !== "p2p" && isUntitledSessionChatName(chatInfo!.name) && !textLower.startsWith("/")) {
         const MAX_PREFIX = 10;
         const prefix = text.slice(0, MAX_PREFIX);
         const adapter = getAdapterForTool(descriptionTool);
@@ -540,9 +620,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
         const newName = sessionChatName(prefix, sessionCwd);
         try {
-          await updateChatInfo(freshToken, chatId, newName, description);
+          await updateChatInfo(freshToken, chatId, newName, description!);
           console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
-          await recordSessionRegistry({ chatId, chatName: newName }).catch(() => {});
+          await recordSessionRegistry({ chatId, sessionId, tool: descriptionTool, chatName: newName }).catch(() => {});
         } catch (err) {
           console.error(`[${ts()}] [RENAME] Failed: ${(err as Error).message}`);
         }
@@ -550,15 +630,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
       if (textLower === "/stop") {
         logTrace(tid, "BRANCH", { cmd: "/stop" });
-        const cEntry = chatSessionMap.get(chatId);
-        if (cEntry) {
-          cEntry.stopped = true;
-          if (cEntry.spinnerTimer) { clearInterval(cEntry.spinnerTimer); cEntry.spinnerTimer = null; }
-          cEntry.close();
-          const prevTs = lastMsgTimestamps.get(chatId);
-          if (prevTs === undefined || cEntry.msgTimestamp > prevTs) {
-            lastMsgTimestamps.set(chatId, cEntry.msgTimestamp);
-          }
+        if (stopSession(sessionId)) {
           console.log(`[${ts()}] [STOP] User sent /stop, session=${sessionId}`);
           await sendTextReply(freshToken, chatId, "会话已停止。").catch(() => {});
           logTrace(tid, "DONE", { outcome: "stopped" });
@@ -572,8 +644,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       if (textLower === "/status") {
         logTrace(tid, "BRANCH", { cmd: "/status" });
         const status = await getSessionStatus(chatId);
-        const running = chatSessionMap.get(chatId);
-        const isActive = running && !running.stopped;
+        const isActive = isSessionRunning(sessionId);
         const statusText = [
           `**群名:** ${status?.chatName || "—"}`,
           `**Session ID:** \`${status?.sessionId ?? sessionId}\``,
@@ -636,17 +707,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           cwd = await getDefaultCwd(chatId);
         }
 
-        const existing = chatSessionMap.get(chatId);
-        if (existing) {
-          existing.stopped = true;
-          if (existing.spinnerTimer) { clearInterval(existing.spinnerTimer); existing.spinnerTimer = null; }
-          existing.close();
-          const prevTs = lastMsgTimestamps.get(chatId);
-          if (prevTs === undefined || existing.msgTimestamp > prevTs) {
-            lastMsgTimestamps.set(chatId, existing.msgTimestamp);
-          }
-          chatSessionMap.delete(chatId);
-        }
+        // 不 abort 旧 session，只解绑当前 chat
+        // 旧 session 如果正在跑，display loop 继续服务其他群
+        unbindChatFromSession(sessionId, chatId);
 
         let newSessionId: string;
         try {
@@ -658,6 +721,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           return;
         }
 
+        // 绑定新 session
+        bindChatToSession(newSessionId, chatId);
+
         const descPrefix = sessionPrefixForTool(descriptionTool);
         const newName = sessionChatName("新会话", cwd);
         await updateChatInfo(freshToken, chatId, newName, `${descPrefix} ${newSessionId}`);
@@ -683,6 +749,12 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
         setChatAvatar(freshToken, chatId, descriptionTool, "new").catch(() => {});
 
+        // 如果新 session 有活跃 prompt，启动 display loop 让本群也能看到
+        if (isSessionRunning(newSessionId)) {
+          const { ensureDisplayLoop } = await import("./session.ts");
+          ensureDisplayLoop(newSessionId);
+        }
+
         await sendCardReply(
           freshToken, chatId, `${toolLabel} Session Reset`,
           `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
@@ -720,16 +792,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         }
         const target = ordered[index];
 
-        const existing2 = chatSessionMap.get(chatId);
-        if (existing2) {
-          existing2.stopped = true;
-          if (existing2.spinnerTimer) { clearInterval(existing2.spinnerTimer); existing2.spinnerTimer = null; }
-          existing2.close();
-          const prevTs2 = lastMsgTimestamps.get(chatId);
-          if (prevTs2 === undefined || existing2.msgTimestamp > prevTs2) {
-            lastMsgTimestamps.set(chatId, existing2.msgTimestamp);
-          }
-          chatSessionMap.delete(chatId);
+        // 不 abort 当前 chat 的旧 session，只解绑再重新绑定
+        if (sessionId) {
+          unbindChatFromSession(sessionId, chatId);
         }
 
         const targetAdapter = getAdapterForTool(target.tool);
@@ -741,6 +806,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           cwd2 = await getDefaultCwd(chatId);
         }
 
+        // 绑定到新 session
+        bindChatToSession(target.sessionId, chatId);
+
         const descPrefix2 = sessionPrefixForTool(target.tool);
         const newName2 = target.chatName || sessionChatName("新会话", cwd2);
         await updateChatInfo(freshToken, chatId, newName2, `${descPrefix2} ${target.sessionId}`);
@@ -763,14 +831,21 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
         setChatAvatar(freshToken, chatId, target.tool, "new").catch(() => {});
 
+        // 如果新 session 有活跃 prompt，加上 display loop
+        if (isSessionRunning(target.sessionId)) {
+          const { ensureDisplayLoop } = await import("./session.ts");
+          ensureDisplayLoop(target.sessionId);
+        }
+
         const targetToolLabel = toolDisplayName(target.tool);
+        const busyNote = isSessionRunning(target.sessionId) ? "\n\n⚠️ 该会话当前正在生成中，请等待完成后再发送消息。" : "";
         await sendCardReply(
           freshToken, chatId, `${targetToolLabel} Session Switched`,
           `已切换到 **${targetToolLabel}** 会话。\n\n` +
             `**序号:** ${index + 1}\n` +
             `**Session ID:** ${target.sessionId}\n` +
             `**工作目录:** \`${cwd2}\`\n\n` +
-            `直接在这里发消息即可继续对话。`,
+            `直接在这里发消息即可继续对话。${busyNote}`,
           "green"
         );
 
@@ -832,50 +907,16 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
-      const existing = chatSessionMap.get(chatId);
-      if (existing && !existing.stopped) {
-        if (msgTimestamp <= existing.msgTimestamp) {
-          logTrace(tid, "DONE", { outcome: "skip_old_message", msgTimestamp, existingTimestamp: existing.msgTimestamp });
-          console.log(`[${ts()}] [SKIP] Older message (${msgTimestamp} <= ${existing.msgTimestamp}), ignoring`);
-          return;
-        }
-
-        if (!ALLOW_INTERRUPT) {
-          logTrace(tid, "BLOCKED", { outcome: "interrupt_disabled", sessionId });
-          console.log(`[${ts()}] [BLOCKED] allowInterrupt=false, ignoring message during generation. Hint sent to user.`);
-          await sendCardReply(
-            freshToken, chatId, "生成中",
-            "AI 正在生成回复中，Agent 不会遗忘当前进度，停止后仍可从断点继续。\n请先点击卡片上的「停止」按钮，再发送新消息。",
-            "yellow"
-          );
-          return;
-        }
-
-        existing.stopped = true;
-        if (existing.spinnerTimer) { clearInterval(existing.spinnerTimer); existing.spinnerTimer = null; }
-        existing.close();
-        const prevTs = lastMsgTimestamps.get(chatId);
-        if (prevTs === undefined || existing.msgTimestamp > prevTs) {
-          lastMsgTimestamps.set(chatId, existing.msgTimestamp);
-        }
-        chatSessionMap.delete(chatId);
-        console.log(`[${ts()}] [INTERRUPT] New message arrived, cancelled previous session ${sessionId}`);
-        logTrace(tid, "INTERRUPT", { oldSessionId: sessionId });
-        if (existing.cardId) {
-          while (existing.cardBusy) {
-            await new Promise(r => setTimeout(r, 20));
-          }
-          const cardId = existing.cardId;
-          const currentContent = existing.accumulatedContent;
-          const interruptedCard = buildProgressCard(
-            currentContent || "新问题已提交，当前回复已中断。",
-            { showStop: false, headerTitle: "已中断", headerTemplate: "yellow" }
-          );
-          let nextSeq = existing.sequence + 1;
-          await updateCardKitCard(freshToken, cardId, interruptedCard, nextSeq).catch((err) => {
-            console.error(`[${ts()}] [INTERRUPT] CardKit update failed: ${(err as Error).message}`);
-          });
-        }
+      // 并发检查：同一 session 只能有一个活跃 prompt
+      if (isSessionRunning(sessionId)) {
+        logTrace(tid, "BLOCKED", { outcome: "session_busy", sessionId });
+        console.log(`[${ts()}] [BLOCKED] Session ${sessionId} is already generating, rejecting message from chat ${chatId}`);
+        await sendCardReply(
+          freshToken, chatId, "生成中",
+          "该会话正在生成回复中，请等待完成后再发送新消息。",
+          "yellow"
+        );
+        return;
       }
 
       try {
@@ -895,13 +936,8 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       }
       return;
     }
-    // 群聊但 description 中没有 session info → 也走 help card
-    logTrace(tid, "BRANCH", { reason: "no_session_info_in_group" });
-  } catch (err) {
-    logTrace(tid, "BRANCH", { reason: "get_chat_info_failed", error: (err as Error).message });
-    console.log(`[${ts()}] [INFO] Cannot get chat info for ${chatId}: ${(err as Error).message}`);
-  }
-  } // end if (chatType !== "p2p")
+
+  // 无会话上下文 → help card
 
   // 私聊或群聊无 session info → 发送 help card
   logTrace(tid, "SEND", { method: "help_card", chatId });
@@ -1151,12 +1187,25 @@ async function startBotServiceCore(): Promise<void> {
     });
   } else {
     resetState();
+    // 启动时修正残留的 running 状态并重建 session→chat 映射
+    fixStaleStreamStates().then(async () => {
+      const registry = await loadSessionRegistryForBinding();
+      rebuildSessionChatsFromRegistry(registry);
+    }).catch((err) => console.error(`[${ts()}] Init bindings failed: ${(err as Error).message}`));
 
     const wsClient = new WSClient({
       appId: APP_ID,
       appSecret: APP_SECRET,
-      onReady: () => { resetState(); },
-      onReconnected: () => { resetState(); },
+      onReady: async () => {
+        resetState();
+        const registry = await loadSessionRegistryForBinding();
+        rebuildSessionChatsFromRegistry(registry);
+      },
+      onReconnected: async () => {
+        resetState();
+        const registry = await loadSessionRegistryForBinding();
+        rebuildSessionChatsFromRegistry(registry);
+      },
     });
 
     console.log(`\n[启动 6/7] 飞书长连接：正在通过 SDK 建立 WebSocket …`);
@@ -1212,7 +1261,7 @@ async function main(): Promise<void> {
     setExtraApiHandler(async (req, res) => {
       const injected = await handleSimInjectMessage(req, res);
       if (injected) return true;
-      return (await handleAgentGrantsRequest(req, res)) || (await handleAgentImageRequest(req, res)) || (await handleAgentFileRequest(req, res));
+      return (await handleAgentImageRequest(req, res)) || (await handleAgentFileRequest(req, res));
     });
 
     const simServer = createServer(createUiRouter());
@@ -1270,7 +1319,7 @@ async function main(): Promise<void> {
     });
   });
   setExtraApiHandler(async (req, res) => {
-    return (await handleAgentGrantsRequest(req, res)) || (await handleAgentImageRequest(req, res)) || (await handleAgentFileRequest(req, res));
+    return (await handleAgentImageRequest(req, res)) || (await handleAgentFileRequest(req, res));
   });
 
   console.log(`[启动 2/7] 环境与凭证检查`);