workspacecord 1.1.3 → 1.1.4

package/dist/{chunk-7GTUWAQR.js → chunk-NNTMVOTM.js}

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import {
   cleanupSessionAttachments
-} from "./chunk-BFINJJYL.js";
+} from "./chunk-66B64WL3.js";
 import {
   STATE_COLORS,
   STATE_LABELS,
+  createSession,
   debouncedSaveSession,
+  endSession,
   gateService,
   getAllSessions,
   getSession,
@@ -17,17 +19,22 @@ import {
   stateMachine,
   toPlatformEvent,
   updateSession
-} from "./chunk-WON3DPE4.js";
+} from "./chunk-JR4B4L7I.js";
 import {
   config,
   truncate
-} from "./chunk-IVXCJA5I.js";
+} from "./chunk-MJ5JKFGS.js";
 
 // ../bot/src/discord/status-card-projection-renderer.ts
 var StatusCardProjectionRenderer = class {
   #pending = /* @__PURE__ */ new Map();
   async renderNow(sessionId, projection, context) {
     if (!context) return;
+    if (process.env.E2E_DEBUG_RENDER === "1") {
+      console.log(
+        `[renderer] ${sessionId} todoList=${projection.todoList?.length ?? 0} denials=${projection.recentPermissionDenials?.length ?? 0} batch=${projection.batchApprovalMode}`
+      );
+    }
     try {
       await context.statusCard.update(projection.state, {
         turn: projection.turn,
@@ -37,7 +44,11 @@ var StatusCardProjectionRenderer = class {
         provider: context.provider,
         permissionsSummary: context.permissionsSummary,
         verbose: context.verbose,
-        monitorGoal: context.monitorGoal
+        monitorGoal: context.monitorGoal,
+        todoList: projection.todoList,
+        recentPermissionDenials: projection.recentPermissionDenials,
+        batchApprovalMode: projection.batchApprovalMode,
+        pendingApprovals: projection.pendingApprovals
       });
     } catch (error) {
       console.error(`\u72B6\u6001\u5361\u66F4\u65B0\u5931\u8D25 (${sessionId}):`, error);
@@ -73,156 +84,105 @@ var StatusCardProjectionRenderer = class {
   }
 };
 
-// ../bot/src/discord/status-card.ts
-import {
-  EmbedBuilder
-} from "discord.js";
-var StatusCard = class {
-  messageId = null;
-  channel;
-  lastState = "idle";
-  lastData = null;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  adopt(messageId) {
-    this.messageId = messageId;
+// ../bot/src/output/event-handlers.ts
+import { existsSync as existsSync2 } from "fs";
+
+// ../engine/src/session-context.ts
+var EMPTY_PROJECTION = Object.freeze({
+  turn: 0,
+  humanResolved: false,
+  updatedAt: 0
+});
+function safeGetSessionController(sessionId) {
+  try {
+    const fn = getSessionController;
+    return typeof fn === "function" ? fn(sessionId) : void 0;
+  } catch {
+    return void 0;
   }
-  getMessageId() {
-    return this.messageId;
+}
+function safeDebouncedSaveSession() {
+  try {
+    const fn = debouncedSaveSession;
+    if (typeof fn === "function") fn();
+  } catch {
   }
-  async initialize(data = {}) {
-    const payload = {
-      turn: data.turn ?? 1,
-      updatedAt: data.updatedAt ?? Date.now(),
-      phase: data.phase,
-      remoteHumanControl: data.remoteHumanControl,
-      provider: data.provider,
-      permissionsSummary: data.permissionsSummary
-    };
-    this.lastState = "idle";
-    this.lastData = payload;
-    if (this.messageId) {
-      await this.update("idle", payload);
-      return;
+}
+function safeGetProjection(sessionId) {
+  try {
+    const sm = stateMachine;
+    if (sm && typeof sm.getSnapshot === "function") {
+      return sm.getSnapshot(sessionId);
     }
-    const embed = this.buildEmbed("idle", payload);
-    await this.sendNewMessage(embed);
+  } catch {
   }
-  async update(state, data) {
-    this.lastState = state;
-    this.lastData = { ...data };
-    const embed = this.buildEmbed(state, data);
-    if (!this.messageId) {
-      await this.sendNewMessage(embed);
-      return;
+  return EMPTY_PROJECTION;
+}
+var SessionSupervisor = class {
+  contexts = /* @__PURE__ */ new Map();
+  get(sessionId) {
+    const live = getSession(sessionId);
+    const cached = this.contexts.get(sessionId);
+    if (!live) {
+      if (cached) this.contexts.delete(sessionId);
+      return void 0;
     }
-    await this.editExistingMessage(embed);
-  }
-  async recreateAtBottom() {
-    if (!this.messageId || !this.lastData) return null;
-    const oldMessageId = this.messageId;
-    const embed = this.buildEmbed(this.lastState, this.lastData);
-    const msg = await this.channel.send({ embeds: [embed] });
-    this.messageId = msg.id;
-    return { oldMessageId, newMessageId: msg.id };
-  }
-  async sendNewMessage(embed) {
-    try {
-      const msg = await this.channel.send({ embeds: [embed] });
-      this.messageId = msg.id;
-    } catch (error) {
-      console.error("\u72B6\u6001\u5361\u521B\u5EFA\u5931\u8D25:", error);
-      throw error;
+    if (cached) {
+      this.syncContext(cached);
+      return cached;
     }
+    const ctx = this.build(live);
+    this.contexts.set(sessionId, ctx);
+    return ctx;
   }
-  async editExistingMessage(embed) {
-    if (!this.messageId) {
-      await this.sendNewMessage(embed);
-      return;
-    }
-    try {
-      const msg = await this.channel.messages.edit(this.messageId, {
-        embeds: [embed],
-        components: []
-      });
-      this.messageId = msg.id;
-    } catch (error) {
-      console.warn(`\u72B6\u6001\u5361\u7F16\u8F91\u5931\u8D25 (${this.messageId}), \u521B\u5EFA\u65B0\u6D88\u606F:`, error);
-      await this.sendNewMessage(embed);
-    }
+  /** 枚举现有 context。用于 supervisor 层面的扫描(健康检查、空闲回收)。 */
+  all() {
+    return Array.from(this.contexts.values());
   }
-  buildEmbed(state, data) {
-    const embed = new EmbedBuilder().setColor(STATE_COLORS[state]).setTitle(`\u{1F916} ${STATE_LABELS[state]}`).addFields(
-      { name: "\u8F6E\u6B21", value: `#${data.turn}`, inline: true },
-      { name: "\u66F4\u65B0", value: `<t:${Math.floor(data.updatedAt / 1e3)}:R>`, inline: true }
-    ).setTimestamp();
-    if (data.provider === "codex") {
-      const managedLabel = data.remoteHumanControl ? "\u2713 \u53D7\u7BA1\u4F1A\u8BDD" : "\u25CB \u975E\u53D7\u7BA1\u4F1A\u8BDD\uFF08\u4EC5\u72B6\u6001\u76D1\u63A7\uFF09";
-      embed.addFields({ name: "\u4F1A\u8BDD\u7C7B\u578B", value: managedLabel, inline: true });
-    }
-    if (data.phase) {
-      const sanitizedPhase = this.sanitizePhase(data.phase);
-      if (sanitizedPhase) {
-        embed.addFields({ name: "\u9636\u6BB5", value: sanitizedPhase, inline: true });
-      }
-    }
-    if (data.verbose !== void 0) {
-      embed.addFields({ name: "\u8F93\u51FA", value: data.verbose ? "\u{1F50A} \u8BE6\u7EC6" : "\u{1F507} \u7CBE\u7B80", inline: true });
-    }
-    if (data.monitorGoal) {
-      embed.addFields({ name: "\u76D1\u63A7\u76EE\u6807", value: truncate(data.monitorGoal, 150) });
-    }
-    if (data.monitorIteration !== void 0 && data.maxMonitorIterations !== void 0) {
-      embed.addFields({ name: "\u8FED\u4EE3", value: `${data.monitorIteration}/${data.maxMonitorIterations}`, inline: true });
-    }
-    if (data.permissionsSummary) {
-      embed.addFields({ name: "\u6743\u9650", value: data.permissionsSummary, inline: false });
-    }
-    return embed;
+  /** 释放某个 session 的 context(endSession 调用时触发)。 */
+  release(sessionId) {
+    this.contexts.delete(sessionId);
   }
-  /**
-   * Sanitize phase text for status card display.
-   * Returns cleaned text or empty string if unsuitable.
-   */
-  sanitizePhase(description) {
-    let normalized = description.trim();
-    if (!normalized) return "";
-    if (normalized.includes("```") || /diff --git/.test(normalized) || this.isLikelyFileList(normalized)) {
-      console.warn(`[StatusCard] Phase contains unsuitable content, stripping: ${normalized.slice(0, 60)}...`);
-      return "";
-    }
-    if (normalized.length > 200) {
-      normalized = normalized.slice(0, 197) + "...";
-    }
-    return normalized;
+  releaseAll() {
+    this.contexts.clear();
   }
-  validate(description) {
-    if (!description) return;
-    const normalized = description.trim();
-    if (!normalized) return;
-    if (normalized.length > 200) {
-      throw new Error("\u72B6\u6001\u5361\u63CF\u8FF0\u8FC7\u957F\uFF0C\u5E94\u79FB\u81F3\u6458\u8981\u5361\u6216\u7ED3\u679C\u6D88\u606F");
-    }
-    if (normalized.includes("```")) {
-      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B\u4EE3\u7801\u5757");
-    }
-    if (/diff --git/.test(normalized)) {
-      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B diff");
-    }
-    if (this.isLikelyFileList(normalized)) {
-      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B\u6587\u4EF6\u5217\u8868");
-    }
+  build(session) {
+    const ctx = {
+      sessionId: session.id,
+      session,
+      controller: safeGetSessionController(session.id),
+      projection: safeGetProjection(session.id),
+      save: () => safeDebouncedSaveSession(),
+      refresh: () => this.syncContext(ctx)
+    };
+    return ctx;
   }
-  isLikelyFileList(text) {
-    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (lines.length < 2) return false;
-    return lines.every((line) => /^[-+*]\s+[\w./\\-]+$/.test(line));
+  syncContext(ctx) {
+    const live = getSession(ctx.sessionId);
+    if (live) {
+      ctx.session = live;
+    }
+    ctx.controller = safeGetSessionController(
+      ctx.sessionId
+    );
+    ctx.projection = safeGetProjection(
+      ctx.sessionId
+    );
   }
 };
+var sessionSupervisor = new SessionSupervisor();
+function getSessionContext(sessionId) {
+  return sessionSupervisor.get(sessionId);
+}
+function getSessionView(sessionId) {
+  return sessionSupervisor.get(sessionId)?.session;
+}
 
-// ../bot/src/discord/summary-handler.ts
-import "discord.js";
+// ../bot/src/subagent-manager.ts
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration
+} from "discord.js";
 
 // ../bot/src/discord/delivery-policy.ts
 import { existsSync, statSync } from "fs";
@@ -338,71 +298,772 @@ async function sendWithBackoff(channel, payload) {
       const message = await channel.send(payload);
       return message.id;
     } catch (error) {
-      if (!isDiscordRateLimitError(error) || attempt >= SEND_MAX_RETRIES) {
-        throw error;
-      }
-      const delayMs = 250 * 2 ** attempt;
-      console.warn(
-        `[Delivery] Discord rate-limited (attempt ${attempt + 1}/${SEND_MAX_RETRIES}), retrying in ${delayMs}ms`
-      );
-      await sleep(delayMs);
-      attempt++;
+      if (!isDiscordRateLimitError(error) || attempt >= SEND_MAX_RETRIES) {
+        throw error;
+      }
+      const delayMs = 250 * 2 ** attempt;
+      console.warn(
+        `[Delivery] Discord rate-limited (attempt ${attempt + 1}/${SEND_MAX_RETRIES}), retrying in ${delayMs}ms`
+      );
+      await sleep(delayMs);
+      attempt++;
+    }
+  }
+}
+async function sendChunk(channel, chunk, options = {}) {
+  const payload = { content: chunk };
+  if (options.files?.length) payload.files = options.files;
+  if (options.replyToMessageId) {
+    payload.reply = { messageReference: options.replyToMessageId };
+  }
+  try {
+    return await sendWithBackoff(channel, payload);
+  } catch (error) {
+    if (!options.replyToMessageId) {
+      throw error;
+    }
+    const fallbackPayload = { content: chunk };
+    if (options.files?.length) fallbackPayload.files = options.files;
+    return sendWithBackoff(channel, fallbackPayload);
+  }
+}
+async function deliver(channel, plan) {
+  pruneStaleSessionStates();
+  const state = getSessionState(plan.sessionId);
+  if (plan.mode === "progress_update") {
+    const targetMessageId = plan.editTargetMessageId ?? state.recentProgressMessageId;
+    if (targetMessageId && plan.chunks.length === 1 && plan.filesOnFirstChunk.length === 0) {
+      try {
+        await channel.messages?.edit(targetMessageId, { content: plan.chunks[0] });
+        state.recentProgressMessageId = targetMessageId;
+        return [targetMessageId];
+      } catch {
+      }
+    }
+  }
+  const ids = [];
+  const replyToMode = plan.replyToMode ?? "first";
+  for (let index = 0; index < plan.chunks.length; index++) {
+    const shouldReply = !!plan.replyToMessageId && replyToMode !== "off" && (replyToMode === "all" || index === 0);
+    const id = await sendChunk(channel, plan.chunks[index], {
+      replyToMessageId: shouldReply ? plan.replyToMessageId : void 0,
+      files: index === 0 ? plan.filesOnFirstChunk : void 0
+    });
+    ids.push(id);
+  }
+  if (ids.length > 0) {
+    if (plan.mode === "progress_update") {
+      state.recentProgressMessageId = ids[ids.length - 1];
+    } else {
+      state.recentFinalMessageId = ids[ids.length - 1];
+    }
+  }
+  return ids;
+}
+
+// ../bot/src/discord/delivery-notices.ts
+function getDeliveryPolicy() {
+  return {
+    textChunkLimit: config.textChunkLimit ?? 2e3,
+    chunkMode: config.chunkMode ?? "length",
+    replyToMode: config.replyToMode ?? "first",
+    ackReaction: config.ackReaction ?? "\u{1F440}"
+  };
+}
+async function sendSystemNotice(channel, sessionId, text, replyToMessageId) {
+  if (!text.trim()) return;
+  const plan = buildDeliveryPlan({
+    sessionId,
+    chatId: channel.id,
+    text,
+    files: [],
+    mode: "system_notice",
+    replyToMessageId,
+    policy: getDeliveryPolicy()
+  });
+  try {
+    await deliver(channel, plan);
+  } catch {
+  }
+}
+
+// ../bot/src/subagent-manager.ts
+var SUBAGENT_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
+function canSpawnSubagent(parentSession) {
+  return parentSession.subagentDepth < config.maxSubagentDepth;
+}
+async function spawnSubagent(parentSession, label, provider, sessionChannel) {
+  if (!canSpawnSubagent(parentSession)) {
+    console.warn(`[SubagentManager] Depth limit hit for session ${parentSession.id} (max depth ${config.maxSubagentDepth})`);
+    throw new Error(
+      `Max subagent depth (${config.maxSubagentDepth}) reached. Cannot spawn further subagents.`
+    );
+  }
+  const threadName = `[sub:${provider}] ${label}`.slice(0, 100);
+  const thread = await sessionChannel.threads.create({
+    name: threadName,
+    type: ChannelType.PublicThread,
+    autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+    reason: `Subagent spawned by session ${parentSession.id}`
+  });
+  const session = await createSession({
+    channelId: thread.id,
+    // Subagent's primary ID is the Thread
+    categoryId: parentSession.categoryId,
+    projectName: parentSession.projectName,
+    agentLabel: label,
+    provider,
+    directory: parentSession.directory,
+    type: "subagent",
+    parentChannelId: parentSession.channelId,
+    // Parent session's TextChannel
+    subagentDepth: parentSession.subagentDepth + 1,
+    mode: parentSession.mode,
+    claudePermissionMode: provider === "claude" ? parentSession.claudePermissionMode : void 0
+  });
+  console.log(`[SubagentManager] Spawned subagent "${label}" session ${session.id} thread ${thread.id} (depth ${session.subagentDepth}, parent ${parentSession.id})`);
+  return session;
+}
+async function archiveSubagent(session, thread, summary) {
+  if (summary) {
+    await sendSystemNotice(thread, session.id, `*\u5B50\u4EFB\u52A1\u5B8C\u6210\uFF1A${summary}*`);
+  }
+  try {
+    await thread.setArchived(true, "Subagent task completed");
+  } catch (error) {
+    console.warn(`[SubagentManager] Failed to archive thread ${thread.id} for subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    await endSession(session.id);
+    console.log(`[SubagentManager] Archived subagent ${session.id} thread ${thread.id}${summary ? ` \u2014 ${summary}` : ""}`);
+  } catch (error) {
+    console.warn(`[SubagentManager] Failed to end session for subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function getSubagents(parentSession) {
+  return getAllSessions().filter(
+    (s) => s.type === "subagent" && s.parentChannelId === parentSession.channelId
+  );
+}
+async function runSubagentWatchdog(getThread) {
+  const now = Date.now();
+  const checked = /* @__PURE__ */ new Set();
+  let archived = 0;
+  let errors = 0;
+  for (const session of getSubagentSessions()) {
+    if (checked.has(session.id)) continue;
+    checked.add(session.id);
+    const idle = now - session.lastActivity;
+    if (idle < SUBAGENT_IDLE_TIMEOUT_MS) continue;
+    if (session.isGenerating) continue;
+    const thread = getThread(session.channelId);
+    if (!thread) {
+      await endSession(session.id).catch((e) => console.warn(`[SubagentWatchdog] Failed to end orphaned subagent ${session.id}: ${e.message}`));
+      console.log(`[SubagentWatchdog] Ended orphaned subagent ${session.id} \u2014 thread ${session.channelId} not found`);
+      continue;
+    }
+    try {
+      await archiveSubagent(session, thread, "Idle timeout reached.");
+      archived += 1;
+    } catch (error) {
+      console.error(`[SubagentWatchdog] Failed to archive idle subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+      errors += 1;
+    }
+  }
+  console.log(`[SubagentWatchdog] Watchdog run: checked ${checked.size} subagents, archived ${archived}, errors ${errors}`);
+}
+async function autoSpawnSubagentThread(parentSession, taskId, description, sessionChannel) {
+  if (parentSession.type === "subagent") return null;
+  if (!canSpawnSubagent(parentSession)) return null;
+  const threadName = `[task] ${description}`.slice(0, 100);
+  const thread = await sessionChannel.threads.create({
+    name: threadName,
+    type: ChannelType.PublicThread,
+    autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+    reason: `Auto-created for task ${taskId} in session ${parentSession.id}`
+  });
+  let session;
+  try {
+    session = await createSession({
+      channelId: thread.id,
+      categoryId: parentSession.categoryId,
+      projectName: parentSession.projectName,
+      agentLabel: description,
+      provider: parentSession.provider,
+      directory: parentSession.directory,
+      type: "subagent",
+      parentChannelId: parentSession.channelId,
+      subagentDepth: (parentSession.subagentDepth || 0) + 1,
+      mode: parentSession.mode,
+      claudePermissionMode: parentSession.provider === "claude" ? parentSession.claudePermissionMode : void 0
+    });
+  } catch (err) {
+    console.warn(`[SubagentManager] createSession failed for auto-spawned task ${taskId}, deleting orphan thread ${thread.id}: ${err instanceof Error ? err.message : String(err)}`);
+    await thread.delete("Session creation failed").catch(
+      (deleteErr) => console.warn(`[SubagentManager] Failed to delete orphan thread ${thread.id}: ${deleteErr instanceof Error ? deleteErr.message : String(deleteErr)}`)
+    );
+    throw err;
+  }
+  console.log(`[SubagentManager] Auto-spawned thread for task ${taskId} session ${session.id} thread ${thread.id}`);
+  return { threadId: thread.id, session };
+}
+function getSubagentSessions() {
+  return getAllSessions().filter((s) => s.type === "subagent");
+}
+
+// ../bot/src/codex-renderer.ts
+import { EmbedBuilder } from "discord.js";
+
+// ../bot/src/output/interaction-controls.ts
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  StringSelectMenuBuilder,
+  EmbedBuilder as EmbedBuilder2
+} from "discord.js";
+
+// ../engine/src/output/answer-store.ts
+var pendingAnswersStore = /* @__PURE__ */ new Map();
+var questionCountStore = /* @__PURE__ */ new Map();
+function setPendingAnswer(sessionId, questionIndex, answer) {
+  if (!pendingAnswersStore.has(sessionId)) {
+    pendingAnswersStore.set(sessionId, /* @__PURE__ */ new Map());
+  }
+  pendingAnswersStore.get(sessionId).set(questionIndex, answer);
+}
+function getPendingAnswers(sessionId) {
+  return pendingAnswersStore.get(sessionId);
+}
+function clearPendingAnswers(sessionId) {
+  pendingAnswersStore.delete(sessionId);
+  questionCountStore.delete(sessionId);
+}
+function getQuestionCount(sessionId) {
+  return questionCountStore.get(sessionId) || 0;
+}
+
+// ../bot/src/output/interaction-controls.ts
+function resolveEffectiveClaudePermissionMode(currentMode, claudePermissionMode) {
+  if (!claudePermissionMode) return void 0;
+  return currentMode === "auto" ? "bypass" : claudePermissionMode;
+}
+function makeModeButtons(sessionId, currentMode, claudePermissionMode) {
+  const modes = [
+    { id: "auto", label: "\u26A1 \u81EA\u52A8\u6A21\u5F0F" },
+    { id: "plan", label: "\u{1F4CB} \u8BA1\u5212\u6A21\u5F0F" },
+    { id: "normal", label: "\u{1F6E1}\uFE0F \u666E\u901A\u6A21\u5F0F" },
+    { id: "monitor", label: "\u{1F9E0} \u76D1\u63A7\u6A21\u5F0F" }
+  ];
+  const row = new ActionRowBuilder();
+  for (const m of modes) {
+    row.addComponents(
+      new ButtonBuilder().setCustomId(`mode:${sessionId}:${m.id}`).setLabel(m.id === currentMode ? `\u2713 ${m.label}` : m.label).setStyle(m.id === currentMode ? ButtonStyle.Success : ButtonStyle.Secondary).setDisabled(false)
+    );
+  }
+  const effectiveClaudePermissionMode = resolveEffectiveClaudePermissionMode(
+    currentMode,
+    claudePermissionMode
+  );
+  if (effectiveClaudePermissionMode) {
+    const permLabel = effectiveClaudePermissionMode === "bypass" ? "\u26A1 \u7ED5\u8FC7\u6743\u9650" : "\u{1F6E1}\uFE0F \u9700\u8981\u786E\u8BA4";
+    row.addComponents(
+      new ButtonBuilder().setCustomId(`perm-info:${sessionId}`).setLabel(permLabel).setStyle(
+        effectiveClaudePermissionMode === "bypass" ? ButtonStyle.Danger : ButtonStyle.Success
+      ).setDisabled(true)
+    );
+  }
+  return row;
+}
+function shouldSuppressCommandExecution(command) {
+  return command.toLowerCase().includes("total-recall");
+}
+
+// ../bot/src/output/event-handlers.ts
+function providerSource(sessionId) {
+  const session = getSessionView(sessionId);
+  return session?.provider === "codex" ? "codex" : "claude";
+}
+var textDelta = (event, ctx) => {
+  ctx.streamer.append(event.text);
+};
+var askUser = async (event, ctx) => {
+  ctx.state.askedUser = true;
+  ctx.state.askUserQuestionsJson = event.questionsJson;
+  await ctx.streamer.discard();
+  const session = getSessionView(ctx.sessionId);
+  if (!session) return;
+  const source = providerSource(ctx.sessionId);
+  await updateSessionState(ctx.sessionId, {
+    type: "awaiting_human",
+    sessionId: ctx.sessionId,
+    source,
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: { detail: event.questionsJson }
+  });
+  await flushDigest(ctx.sessionId);
+  await handleAwaitingHuman(ctx.sessionId, event.questionsJson, { source });
+};
+var task = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, { kind: "tool", text: `\u4EFB\u52A1\u5DE5\u5177\uFF1A${event.action}` });
+  ctx.state.lastToolName = event.action;
+};
+var taskStarted = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, {
+    kind: "subagent",
+    text: `\u5B50\u4EE3\u7406\u542F\u52A8\uFF1A${truncate(event.description, 80)}`
+  });
+  const session = getSessionView(ctx.sessionId);
+  if (!session || ctx.channel.type === void 0) return;
+  autoSpawnSubagentThread(session, event.taskId, event.description, ctx.channel).then((result2) => {
+    if (result2) ctx.state.taskThreadMap.set(event.taskId, result2.threadId);
+  }).catch(
+    (err) => console.warn(
+      `[OutputHandler] Failed to auto-spawn thread for task ${event.taskId}: ${err.message}`
+    )
+  );
+};
+var taskProgress = (event, ctx) => {
+  if (event.summary) {
+    queueDigest(ctx.sessionId, {
+      kind: "subagent",
+      text: `\u5B50\u4EE3\u7406\u8FDB\u5C55\uFF1A${truncate(event.summary, 100)}`
+    });
+  }
+  const threadId = ctx.state.taskThreadMap.get(event.taskId);
+  if (!threadId || !event.summary) return;
+  const thread = ctx.channel.threads?.cache.get(threadId);
+  if (!thread) return;
+  thread.send(`\u{1F4DD} ${truncate(event.summary, 1900)}`).catch(
+    (e) => console.warn(
+      `[OutputHandler] Failed to send progress to thread: ${e.message}`
+    )
+  );
+};
+var taskDone = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, {
+    kind: "subagent",
+    text: `\u5B50\u4EE3\u7406${event.status === "completed" ? "\u5B8C\u6210" : "\u7ED3\u675F"}\uFF1A${truncate(event.summary || "No summary.", 100)}`
+  });
+  const threadId = ctx.state.taskThreadMap.get(event.taskId);
+  if (!threadId) return;
+  const thread = ctx.channel.threads?.cache.get(threadId);
+  if (thread) {
+    const emoji = event.status === "completed" ? "\u2705" : "\u274C";
+    thread.send(`${emoji} \u5B50\u4EFB\u52A1${event.status === "completed" ? "\u5B8C\u6210" : "\u7ED3\u675F"}\uFF1A${truncate(event.summary || "", 1900)}`).catch(
+      (e) => console.warn(
+        `[OutputHandler] Failed to send task done to thread: ${e.message}`
+      )
+    );
+  }
+  ctx.state.taskThreadMap.delete(event.taskId);
+};
+var webSearch = (event, ctx) => {
+  if (ctx.verbose) {
+    queueDigest(ctx.sessionId, { kind: "search", text: `\u68C0\u7D22\uFF1A${truncate(event.query, 80)}` });
+  }
+};
+var toolStart = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, { kind: "tool", text: `\u5DE5\u5177\uFF1A${event.toolName}` });
+  ctx.state.lastToolName = event.toolName;
+};
+var toolResult = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  if (ctx.verbose && event.result) {
+    queueDigest(ctx.sessionId, {
+      kind: "tool",
+      text: `\u5DE5\u5177\u7ED3\u679C\uFF1A${truncate(ctx.state.lastToolName || event.toolName || "tool", 60)}`
+    });
+  }
+};
+var imageFile = (event, ctx) => {
+  if (existsSync2(event.filePath)) {
+    ctx.state.pendingAttachments.push(event.filePath);
+  }
+};
+var commandExecution = (event, ctx) => {
+  ctx.state.commandCount++;
+  if (ctx.state.recentCommands.length < 8) ctx.state.recentCommands.push(event.command);
+  if (!shouldSuppressCommandExecution(event.command)) {
+    queueDigest(ctx.sessionId, {
+      kind: "command",
+      text: `\u547D\u4EE4\uFF1A${truncate(event.command, 80)}${event.exitCode !== null ? `\uFF08\u9000\u51FA\u7801 ${event.exitCode}\uFF09` : ""}`
+    });
+  }
+};
+var fileChange = (event, ctx) => {
+  ctx.state.fileChangeCount += event.changes.length;
+  for (const change of event.changes) {
+    if (!change.filePath) continue;
+    if (ctx.state.changedFiles.includes(change.filePath)) continue;
+    if (ctx.state.changedFiles.length >= 12) break;
+    ctx.state.changedFiles.push(change.filePath);
+  }
+  queueDigest(ctx.sessionId, {
+    kind: "file",
+    text: `\u6587\u4EF6\u53D8\u66F4\uFF1A${event.changes.length} \u4E2A\uFF08\u6700\u8FD1\uFF1A${truncate(ctx.state.changedFiles.slice(-3).join(", "), 120)}\uFF09`
+  });
+};
+var reasoning = (event, ctx) => {
+  if (ctx.verbose) {
+    queueDigest(ctx.sessionId, { kind: "reasoning", text: `\u63A8\u7406\uFF1A${truncate(event.text, 100)}` });
+  }
+};
+var todoList = async (event, ctx) => {
+  const completed = event.items.filter((item) => item.completed).length;
+  queueDigest(ctx.sessionId, {
+    kind: "todo",
+    text: `\u5F85\u529E\u66F4\u65B0\uFF1A${completed}/${event.items.length} \u5DF2\u5B8C\u6210`
+  });
+  await updateSessionState(ctx.sessionId, {
+    type: "todo_updated",
+    sessionId: ctx.sessionId,
+    source: providerSource(ctx.sessionId),
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: { items: event.items }
+  });
+};
+var MODE_LABELS = {
+  auto: "\u81EA\u52A8",
+  plan: "\u8BA1\u5212",
+  normal: "\u666E\u901A",
+  monitor: "\u76D1\u63A7"
+};
+var TERMINAL_REASON_LABELS = {
+  completed: "\u5DF2\u5B8C\u6210",
+  max_turns: "\u5DF2\u8FBE\u6700\u5927\u8F6E\u6B21",
+  aborted: "\u5DF2\u4E2D\u6B62",
+  rate_limited: "\u89E6\u53D1\u901F\u7387\u9650\u5236",
+  context_too_long: "\u4E0A\u4E0B\u6587\u8D85\u957F",
+  model_error: "\u6A21\u578B\u9519\u8BEF",
+  tool_deferred: "\u5DE5\u5177\u5BA1\u6279\u5EF6\u540E",
+  hook_stopped: "\u88AB\u94A9\u5B50\u963B\u65AD",
+  image_error: "\u56FE\u50CF\u9519\u8BEF",
+  error: "\u5F02\u5E38"
+};
+function formatTerminalReason(reason, fallbackSuccess) {
+  if (!reason) return fallbackSuccess ? "\u5DF2\u5B8C\u6210" : "\u5F02\u5E38";
+  return TERMINAL_REASON_LABELS[reason] ?? reason;
+}
+var result = async (event, ctx) => {
+  ctx.state.success = event.success;
+  const lastText = ctx.streamer.getText();
+  const cost = event.costUsd.toFixed(4);
+  const duration = event.durationMs ? `${(event.durationMs / 1e3).toFixed(1)}s` : "unknown";
+  const turns = event.numTurns || 0;
+  const modeLabel = MODE_LABELS[ctx.mode] || "\u81EA\u52A8";
+  const reasonLabel = formatTerminalReason(event.terminalReason, event.success);
+  const showReason = event.terminalReason && event.terminalReason !== "completed";
+  const reasonSuffix = showReason ? ` | ${reasonLabel}` : "";
+  const statusLine = event.success ? `-# $${cost} | ${duration} | ${turns} turns | ${modeLabel}${reasonSuffix}` : `-# ${reasonLabel} | $${cost} | ${duration} | ${turns} turns`;
+  ctx.streamer.append(`
+${statusLine}`, { persist: false });
+  if (!event.success && event.errors.length) {
+    ctx.streamer.append(`
+\`\`\`
+${event.errors.join("\n")}
+\`\`\``, { persist: false });
+  }
+  await ctx.streamer.finalize();
+  const session = getSessionView(ctx.sessionId);
+  if (!session) {
+    ctx.state.pendingAttachments = [];
+    return;
+  }
+  if (ctx.mode === "monitor") {
+    await flushDigest(ctx.sessionId);
+    await updateSessionState(ctx.sessionId, {
+      type: "work_started",
+      sessionId: ctx.sessionId,
+      source: providerSource(ctx.sessionId),
+      confidence: "high",
+      timestamp: Date.now(),
+      metadata: {
+        phase: "\u7B49\u5F85\u76D1\u7763\u5224\u65AD",
+        summary: event.success ? "\u672C\u8F6E\u6267\u884C\u7ED3\u675F\uFF0C\u7B49\u5F85\u76D1\u7763\u5224\u65AD" : "\u672C\u8F6E\u6267\u884C\u5931\u8D25\uFF0C\u7B49\u5F85\u76D1\u7763\u5224\u65AD"
+      }
+    });
+  } else {
+    ctx.state.deferredResult = {
+      event,
+      text: lastText,
+      attachments: [...ctx.state.pendingAttachments]
+    };
+  }
+  ctx.state.pendingAttachments = [];
+};
+var permissionDenied = async (event, ctx) => {
+  queueDigest(ctx.sessionId, {
+    kind: "denied",
+    text: `\u26D4 \u6743\u9650\u62D2\u7EDD\uFF1A${truncate(event.toolName, 40)} \u2014 ${truncate(event.reason, 80)}`
+  });
+  await updateSessionState(ctx.sessionId, {
+    type: "permission_denied",
+    sessionId: ctx.sessionId,
+    source: providerSource(ctx.sessionId),
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: {
+      toolName: event.toolName,
+      reason: event.reason,
+      source: event.source
+    }
+  });
+};
+var errorEvent = async (event, ctx) => {
+  console.warn(`[OutputHandler] Session ${ctx.sessionId}: error event \u2014 ${event.message}`);
+  ctx.state.hadError = true;
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, { kind: "error", text: `\u9519\u8BEF\uFF1A${truncate(event.message, 120)}` });
+  if (ctx.mode === "monitor") return;
+  const session = getSessionView(ctx.sessionId);
+  if (!session) return;
+  await flushDigest(ctx.sessionId);
+  await updateSessionState(ctx.sessionId, {
+    type: "errored",
+    sessionId: ctx.sessionId,
+    source: providerSource(ctx.sessionId),
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: { errorMessage: event.message }
+  });
+};
+var sessionInit = () => {
+};
+var EVENT_HANDLERS = {
+  text_delta: textDelta,
+  ask_user: askUser,
+  task,
+  task_started: taskStarted,
+  task_progress: taskProgress,
+  task_done: taskDone,
+  web_search: webSearch,
+  tool_start: toolStart,
+  tool_result: toolResult,
+  image_file: imageFile,
+  command_execution: commandExecution,
+  file_change: fileChange,
+  reasoning,
+  todo_list: todoList,
+  permission_denied: permissionDenied,
+  result,
+  error: errorEvent,
+  session_init: sessionInit
+};
+async function dispatchEvent(event, ctx) {
+  const handler = EVENT_HANDLERS[event.type];
+  if (!handler) return;
+  await handler(event, ctx);
+}
+
+// ../bot/src/discord/status-card.ts
+import {
+  EmbedBuilder as EmbedBuilder3
+} from "discord.js";
+var StatusCard = class {
+  messageId = null;
+  channel;
+  lastState = "idle";
+  lastData = null;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  adopt(messageId) {
+    this.messageId = messageId;
+  }
+  getMessageId() {
+    return this.messageId;
+  }
+  async initialize(data = {}) {
+    const payload = {
+      turn: data.turn ?? 1,
+      updatedAt: data.updatedAt ?? Date.now(),
+      phase: data.phase,
+      remoteHumanControl: data.remoteHumanControl,
+      provider: data.provider,
+      permissionsSummary: data.permissionsSummary
+    };
+    this.lastState = "idle";
+    this.lastData = payload;
+    if (this.messageId) {
+      await this.update("idle", payload);
+      return;
+    }
+    const embed = this.buildEmbed("idle", payload);
+    await this.sendNewMessage(embed);
+  }
+  async update(state, data) {
+    this.lastState = state;
+    this.lastData = { ...data };
+    const embed = this.buildEmbed(state, data);
+    if (!this.messageId) {
+      await this.sendNewMessage(embed);
+      return;
+    }
+    await this.editExistingMessage(embed);
+  }
+  async recreateAtBottom() {
+    if (!this.messageId || !this.lastData) return null;
+    const oldMessageId = this.messageId;
+    const embed = this.buildEmbed(this.lastState, this.lastData);
+    const msg = await this.channel.send({ embeds: [embed] });
+    this.messageId = msg.id;
+    return { oldMessageId, newMessageId: msg.id };
+  }
+  async sendNewMessage(embed) {
+    try {
+      const msg = await this.channel.send({ embeds: [embed] });
+      this.messageId = msg.id;
+    } catch (error) {
+      console.error("\u72B6\u6001\u5361\u521B\u5EFA\u5931\u8D25:", error);
+      throw error;
     }
   }
-}
-async function sendChunk(channel, chunk, options = {}) {
-  const payload = { content: chunk };
-  if (options.files?.length) payload.files = options.files;
-  if (options.replyToMessageId) {
-    payload.reply = { messageReference: options.replyToMessageId };
-  }
-  try {
-    return await sendWithBackoff(channel, payload);
-  } catch (error) {
-    if (!options.replyToMessageId) {
-      throw error;
+  async editExistingMessage(embed) {
+    if (!this.messageId) {
+      await this.sendNewMessage(embed);
+      return;
+    }
+    try {
+      const msg = await this.channel.messages.edit(this.messageId, {
+        embeds: [embed],
+        components: []
+      });
+      this.messageId = msg.id;
+    } catch (error) {
+      console.warn(`\u72B6\u6001\u5361\u7F16\u8F91\u5931\u8D25 (${this.messageId}), \u521B\u5EFA\u65B0\u6D88\u606F:`, error);
+      await this.sendNewMessage(embed);
     }
-    const fallbackPayload = { content: chunk };
-    if (options.files?.length) fallbackPayload.files = options.files;
-    return sendWithBackoff(channel, fallbackPayload);
   }
-}
-async function deliver(channel, plan) {
-  pruneStaleSessionStates();
-  const state = getSessionState(plan.sessionId);
-  if (plan.mode === "progress_update") {
-    const targetMessageId = plan.editTargetMessageId ?? state.recentProgressMessageId;
-    if (targetMessageId && plan.chunks.length === 1 && plan.filesOnFirstChunk.length === 0) {
-      try {
-        await channel.messages?.edit(targetMessageId, { content: plan.chunks[0] });
-        state.recentProgressMessageId = targetMessageId;
-        return [targetMessageId];
-      } catch {
+  buildEmbed(state, data) {
+    const embed = new EmbedBuilder3().setColor(STATE_COLORS[state]).setTitle(`\u{1F916} ${STATE_LABELS[state]}`).addFields(
+      { name: "\u8F6E\u6B21", value: `#${data.turn}`, inline: true },
+      { name: "\u66F4\u65B0", value: `<t:${Math.floor(data.updatedAt / 1e3)}:R>`, inline: true }
+    ).setTimestamp();
+    if (data.provider === "codex") {
+      const managedLabel = data.remoteHumanControl ? "\u2713 \u53D7\u7BA1\u4F1A\u8BDD" : "\u25CB \u975E\u53D7\u7BA1\u4F1A\u8BDD\uFF08\u4EC5\u72B6\u6001\u76D1\u63A7\uFF09";
+      embed.addFields({ name: "\u4F1A\u8BDD\u7C7B\u578B", value: managedLabel, inline: true });
+    }
+    if (data.phase) {
+      const sanitizedPhase = this.sanitizePhase(data.phase);
+      if (sanitizedPhase) {
+        embed.addFields({ name: "\u9636\u6BB5", value: sanitizedPhase, inline: true });
+      }
+    }
+    if (data.verbose !== void 0) {
+      embed.addFields({ name: "\u8F93\u51FA", value: data.verbose ? "\u{1F50A} \u8BE6\u7EC6" : "\u{1F507} \u7CBE\u7B80", inline: true });
+    }
+    if (data.monitorGoal) {
+      embed.addFields({ name: "\u76D1\u63A7\u76EE\u6807", value: truncate(data.monitorGoal, 150) });
+    }
+    if (data.monitorIteration !== void 0 && data.maxMonitorIterations !== void 0) {
+      embed.addFields({ name: "\u8FED\u4EE3", value: `${data.monitorIteration}/${data.maxMonitorIterations}`, inline: true });
+    }
+    if (data.permissionsSummary) {
+      embed.addFields({ name: "\u6743\u9650", value: data.permissionsSummary, inline: false });
+    }
+    if (data.todoList && data.todoList.length > 0) {
+      const rendered = this.renderTodoList(data.todoList);
+      if (rendered) {
+        const completed = data.todoList.filter((t) => t.completed).length;
+        embed.addFields({
+          name: `\u5F85\u529E\uFF08${completed}/${data.todoList.length}\uFF09`,
+          value: rendered,
+          inline: false
+        });
       }
     }
+    if (data.batchApprovalMode) {
+      const pending = data.pendingApprovals ?? [];
+      const queueLine = pending.length === 0 ? "\u961F\u5217\u4E3A\u7A7A" : pending.slice(0, 5).map((a) => `\u2022 ${truncate(a.toolName, 32)} \u2014 ${truncate(a.detail, 80)}`).join("\n");
+      embed.addFields({
+        name: `\u6279\u91CF\u5BA1\u6279\uFF08${pending.length} \u5F85\u6279\uFF09`,
+        value: queueLine + (pending.length > 5 ? `
+\u2026\u8FD8\u6709 ${pending.length - 5} \u6761` : ""),
+        inline: false
+      });
+    }
+    if (data.recentPermissionDenials && data.recentPermissionDenials.length > 0) {
+      const lines = data.recentPermissionDenials.slice(0, 3).map((d) => `\u26D4 ${truncate(d.toolName, 28)} \u2014 ${truncate(d.reason, 80)}`).join("\n");
+      embed.addFields({ name: "\u6700\u8FD1\u62D2\u7EDD", value: lines, inline: false });
+    }
+    return embed;
   }
-  const ids = [];
-  const replyToMode = plan.replyToMode ?? "first";
-  for (let index = 0; index < plan.chunks.length; index++) {
-    const shouldReply = !!plan.replyToMessageId && replyToMode !== "off" && (replyToMode === "all" || index === 0);
-    const id = await sendChunk(channel, plan.chunks[index], {
-      replyToMessageId: shouldReply ? plan.replyToMessageId : void 0,
-      files: index === 0 ? plan.filesOnFirstChunk : void 0
-    });
-    ids.push(id);
+  renderTodoList(items) {
+    const TOTAL_BUDGET = 950;
+    const MAX_LINES = 8;
+    const MAX_CHAR_PER_LINE = 180;
+    const lines = [];
+    let used = 0;
+    let renderedCount = 0;
+    for (const item of items.slice(0, MAX_LINES)) {
+      const mark = item.completed ? "\u2611" : "\u2610";
+      const line = `${mark} ${truncate(item.text, MAX_CHAR_PER_LINE)}`;
+      const cost = (lines.length > 0 ? 1 : 0) + line.length;
+      if (used + cost > TOTAL_BUDGET) break;
+      lines.push(line);
+      used += cost;
+      renderedCount++;
+    }
+    const hidden = items.length - renderedCount;
+    if (hidden > 0) {
+      const more = `\u2026 \u8FD8\u6709 ${hidden} \u9879`;
+      const cost = (lines.length > 0 ? 1 : 0) + more.length;
+      if (used + cost <= TOTAL_BUDGET) lines.push(more);
+    }
+    return lines.join("\n");
   }
-  if (ids.length > 0) {
-    if (plan.mode === "progress_update") {
-      state.recentProgressMessageId = ids[ids.length - 1];
-    } else {
-      state.recentFinalMessageId = ids[ids.length - 1];
+  /**
+   * Sanitize phase text for status card display.
+   * Returns cleaned text or empty string if unsuitable.
+   */
+  sanitizePhase(description) {
+    let normalized = description.trim();
+    if (!normalized) return "";
+    if (normalized.includes("```") || /diff --git/.test(normalized) || this.isLikelyFileList(normalized)) {
+      console.warn(`[StatusCard] Phase contains unsuitable content, stripping: ${normalized.slice(0, 60)}...`);
+      return "";
+    }
+    if (normalized.length > 200) {
+      normalized = normalized.slice(0, 197) + "...";
     }
+    return normalized;
   }
-  return ids;
-}
+  validate(description) {
+    if (!description) return;
+    const normalized = description.trim();
+    if (!normalized) return;
+    if (normalized.length > 200) {
+      throw new Error("\u72B6\u6001\u5361\u63CF\u8FF0\u8FC7\u957F\uFF0C\u5E94\u79FB\u81F3\u6458\u8981\u5361\u6216\u7ED3\u679C\u6D88\u606F");
+    }
+    if (normalized.includes("```")) {
+      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B\u4EE3\u7801\u5757");
+    }
+    if (/diff --git/.test(normalized)) {
+      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B diff");
+    }
+    if (this.isLikelyFileList(normalized)) {
+      throw new Error("\u72B6\u6001\u5361\u4E0D\u5E94\u5305\u542B\u6587\u4EF6\u5217\u8868");
+    }
+  }
+  isLikelyFileList(text) {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (lines.length < 2) return false;
+    return lines.every((line) => /^[-+*]\s+[\w./\\-]+$/.test(line));
+  }
+};
+
+// ../bot/src/discord/summary-handler.ts
+import "discord.js";
 
 // ../bot/src/discord/digest-delivery.ts
-import { EmbedBuilder as EmbedBuilder2 } from "discord.js";
+import { EmbedBuilder as EmbedBuilder4 } from "discord.js";
 var DigestDelivery = class {
   channel;
   messageIds = [];
@@ -461,7 +1122,7 @@ var DigestDelivery = class {
     return { oldMessageIds, newMessageIds };
   }
   buildDigestEmbed(content, index, total) {
-    const embed = new EmbedBuilder2().setColor(3447003).setDescription(content).setTimestamp();
+    const embed = new EmbedBuilder4().setColor(3447003).setDescription(content).setTimestamp();
     if (index === 0) embed.setTitle("\u{1F4CC} \u6700\u8FD1\u6458\u8981");
     if (total > 1) {
       embed.setFooter({ text: `\u7B2C ${index + 1}/${total} \u90E8\u5206` });
@@ -543,10 +1204,10 @@ var SummaryHandler = class {
 
 // ../bot/src/discord/interaction-card.ts
 import {
-  EmbedBuilder as EmbedBuilder3,
-  ActionRowBuilder,
-  ButtonBuilder,
-  ButtonStyle
+  EmbedBuilder as EmbedBuilder5,
+  ActionRowBuilder as ActionRowBuilder2,
+  ButtonBuilder as ButtonBuilder2,
+  ButtonStyle as ButtonStyle2
 } from "discord.js";
 var InteractionCard = class {
   channel;
@@ -556,16 +1217,16 @@ var InteractionCard = class {
   }
   async show(sessionId, turn, detail, options = {}) {
     const customIdBase = `awaiting_human:${sessionId}:${turn}`;
-    const embed = new EmbedBuilder3().setTitle("\u23F8\uFE0F \u7B49\u5F85\u4EBA\u5DE5\u5904\u7406").setDescription(detail).setColor(16755200).setTimestamp();
+    const embed = new EmbedBuilder5().setTitle("\u23F8\uFE0F \u7B49\u5F85\u4EBA\u5DE5\u5904\u7406").setDescription(detail).setColor(16755200).setTimestamp();
     embed.addFields(
       { name: "\u8F6E\u6B21", value: `#${turn}`, inline: true },
       { name: "\u7B49\u5F85\u81EA", value: `<t:${Math.floor(Date.now() / 1e3)}:R>`, inline: true }
     );
     let components = [];
     if (options.remoteHumanControl !== false) {
-      const row = new ActionRowBuilder().addComponents(
-        new ButtonBuilder().setCustomId(`${customIdBase}:approve`).setLabel("\u5141\u8BB8\u7EE7\u7EED").setStyle(ButtonStyle.Success),
-        new ButtonBuilder().setCustomId(`${customIdBase}:deny`).setLabel("\u62D2\u7EDD").setStyle(ButtonStyle.Danger)
+      const row = new ActionRowBuilder2().addComponents(
+        new ButtonBuilder2().setCustomId(`${customIdBase}:approve`).setLabel("\u5141\u8BB8\u7EE7\u7EED").setStyle(ButtonStyle2.Success),
+        new ButtonBuilder2().setCustomId(`${customIdBase}:deny`).setLabel("\u62D2\u7EDD").setStyle(ButtonStyle2.Danger)
       );
       components = [row];
     } else {
@@ -689,97 +1350,6 @@ var SessionPanelComponent = class {
   }
 };
 
-// ../engine/src/session-context.ts
-var EMPTY_PROJECTION = Object.freeze({
-  turn: 0,
-  humanResolved: false,
-  updatedAt: 0
-});
-function safeGetSessionController(sessionId) {
-  try {
-    const fn = getSessionController;
-    return typeof fn === "function" ? fn(sessionId) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function safeDebouncedSaveSession() {
-  try {
-    const fn = debouncedSaveSession;
-    if (typeof fn === "function") fn();
-  } catch {
-  }
-}
-function safeGetProjection(sessionId) {
-  try {
-    const sm = stateMachine;
-    if (sm && typeof sm.getSnapshot === "function") {
-      return sm.getSnapshot(sessionId);
-    }
-  } catch {
-  }
-  return EMPTY_PROJECTION;
-}
-var SessionSupervisor = class {
-  contexts = /* @__PURE__ */ new Map();
-  get(sessionId) {
-    const live = getSession(sessionId);
-    const cached = this.contexts.get(sessionId);
-    if (!live) {
-      if (cached) this.contexts.delete(sessionId);
-      return void 0;
-    }
-    if (cached) {
-      this.syncContext(cached);
-      return cached;
-    }
-    const ctx = this.build(live);
-    this.contexts.set(sessionId, ctx);
-    return ctx;
-  }
-  /** 枚举现有 context。用于 supervisor 层面的扫描(健康检查、空闲回收)。 */
-  all() {
-    return Array.from(this.contexts.values());
-  }
-  /** 释放某个 session 的 context(endSession 调用时触发)。 */
-  release(sessionId) {
-    this.contexts.delete(sessionId);
-  }
-  releaseAll() {
-    this.contexts.clear();
-  }
-  build(session) {
-    const ctx = {
-      sessionId: session.id,
-      session,
-      controller: safeGetSessionController(session.id),
-      projection: safeGetProjection(session.id),
-      save: () => safeDebouncedSaveSession(),
-      refresh: () => this.syncContext(ctx)
-    };
-    return ctx;
-  }
-  syncContext(ctx) {
-    const live = getSession(ctx.sessionId);
-    if (live) {
-      ctx.session = live;
-    }
-    ctx.controller = safeGetSessionController(
-      ctx.sessionId
-    );
-    ctx.projection = safeGetProjection(
-      ctx.sessionId
-    );
-  }
-};
-var sessionSupervisor = new SessionSupervisor();
-function getSessionContext(sessionId) {
-  return sessionSupervisor.get(sessionId);
-}
-function getSessionView(sessionId) {
-  return sessionSupervisor.get(sessionId)?.session;
-}
-
 // ../bot/src/monitoring/performance-tracker.ts
 import { performance } from "perf_hooks";
 import { memoryUsage, cpuUsage } from "process";
@@ -1018,26 +1588,6 @@ async function relocateSessionPanelToBottom(sessionId, channel, initialize) {
   }
 }
 
-// ../engine/src/output/answer-store.ts
-var pendingAnswersStore = /* @__PURE__ */ new Map();
-var questionCountStore = /* @__PURE__ */ new Map();
-function setPendingAnswer(sessionId, questionIndex, answer) {
-  if (!pendingAnswersStore.has(sessionId)) {
-    pendingAnswersStore.set(sessionId, /* @__PURE__ */ new Map());
-  }
-  pendingAnswersStore.get(sessionId).set(questionIndex, answer);
-}
-function getPendingAnswers(sessionId) {
-  return pendingAnswersStore.get(sessionId);
-}
-function clearPendingAnswers(sessionId) {
-  pendingAnswersStore.delete(sessionId);
-  questionCountStore.delete(sessionId);
-}
-function getQuestionCount(sessionId) {
-  return questionCountStore.get(sessionId) || 0;
-}
-
 // ../bot/src/bot-services-helpers.ts
 var unmanagedCodexHintedSessions = /* @__PURE__ */ new Set();
 function clearCodexHint(sessionId) {
@@ -1293,7 +1843,8 @@ async function updateSessionState(sessionId, event, options = {}) {
   const projection = stateMachine.applyPlatformEvent(platformEvent);
   cacheProjection(sessionId, projection);
   const stateChanged = projection.state !== previousProjection.state || projection.turn !== previousProjection.turn || projection.phase !== previousProjection.phase;
-  if (stateChanged) {
+  const contextChanged = projection.todoList !== previousProjection.todoList || projection.recentPermissionDenials !== previousProjection.recentPermissionDenials || projection.batchApprovalMode !== previousProjection.batchApprovalMode || projection.pendingApprovals !== previousProjection.pendingApprovals;
+  if (stateChanged || contextChanged) {
     await scheduleProjectionRender(sessionId, projection, updateKey);
   } else {
     performanceTracker.endStateUpdate(updateKey, { skipped: true });
@@ -1321,8 +1872,11 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
   } else if (!event.success) {
     const session = getSessionView(sessionId);
     const failureText = textContent.trim() || event.errors.join("\n").trim() || "\u4EFB\u52A1\u5931\u8D25";
+    const reasonLabel = event.terminalReason && event.terminalReason !== "completed" ? formatTerminalReason(event.terminalReason, false) : null;
+    const withReason = reasonLabel ? `\uFF08${reasonLabel}\uFF09
+${failureText}` : failureText;
     await panel.summaryHandler.sendTurnFailure(
-      failureText,
+      withReason,
       projection.turn,
       session?.lastInboundMessageId,
       attachments
@@ -1443,6 +1997,13 @@ export {
   sendTyping,
   sendAckReaction,
   deliver,
+  sendSystemNotice,
+  spawnSubagent,
+  getSubagents,
+  runSubagentWatchdog,
+  resolveEffectiveClaudePermissionMode,
+  makeModeButtons,
+  dispatchEvent,
   cleanupOldMessages,
   notifyUnmanagedCodexHint,
   stopPerformanceMonitoring,