workspacecord 1.1.2 → 1.1.3

package/dist/{chunk-I6EOCCQV.js → chunk-AGB4GP4G.js}

@@ -8,15 +8,15 @@ import {
   cleanupSessionPanel,
   deliver,
   flushDigest,
-  gateCoordinator,
   generatePerformanceReport,
   getPendingAnswers,
   getQuestionCount,
+  getSessionContext,
   getSessionProjection,
+  getSessionView,
   handleAwaitingHuman,
   handleResultEvent,
   initializeSessionPanel,
-  normalizeCodexEvent,
   notifyUnmanagedCodexHint,
   queueDigest,
   registerExistingStatusCard,
@@ -27,10 +27,10 @@ import {
   startPerformanceMonitoring,
   stopPerformanceMonitoring,
   updateSessionState
-} from "./chunk-ZAQV2RZS.js";
+} from "./chunk-7GTUWAQR.js";
 import {
   registerMessageAttachments
-} from "./chunk-L2ZJXV6H.js";
+} from "./chunk-BFINJJYL.js";
 import {
   addMcpServer,
   addSkill,
@@ -51,14 +51,14 @@ import {
   setControlChannelId,
   setHistoryChannelId,
   setPersonality
-} from "./chunk-GMYN4SYT.js";
+} from "./chunk-4KQ7OSK7.js";
 import {
   getAllRegisteredProjects
-} from "./chunk-54DP53ZK.js";
+} from "./chunk-ZO62NAYX.js";
 import {
   buildClaudeSubagentProviderSessionId,
   registerLocalSession
-} from "./chunk-COXPTYH5.js";
+} from "./chunk-WP6YJVAE.js";
 import {
   abortSession,
   abortSessionWithReason,
@@ -67,9 +67,9 @@ import {
   createSession,
   debouncedSaveSession,
   endSession,
+  gateService,
   getAllSessions,
   getOutputPort,
-  getSession,
   getSessionByChannel,
   getSessionByProviderSession,
   getSessionController,
@@ -78,6 +78,7 @@ import {
   getSessionsByCategory,
   loadSessions,
   markSessionGenerating,
+  normalizeCodexEvent,
   registerOutputPort,
   resolveCodexSessionFromMonitor,
   resolveEffectiveClaudePermissionMode,
@@ -91,21 +92,26 @@ import {
   setSessionController,
   setStatusCardBinding,
   setVerbose,
+  stateMachine,
   updateSession,
   updateSessionPermissions,
   updateWorkflowState
-} from "./chunk-RK6EIZOL.js";
+} from "./chunk-WON3DPE4.js";
 import {
+  JsonFileRepository,
+  MonitorRunEnded,
+  MonitorRunStarted,
   ServiceBus,
   config,
   formatDuration,
   formatRelative,
   formatUptime,
+  getDomainBus,
   intervalService,
   isAbortError,
   isUserAllowed,
   truncate
-} from "./chunk-UEX7U2KW.js";
+} from "./chunk-IVXCJA5I.js";
 import {
   __commonJS,
   __require,
@@ -601,9 +607,9 @@ var require_cross_spawn = __commonJS({
     }
     function spawnSync2(command, args, options) {
       const parsed = parse(command, args, options);
-      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-      return result;
+      const result2 = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result2.error = result2.error || enoent.verifyENOENTSync(result2.status, parsed);
+      return result2;
     }
     module.exports = spawn2;
     module.exports.spawn = spawn2;
@@ -858,7 +864,7 @@ providers.set("claude", new ClaudeProvider());
 var codexLoadAttempted = false;
 async function loadCodexProvider() {
   try {
-    const { CodexProvider } = await import("./codex-provider-NYI7KBGO.js");
+    const { CodexProvider } = await import("./codex-provider-Q4Z6UKO6.js");
     providers.set("codex", new CodexProvider());
     codexLoadAttempted = true;
   } catch (err) {
@@ -1033,34 +1039,29 @@ function buildProviderOptions(session, controller, isMonitor = false, runtimeOve
   };
 }
 async function* sendPrompt(sessionId, prompt, runtimeOverrides = {}) {
-  const session = getSession(sessionId);
-  if (!session) throw new Error(`Session "${sessionId}" not found`);
-  if (session.isGenerating) throw new Error("Session is already generating");
+  const ctx = getSessionContext(sessionId);
+  if (!ctx) throw new Error(`Session "${sessionId}" not found`);
+  if (ctx.session.isGenerating) throw new Error("Session is already generating");
   const controller = new AbortController();
-  setSessionController(session.id, controller);
-  markSessionGenerating(session.id, true);
-  const provider = await ensureProvider(session.provider);
+  setSessionController(ctx.sessionId, controller);
+  markSessionGenerating(ctx.sessionId, true);
+  const provider = await ensureProvider(ctx.session.provider);
   try {
     const stream = provider.sendPrompt(
       prompt,
-      buildProviderOptions(session, controller, false, runtimeOverrides)
+      buildProviderOptions(ctx.session, controller, false, runtimeOverrides)
     );
     for await (const event of stream) {
       if (event.type === "session_init") {
-        const current2 = getSession(sessionId);
-        if (current2) {
-          current2.providerSessionId = event.providerSessionId || void 0;
-          debouncedSaveSession();
-        }
+        ctx.session.providerSessionId = event.providerSessionId || void 0;
+        ctx.save();
       }
       if (event.type === "result") {
-        const current2 = getSession(sessionId);
-        if (current2) current2.totalCost += event.costUsd;
+        ctx.session.totalCost += event.costUsd;
       }
       yield event;
     }
-    const current = getSession(sessionId);
-    if (current) current.messageCount++;
+    ctx.session.messageCount++;
   } catch (err) {
     if (!isAbortError(err)) {
       throw err;
@@ -1072,39 +1073,34 @@ async function* sendPrompt(sessionId, prompt, runtimeOverrides = {}) {
       await saveSessionImmediate();
     } catch (cleanupErr) {
       console.error(`[ProviderRuntime] cleanup error for session ${sessionId}:`, cleanupErr);
-      const s = getSession(sessionId);
-      if (s) s.isGenerating = false;
+      const fallback = getSessionContext(sessionId);
+      if (fallback) fallback.session.isGenerating = false;
     }
   }
 }
 async function* continueSessionWithOverrides(sessionId, runtimeOverrides = {}) {
-  const session = getSession(sessionId);
-  if (!session) throw new Error(`Session "${sessionId}" not found`);
-  if (session.isGenerating) throw new Error("Session is already generating");
+  const ctx = getSessionContext(sessionId);
+  if (!ctx) throw new Error(`Session "${sessionId}" not found`);
+  if (ctx.session.isGenerating) throw new Error("Session is already generating");
   const controller = new AbortController();
-  setSessionController(session.id, controller);
-  markSessionGenerating(session.id, true);
-  const provider = await ensureProvider(session.provider);
+  setSessionController(ctx.sessionId, controller);
+  markSessionGenerating(ctx.sessionId, true);
+  const provider = await ensureProvider(ctx.session.provider);
   try {
     const stream = provider.continueSession(
-      buildProviderOptions(session, controller, false, runtimeOverrides)
+      buildProviderOptions(ctx.session, controller, false, runtimeOverrides)
     );
     for await (const event of stream) {
       if (event.type === "session_init") {
-        const current2 = getSession(sessionId);
-        if (current2) {
-          current2.providerSessionId = event.providerSessionId || void 0;
-          debouncedSaveSession();
-        }
+        ctx.session.providerSessionId = event.providerSessionId || void 0;
+        ctx.save();
       }
       if (event.type === "result") {
-        const current2 = getSession(sessionId);
-        if (current2) current2.totalCost += event.costUsd;
+        ctx.session.totalCost += event.costUsd;
       }
       yield event;
     }
-    const current = getSession(sessionId);
-    if (current) current.messageCount++;
+    ctx.session.messageCount++;
   } catch (err) {
     if (!isAbortError(err)) {
       throw err;
@@ -1116,39 +1112,33 @@ async function* continueSessionWithOverrides(sessionId, runtimeOverrides = {}) {
       await saveSessionImmediate();
     } catch (cleanupErr) {
       console.error(`[ProviderRuntime] cleanup error for session ${sessionId}:`, cleanupErr);
-      const s = getSession(sessionId);
-      if (s) s.isGenerating = false;
+      const fallback = getSessionContext(sessionId);
+      if (fallback) fallback.session.isGenerating = false;
     }
   }
 }
 async function* sendMonitorPrompt(sessionId, prompt) {
-  const session = getSession(sessionId);
-  if (!session) throw new Error(`Session "${sessionId}" not found`);
-  const provider = await ensureProvider(session.provider);
-  const current = getSession(sessionId);
-  if (current) current.lastActivity = Date.now();
+  const ctx = getSessionContext(sessionId);
+  if (!ctx) throw new Error(`Session "${sessionId}" not found`);
+  const provider = await ensureProvider(ctx.session.provider);
+  ctx.session.lastActivity = Date.now();
   const mainController = getSessionController(sessionId);
   const controller = new AbortController();
   const onMainAbort = () => controller.abort();
   mainController?.signal.addEventListener("abort", onMainAbort, { once: true });
   try {
-    const stream = provider.sendPrompt(prompt, buildProviderOptions(session, controller, true));
+    const stream = provider.sendPrompt(prompt, buildProviderOptions(ctx.session, controller, true));
     for await (const event of stream) {
       if (event.type === "session_init") {
-        const cur2 = getSession(sessionId);
-        if (cur2) {
-          cur2.monitorProviderSessionId = event.providerSessionId || void 0;
-          debouncedSaveSession();
-        }
+        ctx.session.monitorProviderSessionId = event.providerSessionId || void 0;
+        ctx.save();
       }
       if (event.type === "result") {
-        const cur2 = getSession(sessionId);
-        if (cur2) cur2.totalCost += event.costUsd;
+        ctx.session.totalCost += event.costUsd;
       }
       yield event;
     }
-    const cur = getSession(sessionId);
-    if (cur) cur.lastActivity = Date.now();
+    ctx.session.lastActivity = Date.now();
     debouncedSaveSession();
   } catch (err) {
     if (!isAbortError(err)) {
@@ -1161,21 +1151,21 @@ async function* sendMonitorPrompt(sessionId, prompt) {
 
 // ../engine/src/executor/permission-gate.ts
 function refreshSession(session) {
-  return getSession(session.id) ?? session;
+  return getSessionView(session.id) ?? session;
 }
 function waitForGateResolution(session, gateId) {
   console.log(`[SessionExecutor] gate:waiting sessionId=${session.id} gateId=${gateId}`);
   return new Promise((resolve2) => {
     let settled = false;
-    const settle = (result) => {
+    const settle = (result2) => {
       if (settled) return;
       settled = true;
       console.log(
-        `[SessionExecutor] gate:resolved sessionId=${session.id} gateId=${gateId} action=${result.action} source=${result.source}`
+        `[SessionExecutor] gate:resolved sessionId=${session.id} gateId=${gateId} action=${result2.action} source=${result2.source}`
       );
-      resolve2(result);
+      resolve2(result2);
     };
-    gateCoordinator.registerReceiptHandle(gateId, {
+    gateService.registerReceiptHandle(gateId, {
       type: session.provider === "codex" ? "codex" : "claude",
       sessionId: session.id,
       resolve: (action, source) => settle({ action, source }),
@@ -1259,7 +1249,7 @@ function shouldUseClaudePermissionHandler(session) {
 
 // ../engine/src/executor/session-hooks.ts
 function refreshSession2(session) {
-  return getSession(session.id) ?? session;
+  return getSessionView(session.id) ?? session;
 }
 function applyWorkflowHook(session, hook, patch = {}) {
   return updateWorkflowState(session.id, (current) => ({
@@ -1309,30 +1299,30 @@ function extractRemainingGaps(text) {
     (sentence) => /\b(still|missing|need|remaining|not yet|left to|have not)\b/i.test(sentence)
   ).slice(0, 5);
 }
-function buildWorkerProgressReport(goal, result) {
-  const changedFiles = result.changedFiles ?? [];
-  const recentCommands = result.recentCommands ?? [];
+function buildWorkerProgressReport(goal, result2) {
+  const changedFiles = result2.changedFiles ?? [];
+  const recentCommands = result2.recentCommands ?? [];
   const validationCommands = recentCommands.filter(
     (command) => /\b(test|vitest|jest|pytest|npm test|pnpm test|yarn test|grader|validate|check|lint)\b/i.test(
       command
     )
   ).slice(0, 10);
-  const meaningfulExecution = result.commandCount > 0 || result.fileChangeCount > 0;
-  const blockers = result.hadError ? ["The latest pass reported an error or stalled outcome."] : [];
+  const meaningfulExecution = result2.commandCount > 0 || result2.fileChangeCount > 0;
+  const blockers = result2.hadError ? ["The latest pass reported an error or stalled outcome."] : [];
   return {
     originalGoal: goal,
-    textualResponse: summarizeWorkerText(result.text),
-    commandCount: result.commandCount,
-    fileChangeCount: result.fileChangeCount,
+    textualResponse: summarizeWorkerText(result2.text),
+    commandCount: result2.commandCount,
+    fileChangeCount: result2.fileChangeCount,
     meaningfulExecutionEvidence: meaningfulExecution,
-    providerReportedSuccess: result.success === null ? "unknown" : result.success ? "yes" : "no",
-    workerErrorsObserved: result.hadError,
-    askedForHumanInput: result.askedUser,
-    claimedCompletedOutcomes: extractClaimedCompletedOutcomes(result.text),
+    providerReportedSuccess: result2.success === null ? "unknown" : result2.success ? "yes" : "no",
+    workerErrorsObserved: result2.hadError,
+    askedForHumanInput: result2.askedUser,
+    claimedCompletedOutcomes: extractClaimedCompletedOutcomes(result2.text),
     artifacts: changedFiles,
     validationCommands,
-    goalAssessment: result.text.trim() ? truncate(result.text.trim(), 1200) : meaningfulExecution ? "The worker executed commands or changed files but did not provide an explicit textual assessment." : "The worker did not provide a substantive assessment of progress toward the goal.",
-    remainingGaps: extractRemainingGaps(result.text),
+    goalAssessment: result2.text.trim() ? truncate(result2.text.trim(), 1200) : meaningfulExecution ? "The worker executed commands or changed files but did not provide an explicit textual assessment." : "The worker did not provide a substantive assessment of progress toward the goal.",
+    remainingGaps: extractRemainingGaps(result2.text),
     blockers
   };
 }
@@ -1569,6 +1559,100 @@ function parseAskUserDecision(text) {
   }
 }
 
+// ../engine/src/executor/monitor-run-store.ts
+var monitorRepo = new JsonFileRepository({
+  filename: "monitor-runs.json",
+  idField: "id",
+  debounceMs: 0
+});
+var initialized = false;
+async function ensureInit() {
+  if (initialized) return;
+  await monitorRepo.init();
+  initialized = true;
+}
+function makeId(sessionId, startedAt) {
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `${sessionId}:${startedAt}:${suffix}`;
+}
+async function beginMonitorRun(params) {
+  await ensureInit();
+  const now = Date.now();
+  const stale = monitorRepo.find({
+    where: { sessionId: params.sessionId, status: "running" }
+  });
+  for (const old of stale) {
+    await monitorRepo.update(old.id, { status: "abandoned", lastCheckpointAt: now });
+  }
+  const run = {
+    id: makeId(params.sessionId, now),
+    sessionId: params.sessionId,
+    goal: params.goal,
+    iteration: 0,
+    maxIterations: params.maxIterations,
+    status: "running",
+    startedAt: now,
+    lastCheckpointAt: now
+  };
+  await monitorRepo.save(run);
+  getDomainBus().emit(
+    MonitorRunStarted,
+    {
+      sessionId: run.sessionId,
+      runId: run.id,
+      goal: run.goal,
+      maxIterations: run.maxIterations
+    },
+    "monitor-run-store"
+  );
+  return run;
+}
+async function checkpointMonitorRun(runId, patch) {
+  await ensureInit();
+  return monitorRepo.update(runId, { ...patch, lastCheckpointAt: Date.now() });
+}
+async function finishMonitorRun(runId, status, finalPatch = {}) {
+  await ensureInit();
+  const updated = await monitorRepo.update(runId, {
+    ...finalPatch,
+    status,
+    lastCheckpointAt: Date.now()
+  });
+  if (updated) {
+    getDomainBus().emit(
+      MonitorRunEnded,
+      {
+        sessionId: updated.sessionId,
+        runId: updated.id,
+        status,
+        iteration: updated.iteration,
+        rationale: updated.lastRationale
+      },
+      "monitor-run-store"
+    );
+  }
+}
+async function reconcileMonitorRunsOnStartup() {
+  await ensureInit();
+  const running = monitorRepo.find({ where: { status: "running" } });
+  const now = Date.now();
+  for (const run of running) {
+    await monitorRepo.update(run.id, { status: "abandoned", lastCheckpointAt: now });
+    getDomainBus().emit(
+      MonitorRunEnded,
+      {
+        sessionId: run.sessionId,
+        runId: run.id,
+        status: "abandoned",
+        iteration: run.iteration,
+        rationale: run.lastRationale
+      },
+      "monitor-run-store"
+    );
+  }
+  return running;
+}
+
 // ../engine/src/executor/monitor-loop.ts
 var MAX_MONITOR_ITERATIONS = 6;
 async function runMonitorDecision(session, goal, workerResult, iteration) {
@@ -1786,6 +1870,16 @@ async function runMonitorLoop(session, channel, goal, initialResult, runWorkerPa
   console.log(
     `[SessionExecutor] monitor:loop-start sessionId=${session.id} goal=${truncate(goal, 80)}`
   );
+  const monitorRun = await beginMonitorRun({
+    sessionId: session.id,
+    goal,
+    maxIterations: MAX_MONITOR_ITERATIONS
+  }).catch((err) => {
+    console.warn(
+      `[SessionExecutor] failed to persist MonitorRun for session ${session.id}: ${err.message}`
+    );
+    return null;
+  });
   let workerResult = initialResult;
   let currentSession = refreshSession2(session);
   for (let iteration = 1; iteration <= MAX_MONITOR_ITERATIONS; iteration++) {
@@ -1855,6 +1949,13 @@ async function runMonitorLoop(session, channel, goal, initialResult, runWorkerPa
       });
       const summary = decision.completionSummary || decision.rationale || "The monitor judged the request complete.";
       await getOutputPort().handleResult(currentSession.id, createSyntheticResult(true, summary), summary);
+      if (monitorRun) {
+        await finishMonitorRun(monitorRun.id, "completed", {
+          iteration,
+          lastRationale: decision.rationale
+        }).catch(() => {
+        });
+      }
       console.log(
         `[SessionExecutor] monitor:complete sessionId=${currentSession.id} iteration=${iteration} rationale=${truncate(decision.rationale, 80)}`
       );
@@ -1875,11 +1976,26 @@ async function runMonitorLoop(session, channel, goal, initialResult, runWorkerPa
       await getOutputPort().handleAwaitingHuman(currentSession.id, blocker, {
         source: currentSession.provider === "codex" ? "codex" : "claude"
       });
+      if (monitorRun) {
+        await finishMonitorRun(monitorRun.id, "blocked", {
+          iteration,
+          lastRationale: decision.rationale
+        }).catch(() => {
+        });
+      }
       console.warn(
         `[SessionExecutor] monitor:blocked sessionId=${currentSession.id} iteration=${iteration} reason=${truncate(decision.rationale, 80)}`
       );
       return;
     }
+    if (monitorRun) {
+      await checkpointMonitorRun(monitorRun.id, {
+        iteration,
+        lastRationale: decision.rationale,
+        lastWorkerSummary: summarizeWorkerPass(buildWorkerProgressReport(goal, workerResult))
+      }).catch(() => {
+      });
+    }
     await updatePanelState(currentSession, "work_started", channel);
     getOutputPort().queueDigest(currentSession.id, {
       kind: "monitor",
@@ -1926,6 +2042,13 @@ async function runMonitorLoop(session, channel, goal, initialResult, runWorkerPa
   await getOutputPort().handleAwaitingHuman(currentSession.id, limitSummary, {
     source: currentSession.provider === "codex" ? "codex" : "claude"
   });
+  if (monitorRun) {
+    await finishMonitorRun(monitorRun.id, "failed", {
+      iteration: MAX_MONITOR_ITERATIONS,
+      lastRationale: "Reached the continuation safety limit."
+    }).catch(() => {
+    });
+  }
   console.warn(
     `[SessionExecutor] monitor:limit-reached sessionId=${currentSession.id} iterations=${MAX_MONITOR_ITERATIONS}`
   );
@@ -1968,7 +2091,7 @@ async function runWorkerPass(session, channel, prompt, iteration, mode = "prompt
       watchdogTimer = setTimeout(scheduleWatchdog, delay);
     };
     watchdogTimer = setTimeout(scheduleWatchdog, WATCHDOG_SLOW_INTERVAL);
-    const result = await getOutputPort().handleOutputStream(
+    const result2 = await getOutputPort().handleOutputStream(
       stream,
       channel,
       session.id,
@@ -1984,10 +2107,10 @@ async function runWorkerPass(session, channel, prompt, iteration, mode = "prompt
     const abortReason = consumeAbortReason(session.id);
     if (watchdogTriggered || abortReason === "watchdog") {
       const stalledResult = {
-        ...result,
+        ...result2,
         hadError: true,
         abortReason,
-        text: annotateInactivityAbort(result.text, WORKER_IDLE_TIMEOUT_MS)
+        text: annotateInactivityAbort(result2.text, WORKER_IDLE_TIMEOUT_MS)
       };
       const stalledReport = buildWorkerProgressReport("", stalledResult);
       applyWorkflowHook(session, "on_stall", {
@@ -2000,17 +2123,17 @@ async function runWorkerPass(session, channel, prompt, iteration, mode = "prompt
       );
       return stalledResult;
     }
-    const resultReport = buildWorkerProgressReport("", result);
+    const resultReport = buildWorkerProgressReport("", result2);
     applyWorkflowHook(session, "after_worker_pass", {
       status: session.mode === "monitor" ? "monitor_review" : "idle",
       lastWorkerSummary: summarizeWorkerPass(resultReport),
       lastWorkerReport: resultReport
     });
     console.log(
-      `[SessionExecutor] worker:end sessionId=${session.id} iteration=${iteration} commands=${result.commandCount} files=${result.fileChangeCount} success=${result.success} hasError=${result.hadError}`
+      `[SessionExecutor] worker:end sessionId=${session.id} iteration=${iteration} commands=${result2.commandCount} files=${result2.fileChangeCount} success=${result2.success} hasError=${result2.hadError}`
     );
     return {
-      ...result,
+      ...result2,
       abortReason
     };
   } finally {
@@ -2031,7 +2154,7 @@ async function executeSessionPrompt(session, channel, prompt, options = {}) {
   }
   if ((options.updateMonitorGoal ?? true) && goalText && !session.monitorGoal) {
     setMonitorGoal(session.id, goalText);
-    session = getSession(session.id) ?? session;
+    session = getSessionView(session.id) ?? session;
   }
   const goal = session.monitorGoal || goalText;
   if (!goal) {
@@ -2141,11 +2264,163 @@ function getExpandableContent(id) {
   return expandableStore.get(id)?.content;
 }
 
-// ../bot/src/output-handler.ts
-import { existsSync } from "fs";
+// ../engine/src/executor/monitor-autoresume.ts
+async function reconcileAndCollectAutoResumeCandidates(policy) {
+  const abandoned = await reconcileMonitorRunsOnStartup();
+  if (policy === "abandon-only" || abandoned.length === 0) {
+    return { abandoned, candidates: [] };
+  }
+  const candidates = [];
+  for (const run of abandoned) {
+    const session = getSessionView(run.sessionId);
+    if (!session) continue;
+    if (session.mode !== "monitor") continue;
+    if (session.isGenerating) continue;
+    const goal = session.monitorGoal || run.goal;
+    if (!goal) continue;
+    candidates.push({
+      sessionId: session.id,
+      channelId: session.channelId,
+      runId: run.id,
+      goal,
+      lastIteration: run.iteration,
+      lastRationale: run.lastRationale,
+      abandonedRun: run
+    });
+  }
+  return { abandoned, candidates };
+}
 
-// ../bot/src/codex-renderer.ts
-import { EmbedBuilder } from "discord.js";
+// ../bot/src/output/message-streamer.ts
+function detectRepetition(text) {
+  const sentences = text.split(/[。！？\n]+/).filter((s) => s.trim().length > 5);
+  if (sentences.length < 3) return { isRepetitive: false, cleanedText: text };
+  const counts = /* @__PURE__ */ new Map();
+  for (const sentence of sentences) {
+    const normalized = sentence.trim();
+    counts.set(normalized, (counts.get(normalized) || 0) + 1);
+  }
+  let maxCount = 0;
+  let mostRepeated = "";
+  for (const [sentence, count2] of counts) {
+    if (count2 > maxCount) {
+      maxCount = count2;
+      mostRepeated = sentence;
+    }
+  }
+  if (maxCount >= 5) {
+    const parts = text.split(mostRepeated);
+    const cleaned = parts.slice(0, 3).join(mostRepeated);
+    return {
+      isRepetitive: true,
+      cleanedText: cleaned + `
+
+\u26A0\uFE0F *[\u68C0\u6D4B\u5230\u91CD\u590D\u8F93\u51FA,\u5DF2\u622A\u65AD ${maxCount - 2} \u6B21\u91CD\u590D]*`
+    };
+  }
+  return { isRepetitive: false, cleanedText: text };
+}
+var MessageStreamer = class {
+  _channel;
+  _sessionId;
+  currentText = "";
+  transcriptText = "";
+  dirty = false;
+  flushing = false;
+  timer = null;
+  INTERVAL = 400;
+  constructor(channel, sessionId) {
+    this._channel = channel;
+    this._sessionId = sessionId;
+  }
+  append(text, options = {}) {
+    this.currentText += text;
+    if (options.persist !== false) {
+      this.transcriptText += text;
+    }
+    this.dirty = true;
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.timer || this.flushing) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush().catch((err) => {
+        console.error(`[MessageStreamer] flush error (session ${this._sessionId}):`, err);
+      });
+    }, this.INTERVAL);
+  }
+  async flush() {
+    if (this.flushing || !this.dirty) return;
+    this.flushing = true;
+    try {
+      this.dirty = false;
+      if (this.currentText.trim()) {
+        const plan = buildDeliveryPlan({
+          sessionId: this._sessionId,
+          chatId: this._channel.id,
+          text: this.currentText,
+          files: [],
+          mode: "progress_update",
+          policy: {
+            textChunkLimit: config.textChunkLimit,
+            chunkMode: config.chunkMode,
+            replyToMode: config.replyToMode,
+            ackReaction: config.ackReaction
+          }
+        });
+        await deliver(this._channel, plan);
+      }
+    } finally {
+      this.flushing = false;
+      if (this.dirty) this.scheduleFlush();
+    }
+  }
+  async waitForFlush() {
+    const deadline = Date.now() + 1e4;
+    while (this.flushing) {
+      if (Date.now() > deadline) {
+        console.warn(`[MessageStreamer] flush wait timeout (session ${this._sessionId}), forcing reset`);
+        this.flushing = false;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  async finalize() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.waitForFlush();
+    if (this.dirty) {
+      this.dirty = false;
+      const { cleanedText } = detectRepetition(this.currentText);
+      this.currentText = cleanedText;
+    }
+  }
+  async discard() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.waitForFlush();
+    this.currentText = "";
+    this.dirty = false;
+  }
+  getText() {
+    return this.transcriptText;
+  }
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// ../bot/src/output/event-handlers.ts
+import { existsSync } from "fs";
 
 // ../bot/src/subagent-manager.ts
 import {
@@ -2303,133 +2578,8 @@ function getSubagentSessions() {
   return getAllSessions().filter((s) => s.type === "subagent");
 }
 
-// ../bot/src/output/message-streamer.ts
-function detectRepetition(text) {
-  const sentences = text.split(/[。！？\n]+/).filter((s) => s.trim().length > 5);
-  if (sentences.length < 3) return { isRepetitive: false, cleanedText: text };
-  const counts = /* @__PURE__ */ new Map();
-  for (const sentence of sentences) {
-    const normalized = sentence.trim();
-    counts.set(normalized, (counts.get(normalized) || 0) + 1);
-  }
-  let maxCount = 0;
-  let mostRepeated = "";
-  for (const [sentence, count2] of counts) {
-    if (count2 > maxCount) {
-      maxCount = count2;
-      mostRepeated = sentence;
-    }
-  }
-  if (maxCount >= 5) {
-    const parts = text.split(mostRepeated);
-    const cleaned = parts.slice(0, 3).join(mostRepeated);
-    return {
-      isRepetitive: true,
-      cleanedText: cleaned + `
-
-\u26A0\uFE0F *[\u68C0\u6D4B\u5230\u91CD\u590D\u8F93\u51FA,\u5DF2\u622A\u65AD ${maxCount - 2} \u6B21\u91CD\u590D]*`
-    };
-  }
-  return { isRepetitive: false, cleanedText: text };
-}
-var MessageStreamer = class {
-  _channel;
-  _sessionId;
-  currentText = "";
-  transcriptText = "";
-  dirty = false;
-  flushing = false;
-  timer = null;
-  INTERVAL = 400;
-  constructor(channel, sessionId) {
-    this._channel = channel;
-    this._sessionId = sessionId;
-  }
-  append(text, options = {}) {
-    this.currentText += text;
-    if (options.persist !== false) {
-      this.transcriptText += text;
-    }
-    this.dirty = true;
-    this.scheduleFlush();
-  }
-  scheduleFlush() {
-    if (this.timer || this.flushing) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      this.flush().catch((err) => {
-        console.error(`[MessageStreamer] flush error (session ${this._sessionId}):`, err);
-      });
-    }, this.INTERVAL);
-  }
-  async flush() {
-    if (this.flushing || !this.dirty) return;
-    this.flushing = true;
-    try {
-      this.dirty = false;
-      if (this.currentText.trim()) {
-        const plan = buildDeliveryPlan({
-          sessionId: this._sessionId,
-          chatId: this._channel.id,
-          text: this.currentText,
-          files: [],
-          mode: "progress_update",
-          policy: {
-            textChunkLimit: config.textChunkLimit,
-            chunkMode: config.chunkMode,
-            replyToMode: config.replyToMode,
-            ackReaction: config.ackReaction
-          }
-        });
-        await deliver(this._channel, plan);
-      }
-    } finally {
-      this.flushing = false;
-      if (this.dirty) this.scheduleFlush();
-    }
-  }
-  async waitForFlush() {
-    const deadline = Date.now() + 1e4;
-    while (this.flushing) {
-      if (Date.now() > deadline) {
-        console.warn(`[MessageStreamer] flush wait timeout (session ${this._sessionId}), forcing reset`);
-        this.flushing = false;
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 50));
-    }
-  }
-  async finalize() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    await this.waitForFlush();
-    if (this.dirty) {
-      this.dirty = false;
-      const { cleanedText } = detectRepetition(this.currentText);
-      this.currentText = cleanedText;
-    }
-  }
-  async discard() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    await this.waitForFlush();
-    this.currentText = "";
-    this.dirty = false;
-  }
-  getText() {
-    return this.transcriptText;
-  }
-  destroy() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-};
+// ../bot/src/codex-renderer.ts
+import { EmbedBuilder } from "discord.js";
 
 // ../bot/src/output/interaction-controls.ts
 import {
@@ -2474,24 +2624,267 @@ function shouldSuppressCommandExecution(command) {
   return command.toLowerCase().includes("total-recall");
 }
 
+// ../bot/src/output/event-handlers.ts
+function providerSource(sessionId) {
+  const session = getSessionView(sessionId);
+  return session?.provider === "codex" ? "codex" : "claude";
+}
+var textDelta = (event, ctx) => {
+  ctx.streamer.append(event.text);
+};
+var askUser = async (event, ctx) => {
+  ctx.state.askedUser = true;
+  ctx.state.askUserQuestionsJson = event.questionsJson;
+  await ctx.streamer.discard();
+  const session = getSessionView(ctx.sessionId);
+  if (!session) return;
+  const source = providerSource(ctx.sessionId);
+  await updateSessionState(ctx.sessionId, {
+    type: "awaiting_human",
+    sessionId: ctx.sessionId,
+    source,
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: { detail: event.questionsJson }
+  });
+  await flushDigest(ctx.sessionId);
+  await handleAwaitingHuman(ctx.sessionId, event.questionsJson, { source });
+};
+var task = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, { kind: "tool", text: `\u4EFB\u52A1\u5DE5\u5177\uFF1A${event.action}` });
+  ctx.state.lastToolName = event.action;
+};
+var taskStarted = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, {
+    kind: "subagent",
+    text: `\u5B50\u4EE3\u7406\u542F\u52A8\uFF1A${truncate(event.description, 80)}`
+  });
+  const session = getSessionView(ctx.sessionId);
+  if (!session || ctx.channel.type === void 0) return;
+  autoSpawnSubagentThread(session, event.taskId, event.description, ctx.channel).then((result2) => {
+    if (result2) ctx.state.taskThreadMap.set(event.taskId, result2.threadId);
+  }).catch(
+    (err) => console.warn(
+      `[OutputHandler] Failed to auto-spawn thread for task ${event.taskId}: ${err.message}`
+    )
+  );
+};
+var taskProgress = (event, ctx) => {
+  if (event.summary) {
+    queueDigest(ctx.sessionId, {
+      kind: "subagent",
+      text: `\u5B50\u4EE3\u7406\u8FDB\u5C55\uFF1A${truncate(event.summary, 100)}`
+    });
+  }
+  const threadId = ctx.state.taskThreadMap.get(event.taskId);
+  if (!threadId || !event.summary) return;
+  const thread = ctx.channel.threads?.cache.get(threadId);
+  if (!thread) return;
+  thread.send(`\u{1F4DD} ${truncate(event.summary, 1900)}`).catch(
+    (e) => console.warn(
+      `[OutputHandler] Failed to send progress to thread: ${e.message}`
+    )
+  );
+};
+var taskDone = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, {
+    kind: "subagent",
+    text: `\u5B50\u4EE3\u7406${event.status === "completed" ? "\u5B8C\u6210" : "\u7ED3\u675F"}\uFF1A${truncate(event.summary || "No summary.", 100)}`
+  });
+  const threadId = ctx.state.taskThreadMap.get(event.taskId);
+  if (!threadId) return;
+  const thread = ctx.channel.threads?.cache.get(threadId);
+  if (thread) {
+    const emoji = event.status === "completed" ? "\u2705" : "\u274C";
+    thread.send(`${emoji} \u5B50\u4EFB\u52A1${event.status === "completed" ? "\u5B8C\u6210" : "\u7ED3\u675F"}\uFF1A${truncate(event.summary || "", 1900)}`).catch(
+      (e) => console.warn(
+        `[OutputHandler] Failed to send task done to thread: ${e.message}`
+      )
+    );
+  }
+  ctx.state.taskThreadMap.delete(event.taskId);
+};
+var webSearch = (event, ctx) => {
+  if (ctx.verbose) {
+    queueDigest(ctx.sessionId, { kind: "search", text: `\u68C0\u7D22\uFF1A${truncate(event.query, 80)}` });
+  }
+};
+var toolStart = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  queueDigest(ctx.sessionId, { kind: "tool", text: `\u5DE5\u5177\uFF1A${event.toolName}` });
+  ctx.state.lastToolName = event.toolName;
+};
+var toolResult = async (event, ctx) => {
+  await ctx.streamer.finalize();
+  if (ctx.verbose && event.result) {
+    queueDigest(ctx.sessionId, {
+      kind: "tool",
+      text: `\u5DE5\u5177\u7ED3\u679C\uFF1A${truncate(ctx.state.lastToolName || event.toolName || "tool", 60)}`
+    });
+  }
+};
+var imageFile = (event, ctx) => {
+  if (existsSync(event.filePath)) {
+    ctx.state.pendingAttachments.push(event.filePath);
+  }
+};
+var commandExecution = (event, ctx) => {
+  ctx.state.commandCount++;
+  if (ctx.state.recentCommands.length < 8) ctx.state.recentCommands.push(event.command);
+  if (!shouldSuppressCommandExecution(event.command)) {
+    queueDigest(ctx.sessionId, {
+      kind: "command",
+      text: `\u547D\u4EE4\uFF1A${truncate(event.command, 80)}${event.exitCode !== null ? `\uFF08\u9000\u51FA\u7801 ${event.exitCode}\uFF09` : ""}`
+    });
+  }
+};
+var fileChange = (event, ctx) => {
+  ctx.state.fileChangeCount += event.changes.length;
+  for (const change of event.changes) {
+    if (!change.filePath) continue;
+    if (ctx.state.changedFiles.includes(change.filePath)) continue;
+    if (ctx.state.changedFiles.length >= 12) break;
+    ctx.state.changedFiles.push(change.filePath);
+  }
+  queueDigest(ctx.sessionId, {
+    kind: "file",
+    text: `\u6587\u4EF6\u53D8\u66F4\uFF1A${event.changes.length} \u4E2A\uFF08\u6700\u8FD1\uFF1A${truncate(ctx.state.changedFiles.slice(-3).join(", "), 120)}\uFF09`
+  });
+};
+var reasoning = (event, ctx) => {
+  if (ctx.verbose) {
+    queueDigest(ctx.sessionId, { kind: "reasoning", text: `\u63A8\u7406\uFF1A${truncate(event.text, 100)}` });
+  }
+};
+var todoList = (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`
+  });
+};
+var MODE_LABELS = {
+  auto: "\u81EA\u52A8",
+  plan: "\u8BA1\u5212",
+  normal: "\u666E\u901A",
+  monitor: "\u76D1\u63A7"
+};
+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 statusLine = event.success ? `-# $${cost} | ${duration} | ${turns} turns | ${modeLabel}` : `-# Error | $${cost} | ${duration} | ${turns} turns`;
+  ctx.streamer.append(`
+${statusLine}`, { persist: false });
+  if (!event.success && event.errors.length) {
+    ctx.streamer.append(`
+\`\`\`
+${event.errors.join("\n")}
+\`\`\``, { persist: false });
+  }
+  await ctx.streamer.finalize();
+  const session = getSessionView(ctx.sessionId);
+  if (!session) {
+    ctx.state.pendingAttachments = [];
+    return;
+  }
+  if (ctx.mode === "monitor") {
+    await flushDigest(ctx.sessionId);
+    await updateSessionState(ctx.sessionId, {
+      type: "work_started",
+      sessionId: ctx.sessionId,
+      source: providerSource(ctx.sessionId),
+      confidence: "high",
+      timestamp: Date.now(),
+      metadata: {
+        phase: "\u7B49\u5F85\u76D1\u7763\u5224\u65AD",
+        summary: event.success ? "\u672C\u8F6E\u6267\u884C\u7ED3\u675F\uFF0C\u7B49\u5F85\u76D1\u7763\u5224\u65AD" : "\u672C\u8F6E\u6267\u884C\u5931\u8D25\uFF0C\u7B49\u5F85\u76D1\u7763\u5224\u65AD"
+      }
+    });
+  } else {
+    ctx.state.deferredResult = {
+      event,
+      text: lastText,
+      attachments: [...ctx.state.pendingAttachments]
+    };
+  }
+  ctx.state.pendingAttachments = [];
+};
+var 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,
+  result,
+  error: errorEvent,
+  session_init: sessionInit
+};
+async function dispatchEvent(event, ctx) {
+  const handler = EVENT_HANDLERS[event.type];
+  if (!handler) return;
+  await handler(event, ctx);
+}
+
 // ../bot/src/output-handler.ts
+var DIGEST_FLUSH_INTERVAL_MS = 8e3;
+function createInitialState() {
+  return {
+    askedUser: false,
+    hadError: false,
+    success: null,
+    commandCount: 0,
+    fileChangeCount: 0,
+    recentCommands: [],
+    changedFiles: [],
+    pendingAttachments: [],
+    lastToolName: null,
+    taskThreadMap: /* @__PURE__ */ new Map()
+  };
+}
 async function handleOutputStream(stream, channel, sessionId, verbose = false, mode = "auto", _provider = "claude", options = {}) {
   const streamer = new MessageStreamer(channel, sessionId);
-  console.log(`[OutputHandler] Stream started for session ${sessionId} (provider: ${_provider}, mode: ${mode}, verbose: ${verbose})`);
-  let lastToolName = null;
-  let askedUser = false;
-  let askUserQuestionsJson;
-  let hadError = false;
-  let success = null;
-  let commandCount = 0;
-  let fileChangeCount = 0;
-  const recentCommands = [];
-  const changedFiles = [];
-  const pendingAttachments = [];
-  const taskThreadMap = /* @__PURE__ */ new Map();
-  let deferredResult;
+  console.log(
+    `[OutputHandler] Stream started for session ${sessionId} (provider: ${_provider}, mode: ${mode}, verbose: ${verbose})`
+  );
+  const state = createInitialState();
   let lastDigestFlushAt = Date.now();
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (session) {
     await initializeSessionPanel(sessionId, channel, {
       statusCardMessageId: session.statusCardMessageId,
@@ -2506,238 +2899,34 @@ async function handleOutputStream(stream, channel, sessionId, verbose = false, m
       timestamp: Date.now()
     });
   }
+  const ctx = { sessionId, channel, streamer, verbose, mode, state };
   try {
     for await (const event of stream) {
       options.onEvent?.(event);
-      switch (event.type) {
-        case "text_delta": {
-          streamer.append(event.text);
-          break;
-        }
-        case "ask_user": {
-          console.log(`[OutputHandler] Session ${sessionId}: ask_user event (human input requested)`);
-          askedUser = true;
-          askUserQuestionsJson = event.questionsJson;
-          await streamer.discard();
-          if (session) {
-            await updateSessionState(sessionId, {
-              type: "awaiting_human",
-              sessionId,
-              source: session.provider === "claude" ? "claude" : "codex",
-              confidence: "high",
-              timestamp: Date.now(),
-              metadata: { detail: event.questionsJson }
-            });
-            await flushDigest(sessionId);
-            await handleAwaitingHuman(sessionId, event.questionsJson, {
-              source: session.provider === "claude" ? "claude" : "codex"
-            });
-          }
-          break;
-        }
-        case "task": {
-          await streamer.finalize();
-          queueDigest(sessionId, { kind: "tool", text: `\u4EFB\u52A1\u5DE5\u5177\uFF1A${event.action}` });
-          lastToolName = event.action;
-          break;
-        }
-        case "task_started": {
-          await streamer.finalize();
-          queueDigest(sessionId, {
-            kind: "subagent",
-            text: `\u5B50\u4EE3\u7406\u542F\u52A8\uFF1A${truncate(event.description, 80)}`
-          });
-          if (session && channel.type !== void 0) {
-            autoSpawnSubagentThread(session, event.taskId, event.description, channel).then((result) => {
-              if (result) taskThreadMap.set(event.taskId, result.threadId);
-            }).catch((err) => console.warn(`[OutputHandler] Failed to auto-spawn thread for task ${event.taskId}: ${err.message}`));
-          }
-          break;
-        }
-        case "task_progress": {
-          if (event.summary) {
-            queueDigest(sessionId, {
-              kind: "subagent",
-              text: `\u5B50\u4EE3\u7406\u8FDB\u5C55\uFF1A${truncate(event.summary, 100)}`
-            });
-          }
-          const progressThreadId = taskThreadMap.get(event.taskId);
-          if (progressThreadId && event.summary) {
-            const thread = channel.threads?.cache.get(progressThreadId);
-            if (thread) {
-              thread.send(`\u{1F4DD} ${truncate(event.summary, 1900)}`).catch((e) => console.warn(`[OutputHandler] Failed to send progress to thread: ${e.message}`));
-            }
-          }
-          break;
-        }
-        case "task_done": {
-          await streamer.finalize();
-          queueDigest(sessionId, {
-            kind: "subagent",
-            text: `\u5B50\u4EE3\u7406${event.status === "completed" ? "\u5B8C\u6210" : "\u7ED3\u675F"}\uFF1A${truncate(event.summary || "No summary.", 100)}`
-          });
-          const doneThreadId = taskThreadMap.get(event.taskId);
-          if (doneThreadId) {
-            const thread = channel.threads?.cache.get(doneThreadId);
-            if (thread) {
-              const statusEmoji = event.status === "completed" ? "\u2705" : "\u274C";
-              thread.send(`${statusEmoji} \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}`));
-            }
-            taskThreadMap.delete(event.taskId);
-          }
-          break;
-        }
-        case "web_search": {
-          if (verbose) {
-            queueDigest(sessionId, { kind: "search", text: `\u68C0\u7D22\uFF1A${truncate(event.query, 80)}` });
-          }
-          break;
-        }
-        case "tool_start": {
-          await streamer.finalize();
-          queueDigest(sessionId, { kind: "tool", text: `\u5DE5\u5177\uFF1A${event.toolName}` });
-          lastToolName = event.toolName;
-          break;
-        }
-        case "tool_result": {
-          await streamer.finalize();
-          if (verbose && event.result) {
-            queueDigest(sessionId, {
-              kind: "tool",
-              text: `\u5DE5\u5177\u7ED3\u679C\uFF1A${truncate(lastToolName || event.toolName || "tool", 60)}`
-            });
-          }
-          break;
-        }
-        case "image_file": {
-          if (existsSync(event.filePath)) {
-            pendingAttachments.push(event.filePath);
-          }
-          break;
-        }
-        case "command_execution": {
-          commandCount++;
-          if (recentCommands.length < 8) recentCommands.push(event.command);
-          if (!shouldSuppressCommandExecution(event.command)) {
-            queueDigest(sessionId, {
-              kind: "command",
-              text: `\u547D\u4EE4\uFF1A${truncate(event.command, 80)}${event.exitCode !== null ? `\uFF08\u9000\u51FA\u7801 ${event.exitCode}\uFF09` : ""}`
-            });
-          }
-          break;
-        }
-        case "file_change": {
-          fileChangeCount += event.changes.length;
-          for (const change of event.changes) {
-            if (!change.filePath) continue;
-            if (changedFiles.includes(change.filePath)) continue;
-            if (changedFiles.length >= 12) break;
-            changedFiles.push(change.filePath);
-          }
-          queueDigest(sessionId, {
-            kind: "file",
-            text: `\u6587\u4EF6\u53D8\u66F4\uFF1A${event.changes.length} \u4E2A\uFF08\u6700\u8FD1\uFF1A${truncate(changedFiles.slice(-3).join(", "), 120)}\uFF09`
-          });
-          break;
-        }
-        case "reasoning": {
-          if (verbose) {
-            queueDigest(sessionId, { kind: "reasoning", text: `\u63A8\u7406\uFF1A${truncate(event.text, 100)}` });
-          }
-          break;
-        }
-        case "todo_list": {
-          queueDigest(sessionId, {
-            kind: "todo",
-            text: `\u5F85\u529E\u66F4\u65B0\uFF1A${event.items.filter((item) => item.completed).length}/${event.items.length} \u5DF2\u5B8C\u6210`
-          });
-          break;
-        }
-        case "result": {
-          success = event.success;
-          const lastText = 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 = { auto: "\u81EA\u52A8", plan: "\u8BA1\u5212", normal: "\u666E\u901A", monitor: "\u76D1\u63A7" }[mode] || "\u81EA\u52A8";
-          const statusLine = event.success ? `-# $${cost} | ${duration} | ${turns} turns | ${modeLabel}` : `-# Error | $${cost} | ${duration} | ${turns} turns`;
-          streamer.append(`
-${statusLine}`, { persist: false });
-          if (!event.success && event.errors.length) {
-            streamer.append(`
-\`\`\`
-${event.errors.join("\n")}
-\`\`\``, { persist: false });
-          }
-          await streamer.finalize();
-          if (session) {
-            if (mode === "monitor") {
-              await flushDigest(sessionId);
-              await updateSessionState(sessionId, {
-                type: "work_started",
-                sessionId,
-                source: session.provider === "claude" ? "claude" : "codex",
-                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 {
-              deferredResult = {
-                event,
-                text: lastText,
-                attachments: [...pendingAttachments]
-              };
-            }
-          }
-          pendingAttachments.length = 0;
-          break;
-        }
-        case "error": {
-          console.warn(`[OutputHandler] Session ${sessionId}: error event \u2014 ${event.message}`);
-          hadError = true;
-          await streamer.finalize();
-          queueDigest(sessionId, { kind: "error", text: `\u9519\u8BEF\uFF1A${truncate(event.message, 120)}` });
-          if (session && mode !== "monitor") {
-            await flushDigest(sessionId);
-            await updateSessionState(sessionId, {
-              type: "errored",
-              sessionId,
-              source: session.provider === "claude" ? "claude" : "codex",
-              confidence: "high",
-              timestamp: Date.now(),
-              metadata: { errorMessage: event.message }
-            });
-          }
-          break;
-        }
-        case "session_init": {
-          break;
-        }
-      }
-      if (session && Date.now() - lastDigestFlushAt >= 8e3) {
+      await dispatchEvent(event, ctx);
+      if (session && Date.now() - lastDigestFlushAt >= DIGEST_FLUSH_INTERVAL_MS) {
         await flushDigest(sessionId);
         lastDigestFlushAt = Date.now();
       }
     }
-    if (session && mode !== "monitor" && deferredResult) {
-      console.log(`[OutputHandler] Session ${sessionId}: delivering deferred result (success: ${deferredResult.event.success})`);
+    if (session && mode !== "monitor" && state.deferredResult) {
+      console.log(
+        `[OutputHandler] Session ${sessionId}: delivering deferred result (success: ${state.deferredResult.event.success})`
+      );
       await flushDigest(sessionId);
       await handleResultEvent(
         sessionId,
-        deferredResult.event,
-        deferredResult.text,
-        deferredResult.attachments
+        state.deferredResult.event,
+        state.deferredResult.text,
+        state.deferredResult.attachments
       );
     }
   } catch (err) {
-    hadError = true;
+    state.hadError = true;
     await streamer.finalize();
     if (!isAbortError(err)) {
-      console.error(`[OutputHandler] Session ${sessionId}: unhandled stream error \u2014 ${err.message || ""}`);
       const errMsg = err.message || "";
+      console.error(`[OutputHandler] Session ${sessionId}: unhandled stream error \u2014 ${errMsg}`);
       queueDigest(sessionId, { kind: "error", text: `\u5F02\u5E38\uFF1A${truncate(errMsg, 120)}` });
       if (session) {
         await flushDigest(sessionId);
@@ -2755,37 +2944,56 @@ ${event.errors.join("\n")}
     streamer.destroy();
   }
   const finalText = streamer.getText();
-  console.log(`[OutputHandler] Stream ended for session ${sessionId} (text: ${finalText.length} chars, commands: ${commandCount}, files: ${fileChangeCount}, success: ${success}, hadError: ${hadError})`);
+  console.log(
+    `[OutputHandler] Stream ended for session ${sessionId} (text: ${finalText.length} chars, commands: ${state.commandCount}, files: ${state.fileChangeCount}, success: ${state.success}, hadError: ${state.hadError})`
+  );
   return {
     text: finalText,
-    askedUser,
-    askUserQuestionsJson,
-    hadError,
-    success,
-    commandCount,
-    fileChangeCount,
-    recentCommands,
-    changedFiles
+    askedUser: state.askedUser,
+    askUserQuestionsJson: state.askUserQuestionsJson,
+    hadError: state.hadError,
+    success: state.success,
+    commandCount: state.commandCount,
+    fileChangeCount: state.fileChangeCount,
+    recentCommands: state.recentCommands,
+    changedFiles: state.changedFiles
   };
 }
 
 // ../bot/src/discord-output-port.ts
+function asSessionChannel(ref) {
+  return ref;
+}
+function toResultEvent(data) {
+  return {
+    type: "result",
+    success: data.success,
+    costUsd: data.costUsd,
+    durationMs: data.durationMs,
+    numTurns: data.numTurns,
+    errors: data.errors,
+    metadata: data.metadata
+  };
+}
 var DiscordOutputPort = class {
   async initializePanel(session, channel) {
-    await initializeSessionPanel(session.id, channel);
+    await initializeSessionPanel(session.id, asSessionChannel(channel));
   }
   async updateState(sessionId, event, options) {
-    await updateSessionState(sessionId, event, options?.channel ? { channel: options.channel } : void 0);
+    await updateSessionState(
+      sessionId,
+      event,
+      options?.channel ? { channel: asSessionChannel(options.channel) } : void 0
+    );
   }
   async handleResult(sessionId, resultEvent, summary) {
-    const event = resultEvent;
-    await handleResultEvent(sessionId, event, summary ?? "");
+    await handleResultEvent(sessionId, toResultEvent(resultEvent), summary ?? "");
   }
   async handleAwaitingHuman(sessionId, reason, options) {
     await handleAwaitingHuman(sessionId, reason, options);
   }
   async relocatePanel(sessionId, channel) {
-    await relocateSessionPanelToBottom(sessionId, channel);
+    await relocateSessionPanelToBottom(sessionId, asSessionChannel(channel));
   }
   cleanupPanel(sessionId) {
     cleanupSessionPanel(sessionId);
@@ -2796,7 +3004,7 @@ var DiscordOutputPort = class {
   async handleOutputStream(stream, channel, sessionId, verbose = false, mode = "auto", provider = "claude", options = {}) {
     return handleOutputStream(
       stream,
-      channel,
+      asSessionChannel(channel),
       sessionId,
       verbose,
       mode,
@@ -2927,36 +3135,36 @@ function buildProjectCleanupPreview(input) {
   return preview;
 }
 async function archiveSessionsById(guild, sessionIds, summary = "Bulk cleanup from Discord command") {
-  const result = {
+  const result2 = {
     archivedSessions: 0,
     skippedGenerating: 0,
     missingSessions: 0,
     failed: []
   };
   for (const sessionId of new Set(Array.from(sessionIds).filter(Boolean))) {
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     if (!session || session.type !== "persistent") {
-      result.missingSessions += 1;
+      result2.missingSessions += 1;
       continue;
     }
     if (session.isGenerating) {
-      result.skippedGenerating += 1;
+      result2.skippedGenerating += 1;
       continue;
     }
     try {
       await archiveSession(session, guild, summary);
-      result.archivedSessions += 1;
+      result2.archivedSessions += 1;
     } catch (error) {
       console.error(`[Housekeeping] Failed to archive session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
-      result.failed.push({
+      result2.failed.push({
         sessionId: session.id,
         channelId: session.channelId,
         message: error instanceof Error ? error.message : String(error)
       });
     }
   }
-  console.log(`[Housekeeping] Archive result: ${result.archivedSessions} archived, ${result.skippedGenerating} skipped, ${result.missingSessions} missing, ${result.failed.length} failed`);
-  return result;
+  console.log(`[Housekeeping] Archive result: ${result2.archivedSessions} archived, ${result2.skippedGenerating} skipped, ${result2.missingSessions} missing, ${result2.failed.length} failed`);
+  return result2;
 }
 async function reconcileSessionRecordsWithGuild(guild) {
   const sessions = getAllSessions();
@@ -3446,6 +3654,7 @@ var POLL_INTERVAL_IDLE_MS = 5e3;
 var STALE_CLEANUP_MS = 12e4;
 var MAX_LINES_PER_POLL = 100;
 var MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+var MAX_FILE_SIZE_BYTES = 500 * 1024 * 1024;
 var CodexLogMonitor = class {
   tracked = /* @__PURE__ */ new Map();
   interval = null;
@@ -3539,6 +3748,14 @@ var CodexLogMonitor = class {
     } catch {
       return;
     }
+    if (stat.size > MAX_FILE_SIZE_BYTES) {
+      if (!this.tracked.has(filePath)) {
+        console.warn(
+          `[CodexLogMonitor] Skipping oversized rollout file (${Math.round(stat.size / 1024 / 1024)}MB): ${filePath}`
+        );
+      }
+      return;
+    }
     let tracked = this.tracked.get(filePath);
     if (!tracked) {
       const sessionId = this.extractSessionId(fileName);
@@ -3785,7 +4002,7 @@ async function handleCodexMonitorStateChange(resolveChannel2, monitorSessionId,
 
 // ../bot/src/ipc-server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync3 } from "fs";
+import { unlinkSync, existsSync as existsSync3, chmodSync } from "fs";
 
 // ../bot/src/session-discovery.ts
 async function discoverAndRegisterSession(client2, params) {
@@ -3794,7 +4011,7 @@ async function discoverAndRegisterSession(client2, params) {
     console.warn("[Session Discovery] No guild found, cannot register local session");
     return null;
   }
-  const result = await registerLocalSession(
+  const result2 = await registerLocalSession(
     {
       provider: params.provider,
       providerSessionId: params.providerSessionId,
@@ -3806,11 +4023,11 @@ async function discoverAndRegisterSession(client2, params) {
     },
     guild
   );
-  if (!result) return null;
+  if (!result2) return null;
   return {
-    sessionId: result.session.id,
-    channelId: result.session.channelId,
-    isNew: result.isNewlyCreated
+    sessionId: result2.session.id,
+    channelId: result2.session.channelId,
+    isNew: result2.isNewlyCreated
   };
 }
 
@@ -3871,6 +4088,15 @@ function startIpcServer(client2) {
     });
   });
   server.listen(socketPath, () => {
+    if (process.platform !== "win32") {
+      try {
+        chmodSync(socketPath, 384);
+      } catch (err) {
+        console.warn(
+          `[IpcServer] Failed to set 0600 on socket ${socketPath}: ${err.message}`
+        );
+      }
+    }
     console.log(`[IpcServer] Listening on ${socketPath}`);
   });
   server.on("error", (err) => {
@@ -3941,7 +4167,7 @@ async function handleHookEvent(payload) {
       } : void 0
     });
     if (registered) {
-      session = getSession(registered.sessionId);
+      session = getSessionView(registered.sessionId);
       console.log(`[IpcServer] Auto-registered session: ${registered.sessionId}`);
     }
   }
@@ -3961,14 +4187,14 @@ async function handleHookEvent(payload) {
 async function handleGateResolved(payload) {
   const data = payload;
   console.log(`[IpcServer] Terminal resolved gate ${data.gateId}: ${data.action}`);
-  const result = gateCoordinator.notifyTerminalResolved(data.gateId, data.action);
-  if (!result.success) {
-    console.warn(`[IpcServer] Gate resolution failed: ${result.message}`);
+  const result2 = gateService.notifyTerminalResolved(data.gateId, data.action);
+  if (!result2.success) {
+    console.warn(`[IpcServer] Gate resolution failed: ${result2.message}`);
     return;
   }
-  const gate = gateCoordinator.getGate(data.gateId);
+  const gate = gateService.getGate(data.gateId);
   if (gate?.discordMessageId) {
-    const session = getSession(data.sessionId);
+    const session = getSessionView(data.sessionId);
     if (session) {
       const channel = discordClient?.channels.cache.get(session.channelId);
       if (channel) {
@@ -4656,7 +4882,9 @@ var BotServicesOrchestrator = class {
       logBuffer2.log(`Reconciled ${reconciled.endedMissingSessions} stale session record(s) on startup.`);
     }
     setBotStartTime(Date.now());
-    await this.#invalidatePendingGates(client2);
+    await gateService.init();
+    await this.#reconcilePendingGates(client2, logBuffer2);
+    await this.#resumeAbandonedMonitorRuns(client2, logBuffer2);
     if (config.messageRetentionDays) {
       await cleanupOldMessages(client2);
     }
@@ -4667,15 +4895,55 @@ var BotServicesOrchestrator = class {
     logBuffer2.log("Codex log monitor started");
     return { serviceBus: this.#serviceBus, logBuffer: logBuffer2, presenceManager, logChannel, codexMonitor: null };
   }
-  async #invalidatePendingGates(client2) {
-    const invalidated = gateCoordinator.invalidateAllOnRestart();
-    if (!invalidated.length) return;
-    console.log(`[GateInvalidation] Invalidating ${invalidated.length} pending gates on restart`);
-    for (const { gateId, discordMessageId } of invalidated) {
+  /**
+   * 重启后对悬挂的 Monitor run 执行 reconcile,并按 config.monitorAutoResumePolicy 续跑符合条件的 session。
+   * 续跑采用 fire-and-forget:每个 session 独立异步运行,不阻塞启动。
+   */
+  async #resumeAbandonedMonitorRuns(client2, logBuffer2) {
+    let result2;
+    try {
+      result2 = await reconcileAndCollectAutoResumeCandidates(config.monitorAutoResumePolicy);
+    } catch (err) {
+      console.error("[MonitorAutoResume] reconcile failed:", err);
+      return;
+    }
+    if (result2.abandoned.length > 0) {
+      logBuffer2.log(
+        `Marked ${result2.abandoned.length} orphan monitor run(s) as abandoned on startup.`
+      );
+    }
+    if (result2.candidates.length === 0) return;
+    logBuffer2.log(
+      `Auto-resuming ${result2.candidates.length} monitor session(s) (policy=${config.monitorAutoResumePolicy}).`
+    );
+    for (const candidate of result2.candidates) {
+      const session = getSessionView(candidate.sessionId);
+      if (!session) continue;
+      const channel = client2.channels.cache.get(candidate.channelId);
+      if (!channel) {
+        console.warn(
+          `[MonitorAutoResume] sessionId=${candidate.sessionId} channel ${candidate.channelId} not accessible, skipping`
+        );
+        continue;
+      }
+      console.log(
+        `[MonitorAutoResume] resuming sessionId=${candidate.sessionId} runId=${candidate.runId} lastIteration=${candidate.lastIteration}`
+      );
+      void executeSessionContinue(session, channel).catch((err) => {
+        console.error(
+          `[MonitorAutoResume] sessionId=${candidate.sessionId} resume failed:`,
+          err
+        );
+      });
+    }
+  }
+  async #reconcilePendingGates(client2, logBuffer2) {
+    const result2 = gateService.reconcileOnStartup(config.gateRestartPolicy);
+    for (const { gateId, discordMessageId } of result2.invalidated) {
       if (!discordMessageId) continue;
-      const gate = gateCoordinator.getGate(gateId);
+      const gate = gateService.getGate(gateId);
       if (!gate?.sessionId) continue;
-      const session = getSession(gate.sessionId);
+      const session = getSessionView(gate.sessionId);
       if (!session) continue;
       const channel = client2.channels.cache.get(session.channelId);
       if (!channel?.messages) continue;
@@ -4692,10 +4960,17 @@ var BotServicesOrchestrator = class {
           }))
         });
       } catch (err) {
-        console.error(`[GateInvalidation] Failed to update message for gate ${gateId}:`, err);
+        console.error(`[GateReconcile] Failed to update message for gate ${gateId}:`, err);
       }
     }
-    console.log(`[GateInvalidation] ${invalidated.length} gates invalidated`);
+    if (result2.resumed.length > 0) {
+      logBuffer2.log(
+        `Resumed ${result2.resumed.length} pending gate(s) across restart (policy=resume-pending).`
+      );
+    }
+    if (result2.invalidated.length > 0) {
+      logBuffer2.log(`Closed ${result2.invalidated.length} orphan/overdue gate(s) on startup.`);
+    }
   }
   #registerServices(client2, logBuffer2, presence) {
     this.#serviceBus.register({ name: "message-handler", start() {
@@ -4720,10 +4995,10 @@ var BotServicesOrchestrator = class {
         );
       },
       async (providerSessionId, cwd, remoteHumanControl, subagent) => {
-        const { registerLocalSession: registerLocalSession2 } = await import("./session-local-registration-RIO5EPZ5.js");
+        const { registerLocalSession: registerLocalSession2 } = await import("./session-local-registration-MISPPGXF.js");
         const g = client2.guilds.cache.first();
         if (!g) return false;
-        const result = await registerLocalSession2(
+        const result2 = await registerLocalSession2(
           {
             provider: "codex",
             providerSessionId,
@@ -4735,10 +5010,10 @@ var BotServicesOrchestrator = class {
           },
           g
         );
-        if (result?.isNewlyCreated && result.session.remoteHumanControl === false) {
-          void notifyUnmanagedCodexHint(client2, result.session.id, result.session.channelId);
+        if (result2?.isNewlyCreated && result2.session.remoteHumanControl === false) {
+          void notifyUnmanagedCodexHint(client2, result2.session.id, result2.session.channelId);
         }
-        return result !== null;
+        return result2 !== null;
       }
     );
     this.#serviceBus.register({
@@ -4768,8 +5043,8 @@ var BotServicesOrchestrator = class {
       stopPerformanceMonitoring();
     } });
     this.#serviceBus.register(intervalService("gate-housekeeping", () => {
-      const expired = gateCoordinator.cleanupExpired();
-      const archived = gateCoordinator.archiveResolved(100);
+      const expired = gateService.cleanupExpired();
+      const archived = gateService.archiveResolved(100);
       if (expired || archived) console.log(`[GateHousekeeping] expired=${expired}, archived=${archived}`);
     }, 6e4));
     this.#serviceBus.register(intervalService("presence", () => presence.updatePresence(), 3e4));
@@ -4874,7 +5149,7 @@ var PROVIDER_COLORS = {
   claude: 3447003,
   codex: 1090431
 };
-var MODE_LABELS = {
+var MODE_LABELS2 = {
   auto: "\u26A1 \u81EA\u52A8\u6A21\u5F0F \u2014 \u5B8C\u5168\u81EA\u4E3B",
   plan: "\u{1F4CB} \u8BA1\u5212\u6A21\u5F0F \u2014 \u53D8\u66F4\u524D\u5148\u89C4\u5212",
   normal: "\u{1F6E1}\uFE0F \u666E\u901A\u6A21\u5F0F \u2014 \u7834\u574F\u6027\u64CD\u4F5C\u524D\u786E\u8BA4",
@@ -4884,7 +5159,7 @@ var CONTROL_CHANNEL_NAME = "control";
 var CLEANUP_PREVIEW_LIST_LIMIT = 10;
 var CLEANUP_PREVIEW_LABEL_LIMIT = 120;
 async function registerStatusCardWithPanelAdapter(sessionId, channel, statusCardMessageId) {
-  const { registerExistingStatusCard: registerExistingStatusCard2 } = await import("./panel-adapter-QTDL3S6O.js");
+  const { registerExistingStatusCard: registerExistingStatusCard2 } = await import("./panel-adapter-U75WXDLB.js");
   if (typeof registerExistingStatusCard2 !== "function") {
     log(`[panel-adapter] registerExistingStatusCard \u672A\u66B4\u9732\uFF0Csession=${sessionId}`);
     return false;
@@ -5514,7 +5789,7 @@ async function handleAgentSpawn(interaction) {
   const embed = new EmbedBuilder4().setColor(3066993).setTitle(`\u2705 Agent \u5DF2\u521B\u5EFA\uFF1A${label}`).addFields(
     { name: "\u9891\u9053", value: `<#${sessionChannel.id}>`, inline: true },
     { name: "\u63D0\u4F9B\u5546", value: PROVIDER_LABELS[provider], inline: true },
-    { name: "\u6A21\u5F0F", value: MODE_LABELS?.[mode] ?? mode, inline: false },
+    { name: "\u6A21\u5F0F", value: MODE_LABELS2?.[mode] ?? mode, inline: false },
     { name: "\u76EE\u5F55", value: `\`${session.directory}\``, inline: false }
   );
   if (provider === "claude" && session.claudePermissionMode) {
@@ -5682,7 +5957,7 @@ async function handleAgentMode(interaction) {
   }
   const mode = interaction.options.getString("mode", true);
   setMode(session.id, mode);
-  await interaction.reply({ content: `\u6A21\u5F0F\u5DF2\u8BBE\u4E3A **${MODE_LABELS?.[mode] ?? mode}**\u3002`, ephemeral: true });
+  await interaction.reply({ content: `\u6A21\u5F0F\u5DF2\u8BBE\u4E3A **${MODE_LABELS2?.[mode] ?? mode}**\u3002`, ephemeral: true });
 }
 async function handleAgentGoal(interaction) {
   const session = getSessionByChannel(interaction.channelId);
@@ -5736,7 +6011,7 @@ async function handleAgentPermissions(interaction) {
     return;
   }
   await updateSessionPermissions(session.id, patch);
-  const refreshed = getSession(session.id) ?? { ...session, ...patch };
+  const refreshed = getSessionView(session.id) ?? { ...session, ...patch };
   const timing = session.isGenerating ? "\u5DF2\u4FDD\u5B58\uFF0C\u5C06\u5728\u4E0B\u4E00\u8F6E\u751F\u6548\u3002" : "\u5DF2\u66F4\u65B0\u5E76\u7ACB\u5373\u751F\u6548\u3002";
   await interaction.reply({
     content: `${timing}
@@ -5912,13 +6187,13 @@ var joinToUint8Array = (uint8ArraysOrStrings) => {
 };
 var stringsToUint8Arrays = (uint8ArraysOrStrings) => uint8ArraysOrStrings.map((uint8ArrayOrString) => typeof uint8ArrayOrString === "string" ? stringToUint8Array(uint8ArrayOrString) : uint8ArrayOrString);
 var concatUint8Arrays = (uint8Arrays) => {
-  const result = new Uint8Array(getJoinLength(uint8Arrays));
+  const result2 = new Uint8Array(getJoinLength(uint8Arrays));
   let index = 0;
   for (const uint8Array of uint8Arrays) {
-    result.set(uint8Array, index);
+    result2.set(uint8Array, index);
     index += uint8Array.length;
   }
-  return result;
+  return result2;
 };
 var getJoinLength = (uint8Arrays) => {
   let joinLength = 0;
@@ -6473,17 +6748,17 @@ var format = (open2, close) => {
     if (index === -1) {
       return openCode + string + closeCode;
     }
-    let result = openCode;
+    let result2 = openCode;
     let lastIndex = 0;
     const reopenOnNestedClose = close === 22;
     const replaceCode = (reopenOnNestedClose ? closeCode : "") + openCode;
     while (index !== -1) {
-      result += string.slice(lastIndex, index) + replaceCode;
+      result2 += string.slice(lastIndex, index) + replaceCode;
       lastIndex = index + closeCode.length;
       index = string.indexOf(closeCode, lastIndex);
     }
-    result += string.slice(lastIndex) + closeCode;
-    return result;
+    result2 += string.slice(lastIndex) + closeCode;
+    return result2;
   };
 };
 var reset = format(0, 0);
@@ -6585,8 +6860,8 @@ var appendNewline = (printedLine) => printedLine.endsWith("\n") ? printedLine :
 `;
 
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/verbose/log.js
-var verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
-  const verboseObject = getVerboseObject({ type, result, verboseInfo });
+var verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result: result2 }) => {
+  const verboseObject = getVerboseObject({ type, result: result2, verboseInfo });
   const printedLines = getPrintedLines(verboseMessage, verboseObject);
   const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
   if (finalLines !== "") {
@@ -6595,7 +6870,7 @@ var verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
 };
 var getVerboseObject = ({
   type,
-  result,
+  result: result2,
   verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false, ...options } }
 }) => ({
   type,
@@ -6603,7 +6878,7 @@ var getVerboseObject = ({
   commandId: `${commandId}`,
   timestamp: /* @__PURE__ */ new Date(),
   piped,
-  result,
+  result: result2,
   options
 });
 var getPrintedLines = (verboseMessage, verboseObject) => verboseMessage.split("\n").map((message) => getPrintedLine({ ...verboseObject, message }));
@@ -6732,28 +7007,28 @@ var npmRunPath = ({
   addExecPath = true
 } = {}) => {
   const cwdPath = path2.resolve(toPath(cwd));
-  const result = [];
+  const result2 = [];
   const pathParts = pathOption.split(path2.delimiter);
   if (preferLocal) {
-    applyPreferLocal(result, pathParts, cwdPath);
+    applyPreferLocal(result2, pathParts, cwdPath);
   }
   if (addExecPath) {
-    applyExecPath(result, pathParts, execPath2, cwdPath);
+    applyExecPath(result2, pathParts, execPath2, cwdPath);
   }
-  return pathOption === "" || pathOption === path2.delimiter ? `${result.join(path2.delimiter)}${pathOption}` : [...result, pathOption].join(path2.delimiter);
+  return pathOption === "" || pathOption === path2.delimiter ? `${result2.join(path2.delimiter)}${pathOption}` : [...result2, pathOption].join(path2.delimiter);
 };
-var applyPreferLocal = (result, pathParts, cwdPath) => {
+var applyPreferLocal = (result2, pathParts, cwdPath) => {
   for (const directory of traversePathUp(cwdPath)) {
     const pathPart = path2.join(directory, "node_modules/.bin");
     if (!pathParts.includes(pathPart)) {
-      result.push(pathPart);
+      result2.push(pathPart);
     }
   }
 };
-var applyExecPath = (result, pathParts, execPath2, cwdPath) => {
+var applyExecPath = (result2, pathParts, execPath2, cwdPath) => {
   const pathPart = path2.resolve(cwdPath, toPath(execPath2), "..");
   if (!pathParts.includes(pathPart)) {
-    result.push(pathPart);
+    result2.push(pathPart);
   }
 };
 var npmRunPathEnv = ({ env = process4.env, ...options } = {}) => {
@@ -8572,13 +8847,13 @@ var getMaxBufferInfo = (error, maxBuffer) => {
   }
   return { streamName: getStreamName(fdNumber), threshold, unit };
 };
-var isMaxBufferSync = (resultError, output, maxBuffer) => resultError?.code === "ENOBUFS" && output !== null && output.some((result) => result !== null && result.length > getMaxBufferSync(maxBuffer));
-var truncateMaxBufferSync = (result, isMaxBuffer, maxBuffer) => {
+var isMaxBufferSync = (resultError, output, maxBuffer) => resultError?.code === "ENOBUFS" && output !== null && output.some((result2) => result2 !== null && result2.length > getMaxBufferSync(maxBuffer));
+var truncateMaxBufferSync = (result2, isMaxBuffer, maxBuffer) => {
   if (!isMaxBuffer) {
-    return result;
+    return result2;
   }
   const maxBufferValue = getMaxBufferSync(maxBuffer);
-  return result.length > maxBufferValue ? result.slice(0, maxBufferValue) : result;
+  return result2.length > maxBufferValue ? result2.slice(0, maxBufferValue) : result2;
 };
 var getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;
 
@@ -8865,7 +9140,7 @@ var getErrorProperties = ({
   ipcOutput,
   pipedFrom: []
 });
-var omitUndefinedProperties = (result) => Object.fromEntries(Object.entries(result).filter(([, value]) => value !== void 0));
+var omitUndefinedProperties = (result2) => Object.fromEntries(Object.entries(result2).filter(([, value]) => value !== void 0));
 var normalizeExitPayload = (rawExitCode, rawSignal) => {
   const exitCode = rawExitCode === null ? void 0 : rawExitCode;
   const signal = rawSignal === null ? void 0 : rawSignal;
@@ -8936,25 +9211,25 @@ function prettyMilliseconds(milliseconds, options) {
     options.secondsDecimalDigits = 0;
     options.millisecondsDecimalDigits = 0;
   }
-  let result = [];
+  let result2 = [];
   const floorDecimals = (value, decimalDigits) => {
     const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
     const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
     return flooredValue.toFixed(decimalDigits);
   };
   const add = (value, long, short, valueString) => {
-    if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) {
+    if ((result2.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) {
       return;
     }
     valueString ??= String(value);
     if (options.colonNotation) {
       const wholeDigits = valueString.includes(".") ? valueString.split(".")[0].length : valueString.length;
-      const minLength = result.length > 0 ? 2 : 1;
+      const minLength = result2.length > 0 ? 2 : 1;
       valueString = "0".repeat(Math.max(0, minLength - wholeDigits)) + valueString;
     } else {
       valueString += options.verbose ? " " + pluralize(long, value) : short;
     }
-    result.push(valueString);
+    result2.push(valueString);
   };
   const parsed = parseMilliseconds(milliseconds);
   const days = BigInt(parsed.days);
@@ -9001,53 +9276,53 @@ function prettyMilliseconds(milliseconds, options) {
       add(Number.parseFloat(secondsString), "second", "s", secondsString);
     }
   }
-  if (result.length === 0) {
+  if (result2.length === 0) {
     return sign + "0" + (options.verbose ? " milliseconds" : "ms");
   }
   const separator = options.colonNotation ? ":" : " ";
   if (typeof options.unitCount === "number") {
-    result = result.slice(0, Math.max(options.unitCount, 1));
+    result2 = result2.slice(0, Math.max(options.unitCount, 1));
   }
-  return sign + result.join(separator);
+  return sign + result2.join(separator);
 }
 
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/verbose/error.js
-var logError = (result, verboseInfo) => {
-  if (result.failed) {
+var logError = (result2, verboseInfo) => {
+  if (result2.failed) {
     verboseLog({
       type: "error",
-      verboseMessage: result.shortMessage,
+      verboseMessage: result2.shortMessage,
       verboseInfo,
-      result
+      result: result2
     });
   }
 };
 
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/verbose/complete.js
-var logResult = (result, verboseInfo) => {
+var logResult = (result2, verboseInfo) => {
   if (!isVerbose(verboseInfo)) {
     return;
   }
-  logError(result, verboseInfo);
-  logDuration(result, verboseInfo);
+  logError(result2, verboseInfo);
+  logDuration(result2, verboseInfo);
 };
-var logDuration = (result, verboseInfo) => {
-  const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
+var logDuration = (result2, verboseInfo) => {
+  const verboseMessage = `(done in ${prettyMilliseconds(result2.durationMs)})`;
   verboseLog({
     type: "duration",
     verboseMessage,
     verboseInfo,
-    result
+    result: result2
   });
 };
 
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/return/reject.js
-var handleResult = (result, verboseInfo, { reject }) => {
-  logResult(result, verboseInfo);
-  if (result.failed && reject) {
-    throw result;
+var handleResult = (result2, verboseInfo, { reject }) => {
+  logResult(result2, verboseInfo);
+  if (result2.failed && reject) {
+    throw result2;
   }
-  return result;
+  return result2;
 };
 
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/stdio/handle-sync.js
@@ -10131,8 +10406,8 @@ var transformOutputSync = ({ fileDescriptors, syncResult: { output }, options, i
   }
   const state = {};
   const outputFiles = /* @__PURE__ */ new Set([]);
-  const transformedOutput = output.map((result, fdNumber) => transformOutputResultSync({
-    result,
+  const transformedOutput = output.map((result2, fdNumber) => transformOutputResultSync({
+    result: result2,
     fileDescriptors,
     fdNumber,
     state,
@@ -10142,11 +10417,11 @@ var transformOutputSync = ({ fileDescriptors, syncResult: { output }, options, i
   }, options));
   return { output: transformedOutput, ...state };
 };
-var transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline: stripFinalNewline2, maxBuffer }) => {
-  if (result === null) {
+var transformOutputResultSync = ({ result: result2, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline: stripFinalNewline2, maxBuffer }) => {
+  if (result2 === null) {
     return;
   }
-  const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
+  const truncatedResult = truncateMaxBufferSync(result2, isMaxBuffer, maxBuffer);
   const uint8ArrayResult = bufferToUint8Array(truncatedResult);
   const { stdioItems, objectMode } = fileDescriptors[fdNumber];
   const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
@@ -10307,7 +10582,7 @@ var getResultError = (error, exitCode, signal) => {
 // ../../node_modules/.pnpm/execa@9.6.1/node_modules/execa/lib/methods/main-sync.js
 var execaCoreSync = (rawFile, rawArguments, rawOptions) => {
   const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
-  const result = spawnSubprocessSync({
+  const result2 = spawnSubprocessSync({
     file,
     commandArguments,
     options,
@@ -10317,7 +10592,7 @@ var execaCoreSync = (rawFile, rawArguments, rawOptions) => {
     fileDescriptors,
     startTime
   });
-  return handleResult(result, verboseInfo, options);
+  return handleResult(result2, verboseInfo, options);
 };
 var handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
   const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
@@ -12453,7 +12728,7 @@ var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDe
   onInternalError.resolve();
   const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
   const all = stripNewline(allResult, options, "all");
-  const result = getAsyncResult({
+  const result2 = getAsyncResult({
     errorInfo,
     exitCode,
     signal,
@@ -12466,7 +12741,7 @@ var handlePromise = async ({ subprocess, options, startTime, verboseInfo, fileDe
     escapedCommand,
     startTime
   });
-  return handleResult(result, verboseInfo, options);
+  return handleResult(result2, verboseInfo, options);
 };
 var getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
   error: errorInfo.error,
@@ -12664,28 +12939,28 @@ async function executeShellCommand(command, cwd, channel) {
     kind: "command",
     text: `\u6267\u884C\u547D\u4EE4\uFF1A${truncate(command, 120)}`
   });
-  const result = await child;
+  const result2 = await child;
   const output = [
-    result.all?.trim() || "",
-    result.timedOut ? "[Timed out after 60s]" : "",
-    `[Exit code: ${result.exitCode ?? "killed"}]`
+    result2.all?.trim() || "",
+    result2.timedOut ? "[Timed out after 60s]" : "",
+    `[Exit code: ${result2.exitCode ?? "killed"}]`
   ].filter(Boolean).join("\n");
   runningProcesses.delete(pid);
   execaProcesses.delete(pid);
   queueDigest(shellSessionId, {
     kind: "command",
-    text: `\u547D\u4EE4\u7ED3\u675F\uFF1A\u9000\u51FA\u7801 ${result.exitCode ?? "killed"}`
+    text: `\u547D\u4EE4\u7ED3\u675F\uFF1A\u9000\u51FA\u7801 ${result2.exitCode ?? "killed"}`
   });
   await flushDigest(shellSessionId);
   await handleResultEvent(
     shellSessionId,
     {
       type: "result",
-      success: result.exitCode === 0,
+      success: result2.exitCode === 0,
       costUsd: 0,
       durationMs: Date.now() - shellProcess.startedAt,
       numTurns: 1,
-      errors: result.exitCode === 0 ? [] : [output],
+      errors: result2.exitCode === 0 ? [] : [output],
       metadata: { sessionEnd: false }
     },
     renderShellOutput(command, output)
@@ -12774,9 +13049,6 @@ async function handleShellKill(interaction) {
   });
 }
 
-// ../bot/src/button-handler.ts
-import "discord.js";
-
 // ../bot/src/button-handler-actions.ts
 import {
   ActionRowBuilder as ActionRowBuilder3,
@@ -12786,12 +13058,11 @@ function asComponentLike(component) {
   return component || {};
 }
 async function resolveAwaitingHumanIfNeeded(sessionId) {
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (!session?.currentInteractionMessageId) {
     return;
   }
   updateSession(sessionId, {
-    humanResolved: true,
     currentInteractionMessageId: void 0
   });
   await updateSessionState(sessionId, {
@@ -12803,19 +13074,19 @@ async function resolveAwaitingHumanIfNeeded(sessionId) {
     metadata: { source: "answer" }
   });
 }
-function renderCleanupResultMessage(result) {
+function renderCleanupResultMessage(result2) {
   const lines = [
     "\u6279\u91CF\u6E05\u7406\u5B8C\u6210",
     "",
-    `- \u5DF2\u5F52\u6863\uFF1A${result.archivedSessions}`,
-    `- \u8DF3\u8FC7\u8FDB\u884C\u4E2D\uFF1A${result.skippedGenerating}`,
-    `- \u7F3A\u5931\uFF1A${result.missingSessions}`,
-    `- \u5931\u8D25\uFF1A${result.failed.length}`
+    `- \u5DF2\u5F52\u6863\uFF1A${result2.archivedSessions}`,
+    `- \u8DF3\u8FC7\u8FDB\u884C\u4E2D\uFF1A${result2.skippedGenerating}`,
+    `- \u7F3A\u5931\uFF1A${result2.missingSessions}`,
+    `- \u5931\u8D25\uFF1A${result2.failed.length}`
   ];
-  if (result.failed.length > 0) {
+  if (result2.failed.length > 0) {
     lines.push("", "\u5931\u8D25\u660E\u7EC6\uFF1A");
     lines.push(
-      ...result.failed.map((item) => `- ${item.channelId ? `<#${item.channelId}> ` : ""}${item.sessionId}\uFF1A${item.message}`)
+      ...result2.failed.map((item) => `- ${item.channelId ? `<#${item.channelId}> ` : ""}${item.sessionId}\uFF1A${item.message}`)
     );
   }
   return lines.join("\n");
@@ -12838,7 +13109,7 @@ async function handleAwaitingHumanButton(interaction) {
   const sessionId = parts[1];
   const turn = parseInt(parts[2], 10);
   const action = parts[3];
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (!session) {
     await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728", ephemeral: true });
     return true;
@@ -12856,24 +13127,24 @@ async function handleAwaitingHumanButton(interaction) {
     await interaction.reply({ content: "\u5DF2\u88AB\u5176\u4ED6\u4EBA\u5904\u7406", ephemeral: true });
     return true;
   }
-  const activeGate = session.activeHumanGateId ? gateCoordinator.getGate(session.activeHumanGateId) : gateCoordinator.getActiveGateForSession(sessionId);
+  const activeGate = session.activeHumanGateId ? gateService.getGate(session.activeHumanGateId) : gateService.getActiveGateForSession(sessionId);
   if (!activeGate) {
     await interaction.reply({ content: "\u672A\u627E\u5230\u6D3B\u8DC3\u7684\u95E8\u63A7\u8BB0\u5F55", ephemeral: true });
     return true;
   }
-  const result = await gateCoordinator.resolveFromDiscord(
+  const result2 = await gateService.resolveFromDiscord(
     activeGate.id,
     action === "approve" ? "approve" : "reject"
   );
-  if (!result.success) {
+  if (!result2.success) {
     await interaction.reply({
-      content: `\u5904\u7406\u5931\u8D25: ${result.message || "\u672A\u77E5\u9519\u8BEF"}`,
+      content: `\u5904\u7406\u5931\u8D25: ${result2.message || "\u672A\u77E5\u9519\u8BEF"}`,
       ephemeral: true
     });
     return true;
   }
+  stateMachine.setHumanResolved(sessionId, true);
   updateSession(sessionId, {
-    humanResolved: true,
     currentInteractionMessageId: void 0,
     activeHumanGateId: void 0
   });
@@ -12886,7 +13157,7 @@ async function handleAwaitingHumanButton(interaction) {
       }
     }))
   });
-  if (result.handledByReceipt) {
+  if (result2.handledByReceipt) {
     return true;
   }
   if (action === "approve") {
@@ -12929,7 +13200,7 @@ async function handleContinueButton(interaction) {
   const customId = interaction.customId;
   if (!customId.startsWith("continue:")) return false;
   const sessionId = customId.slice(9);
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (!session) {
     await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002", ephemeral: true });
     return true;
@@ -13016,13 +13287,13 @@ async function handleCleanupButtons(interaction) {
     await interaction.deferUpdate();
     try {
       console.log(`[ButtonHandler] Cleanup confirmed by ${interaction.user.tag} \u2014 archiving ${request.candidateSessionIds.length} sessions`);
-      const result = await archiveSessionsById(
+      const result2 = await archiveSessionsById(
         interaction.guild,
         request.candidateSessionIds,
         "Bulk cleanup from Discord command"
       );
       deleteCleanupRequest(requestId);
-      await interaction.editReply({ content: renderCleanupResultMessage(result), components: [] });
+      await interaction.editReply({ content: renderCleanupResultMessage(result2), components: [] });
     } finally {
       releaseCleanupLock(request.categoryId);
     }
@@ -13036,7 +13307,7 @@ async function handleModeButton(interaction) {
   const parts = customId.split(":");
   const sessionId = parts[1];
   const newMode = parts[2];
-  const session = getSession(sessionId);
+  const session = getSessionView(sessionId);
   if (!session) {
     await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002", ephemeral: true });
     return true;
@@ -13053,7 +13324,7 @@ async function handleModeButton(interaction) {
   await interaction.reply({ content: `\u5DF2\u5207\u6362\u81F3 **${labels[newMode]}**`, ephemeral: true });
   try {
     const original = interaction.message;
-    const liveSession = getSession(sessionId);
+    const liveSession = getSessionView(sessionId);
     const updatedComponents = original.components.map((row) => {
       if (!("components" in row)) return row;
       const first = asComponentLike(row.components?.[0]);
@@ -13074,7 +13345,7 @@ async function handleSelectMenuAction(interaction) {
     const sessionId = parts[1];
     const questionIndex = parseInt(parts[2], 10);
     const selected = interaction.values[0];
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     if (!session) {
       await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002", ephemeral: true });
       return true;
@@ -13113,7 +13384,7 @@ async function handleSelectMenuAction(interaction) {
     const afterPrefix = customId.slice(14);
     const sessionId = afterPrefix.includes(":") ? afterPrefix.split(":")[0] : afterPrefix;
     const selected = interaction.values[0];
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     if (!session) {
       await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002", ephemeral: true });
       return true;
@@ -13132,7 +13403,7 @@ async function handleSelectMenuAction(interaction) {
   if (customId.startsWith("select:")) {
     const sessionId = customId.slice(7);
     const selected = interaction.values[0];
-    const session = getSession(sessionId);
+    const session = getSessionView(sessionId);
     if (!session) {
       await interaction.reply({ content: "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002", ephemeral: true });
       return true;
@@ -13151,31 +13422,58 @@ async function handleSelectMenuAction(interaction) {
   return false;
 }
 
-// ../bot/src/button-handler.ts
-async function handleButton(interaction) {
-  if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
-    console.warn(`[ButtonHandler] Unauthorized button press by user ${interaction.user.id}: ${interaction.customId}`);
-    await interaction.reply({ content: "\u672A\u6388\u6743\u3002", ephemeral: true });
+// ../bot/src/button-router.ts
+var BUTTON_ROUTES = [
+  handleStopButton,
+  handleAwaitingHumanButton,
+  handleContinueButton,
+  handleExpandButton,
+  handleDeprecatedInteractionButton,
+  handleCleanupButtons,
+  handleModeButton
+];
+var SELECT_ROUTES = [handleSelectMenuAction];
+async function checkAuthorization(userId, reply) {
+  if (isUserAllowed(userId, config.allowedUsers, config.allowAllUsers)) return true;
+  await reply("\u672A\u6388\u6743\u3002");
+  return false;
+}
+async function routeButton(interaction) {
+  const ok = await checkAuthorization(
+    interaction.user.id,
+    (content) => interaction.reply({ content, ephemeral: true })
+  );
+  if (!ok) {
+    console.warn(
+      `[ButtonHandler] Unauthorized button press by user ${interaction.user.id}: ${interaction.customId}`
+    );
     return;
   }
-  if (await handleStopButton(interaction)) return;
-  if (await handleAwaitingHumanButton(interaction)) return;
-  if (await handleContinueButton(interaction)) return;
-  if (await handleExpandButton(interaction)) return;
-  if (await handleDeprecatedInteractionButton(interaction)) return;
-  if (await handleCleanupButtons(interaction)) return;
-  if (await handleModeButton(interaction)) return;
+  for (const route of BUTTON_ROUTES) {
+    if (await route(interaction)) return;
+  }
   await interaction.reply({ content: "\u672A\u77E5\u6309\u94AE\u3002", ephemeral: true });
 }
-async function handleSelectMenu(interaction) {
-  if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
-    await interaction.reply({ content: "\u672A\u6388\u6743\u3002", ephemeral: true });
-    return;
+async function routeSelectMenu(interaction) {
+  const ok = await checkAuthorization(
+    interaction.user.id,
+    (content) => interaction.reply({ content, ephemeral: true })
+  );
+  if (!ok) return;
+  for (const route of SELECT_ROUTES) {
+    if (await route(interaction)) return;
   }
-  if (await handleSelectMenuAction(interaction)) return;
   await interaction.reply({ content: "\u672A\u77E5\u9009\u62E9\u3002", ephemeral: true });
 }
 
+// ../bot/src/button-handler.ts
+async function handleButton(interaction) {
+  await routeButton(interaction);
+}
+async function handleSelectMenu(interaction) {
+  await routeSelectMenu(interaction);
+}
+
 // ../bot/src/bot-event-router.ts
 import {
   InteractionType
@@ -13356,7 +13654,7 @@ async function runCli() {
     await startBot();
   });
   cli.command("config [action] [key] [value]", "Manage configuration").action(async (action, key, value) => {
-    const { handleConfig } = await import("./config-cli-RQR2ZRQ5.js");
+    const { handleConfig } = await import("./config-cli-7JEV3WYY.js");
     const args = [action || "list"].filter(Boolean);
     if (key) args.push(key);
     if (value) args.push(value);
@@ -13364,12 +13662,12 @@ async function runCli() {
     await handleConfig(args);
   });
   cli.command("project [action] [...args]", "Manage mounted projects").action(async (action, args) => {
-    const { handleProject: handleProject2 } = await import("./project-cli-6P6ZWDR6.js");
+    const { handleProject: handleProject2 } = await import("./project-cli-ZXMHOFUJ.js");
     const cmdArgs = [action || "help"].filter(Boolean).concat(args || []);
     await handleProject2(cmdArgs);
   });
   cli.command("attachment [action]", "Manage attachments").action(async (action) => {
-    const { handleAttachment } = await import("./attachment-cli-IGQBB6YJ.js");
+    const { handleAttachment } = await import("./attachment-cli-MF7XZ4WT.js");
     await handleAttachment([action || "fetch"]);
   });
   cli.command("daemon <action>", "Manage background service").action(async (action) => {
@@ -13377,7 +13675,7 @@ async function runCli() {
     await handleDaemon(action);
   });
   cli.command("codex [...options]", "Launch managed Codex session with remote approval").allowUnknownOptions().action(async function(options) {
-    const { handleCodexCommand } = await import("./codex-launcher-VDQ5VZPT.js");
+    const { handleCodexCommand } = await import("./codex-launcher-ZBQ5VL6L.js");
     const parsed = this.options;
     const rawArgs = [];
     for (const [key, value] of Object.entries(parsed)) {