workspacecord 1.1.2 → 1.1.4

package/dist/{chunk-ZAQV2RZS.js → chunk-NNTMVOTM.js}

@@ -1,26 +1,40 @@
 #!/usr/bin/env node
 import {
   cleanupSessionAttachments
-} from "./chunk-L2ZJXV6H.js";
+} from "./chunk-66B64WL3.js";
 import {
+  STATE_COLORS,
+  STATE_LABELS,
+  createSession,
+  debouncedSaveSession,
+  endSession,
+  gateService,
   getAllSessions,
   getSession,
+  getSessionController,
   getSessionPermissionSummary,
+  mapPlatformEventToState,
   setCurrentInteractionMessage,
   setStatusCardBinding,
+  stateMachine,
+  toPlatformEvent,
   updateSession
-} from "./chunk-RK6EIZOL.js";
+} from "./chunk-JR4B4L7I.js";
 import {
-  Store,
   config,
   truncate
-} from "./chunk-UEX7U2KW.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,
@@ -30,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);
@@ -66,1005 +84,788 @@ var StatusCardProjectionRenderer = class {
   }
 };
 
-// ../bot/src/discord/status-card.ts
-import {
-  EmbedBuilder
-} from "discord.js";
-
-// ../state/src/types.ts
-var STATE_PRIORITY = {
-  error: 9,
-  awaiting_human: 8,
-  stalled: 7,
-  summarizing: 6,
-  working: 5,
-  thinking: 4,
-  completed: 3,
-  idle: 2,
-  offline: 1
-};
-var STATE_LABELS = {
-  idle: "\u5F85\u547D",
-  thinking: "\u6B63\u5728\u601D\u8003",
-  working: "\u6B63\u5728\u6267\u884C",
-  awaiting_human: "\u7B49\u5F85\u4EBA\u5DE5\u5904\u7406",
-  summarizing: "\u6B63\u5728\u6574\u7406\u4E0A\u4E0B\u6587",
-  completed: "\u672C\u8F6E\u5DF2\u5B8C\u6210",
-  error: "\u51FA\u73B0\u5F02\u5E38",
-  stalled: "\u7591\u4F3C\u5361\u4F4F",
-  offline: "\u5DF2\u79BB\u7EBF"
-};
-var STATE_COLORS = {
-  idle: 8421504,
-  // 灰色
-  thinking: 3447003,
-  // 蓝色
-  working: 3066993,
-  // 绿色
-  awaiting_human: 15965202,
-  // 橙色
-  summarizing: 10181046,
-  // 紫色
-  completed: 2600544,
-  // 深绿
-  error: 15158332,
-  // 红色
-  stalled: 15105570,
-  // 深橙
-  offline: 9807270
-  // 浅灰
-};
-var PLATFORM_EVENT_TO_STATE = {
-  session_started: "idle",
-  session_idle: "idle",
-  thinking_started: "thinking",
-  work_started: "working",
-  awaiting_human: "awaiting_human",
-  human_resolved: "working",
-  compaction_started: "summarizing",
-  completed: "completed",
-  errored: "error",
-  stalled: "stalled",
-  session_ended: "offline"
-};
-
-// ../state/src/state-projections.ts
-function toProjection(state) {
-  return {
-    state: state.displayState,
-    stateSource: state.stateSource,
-    confidence: state.confidence,
-    updatedAt: state.updatedAt,
-    turn: state.turn,
-    phase: state.phase,
-    humanResolved: state.humanResolved
-  };
-}
-function toPanelProjection(state) {
-  return {
-    ...toProjection(state),
-    isWaitingHuman: state.lifecycle === "waiting_human" || state.gate === "pending" || state.displayState === "awaiting_human",
-    isCompleted: state.displayState === "completed" || state.lifecycle === "completed",
-    isError: state.displayState === "error" || state.lifecycle === "error",
-    isStalled: state.displayState === "stalled"
-  };
-}
-function resolveDisplayState(sessions) {
-  let best = "idle";
-  let bestPri = 0;
-  for (const state of sessions) {
-    const pri = STATE_PRIORITY[state.displayState] || 0;
-    if (pri > bestPri) {
-      best = state.displayState;
-      bestPri = pri;
-    }
-  }
-  return best;
-}
-function getStateLabel(state) {
-  return STATE_LABELS[state] || state;
-}
-function getStateColor(state) {
-  return STATE_COLORS[state] || 8421504;
-}
+// ../bot/src/output/event-handlers.ts
+import { existsSync as existsSync2 } from "fs";
 
