workspacecord 1.1.1 → 1.1.3

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

@@ -1,16 +1,27 @@
 #!/usr/bin/env node
 import {
+  cleanupSessionAttachments
+} from "./chunk-BFINJJYL.js";
+import {
+  STATE_COLORS,
+  STATE_LABELS,
+  debouncedSaveSession,
+  gateService,
   getAllSessions,
   getSession,
+  getSessionController,
   getSessionPermissionSummary,
+  mapPlatformEventToState,
   setCurrentInteractionMessage,
   setStatusCardBinding,
+  stateMachine,
+  toPlatformEvent,
   updateSession
-} from "./chunk-RK6EIZOL.js";
+} from "./chunk-WON3DPE4.js";
 import {
-  Store,
-  config
-} from "./chunk-UEX7U2KW.js";
+  config,
+  truncate
+} from "./chunk-IVXCJA5I.js";
 
 // ../bot/src/discord/status-card-projection-renderer.ts
 var StatusCardProjectionRenderer = class {
@@ -24,7 +35,9 @@ var StatusCardProjectionRenderer = class {
         phase: projection.phase,
         remoteHumanControl: context.remoteHumanControl,
         provider: context.provider,
-        permissionsSummary: context.permissionsSummary
+        permissionsSummary: context.permissionsSummary,
+        verbose: context.verbose,
+        monitorGoal: context.monitorGoal
       });
     } catch (error) {
       console.error(`\u72B6\u6001\u5361\u66F4\u65B0\u5931\u8D25 (${sessionId}):`, error);
@@ -64,1001 +77,6 @@ var StatusCardProjectionRenderer = class {
 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;
-}
-
-// ../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;
-  }
-}
-function resolveTurn(event, current) {
-  if (event.type === "session_started" && current.turn <= 0) {
-    return 1;
-  }
-  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 };
-    }
-    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) || [];
-  }
-  resolveDisplayState() {
-    return resolveDisplayState(this.sessions.values());
-  }
-  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;
-    }
-    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
-      }
-    );
-    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
-    );
-    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);
-    }
-    this.completedTimerTokens.delete(sessionId);
-  }
-  isSessionIdleTransitionAllowed(event, current) {
-    if (current.displayState === "completed") {
-      return true;
-    }
-    const idleTimerToken = this.readNumericMetadata(event.metadata, "idleTimerToken");
-    if (idleTimerToken === void 0) {
-      return false;
-    }
-    const activeTimerToken = this.completedTimerTokens.get(event.sessionId);
-    if (activeTimerToken !== idleTimerToken) {
-      return false;
-    }
-    const timerTurn = this.readNumericMetadata(event.metadata, "turn");
-    if (timerTurn !== void 0 && timerTurn !== current.turn) {
-      return false;
-    }
-    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";
-  return {
-    type: platformType,
-    sessionId,
-    source: "codex",
-    stateSource,
-    confidence: isPermissionEvent ? "medium" : "high",
-    metadata: { eventKey, ...extra },
-    timestamp: Date.now()
-  };
-}
-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;
-}
-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;
-  }
-  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()
-    };
-  }
-  if (source === "codex") {
-    return null;
-  }
-  return normalizeClaudeEvent(event, sessionId);
-}
-function mapPlatformEventToState(type) {
-  return PLATFORM_EVENT_TO_STATE[type] ?? null;
-}
-
-// ../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() {
-    try {
-      const data = await this.store.read();
-      if (data && Array.isArray(data)) {
-        for (const record of data) {
-          this.gates.set(record.id, record);
-        }
-      }
-    } catch (err) {
-      console.error("[HumanGateRegistry] Failed to load persisted gates:", err);
-    }
-  }
-  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
-    };
-  }
-  // 批量失效门控（用于重启后清理）
-  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++;
-      }
-    }
-    this._save();
-    return count;
-  }
-  // 删除门控记录
-  delete(id) {
-    const result = this.gates.delete(id);
-    if (result) this._save();
-    return result;
-  }
-  // 清理过期门控（超过指定时间未解决）
-  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++;
-      }
-    }
-    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;
-  }
-  // 获取所有门控（用于调试）
-  getAll() {
-    return Array.from(this.gates.values());
-  }
-  // 获取统计信息
-  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
-    };
-  }
-  // 验证状态转换合法性
-  isValidTransition(from, to) {
-    const validTransitions = {
-      pending: ["approved", "rejected", "expired", "invalidated"],
-      approved: [],
-      // 终态
-      rejected: [],
-      // 终态
-      expired: [],
-      // 终态
-      invalidated: []
-      // 终态
-    };
-    return validTransitions[from]?.includes(to) ?? false;
-  }
-  // 生成唯一 ID
-  generateId() {
-    return `gate_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-  }
-};
-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;
-  }
-  /**
-   * 创建新的人工门控
-   */
-  createGate(params) {
-    const record = this.registry.create(params);
-    if (record.supportsRemoteDecision && record.isBlocking) {
-      this.setupTimeout(record.id);
-    }
-    return record;
-  }
-  /**
-   * 注册回执句柄（仅内存，不持久化）
-   */
-  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;
-    }
-    this.receiptHandles.set(gateId, { ...handle, gateId });
-  }
-  /**
-   * 绑定 Discord 交互卡消息 ID
-   */
-  bindDiscordMessage(gateId, discordMessageId) {
-    const record = this.registry.get(gateId);
-    if (!record) {
-      return false;
-    }
-    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
-    });
-    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 };
-  }
-  /**
-   * 通知终端已处理（由钩子调用）
-   */
-  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
-    });
-    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);
-  }
-  /**
-   * 清理超时定时器
-   */
-  clearTimeout(gateId) {
-    const timer = this.timeoutTimers.get(gateId);
-    if (timer) {
-      clearTimeout(timer);
-      this.timeoutTimers.delete(gateId);
-    }
-  }
-  /**
-   * 处理超时
-   */
-  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"
-    });
-    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;
-  }
-  /**
-   * 获取门控记录
-   */
-  getGate(gateId) {
-    return this.registry.get(gateId);
-  }
-  /**
-   * 获取会话的活跃门控
-   */
-  getActiveGateForSession(sessionId) {
-    const active = this.registry.getActiveBySession(sessionId);
-    return active[0];
-  }
-  /**
-   * 清理过期门控
-   */
-  cleanupExpired() {
-    return this.registry.cleanupExpired();
-  }
-  /**
-   * 归档已解决门控，保留最近 N 条
-   */
-  archiveResolved(keepCount = 100) {
-    return this.registry.archiveResolved(keepCount);
-  }
-};
-var gateCoordinator = new GateCoordinator(humanGateRegistry);
-
-// ../bot/src/discord/status-card.ts
 var StatusCard = class {
   messageId = null;
   channel;
@@ -1149,6 +167,15 @@ var StatusCard = class {
         embed.addFields({ name: "\u9636\u6BB5", value: sanitizedPhase, inline: true });
       }
     }
+    if (data.verbose !== void 0) {
+      embed.addFields({ name: "\u8F93\u51FA", value: data.verbose ? "\u{1F50A} \u8BE6\u7EC6" : "\u{1F507} \u7CBE\u7B80", inline: true });
+    }
+    if (data.monitorGoal) {
+      embed.addFields({ name: "\u76D1\u63A7\u76EE\u6807", value: truncate(data.monitorGoal, 150) });
+    }
+    if (data.monitorIteration !== void 0 && data.maxMonitorIterations !== void 0) {
+      embed.addFields({ name: "\u8FED\u4EE3", value: `${data.monitorIteration}/${data.maxMonitorIterations}`, inline: true });
+    }
     if (data.permissionsSummary) {
       embed.addFields({ name: "\u6743\u9650", value: data.permissionsSummary, inline: false });
     }
@@ -1295,6 +322,34 @@ async function sendAckReaction(message, reaction) {
   } catch {
   }
 }
+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;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sendWithBackoff(channel, payload) {
+  let attempt = 0;
+  while (true) {
+    try {
+      const message = await channel.send(payload);
+      return message.id;
+    } catch (error) {
+      if (!isDiscordRateLimitError(error) || attempt >= SEND_MAX_RETRIES) {
+        throw error;
+      }
+      const delayMs = 250 * 2 ** attempt;
+      console.warn(
+        `[Delivery] Discord rate-limited (attempt ${attempt + 1}/${SEND_MAX_RETRIES}), retrying in ${delayMs}ms`
+      );
+      await sleep(delayMs);
+      attempt++;
+    }
+  }
+}
 async function sendChunk(channel, chunk, options = {}) {
   const payload = { content: chunk };
   if (options.files?.length) payload.files = options.files;
@@ -1302,16 +357,14 @@ async function sendChunk(channel, chunk, options = {}) {
     payload.reply = { messageReference: options.replyToMessageId };
   }
   try {
-    const message = await channel.send(payload);
-    return message.id;
+    return await sendWithBackoff(channel, payload);
   } catch (error) {
     if (!options.replyToMessageId) {
       throw error;
     }
     const fallbackPayload = { content: chunk };
     if (options.files?.length) fallbackPayload.files = options.files;
-    const fallbackMessage = await channel.send(fallbackPayload);
-    return fallbackMessage.id;
+    return sendWithBackoff(channel, fallbackPayload);
   }
 }
 async function deliver(channel, plan) {
@@ -1381,8 +434,7 @@ var DigestDelivery = class {
       nextMessageIds.push(message.id);
     }
     for (const staleId of [...replacedMessageIds, ...this.messageIds.slice(chunks.length)]) {
-      await this.channel.messages.delete(staleId).catch(() => {
-      });
+      await this.channel.messages.delete(staleId).catch((e) => console.warn(`[DigestDelivery] Failed to delete message: ${e.message}`));
     }
     this.messageIds = nextMessageIds;
     this.chunks = [...chunks];
@@ -1401,8 +453,7 @@ var DigestDelivery = class {
       }
     } catch (error) {
       for (const messageId of newMessageIds) {
-        await this.channel.messages.delete(messageId).catch(() => {
-        });
+        await this.channel.messages.delete(messageId).catch((e) => console.warn(`[DigestDelivery] Failed to delete message: ${e.message}`));
       }
       throw error;
     }
@@ -1506,6 +557,10 @@ 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();
+    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(
@@ -1607,7 +662,7 @@ var SessionPanelComponent = class {
     }
     this.digestQueue.push({ kind: item.kind, text });
     if (this.digestQueue.length > MAX_DIGEST_QUEUE_SIZE) {
-      this.digestQueue.splice(0, this.digestQueue.length - MAX_DIGEST_QUEUE_SIZE);
+      this.digestQueue = this.digestQueue.slice(-MAX_DIGEST_QUEUE_SIZE);
     }
   }
   getDigestQueue() {
@@ -1634,6 +689,97 @@ var SessionPanelComponent = class {
   }
 };
 
+// ../engine/src/session-context.ts
+var EMPTY_PROJECTION = Object.freeze({
+  turn: 0,
+  humanResolved: false,
+  updatedAt: 0
+});
+function safeGetSessionController(sessionId) {
+  try {
+    const fn = getSessionController;
+    return typeof fn === "function" ? fn(sessionId) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function safeDebouncedSaveSession() {
+  try {
+    const fn = debouncedSaveSession;
+    if (typeof fn === "function") fn();
+  } catch {
+  }
+}
+function safeGetProjection(sessionId) {
+  try {
+    const sm = stateMachine;
+    if (sm && typeof sm.getSnapshot === "function") {
+      return sm.getSnapshot(sessionId);
+    }
+  } catch {
+  }
+  return EMPTY_PROJECTION;
+}
+var SessionSupervisor = class {
+  contexts = /* @__PURE__ */ new Map();
+  get(sessionId) {
+    const live = getSession(sessionId);
+    const cached = this.contexts.get(sessionId);
+    if (!live) {
+      if (cached) this.contexts.delete(sessionId);
+      return void 0;
+    }
+    if (cached) {
+      this.syncContext(cached);
+      return cached;
+    }
+    const ctx = this.build(live);
+    this.contexts.set(sessionId, ctx);
+    return ctx;
+  }
+  /** 枚举现有 context。用于 supervisor 层面的扫描(健康检查、空闲回收)。 */
+  all() {
+    return Array.from(this.contexts.values());
+  }
+  /** 释放某个 session 的 context(endSession 调用时触发)。 */
+  release(sessionId) {
+    this.contexts.delete(sessionId);
+  }
+  releaseAll() {
+    this.contexts.clear();
+  }
+  build(session) {
+    const ctx = {
+      sessionId: session.id,
+      session,
+      controller: safeGetSessionController(session.id),
+      projection: safeGetProjection(session.id),
+      save: () => safeDebouncedSaveSession(),
+      refresh: () => this.syncContext(ctx)
+    };
+    return ctx;
+  }
+  syncContext(ctx) {
+    const live = getSession(ctx.sessionId);
+    if (live) {
+      ctx.session = live;
+    }
+    ctx.controller = safeGetSessionController(
+      ctx.sessionId
+    );
+    ctx.projection = safeGetProjection(
+      ctx.sessionId
+    );
+  }
+};
+var sessionSupervisor = new SessionSupervisor();
+function getSessionContext(sessionId) {
+  return sessionSupervisor.get(sessionId);
+}
+function getSessionView(sessionId) {
+  return sessionSupervisor.get(sessionId)?.session;
+}
+
 // ../bot/src/monitoring/performance-tracker.ts
 import { performance } from "perf_hooks";
 import { memoryUsage, cpuUsage } from "process";
@@ -1778,6 +924,100 @@ var PerformanceTracker = class {
 };
 var performanceTracker = new PerformanceTracker();
 
+// ../bot/src/panel/panel-state.ts
+var sessionPanels = /* @__PURE__ */ new Map();
+var sessionInitializationPromises = /* @__PURE__ */ new Map();
+function getPanel(sessionId) {
+  return sessionPanels.get(sessionId);
+}
+function setPanel(sessionId, panel) {
+  sessionPanels.set(sessionId, panel);
+}
+function deletePanel(sessionId) {
+  sessionPanels.delete(sessionId);
+}
+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}`
+      )
+    );
+  }
+}
+
 // ../engine/src/output/answer-store.ts
 var pendingAnswersStore = /* @__PURE__ */ new Map();
 var questionCountStore = /* @__PURE__ */ new Map();