-// ../state/src/state-event-mapper.ts
-function mapEventToTransition(event, currentState, context) {
-  const mappedState = PLATFORM_EVENT_TO_STATE[event.type];
-  if (!mappedState) return null;
-  if (event.type === "session_idle" && !context.isSessionIdleTransitionAllowed(event, currentState)) {
-    return null;
-  }
-  const allowTransition = event.type === "human_resolved" || event.type === "completed" || event.type === "session_ended" || context.shouldTransition(
-    currentState.displayState,
-    mappedState,
-    currentState.stateSource,
-    event.stateSource ?? "formal"
-  );
-  if (!allowTransition) {
-    return null;
-  }
-  const lifecycle = mapLifecycle(event, currentState, mappedState);
-  const execution = mapExecution(event, currentState, mappedState, lifecycle);
-  const gate = mapGate(event, currentState);
-  const turn = resolveTurn(event, currentState);
-  const humanResolved = resolveHumanResolved(event, currentState);
-  const phaseLabel = event.metadata?.phase ?? getStateLabel(mappedState);
-  return {
-    updates: {
-      lifecycle,
-      execution,
-      gate
-    },
-    metadata: {
-      displayState: mappedState,
-      stateSource: event.stateSource ?? "formal",
-      confidence: event.confidence,
-      updatedAt: event.timestamp,
-      turn,
-      phase: phaseLabel,
-      humanResolved
-    }
-  };
-}
-function mapLifecycle(event, current, mappedState) {
-  switch (event.type) {
-    case "session_started":
-    case "session_idle":
-    case "thinking_started":
-    case "work_started":
-    case "human_resolved":
-    case "compaction_started":
-      return "active";
-    case "awaiting_human":
-      return "waiting_human";
-    case "completed":
-      return "completed";
-    case "errored":
-      return "error";
-    case "stalled":
-      return current.lifecycle === "active" ? "paused" : current.lifecycle;
-    case "session_ended":
-      return current.lifecycle === "initializing" ? "initializing" : "paused";
-    default:
-      return mapLifecycleFromState(mappedState, current.lifecycle);
-  }
-}
-function mapLifecycleFromState(mappedState, fallback) {
-  switch (mappedState) {
-    case "idle":
-    case "thinking":
-    case "working":
-    case "summarizing":
-      return "active";
-    case "awaiting_human":
-      return "waiting_human";
-    case "completed":
-      return "completed";
-    case "error":
-      return "error";
-    case "stalled":
-      return "paused";
-    case "offline":
-      return fallback === "initializing" ? "initializing" : "paused";
-    default:
-      return fallback;
-  }
-}
-function mapExecution(event, current, mappedState, lifecycle) {
-  if (lifecycle !== "active") return null;
-  switch (event.type) {
-    case "session_started":
-    case "session_idle":
-      return "idle";
-    case "thinking_started":
-      return "thinking";
-    case "work_started":
-      return "tool_executing";
-    case "human_resolved":
-      return "tool_executing";
-    case "compaction_started":
-      return "thinking";
-    default:
-      return mapExecutionFromState(mappedState, current.execution);
-  }
-}
-function mapExecutionFromState(mappedState, fallback) {
-  switch (mappedState) {
-    case "idle":
-      return "idle";
-    case "thinking":
-    case "summarizing":
-      return "thinking";
-    case "working":
-      return "tool_executing";
-    default:
-      return fallback;
-  }
-}
-function mapGate(event, current) {
-  switch (event.type) {
-    case "awaiting_human":
-      return "pending";
-    case "human_resolved":
-      return event.metadata?.action === "reject" ? "rejected" : "approved";
-    case "session_idle":
-      if (event.metadata?.action === "reject" && current.gate === "pending") {
-        return "rejected";
-      }
-      return current.gate;
-    case "session_ended":
-      return current.gate === "pending" ? "invalidated" : current.gate;
-    default:
-      return current.gate;
+// ../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 resolveTurn(event, current) {
-  if (event.type === "session_started" && current.turn <= 0) {
-    return 1;
+function safeDebouncedSaveSession() {
+  try {
+    const fn = debouncedSaveSession;
+    if (typeof fn === "function") fn();
+  } catch {
   }
-  return current.turn;
 }
-function resolveHumanResolved(event, current) {
-  if (event.type === "awaiting_human") return false;
-  if (event.type === "human_resolved") return true;
-  if (event.type === "session_idle" && event.metadata?.action === "reject") return true;
-  return current.humanResolved;
-}
-
-// ../state/src/state-machine.ts
-var LIFECYCLE_TRANSITIONS = {
-  initializing: ["active", "waiting_human", "paused", "completed", "error"],
-  active: ["waiting_human", "paused", "completed", "error"],
-  waiting_human: ["active", "paused", "error"],
-  paused: ["active", "completed", "error"],
-  completed: ["active"],
-  error: ["active", "completed"]
-};
-var EXECUTION_TRANSITIONS = {
-  idle: ["thinking", "tool_executing"],
-  thinking: ["tool_executing", "streaming_output", "idle"],
-  tool_executing: ["thinking", "streaming_output", "idle"],
-  streaming_output: ["idle", "thinking"]
-};
-var StateMachine = class {
-  sessions = /* @__PURE__ */ new Map();
-  transitionHistory = /* @__PURE__ */ new Map();
-  completedTimers = /* @__PURE__ */ new Map();
-  completedTimerTokens = /* @__PURE__ */ new Map();
-  completedTimerSequence = 0;
-  getState(sessionId) {
-    const existing = this.sessions.get(sessionId);
-    if (existing) return existing;
-    const defaultState = this.createDefaultState();
-    this.sessions.set(sessionId, defaultState);
-    return defaultState;
-  }
-  getSnapshot(sessionId) {
-    return toProjection(this.getState(sessionId));
-  }
-  getPanelProjection(sessionId) {
-    return toPanelProjection(this.getState(sessionId));
-  }
-  transition(sessionId, event, updates, metadata = {}) {
-    const current = this.getState(sessionId);
-    const timestamp = metadata.updatedAt ?? Date.now();
-    const target = {
-      ...current,
-      lifecycle: updates.lifecycle ?? current.lifecycle,
-      execution: updates.execution !== void 0 ? updates.execution : current.execution,
-      gate: updates.gate !== void 0 ? updates.gate : current.gate,
-      displayState: metadata.displayState ?? current.displayState,
-      stateSource: metadata.stateSource ?? current.stateSource,
-      confidence: metadata.confidence ?? current.confidence,
-      updatedAt: timestamp,
-      turn: metadata.turn ?? current.turn,
-      phase: metadata.phase ?? current.phase,
-      humanResolved: metadata.humanResolved ?? current.humanResolved
-    };
-    if (updates.lifecycle && updates.lifecycle !== current.lifecycle) {
-      const allowed = LIFECYCLE_TRANSITIONS[current.lifecycle];
-      if (!allowed.includes(updates.lifecycle)) {
-        return {
-          success: false,
-          state: current,
-          error: `\u975E\u6CD5\u751F\u547D\u5468\u671F\u8F6C\u6362: ${current.lifecycle} -> ${updates.lifecycle}`
-        };
-      }
-    }
-    if (updates.execution !== void 0 && updates.execution !== current.execution) {
-      if (target.lifecycle !== "active" && updates.execution !== null) {
-        return {
-          success: false,
-          state: current,
-          error: `\u6267\u884C\u72B6\u6001\u4EC5\u5728 lifecycle=active \u65F6\u6709\u6548\uFF0C\u5F53\u524D lifecycle=${target.lifecycle}`
-        };
-      }
-      if (current.execution && updates.execution) {
-        const allowed = EXECUTION_TRANSITIONS[current.execution];
-        if (!allowed.includes(updates.execution)) {
-          return {
-            success: false,
-            state: current,
-            error: `\u975E\u6CD5\u6267\u884C\u72B6\u6001\u8F6C\u6362: ${current.execution} -> ${updates.execution}`
-          };
-        }
-      }
-    }
-    if (target.lifecycle !== "active" && target.execution !== null) {
-      target.execution = null;
-    }
-    if (this.isSameState(current, target)) {
-      return { success: true, state: current };
+function safeGetProjection(sessionId) {
+  try {
+    const sm = stateMachine;
+    if (sm && typeof sm.getSnapshot === "function") {
+      return sm.getSnapshot(sessionId);
     }
-    this.sessions.set(sessionId, target);
-    const transition = {
-      from: { ...current },
-      to: { ...target },
-      event,
-      timestamp,
-      sessionId
-    };
-    const history = this.transitionHistory.get(sessionId) || [];
-    history.push(transition);
-    if (history.length > 100) {
-      history.shift();
-    }
-    this.transitionHistory.set(sessionId, history);
-    console.log(
-      `[state-machine] ${sessionId} | ${event} | lifecycle: ${current.lifecycle} -> ${target.lifecycle} | execution: ${current.execution} -> ${target.execution} | gate: ${current.gate} -> ${target.gate} | display: ${current.displayState} -> ${target.displayState}`
-    );
-    return { success: true, state: target };
-  }
-  getTransitionHistory(sessionId) {
-    return this.transitionHistory.get(sessionId) || [];
+  } catch {
   }
-  resolveDisplayState() {
-    return resolveDisplayState(this.sessions.values());
+  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;
   }
-  shouldTransition(from, to, fromSource = "formal", toSource = "formal") {
-    const fromPri = STATE_PRIORITY[from] || 0;
-    const toPri = STATE_PRIORITY[to] || 0;
-    if (fromSource === "formal" && toSource === "inferred") {
-      return toPri > fromPri;
+  syncContext(ctx) {
+    const live = getSession(ctx.sessionId);
+    if (live) {
+      ctx.session = live;
     }
-    return toPri >= fromPri;
-  }
-  getStateLabel(state) {
-    return getStateLabel(state);
-  }
-  getStateColor(state) {
-    return getStateColor(state);
-  }
-  setTurn(sessionId, turn, event = "turn_set") {
-    const result = this.transition(sessionId, event, {}, { turn, humanResolved: false });
-    return toProjection(result.state);
-  }
-  incrementTurn(sessionId) {
-    const current = this.getState(sessionId);
-    const result = this.transition(sessionId, "turn_incremented", {}, {
-      turn: current.turn + 1,
-      humanResolved: false
-    });
-    return toProjection(result.state);
-  }
-  advanceTurnToIdle(sessionId) {
-    const current = this.getState(sessionId);
-    const incremented = this.transition(sessionId, "turn_incremented", {}, {
-      turn: current.turn + 1,
-      humanResolved: false
-    });
-    const baseState = incremented.success ? incremented.state : current;
-    const settled = this.transition(
-      sessionId,
-      "turn_completed",
-      { lifecycle: "active", execution: "idle", gate: null },
-      {
-        displayState: "idle",
-        stateSource: "formal",
-        confidence: "high",
-        phase: getStateLabel("idle"),
-        humanResolved: false,
-        turn: baseState.turn
-      }
+    ctx.controller = safeGetSessionController(
+      ctx.sessionId
     );
-    return toProjection(settled.success ? settled.state : baseState);
-  }
-  applyPlatformEvent(event) {
-    const current = this.getState(event.sessionId);
-    const mapped = mapEventToTransition(event, current, {
-      shouldTransition: this.shouldTransition.bind(this),
-      isSessionIdleTransitionAllowed: this.isSessionIdleTransitionAllowed.bind(this)
-    });
-    if (!mapped) return toProjection(current);
-    const mappedState = PLATFORM_EVENT_TO_STATE[event.type];
-    const shouldResetCompletedTimer = event.type === "session_started" || event.type === "session_ended" || event.type !== "completed" && mappedState !== "completed" && current.displayState === "completed";
-    if (shouldResetCompletedTimer) {
-      this.clearCompletedTimer(event.sessionId);
-    }
-    const result = this.transition(
-      event.sessionId,
-      event.type,
-      mapped.updates,
-      mapped.metadata
+    ctx.projection = safeGetProjection(
+      ctx.sessionId
     );
-    if (!result.success) {
-      return toProjection(current);
-    }
-    if (mappedState === "completed") {
-      this.clearCompletedTimer(event.sessionId);
-      const timerToken = ++this.completedTimerSequence;
-      const completedTurn = result.state.turn;
-      const timer = setTimeout(() => {
-        this.applyPlatformEvent({
-          type: "session_idle",
-          sessionId: event.sessionId,
-          source: event.source,
-          stateSource: "formal",
-          confidence: "high",
-          timestamp: Date.now(),
-          metadata: {
-            phase: "\u5F85\u547D",
-            idleTimerToken: timerToken,
-            turn: completedTurn
-          }
-        });
-        this.clearCompletedTimer(event.sessionId);
-      }, 3e3);
-      this.completedTimers.set(event.sessionId, timer);
-      this.completedTimerTokens.set(event.sessionId, timerToken);
-    }
-    return toProjection(result.state);
-  }
-  clearSession(sessionId) {
-    this.sessions.delete(sessionId);
-    this.transitionHistory.delete(sessionId);
-    this.clearCompletedTimer(sessionId);
-  }
-  getSessionCount() {
-    return this.sessions.size;
-  }
-  createDefaultState() {
-    return {
-      lifecycle: "initializing",
-      execution: null,
-      gate: null,
-      displayState: "idle",
-      stateSource: "formal",
-      confidence: "high",
-      updatedAt: Date.now(),
-      turn: 0,
-      phase: STATE_LABELS.idle,
-      humanResolved: false
-    };
   }
-  isSameState(a, b) {
-    return a.lifecycle === b.lifecycle && a.execution === b.execution && a.gate === b.gate && a.displayState === b.displayState && a.stateSource === b.stateSource && a.confidence === b.confidence && a.updatedAt === b.updatedAt && a.turn === b.turn && a.phase === b.phase && a.humanResolved === b.humanResolved;
-  }
-  clearCompletedTimer(sessionId) {
-    const completedTimer = this.completedTimers.get(sessionId);
-    if (completedTimer) {
-      clearTimeout(completedTimer);
-      this.completedTimers.delete(sessionId);
+};
+var sessionSupervisor = new SessionSupervisor();
+function getSessionContext(sessionId) {
+  return sessionSupervisor.get(sessionId);
+}
+function getSessionView(sessionId) {
+  return sessionSupervisor.get(sessionId)?.session;
+}
+
+// ../bot/src/subagent-manager.ts
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration
+} from "discord.js";
+
+// ../bot/src/discord/delivery-policy.ts
+import { existsSync, statSync } from "fs";
+var MAX_CHUNK_LIMIT = 2e3;
+var MAX_ATTACHMENTS = 10;
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+function clampChunkLimit(limit) {
+  if (!Number.isFinite(limit)) return MAX_CHUNK_LIMIT;
+  return Math.max(1, Math.min(Math.trunc(limit), MAX_CHUNK_LIMIT));
+}
+function chunkText(text, limit, mode) {
+  const safeLimit = clampChunkLimit(limit);
+  if (text.length <= safeLimit) return [text];
+  const out = [];
+  let rest = text;
+  while (rest.length > safeLimit) {
+    let cut = safeLimit;
+    if (mode === "newline") {
+      const para = rest.lastIndexOf("\n\n", safeLimit);
+      const line = rest.lastIndexOf("\n", safeLimit);
+      const space = rest.lastIndexOf(" ", safeLimit);
+      cut = para > safeLimit / 2 ? para : line > safeLimit / 2 ? line : space > 0 ? space : safeLimit;
     }
-    this.completedTimerTokens.delete(sessionId);
+    out.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\n+/, "");
   }
-  isSessionIdleTransitionAllowed(event, current) {
-    if (current.displayState === "completed") {
-      return true;
-    }
-    const idleTimerToken = this.readNumericMetadata(event.metadata, "idleTimerToken");
-    if (idleTimerToken === void 0) {
-      return false;
+  if (rest) out.push(rest);
+  return out;
+}
+function validateOutboundAttachments(files) {
+  if (files.length > MAX_ATTACHMENTS) {
+    throw new Error(`\u6700\u591A\u53EA\u80FD\u53D1\u9001 ${MAX_ATTACHMENTS} \u4E2A\u9644\u4EF6`);
+  }
+  for (const filePath of files) {
+    if (!filePath.trim()) {
+      throw new Error("\u9644\u4EF6\u8DEF\u5F84\u65E0\u6548");
     }
-    const activeTimerToken = this.completedTimerTokens.get(event.sessionId);
-    if (activeTimerToken !== idleTimerToken) {
-      return false;
+    if (!existsSync(filePath)) continue;
+    const stats = statSync(filePath);
+    if (stats.isDirectory()) {
+      throw new Error(`\u9644\u4EF6\u8DEF\u5F84\u4E0D\u80FD\u662F\u76EE\u5F55: ${filePath}`);
     }
-    const timerTurn = this.readNumericMetadata(event.metadata, "turn");
-    if (timerTurn !== void 0 && timerTurn !== current.turn) {
-      return false;
+    if (stats.size > MAX_ATTACHMENT_BYTES) {
+      throw new Error(`\u9644\u4EF6 ${filePath} \u5927\u5C0F\u8D85\u8FC7 ${MAX_ATTACHMENT_BYTES} bytes`);
     }
-    return true;
   }
-  readNumericMetadata(metadata, field) {
-    const value = metadata?.[field];
-    return typeof value === "number" ? value : void 0;
-  }
-};
-var stateMachine = new StateMachine();
-
-// ../state/src/event-normalizer.ts
-var CLAUDE_EVENT_MAP = {
-  session_init: "idle",
-  text_delta: "thinking",
-  tool_start: "working",
-  tool_result: "working",
-  ask_user: "awaiting_human",
-  result: "completed",
-  error: "error"
-};
-function normalizeClaudeEvent(event, sessionId) {
-  const state = CLAUDE_EVENT_MAP[event.type];
-  if (!state) return null;
-  const platformType = mapToPlatformType(event.type);
-  if (!platformType) return null;
-  return {
-    type: platformType,
-    sessionId,
-    source: "claude",
-    stateSource: "formal",
-    confidence: "high",
-    metadata: event,
-    timestamp: Date.now()
-  };
 }
-function mapToPlatformType(eventType) {
-  const mapping = {
-    session_init: "session_started",
-    text_delta: "thinking_started",
-    tool_start: "work_started",
-    ask_user: "awaiting_human",
-    result: "completed",
-    error: "errored"
-  };
-  return mapping[eventType] || null;
-}
-function normalizeCodexEvent(eventKey, sessionId, extra) {
-  const byEvent = mapCodexToPlatformType(eventKey);
-  const byState = mapCodexStateToPlatformType(extra.observedState);
-  const preferStateOverride = extra.observedState === "codex-permission";
-  const platformType = preferStateOverride ? byState ?? byEvent : byEvent ?? byState;
-  if (!platformType) return null;
-  const isPermissionEvent = eventKey === "codex-permission" || extra.observedState === "codex-permission";
-  const inferredFromState = Boolean(byState && !byEvent);
-  const stateSource = isPermissionEvent || inferredFromState ? "inferred" : "formal";
+function buildDeliveryPlan(input) {
+  validateOutboundAttachments(input.files);
+  const chunks = chunkText(input.text, input.policy.textChunkLimit, input.policy.chunkMode);
+  const filesOnFirstChunk = input.files.slice(0, MAX_ATTACHMENTS);
+  const replyToMode = input.policy.replyToMode;
+  const replyToMessageId = input.mode === "system_notice" || input.mode === "summary" ? void 0 : replyToMode === "off" ? void 0 : input.replyToMessageId;
   return {
-    type: platformType,
-    sessionId,
-    source: "codex",
-    stateSource,
-    confidence: isPermissionEvent ? "medium" : "high",
-    metadata: { eventKey, ...extra },
-    timestamp: Date.now()
+    sessionId: input.sessionId,
+    chatId: input.chatId,
+    replyToMessageId,
+    replyToMode,
+    editTargetMessageId: input.editTargetMessageId,
+    chunks,
+    filesOnFirstChunk,
+    mode: input.mode
   };
 }
-function mapCodexToPlatformType(eventKey) {
-  const mapping = {
-    "session_meta": "session_started",
-    "event_msg:task_started": "thinking_started",
-    "event_msg:user_message": "thinking_started",
-    "response_item:function_call": "work_started",
-    "response_item:custom_tool_call": "work_started",
-    "response_item:web_search_call": "work_started",
-    "event_msg:exec_command_start": "work_started",
-    "codex-permission": "awaiting_human",
-    "event_msg:task_complete": "completed",
-    "event_msg:context_compacted": "compaction_started",
-    "event_msg:turn_aborted": "session_idle",
-    "codex-turn-end": "completed",
-    "event_msg:error": "errored",
-    "stale-cleanup": "session_ended"
-  };
-  return mapping[eventKey] || null;
-}
-function mapCodexStateToPlatformType(state) {
-  if (!state) return null;
-  const mapping = {
-    thinking: "thinking_started",
-    working: "work_started",
-    sweeping: "compaction_started",
-    "codex-permission": "awaiting_human",
-    attention: "completed",
-    idle: "session_idle",
-    error: "errored",
-    sleeping: "session_ended"
-  };
-  return mapping[state] ?? null;
+
+// ../bot/src/discord/delivery.ts
+var sessionState = /* @__PURE__ */ new Map();
+function getSessionState(sessionId) {
+  if (!sessionState.has(sessionId)) {
+    sessionState.set(sessionId, {});
+  }
+  const state = sessionState.get(sessionId);
+  state.lastUsed = Date.now();
+  return state;
 }
-function isPlatformEvent(input) {
-  if (!input || typeof input !== "object") return false;
-  const obj = input;
-  if (typeof obj.type !== "string") return false;
-  if (typeof obj.sessionId !== "string") return false;
-  if (obj.source !== "claude" && obj.source !== "codex") return false;
-  if (obj.confidence !== "high" && obj.confidence !== "medium" && obj.confidence !== "low") {
-    return false;
+function pruneStaleSessionStates(maxAgeMs = 5 * 60 * 1e3) {
+  const cutoff = Date.now() - maxAgeMs;
+  for (const [sessionId, state] of sessionState) {
+    if (!state.lastUsed || state.lastUsed < cutoff) {
+      sessionState.delete(sessionId);
+    }
   }
-  return typeof obj.timestamp === "number";
 }
-function toPlatformEvent(event, sessionId, source = "claude") {
-  if (isPlatformEvent(event)) {
-    return {
-      ...event,
-      sessionId: event.sessionId || sessionId,
-      source: event.source || source,
-      stateSource: event.stateSource ?? "formal",
-      timestamp: event.timestamp || Date.now()
-    };
+function cleanupSessionDeliveryState(sessionId) {
+  sessionState.delete(sessionId);
+}
+async function sendTyping(channel) {
+  try {
+    await channel.sendTyping?.();
+  } catch {
   }
-  if (source === "codex") {
-    return null;
+}
+async function sendAckReaction(message, reaction) {
+  if (!reaction) return;
+  try {
+    await message.react(reaction);
+  } catch {
   }
-  return normalizeClaudeEvent(event, sessionId);
 }
-function mapPlatformEventToState(type) {
-  return PLATFORM_EVENT_TO_STATE[type] ?? null;
+var SEND_MAX_RETRIES = 3;
+function isDiscordRateLimitError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.code === 429 || e.status === 429 || e.httpStatus === 429;
 }
-
-// ../state/src/human-gate.ts
-var HumanGateRegistry = class {
-  gates = /* @__PURE__ */ new Map();
-  store;
-  constructor() {
-    this.store = new Store("gates.json");
-  }
-  /** Load persisted gates from disk. Call during startup before using the registry. */
-  async init() {
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sendWithBackoff(channel, payload) {
+  let attempt = 0;
+  while (true) {
     try {
-      const data = await this.store.read();
-      if (data && Array.isArray(data)) {
-        for (const record of data) {
-          this.gates.set(record.id, record);
-        }
+      const message = await channel.send(payload);
+      return message.id;
+    } catch (error) {
+      if (!isDiscordRateLimitError(error) || attempt >= SEND_MAX_RETRIES) {
+        throw error;
       }
-    } catch (err) {
-      console.error("[HumanGateRegistry] Failed to load persisted gates:", err);
+      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 _save() {
-    return this.store.write(Array.from(this.gates.values())).catch((err) => {
-      console.error("[HumanGateRegistry] Failed to persist gates:", err);
-    });
-  }
-  // 创建新门控
-  create(params) {
-    const id = this.generateId();
-    const record = {
-      ...params,
-      id,
-      version: 1,
-      createdAt: Date.now(),
-      status: "pending"
-    };
-    this.gates.set(id, record);
-    this._save();
-    return record;
-  }
-  // 获取门控记录
-  get(id) {
-    return this.gates.get(id);
-  }
-  // 获取会话的所有门控
-  getBySession(sessionId) {
-    return Array.from(this.gates.values()).filter((g) => g.sessionId === sessionId);
-  }
-  // 获取会话的活跃门控（pending 状态）
-  getActiveBySession(sessionId) {
-    return this.getBySession(sessionId).filter((g) => g.status === "pending");
-  }
-  // CAS 更新：使用乐观锁保证原子性
-  update(id, expectedVersion, updates) {
-    const current = this.gates.get(id);
-    if (!current) {
-      return {
-        success: false,
-        error: "not_found",
-        message: `Gate ${id} not found`
-      };
-    }
-    if (current.version !== expectedVersion) {
-      return {
-        success: false,
-        error: "version_conflict",
-        message: `Version conflict: expected ${expectedVersion}, got ${current.version}`
-      };
-    }
-    if (updates.status && !this.isValidTransition(current.status, updates.status)) {
-      return {
-        success: false,
-        error: "invalid_transition",
-        message: `Invalid transition: ${current.status} -> ${updates.status}`
-      };
-    }
-    const updated = {
-      ...current,
-      ...updates,
-      version: current.version + 1
-    };
-    this.gates.set(id, updated);
-    this._save();
-    return {
-      success: true,
-      record: updated
-    };
+}
+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 };
   }
-  // 批量失效门控（用于重启后清理）
-  invalidateAll(reason = "restart") {
-    let count = 0;
-    for (const [id, gate] of this.gates.entries()) {
-      if (gate.status === "pending") {
-        const updated = {
-          ...gate,
-          status: "invalidated",
-          resolvedAt: Date.now(),
-          resolvedBy: reason,
-          version: gate.version + 1
-        };
-        this.gates.set(id, updated);
-        count++;
-      }
+  try {
+    return await sendWithBackoff(channel, payload);
+  } catch (error) {
+    if (!options.replyToMessageId) {
+      throw error;
     }
-    this._save();
-    return count;
-  }
-  // 删除门控记录
-  delete(id) {
-    const result = this.gates.delete(id);
-    if (result) this._save();
-    return result;
+    const fallbackPayload = { content: chunk };
+    if (options.files?.length) fallbackPayload.files = options.files;
+    return sendWithBackoff(channel, fallbackPayload);
   }
-  // 清理过期门控（超过指定时间未解决）
-  cleanupExpired(maxAgeMs = 5 * 60 * 1e3) {
-    const now = Date.now();
-    let count = 0;
-    for (const [id, gate] of this.gates.entries()) {
-      if (gate.status === "pending" && now - gate.createdAt >= maxAgeMs) {
-        const updated = {
-          ...gate,
-          status: "expired",
-          resolvedAt: now,
-          resolvedBy: "timeout",
-          version: gate.version + 1
-        };
-        this.gates.set(id, updated);
-        count++;
+}
+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 {
       }
     }
-    this._save();
-    return count;
   }
-  // 归档已解决的门控（保留最近 N 条）
-  archiveResolved(keepCount = 100) {
-    const resolved = Array.from(this.gates.values()).filter((g) => g.status !== "pending").sort((a, b) => (b.resolvedAt || 0) - (a.resolvedAt || 0));
-    if (resolved.length <= keepCount) {
-      return 0;
-    }
-    const toArchive = resolved.slice(keepCount);
-    for (const gate of toArchive) {
-      this.gates.delete(gate.id);
-    }
-    this._save();
-    return toArchive.length;
+  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);
   }
-  // 获取所有门控（用于调试）
-  getAll() {
-    return Array.from(this.gates.values());
+  if (ids.length > 0) {
+    if (plan.mode === "progress_update") {
+      state.recentProgressMessageId = ids[ids.length - 1];
+    } else {
+      state.recentFinalMessageId = ids[ids.length - 1];
+    }
   }
-  // 获取统计信息
-  getStats() {
-    const all = this.getAll();
-    return {
-      total: all.length,
-      pending: all.filter((g) => g.status === "pending").length,
-      approved: all.filter((g) => g.status === "approved").length,
-      rejected: all.filter((g) => g.status === "rejected").length,
-      expired: all.filter((g) => g.status === "expired").length,
-      invalidated: all.filter((g) => g.status === "invalidated").length
-    };
+  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 {
   }
-  // 验证状态转换合法性
-  isValidTransition(from, to) {
-    const validTransitions = {
-      pending: ["approved", "rejected", "expired", "invalidated"],
-      approved: [],
-      // 终态
-      rejected: [],
-      // 终态
-      expired: [],
-      // 终态
-      invalidated: []
-      // 终态
-    };
-    return validTransitions[from]?.includes(to) ?? false;
+}
+
+// ../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.`
+    );
   }
-  // 生成唯一 ID
-  generateId() {
-    return `gate_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  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}*`);
   }
-};
-var humanGateRegistry = new HumanGateRegistry();
-
-// ../state/src/gate-coordinator.ts
-var GateCoordinator = class {
-  registry;
-  receiptHandles = /* @__PURE__ */ new Map();
-  timeoutTimers = /* @__PURE__ */ new Map();
-  constructor(registry) {
-    this.registry = registry;
+  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)}`);
   }
-  /**
-   * 创建新的人工门控
-   */
-  createGate(params) {
-    const record = this.registry.create(params);
-    if (record.supportsRemoteDecision && record.isBlocking) {
-      this.setupTimeout(record.id);
-    }
-    return record;
+  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)}`);
   }
-  /**
-   * 注册回执句柄（仅内存，不持久化）
-   */
-  registerReceiptHandle(gateId, handle) {
-    const record = this.registry.get(gateId);
-    if (!record || record.status !== "pending") {
-      handle.reject("\u95E8\u63A7\u4E0D\u5B58\u5728\u6216\u5DF2\u5904\u7406");
-      return;
+}
+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;
     }
-    this.receiptHandles.set(gateId, { ...handle, gateId });
-  }
-  /**
-   * 绑定 Discord 交互卡消息 ID
-   */
-  bindDiscordMessage(gateId, discordMessageId) {
-    const record = this.registry.get(gateId);
-    if (!record) {
-      return false;
+    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;
     }
-    const result = this.registry.update(gateId, record.version, { discordMessageId });
-    return result.success;
   }
-  /**
-   * 尝试通过 Discord 解决门控（CAS 更新）
-   */
-  async resolveFromDiscord(gateId, action) {
-    const record = this.registry.get(gateId);
-    if (!record) {
-      return { success: false, message: "\u95E8\u63A7\u4E0D\u5B58\u5728", handledByReceipt: false };
-    }
-    if (record.status !== "pending") {
-      return { success: false, message: "\u95E8\u63A7\u5DF2\u88AB\u5904\u7406", handledByReceipt: false };
-    }
-    const result = this.registry.update(record.id, record.version, {
-      status: action === "approve" ? "approved" : "rejected",
-      resolvedAt: Date.now(),
-      resolvedBy: "discord",
-      resolvedAction: action
+  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
     });
-    if (!result.success) {
-      return { success: false, message: result.message, handledByReceipt: false };
-    }
-    this.clearTimeout(gateId);
-    const handle = this.receiptHandles.get(gateId);
-    let handledByReceipt = false;
-    if (handle) {
-      handle.resolve(action, "discord");
-      this.receiptHandles.delete(gateId);
-      handledByReceipt = true;
-    }
-    return { success: true, handledByReceipt };
+  } 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;
   }
-  /**
-   * 通知终端已处理（由钩子调用）
-   */
-  notifyTerminalResolved(gateId, action) {
-    const record = this.registry.get(gateId);
-    if (!record) {
-      return { success: false, message: "\u95E8\u63A7\u4E0D\u5B58\u5728", handledByReceipt: false };
-    }
-    if (record.status !== "pending") {
-      return { success: false, message: "\u95E8\u63A7\u5DF2\u88AB\u5904\u7406", handledByReceipt: false };
-    }
-    const result = this.registry.update(record.id, record.version, {
-      status: action === "approve" ? "approved" : "rejected",
-      resolvedAt: Date.now(),
-      resolvedBy: "terminal",
-      resolvedAction: action
+  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)}`
     });
-    if (!result.success) {
-      return { success: false, message: result.message, handledByReceipt: false };
-    }
-    this.clearTimeout(gateId);
-    const handle = this.receiptHandles.get(gateId);
-    let handledByReceipt = false;
-    if (handle) {
-      handle.resolve(action, "terminal");
-      this.receiptHandles.delete(gateId);
-      handledByReceipt = true;
-    }
-    return { success: true, handledByReceipt };
   }
-  /**
-   * 设置超时定时器（5 分钟）
-   */
-  setupTimeout(gateId) {
-    const timer = setTimeout(() => {
-      this.handleTimeout(gateId);
-    }, 5 * 60 * 1e3);
-    this.timeoutTimers.set(gateId, timer);
+  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}`
+      )
+    );
   }
-  /**
-   * 清理超时定时器
-   */
-  clearTimeout(gateId) {
-    const timer = this.timeoutTimers.get(gateId);
-    if (timer) {
-      clearTimeout(timer);
-      this.timeoutTimers.delete(gateId);
-    }
+  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)}` });
   }
-  /**
-   * 处理超时
-   */
-  handleTimeout(gateId) {
-    const record = this.registry.get(gateId);
-    if (!record || record.status !== "pending") {
-      return;
-    }
-    this.registry.update(record.id, record.version, {
-      status: "expired",
-      resolvedAt: Date.now(),
-      resolvedBy: "timeout"
+};
+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)}`
     });
-    const handle = this.receiptHandles.get(gateId);
-    if (handle) {
-      handle.reject("\u5BA1\u6279\u8D85\u65F6\uFF085 \u5206\u949F\uFF09");
-      this.receiptHandles.delete(gateId);
-    }
-    this.timeoutTimers.delete(gateId);
   }
-  /**
-   * 重启时失效所有待处理门控
-   */
-  invalidateAllOnRestart() {
-    const count = this.registry.invalidateAll("restart");
-    console.log(`[GateCoordinator] Invalidated ${count} pending gates on restart`);
-    const toUpdate = [];
-    for (const gate of this.registry.getAll()) {
-      if (gate.status === "invalidated" && gate.discordMessageId) {
-        toUpdate.push({
-          gateId: gate.id,
-          discordMessageId: gate.discordMessageId
-        });
-      }
-    }
-    this.receiptHandles.clear();
-    for (const timer of this.timeoutTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.timeoutTimers.clear();
-    return toUpdate;
+};
+var imageFile = (event, ctx) => {
+  if (existsSync2(event.filePath)) {
+    ctx.state.pendingAttachments.push(event.filePath);
   }
-  /**
-   * 获取门控记录
-   */
-  getGate(gateId) {
-    return this.registry.get(gateId);
+};
+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` : ""}`
+    });
   }
-  /**
-   * 获取会话的活跃门控
-   */
-  getActiveGateForSession(sessionId) {
-    const active = this.registry.getActiveBySession(sessionId);
-    return active[0];
+};
+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)}` });
   }
-  /**
-   * 清理过期门控
-   */
-  cleanupExpired() {
-    return this.registry.cleanupExpired();
+};
+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;
   }
-  /**
-   * 归档已解决门控，保留最近 N 条
-   */
-  archiveResolved(keepCount = 100) {
-    return this.registry.archiveResolved(keepCount);
+  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
 };
-var gateCoordinator = new GateCoordinator(humanGateRegistry);
+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;
@@ -1141,7 +942,7 @@ var StatusCard = class {
     }
   }
   buildEmbed(state, data) {
-    const embed = new EmbedBuilder().setColor(STATE_COLORS[state]).setTitle(`\u{1F916} ${STATE_LABELS[state]}`).addFields(
+    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();
@@ -1167,204 +968,102 @@ var StatusCard = class {
     if (data.permissionsSummary) {
       embed.addFields({ name: "\u6743\u9650", value: data.permissionsSummary, inline: false });
     }
-    return embed;
-  }
-  /**
-   * 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;
-  }
-  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/delivery-policy.ts
-import { existsSync, statSync } from "fs";
-var MAX_CHUNK_LIMIT = 2e3;
-var MAX_ATTACHMENTS = 10;
-var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
-function clampChunkLimit(limit) {
-  if (!Number.isFinite(limit)) return MAX_CHUNK_LIMIT;
-  return Math.max(1, Math.min(Math.trunc(limit), MAX_CHUNK_LIMIT));
-}
-function chunkText(text, limit, mode) {
-  const safeLimit = clampChunkLimit(limit);
-  if (text.length <= safeLimit) return [text];
-  const out = [];
-  let rest = text;
-  while (rest.length > safeLimit) {
-    let cut = safeLimit;
-    if (mode === "newline") {
-      const para = rest.lastIndexOf("\n\n", safeLimit);
-      const line = rest.lastIndexOf("\n", safeLimit);
-      const space = rest.lastIndexOf(" ", safeLimit);
-      cut = para > safeLimit / 2 ? para : line > safeLimit / 2 ? line : space > 0 ? space : safeLimit;
-    }
-    out.push(rest.slice(0, cut));
-    rest = rest.slice(cut).replace(/^\n+/, "");
-  }
-  if (rest) out.push(rest);
-  return out;
-}
-function validateOutboundAttachments(files) {
-  if (files.length > MAX_ATTACHMENTS) {
-    throw new Error(`\u6700\u591A\u53EA\u80FD\u53D1\u9001 ${MAX_ATTACHMENTS} \u4E2A\u9644\u4EF6`);
-  }
-  for (const filePath of files) {
-    if (!filePath.trim()) {
-      throw new Error("\u9644\u4EF6\u8DEF\u5F84\u65E0\u6548");
-    }
-    if (!existsSync(filePath)) continue;
-    const stats = statSync(filePath);
-    if (stats.isDirectory()) {
-      throw new Error(`\u9644\u4EF6\u8DEF\u5F84\u4E0D\u80FD\u662F\u76EE\u5F55: ${filePath}`);
-    }
-    if (stats.size > MAX_ATTACHMENT_BYTES) {
-      throw new Error(`\u9644\u4EF6 ${filePath} \u5927\u5C0F\u8D85\u8FC7 ${MAX_ATTACHMENT_BYTES} bytes`);
-    }
-  }
-}
-function buildDeliveryPlan(input) {
-  validateOutboundAttachments(input.files);
-  const chunks = chunkText(input.text, input.policy.textChunkLimit, input.policy.chunkMode);
-  const filesOnFirstChunk = input.files.slice(0, MAX_ATTACHMENTS);
-  const replyToMode = input.policy.replyToMode;
-  const replyToMessageId = input.mode === "system_notice" || input.mode === "summary" ? void 0 : replyToMode === "off" ? void 0 : input.replyToMessageId;
-  return {
-    sessionId: input.sessionId,
-    chatId: input.chatId,
-    replyToMessageId,
-    replyToMode,
-    editTargetMessageId: input.editTargetMessageId,
-    chunks,
-    filesOnFirstChunk,
-    mode: input.mode
-  };
-}
-
-// ../bot/src/discord/delivery.ts
-var sessionState = /* @__PURE__ */ new Map();
-function getSessionState(sessionId) {
-  if (!sessionState.has(sessionId)) {
-    sessionState.set(sessionId, {});
-  }
-  const state = sessionState.get(sessionId);
-  state.lastUsed = Date.now();
-  return state;
-}
-function pruneStaleSessionStates(maxAgeMs = 5 * 60 * 1e3) {
-  const cutoff = Date.now() - maxAgeMs;
-  for (const [sessionId, state] of sessionState) {
-    if (!state.lastUsed || state.lastUsed < cutoff) {
-      sessionState.delete(sessionId);
+    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
+        });
+      }
     }
-  }
-}
-function cleanupSessionDeliveryState(sessionId) {
-  sessionState.delete(sessionId);
-}
-async function sendTyping(channel) {
-  try {
-    await channel.sendTyping?.();
-  } catch {
-  }
-}
-async function sendAckReaction(message, reaction) {
-  if (!reaction) return;
-  try {
-    await message.react(reaction);
-  } catch {
-  }
-}
-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 {
-    const message = await channel.send(payload);
-    return message.id;
-  } catch (error) {
-    if (!options.replyToMessageId) {
-      throw error;
+    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
+      });
     }
-    const fallbackPayload = { content: chunk };
-    if (options.files?.length) fallbackPayload.files = options.files;
-    const fallbackMessage = await channel.send(fallbackPayload);
-    return fallbackMessage.id;
-  }
-}
-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 {
-      }
+    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 = [];
@@ -1423,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` });
@@ -1505,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;
@@ -1518,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 {
@@ -1795,24 +1494,98 @@ var PerformanceTracker = class {
 };
 var performanceTracker = new PerformanceTracker();
 
-// ../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);
+// ../bot/src/panel/panel-state.ts
+var sessionPanels = /* @__PURE__ */ new Map();
+var sessionInitializationPromises = /* @__PURE__ */ new Map();
+function getPanel(sessionId) {
+  return sessionPanels.get(sessionId);
 }
-function getPendingAnswers(sessionId) {
-  return pendingAnswersStore.get(sessionId);
+function setPanel(sessionId, panel) {
+  sessionPanels.set(sessionId, panel);
 }
-function clearPendingAnswers(sessionId) {
-  pendingAnswersStore.delete(sessionId);
-  questionCountStore.delete(sessionId);
+function deletePanel(sessionId) {
+  sessionPanels.delete(sessionId);
 }
-function getQuestionCount(sessionId) {
-  return questionCountStore.get(sessionId) || 0;
+function getAllPanels() {
+  return sessionPanels.entries();
+}
+function getPanelCount() {
+  return sessionPanels.size;
+}
+function getInitializationPromise(sessionId) {
+  return sessionInitializationPromises.get(sessionId);
+}
+function setInitializationPromise(sessionId, promise) {
+  sessionInitializationPromises.set(sessionId, promise);
+}
+function deleteInitializationPromise(sessionId) {
+  sessionInitializationPromises.delete(sessionId);
+}
+
+// ../bot/src/panel/panel-relocation.ts
+var RELOCATION_TIMEOUT_MS = 15e3;
+async function relocateSessionPanelToBottom(sessionId, channel, initialize) {
+  let panel = getPanel(sessionId);
+  if (!panel && channel) {
+    const session = getSessionView(sessionId);
+    const initPromise = initialize(sessionId, channel, {
+      statusCardMessageId: session?.statusCardMessageId,
+      initialTurn: session?.currentTurn || 1
+    });
+    let timeoutHandle;
+    const timeout = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(
+        () => reject(new Error("Panel initialization timeout")),
+        RELOCATION_TIMEOUT_MS
+      );
+    });
+    try {
+      await Promise.race([initPromise, timeout]);
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    }
+    panel = getPanel(sessionId);
+  }
+  if (!panel) return;
+  let statusRelocation = null;
+  try {
+    statusRelocation = await panel.statusCard.recreateAtBottom();
+  } catch (error) {
+    console.warn(`\u72B6\u6001\u6D88\u606F\u8FC1\u79FB\u5931\u8D25 (${sessionId})\uFF1A`, error);
+    return;
+  }
+  let digestRelocation = { oldMessageIds: [], newMessageIds: [] };
+  try {
+    digestRelocation = await panel.summaryHandler.relocateDigestToBottom();
+  } catch (error) {
+    console.warn(`\u6458\u8981\u6D88\u606F\u8FC1\u79FB\u5931\u8D25 (${sessionId})\uFF1A`, error);
+    if (statusRelocation?.oldMessageId && statusRelocation.newMessageId) {
+      panel.statusCard.adopt(statusRelocation.oldMessageId);
+      await panel.channel.messages.delete(statusRelocation.newMessageId).catch(
+        (e) => console.warn(
+          `[PanelAdapter] Failed to cleanup new status card (${sessionId}): ${e.message}`
+        )
+      );
+    }
+    return;
+  }
+  if (statusRelocation?.newMessageId) {
+    setStatusCardBinding(sessionId, { messageId: statusRelocation.newMessageId });
+  }
+  if (statusRelocation?.oldMessageId) {
+    await panel.channel.messages.delete(statusRelocation.oldMessageId).catch(
+      (e) => console.warn(
+        `[PanelAdapter] Failed to delete old status card (${sessionId}): ${e.message}`
+      )
+    );
+  }
+  for (const messageId of digestRelocation.oldMessageIds) {
+    await panel.channel.messages.delete(messageId).catch(
+      (e) => console.warn(
+        `[PanelAdapter] Failed to delete old digest (${sessionId}): ${e.message}`
+      )
+    );
+  }
 }
 
 // ../bot/src/bot-services-helpers.ts
@@ -1868,15 +1641,82 @@ async function notifyUnmanagedCodexHint(client, sessionId, channelId) {
   }
 }
 
+// ../bot/src/panel/panel-performance.ts
+var SESSION_INACTIVE_TIMEOUT_MS = 36e5;
+function createCleanupSessionPanel(renderer) {
+  return function cleanupSessionPanel2(sessionId) {
+    const panel = getPanel(sessionId);
+    if (panel) panel.cleanup();
+    deletePanel(sessionId);
+    renderer.clear(sessionId);
+    stateMachine.clearSession(sessionId);
+    clearPendingAnswers(sessionId);
+    cleanupSessionDeliveryState(sessionId);
+    clearCodexHint(sessionId);
+    cleanupSessionAttachments(sessionId).catch(
+      (e) => console.warn(
+        `[PanelAdapter] Failed to cleanup attachments (${sessionId}): ${e.message}`
+      )
+    );
+    const activeGate = gateService.getActiveGateForSession(sessionId);
+    if (activeGate) {
+      gateService.resolveFromDiscord(activeGate.id, "reject").catch(
+        (e) => console.warn(
+          `[PanelAdapter] Failed to invalidate gate on cleanup (${sessionId}): ${e.message}`
+        )
+      );
+    }
+  };
+}
+function createCleanupInactiveSessions(renderer) {
+  return function cleanupInactiveSessions2() {
+    const now = Date.now();
+    for (const [sessionId, panel] of getAllPanels()) {
+      if (now - panel.getLastActivity() > SESSION_INACTIVE_TIMEOUT_MS) {
+        panel.cleanup();
+        deletePanel(sessionId);
+        renderer.clear(sessionId);
+        console.log(`\u6E05\u7406\u5931\u6D3B\u4F1A\u8BDD\u72B6\u6001\u6295\u5F71: ${sessionId}`);
+      }
+    }
+  };
+}
+function createGetPerformanceStats() {
+  return function getPerformanceStats2() {
+    let projectionCount = 0;
+    for (const [, panel] of getAllPanels()) {
+      if (panel.getCachedProjection() !== null) projectionCount++;
+    }
+    return {
+      discoveryLatency: performanceTracker.getMetricStats("session_discovery_latency"),
+      updateLatency: performanceTracker.getMetricStats("state_update_latency"),
+      activeSessions: getPanelCount(),
+      projectionCount
+    };
+  };
+}
+var cleanupInterval = null;
+function startPerformanceMonitoring(onTick) {
+  if (cleanupInterval) return;
+  cleanupInterval = setInterval(() => {
+    onTick();
+    performanceTracker.takeSnapshot();
+    performanceTracker.cleanup();
+  }, 6e4);
+}
+function stopPerformanceMonitoring() {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+function generatePerformanceReport() {
+  return performanceTracker.generateReport();
+}
+
 // ../bot/src/panel-adapter.ts
-var sessionPanels = /* @__PURE__ */ new Map();
-var sessionInitializationPromises = /* @__PURE__ */ new Map();
 var BATCH_UPDATE_DELAY_MS = 500;
 var statusCardProjectionRenderer = new StatusCardProjectionRenderer();
-var SESSION_INACTIVE_TIMEOUT_MS = 36e5;
-function getPanel(sessionId) {
-  return sessionPanels.get(sessionId);
-}
 function getSessionProjection(sessionId) {
   return stateMachine.getSnapshot(sessionId);
 }
@@ -1889,20 +1729,18 @@ function ensureProjectionTurn(sessionId, turn = 1, event = "turn_bootstrap") {
 }
 function cacheProjection(sessionId, projection) {
   const panel = getPanel(sessionId);
-  if (panel) {
-    panel.updateProjection(projection);
-  }
+  if (panel) panel.updateProjection(projection);
 }
-function persistTurnState(sessionId, projection) {
+stateMachine.registerTurnStatePersister((sessionId, projection) => {
   updateSession(sessionId, {
     currentTurn: projection.turn,
     humanResolved: projection.humanResolved
   });
-}
+});
 function createStatusCardProjectionContext(sessionId) {
   const panel = getPanel(sessionId);
   if (!panel) return void 0;
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   return {
     statusCard: panel.statusCard,
     remoteHumanControl: session?.remoteHumanControl,
@@ -1929,17 +1767,16 @@ async function scheduleProjectionRender(sessionId, projection, updateKey) {
   );
 }
 function resolveProviderSource(sessionId, fallback = "claude") {
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   return session?.provider === "codex" ? "codex" : fallback;
 }
 async function initializeSessionPanel(sessionId, channel, options = {}) {
   performanceTracker.startSessionDiscovery(sessionId);
-  const existing = getPanel(sessionId);
-  if (existing) {
+  if (getPanel(sessionId)) {
     performanceTracker.endSessionDiscovery(sessionId, { cached: true });
     return;
   }
-  const pendingInitialization = sessionInitializationPromises.get(sessionId);
+  const pendingInitialization = getInitializationPromise(sessionId);
   if (pendingInitialization) {
     await pendingInitialization;
     performanceTracker.endSessionDiscovery(sessionId, { cached: true });
@@ -1947,7 +1784,7 @@ async function initializeSessionPanel(sessionId, channel, options = {}) {
   }
   const initialization = (async () => {
     const panel = new SessionPanelComponent(sessionId, channel);
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     await panel.initialize({
       statusCardMessageId: options.statusCardMessageId,
       initialTurn: options.initialTurn,
@@ -1956,7 +1793,7 @@ async function initializeSessionPanel(sessionId, channel, options = {}) {
       provider: session?.provider,
       permissionsSummary: session ? getSessionPermissionSummary(session) : void 0
     });
-    sessionPanels.set(sessionId, panel);
+    setPanel(sessionId, panel);
     setStatusCardBinding(sessionId, {
       messageId: panel.getMessageId() ?? options.statusCardMessageId
     });
@@ -1967,24 +1804,22 @@ async function initializeSessionPanel(sessionId, channel, options = {}) {
     );
     cacheProjection(sessionId, projection);
   })();
-  sessionInitializationPromises.set(sessionId, initialization);
+  setInitializationPromise(sessionId, initialization);
   try {
     await initialization;
     performanceTracker.endSessionDiscovery(sessionId, { cached: false });
   } finally {
-    sessionInitializationPromises.delete(sessionId);
+    deleteInitializationPromise(sessionId);
   }
 }
 async function registerExistingStatusCard(sessionId, channel, statusCardMessageId) {
-  await initializeSessionPanel(sessionId, channel, {
-    statusCardMessageId
-  });
+  await initializeSessionPanel(sessionId, channel, { statusCardMessageId });
 }
 async function updateSessionState(sessionId, event, options = {}) {
   const updateKey = `${sessionId}:state`;
   performanceTracker.startStateUpdate(updateKey);
   if (!getPanel(sessionId) && options.channel) {
-    const session2 = getSession(sessionId);
+    const session2 = getSessionView(sessionId);
     await initializeSessionPanel(sessionId, options.channel, {
       statusCardMessageId: session2?.statusCardMessageId,
       initialTurn: session2?.currentTurn || 1
@@ -1999,7 +1834,7 @@ async function updateSessionState(sessionId, event, options = {}) {
     performanceTracker.endStateUpdate(updateKey, { skipped: true });
     return null;
   }
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (platformEvent.source === "codex" && platformEvent.type === "completed" && session?.isGenerating) {
     performanceTracker.endStateUpdate(updateKey, { skipped: true });
     return getSessionProjection(sessionId);
@@ -2008,12 +1843,12 @@ 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 });
   }
-  persistTurnState(sessionId, projection);
   return projection;
 }
 async function handleResultEvent(sessionId, event, textContent, attachments = []) {
@@ -2035,10 +1870,13 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
       metadata: { from: "result" }
     });
   } else if (!event.success) {
-    const session = getSession(sessionId);
+    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
@@ -2053,7 +1891,7 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
     });
   } else {
     const beforeProjection = getSessionProjection(sessionId);
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     await panel.summaryHandler.sendTurnSummary(
       textContent,
       beforeProjection.turn,
@@ -2061,7 +1899,6 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
       attachments
     );
     const projectionAfterTurn = stateMachine.advanceTurnToIdle(sessionId);
-    persistTurnState(sessionId, projectionAfterTurn);
     await renderProjectionToStatusCard(sessionId, projectionAfterTurn);
     cacheProjection(sessionId, projectionAfterTurn);
   }
@@ -2069,15 +1906,17 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
 async function handleAwaitingHuman(sessionId, detail, options = {}) {
   const panel = getPanel(sessionId);
   if (!panel) return null;
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (!panel.checkInteractionCooldown()) {
-    console.warn(`\u4EA4\u4E92\u5361\u521B\u5EFA\u9650\u6D41 (${sessionId}): \u8DDD\u4E0A\u6B21\u521B\u5EFA\u4EC5 ${panel.getTimeSinceLastInteraction()}ms`);
+    console.warn(
+      `\u4EA4\u4E92\u5361\u521B\u5EFA\u9650\u6D41 (${sessionId}): \u8DDD\u4E0A\u6B21\u521B\u5EFA\u4EC5 ${panel.getTimeSinceLastInteraction()}ms`
+    );
     return null;
   }
   const projection = ensureProjectionTurn(sessionId, 1, "turn_bootstrap");
   const provider = session?.provider ?? resolveProviderSource(sessionId);
   const remoteHumanControl = session?.remoteHumanControl !== false;
-  const gate = gateCoordinator.createGate({
+  const gate = gateService.createGate({
     sessionId,
     provider,
     type: "binary_approval",
@@ -2099,7 +1938,7 @@ async function handleAwaitingHuman(sessionId, detail, options = {}) {
     remoteHumanControl,
     provider
   });
-  gateCoordinator.bindDiscordMessage(gate.id, messageId);
+  gateService.bindDiscordMessage(gate.id, messageId);
   panel.recordInteractionCardTime();
   cacheProjection(sessionId, getSessionProjection(sessionId));
   updateSession(sessionId, {
@@ -2111,73 +1950,21 @@ async function handleAwaitingHuman(sessionId, detail, options = {}) {
   setCurrentInteractionMessage(sessionId, messageId);
   return messageId;
 }
-var RELOCATION_TIMEOUT_MS = 15e3;
-async function relocateSessionPanelToBottom(sessionId, channel) {
-  let panel = getPanel(sessionId);
-  if (!panel && channel) {
-    const session = getSession(sessionId);
-    const initPromise = initializeSessionPanel(sessionId, channel, {
-      statusCardMessageId: session?.statusCardMessageId,
-      initialTurn: session?.currentTurn || 1
-    });
-    let timeoutHandle;
-    const timeout = new Promise((_, reject) => {
-      timeoutHandle = setTimeout(
-        () => reject(new Error("Panel initialization timeout")),
-        RELOCATION_TIMEOUT_MS
-      );
-    });
-    try {
-      await Promise.race([initPromise, timeout]);
-    } finally {
-      if (timeoutHandle) clearTimeout(timeoutHandle);
-    }
-    panel = getPanel(sessionId);
-  }
-  if (!panel) return;
-  let statusRelocation = null;
-  try {
-    statusRelocation = await panel.statusCard.recreateAtBottom();
-  } catch (error) {
-    console.warn(`\u72B6\u6001\u6D88\u606F\u8FC1\u79FB\u5931\u8D25 (${sessionId})\uFF1A`, error);
-    return;
-  }
-  let digestRelocation = { oldMessageIds: [], newMessageIds: [] };
-  try {
-    digestRelocation = await panel.summaryHandler.relocateDigestToBottom();
-  } catch (error) {
-    console.warn(`\u6458\u8981\u6D88\u606F\u8FC1\u79FB\u5931\u8D25 (${sessionId})\uFF1A`, error);
-    if (statusRelocation?.oldMessageId && statusRelocation.newMessageId) {
-      panel.statusCard.adopt(statusRelocation.oldMessageId);
-      await panel.channel.messages.delete(statusRelocation.newMessageId).catch((e) => console.warn(`[PanelAdapter] Failed to cleanup new status card (${sessionId}): ${e.message}`));
-    }
-    return;
-  }
-  if (statusRelocation?.newMessageId) {
-    setStatusCardBinding(sessionId, {
-      messageId: statusRelocation.newMessageId
-    });
-  }
-  if (statusRelocation?.oldMessageId) {
-    await panel.channel.messages.delete(statusRelocation.oldMessageId).catch((e) => console.warn(`[PanelAdapter] Failed to delete old status card (${sessionId}): ${e.message}`));
-  }
-  for (const messageId of digestRelocation.oldMessageIds) {
-    await panel.channel.messages.delete(messageId).catch((e) => console.warn(`[PanelAdapter] Failed to delete old digest (${sessionId}): ${e.message}`));
-  }
+async function relocateSessionPanelToBottom2(sessionId, channel) {
+  await relocateSessionPanelToBottom(
+    sessionId,
+    channel,
+    (sid, ch, options) => initializeSessionPanel(sid, ch, options)
+  );
 }
 function queueDigest(sessionId, item) {
-  const panel = getPanel(sessionId);
-  if (!panel) return;
-  panel.queueDigest(item);
+  getPanel(sessionId)?.queueDigest(item);
 }
 function getDigestQueue(sessionId) {
-  const panel = getPanel(sessionId);
-  if (!panel) return [];
-  return panel.getDigestQueue();
+  return getPanel(sessionId)?.getDigestQueue() ?? [];
 }
 function clearDigestQueue(sessionId) {
-  const panel = getPanel(sessionId);
-  if (panel) panel.clearDigestQueue();
+  getPanel(sessionId)?.clearDigestQueue();
 }
 async function flushDigest(sessionId) {
   const panel = getPanel(sessionId);
@@ -2193,66 +1980,16 @@ function mapPlatformEventTypeToUnifiedState(type) {
 function getStateMachine() {
   return stateMachine;
 }
-function cleanupSessionPanel(sessionId) {
-  const panel = getPanel(sessionId);
-  if (panel) panel.cleanup();
-  sessionPanels.delete(sessionId);
-  statusCardProjectionRenderer.clear(sessionId);
-  stateMachine.clearSession(sessionId);
-  clearPendingAnswers(sessionId);
-  cleanupSessionDeliveryState(sessionId);
-  clearCodexHint(sessionId);
-  cleanupSessionAttachments(sessionId).catch((e) => console.warn(`[PanelAdapter] Failed to cleanup attachments (${sessionId}): ${e.message}`));
-  const activeGate = gateCoordinator.getActiveGateForSession(sessionId);
-  if (activeGate) {
-    gateCoordinator.resolveFromDiscord(activeGate.id, "reject").catch((e) => console.warn(`[PanelAdapter] Failed to invalidate gate on cleanup (${sessionId}): ${e.message}`));
-  }
-}
-function cleanupInactiveSessions() {
-  const now = Date.now();
-  for (const [sessionId, panel] of sessionPanels) {
-    if (now - panel.getLastActivity() > SESSION_INACTIVE_TIMEOUT_MS) {
-      panel.cleanup();
-      sessionPanels.delete(sessionId);
-      statusCardProjectionRenderer.clear(sessionId);
-      console.log(`\u6E05\u7406\u5931\u6D3B\u4F1A\u8BDD\u72B6\u6001\u6295\u5F71: ${sessionId}`);
-    }
-  }
-}
-function getPerformanceStats() {
-  let projectionCount = 0;
-  for (const panel of sessionPanels.values()) {
-    if (panel.getCachedProjection() !== null) projectionCount++;
-  }
-  return {
-    discoveryLatency: performanceTracker.getMetricStats("session_discovery_latency"),
-    updateLatency: performanceTracker.getMetricStats("state_update_latency"),
-    activeSessions: sessionPanels.size,
-    projectionCount
-  };
-}
-var cleanupInterval = null;
-function startPerformanceMonitoring() {
-  if (cleanupInterval) return;
-  cleanupInterval = setInterval(() => {
-    cleanupInactiveSessions();
-    performanceTracker.takeSnapshot();
-    performanceTracker.cleanup();
-  }, 6e4);
-}
-function stopPerformanceMonitoring() {
-  if (cleanupInterval) {
-    clearInterval(cleanupInterval);
-    cleanupInterval = null;
-  }
-}
-function generatePerformanceReport() {
-  return performanceTracker.generateReport();
+var cleanupSessionPanel = createCleanupSessionPanel(statusCardProjectionRenderer);
+var cleanupInactiveSessions = createCleanupInactiveSessions(statusCardProjectionRenderer);
+var getPerformanceStats = createGetPerformanceStats();
+function startPerformanceMonitoring2() {
+  startPerformanceMonitoring(() => cleanupInactiveSessions());
 }
 
 export {
-  normalizeCodexEvent,
-  gateCoordinator,
+  getSessionContext,
+  getSessionView,
   setPendingAnswer,
   getPendingAnswers,
   getQuestionCount,
@@ -2260,15 +1997,24 @@ export {
   sendTyping,
   sendAckReaction,
   deliver,
+  sendSystemNotice,
+  spawnSubagent,
+  getSubagents,
+  runSubagentWatchdog,
+  resolveEffectiveClaudePermissionMode,
+  makeModeButtons,
+  dispatchEvent,
   cleanupOldMessages,
   notifyUnmanagedCodexHint,
+  stopPerformanceMonitoring,
+  generatePerformanceReport,
   getSessionProjection,
   initializeSessionPanel,
   registerExistingStatusCard,
   updateSessionState,
   handleResultEvent,
   handleAwaitingHuman,
-  relocateSessionPanelToBottom,
+  relocateSessionPanelToBottom2 as relocateSessionPanelToBottom,
   queueDigest,
   getDigestQueue,
   clearDigestQueue,
@@ -2278,7 +2024,5 @@ export {
   cleanupSessionPanel,
   cleanupInactiveSessions,
   getPerformanceStats,
-  startPerformanceMonitoring,
-  stopPerformanceMonitoring,
-  generatePerformanceReport
+  startPerformanceMonitoring2 as startPerformanceMonitoring
 };