@@ -1851,15 +1091,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);
 }
@@ -1872,25 +1179,25 @@ 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,
     provider: session?.provider,
-    permissionsSummary: session ? getSessionPermissionSummary(session) : void 0
+    permissionsSummary: session ? getSessionPermissionSummary(session) : void 0,
+    verbose: session?.verbose,
+    monitorGoal: session?.monitorGoal
   };
 }
 async function renderProjectionToStatusCard(sessionId, projection) {
@@ -1910,17 +1217,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 });
@@ -1928,7 +1234,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,
@@ -1937,7 +1243,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
     });
@@ -1948,24 +1254,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
@@ -1980,15 +1284,20 @@ 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);
   }
+  const previousProjection = getSessionProjection(sessionId);
   const projection = stateMachine.applyPlatformEvent(platformEvent);
   cacheProjection(sessionId, projection);
-  await scheduleProjectionRender(sessionId, projection, updateKey);
-  persistTurnState(sessionId, projection);
+  const stateChanged = projection.state !== previousProjection.state || projection.turn !== previousProjection.turn || projection.phase !== previousProjection.phase;
+  if (stateChanged) {
+    await scheduleProjectionRender(sessionId, projection, updateKey);
+  } else {
+    performanceTracker.endStateUpdate(updateKey, { skipped: true });
+  }
   return projection;
 }
 async function handleResultEvent(sessionId, event, textContent, attachments = []) {
@@ -2010,7 +1319,7 @@ 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";
     await panel.summaryHandler.sendTurnFailure(
       failureText,
@@ -2028,7 +1337,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,
@@ -2036,7 +1345,6 @@ async function handleResultEvent(sessionId, event, textContent, attachments = []
       attachments
     );
     const projectionAfterTurn = stateMachine.advanceTurnToIdle(sessionId);
-    persistTurnState(sessionId, projectionAfterTurn);
     await renderProjectionToStatusCard(sessionId, projectionAfterTurn);
     cacheProjection(sessionId, projectionAfterTurn);
   }
@@ -2044,15 +1352,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",
@@ -2074,7 +1384,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, {
@@ -2086,63 +1396,21 @@ async function handleAwaitingHuman(sessionId, detail, options = {}) {
   setCurrentInteractionMessage(sessionId, messageId);
   return messageId;
 }
-async function relocateSessionPanelToBottom(sessionId, channel) {
-  let panel = getPanel(sessionId);
-  if (!panel && channel) {
-    const session = getSession(sessionId);
-    await initializeSessionPanel(sessionId, channel, {
-      statusCardMessageId: session?.statusCardMessageId,
-      initialTurn: session?.currentTurn || 1
-    });
-    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(() => {
-      });
-    }
-    return;
-  }
-  if (statusRelocation?.newMessageId) {
-    setStatusCardBinding(sessionId, {
-      messageId: statusRelocation.newMessageId
-    });
-  }
-  if (statusRelocation?.oldMessageId) {
-    await panel.channel.messages.delete(statusRelocation.oldMessageId).catch(() => {
-    });
-  }
-  for (const messageId of digestRelocation.oldMessageIds) {
-    await panel.channel.messages.delete(messageId).catch(() => {
-    });
-  }
+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);
@@ -2158,66 +1426,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);
-  const activeGate = gateCoordinator.getActiveGateForSession(sessionId);
-  if (activeGate) {
-    gateCoordinator.resolveFromDiscord(activeGate.id, "reject").catch(() => {
-    });
-  }
-}
-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,
@@ -2227,13 +1445,15 @@ export {
   deliver,
   cleanupOldMessages,
   notifyUnmanagedCodexHint,
+  stopPerformanceMonitoring,
+  generatePerformanceReport,
   getSessionProjection,
   initializeSessionPanel,
   registerExistingStatusCard,
   updateSessionState,
   handleResultEvent,
   handleAwaitingHuman,
-  relocateSessionPanelToBottom,
+  relocateSessionPanelToBottom2 as relocateSessionPanelToBottom,
   queueDigest,
   getDigestQueue,
   clearDigestQueue,
@@ -2243,7 +1463,5 @@ export {
   cleanupSessionPanel,
   cleanupInactiveSessions,
   getPerformanceStats,
-  startPerformanceMonitoring,
-  stopPerformanceMonitoring,
-  generatePerformanceReport
+  startPerformanceMonitoring2 as startPerformanceMonitoring
 };