workspacecord 1.1.2 → 1.1.4

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

@@ -1,36 +1,43 @@
 #!/usr/bin/env node
 import {
-  Aa
-} from "./chunk-QWPKAUSV.js";
+  E$$
+} from "./chunk-C4L34VJK.js";
 import {
   buildDeliveryPlan,
   cleanupOldMessages,
   cleanupSessionPanel,
   deliver,
+  dispatchEvent,
   flushDigest,
-  gateCoordinator,
   generatePerformanceReport,
   getPendingAnswers,
   getQuestionCount,
+  getSessionContext,
   getSessionProjection,
+  getSessionView,
+  getSubagents,
   handleAwaitingHuman,
   handleResultEvent,
   initializeSessionPanel,
-  normalizeCodexEvent,
+  makeModeButtons,
   notifyUnmanagedCodexHint,
   queueDigest,
   registerExistingStatusCard,
   relocateSessionPanelToBottom,
+  resolveEffectiveClaudePermissionMode as resolveEffectiveClaudePermissionMode2,
+  runSubagentWatchdog,
   sendAckReaction,
+  sendSystemNotice,
   sendTyping,
   setPendingAnswer,
+  spawnSubagent,
   startPerformanceMonitoring,
   stopPerformanceMonitoring,
   updateSessionState
-} from "./chunk-ZAQV2RZS.js";
+} from "./chunk-NNTMVOTM.js";
 import {
   registerMessageAttachments
-} from "./chunk-L2ZJXV6H.js";
+} from "./chunk-66B64WL3.js";
 import {
   addMcpServer,
   addSkill,
@@ -51,14 +58,14 @@ import {
   setControlChannelId,
   setHistoryChannelId,
   setPersonality
-} from "./chunk-GMYN4SYT.js";
+} from "./chunk-SV7EHL3B.js";
 import {
   getAllRegisteredProjects
-} from "./chunk-54DP53ZK.js";
+} from "./chunk-5EMN2IL5.js";
 import {
   buildClaudeSubagentProviderSessionId,
   registerLocalSession
-} from "./chunk-COXPTYH5.js";
+} from "./chunk-PWMEOBXG.js";
 import {
   abortSession,
   abortSessionWithReason,
@@ -66,10 +73,13 @@ import {
   consumeAbortReason,
   createSession,
   debouncedSaveSession,
+  drainBatchApprovals,
   endSession,
+  enqueueBatchApproval,
+  gateService,
   getAllSessions,
+  getBatchApprovalCount,
   getOutputPort,
-  getSession,
   getSessionByChannel,
   getSessionByProviderSession,
   getSessionController,
@@ -78,7 +88,9 @@ import {
   getSessionsByCategory,
   loadSessions,
   markSessionGenerating,
+  normalizeCodexEvent,
   registerOutputPort,
+  removeBatchApproval,
   resolveCodexSessionFromMonitor,
   resolveEffectiveClaudePermissionMode,
   resolveEffectiveCodexOptions,
@@ -91,21 +103,26 @@ import {
   setSessionController,
   setStatusCardBinding,
   setVerbose,
+  stateMachine,
   updateSession,
   updateSessionPermissions,
   updateWorkflowState
-} from "./chunk-RK6EIZOL.js";
+} from "./chunk-JR4B4L7I.js";
 import {
+  JsonFileRepository,
+  MonitorRunEnded,
+  MonitorRunStarted,
   ServiceBus,
   config,
   formatDuration,
   formatRelative,
   formatUptime,
+  getDomainBus,
   intervalService,
   isAbortError,
   isUserAllowed,
   truncate
-} from "./chunk-UEX7U2KW.js";
+} from "./chunk-MJ5JKFGS.js";
 import {
   __commonJS,
   __require,
@@ -620,15 +637,43 @@ import cac from "cac";
 import {
   Client as Client2,
   GatewayIntentBits,
-  ChannelType as ChannelType8
+  ChannelType as ChannelType7
 } from "discord.js";
 
 // ../bot/src/bot-services-orchestrator.ts
-import { ChannelType as ChannelType4 } from "discord.js";
+import { ChannelType as ChannelType3 } from "discord.js";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 
 // ../providers/src/claude-provider.ts
+function mapClaudeTerminalReason(raw) {
+  if (!raw) return void 0;
+  switch (raw) {
+    case "completed":
+      return "completed";
+    case "max_turns":
+      return "max_turns";
+    case "blocking_limit":
+    case "rapid_refill_breaker":
+      return "rate_limited";
+    case "prompt_too_long":
+      return "context_too_long";
+    case "image_error":
+      return "image_error";
+    case "model_error":
+      return "model_error";
+    case "aborted_streaming":
+    case "aborted_tools":
+      return "aborted";
+    case "stop_hook_prevented":
+    case "hook_stopped":
+      return "hook_stopped";
+    case "tool_deferred":
+      return "tool_deferred";
+    default:
+      return "error";
+  }
+}
 var TASK_TOOLS = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet"]);
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"]);
 function extractImagePath(toolName, toolInput) {
@@ -681,7 +726,7 @@ var ClaudeProvider = class {
     let resumeId = options.providerSessionId;
     while (true) {
       let failed = false;
-      const stream = Aa({
+      const stream = E$$({
         prompt: buildQueryPrompt(),
         options: {
           cwd: options.directory,
@@ -716,7 +761,7 @@ var ClaudeProvider = class {
     let resumeId = options.providerSessionId;
     while (true) {
       let failed = false;
-      const stream = Aa({
+      const stream = E$$({
         prompt: "",
         options: {
           cwd: options.directory,
@@ -791,13 +836,14 @@ var ClaudeProvider = class {
         let resultText = "";
         const toolName = "";
         if (Array.isArray(content)) {
-          for (const block of content) {
+          for (const rawBlock of content) {
+            const block = rawBlock;
             if (block.type === "tool_result" && block.content) {
               if (typeof block.content === "string") {
                 resultText += block.content;
               } else if (Array.isArray(block.content)) {
                 for (const sub of block.content) {
-                  if (sub.type === "text") resultText += sub.text;
+                  if (sub.type === "text" && sub.text) resultText += sub.text;
                 }
               }
             }
@@ -845,7 +891,8 @@ var ClaudeProvider = class {
           costUsd: r.total_cost_usd ?? 0,
           durationMs: r.duration_ms ?? 0,
           numTurns: r.num_turns ?? 0,
-          errors: r.errors ?? []
+          errors: r.errors ?? [],
+          terminalReason: mapClaudeTerminalReason(r.terminal_reason) ?? (r.subtype === "success" ? "completed" : "error")
         };
       }
     }
@@ -858,7 +905,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-VLOS5QB6.js");
     providers.set("codex", new CodexProvider());
     codexLoadAttempted = true;
   } catch (err) {
@@ -1017,15 +1064,18 @@ function buildMonitorSystemPromptParts(session) {
 // ../engine/src/session/provider-runtime.ts
 function buildProviderOptions(session, controller, isMonitor = false, runtimeOverrides = {}) {
   const effectiveCodex = resolveEffectiveCodexOptions(session);
+  const monitorEffort = isMonitor ? config.monitorReasoningEffort || void 0 : void 0;
+  const useMonitorJudgeModel = isMonitor && session.provider === "claude" && (monitorEffort === "high" || monitorEffort === "xhigh");
+  const model = useMonitorJudgeModel ? config.monitorClaudeModel || session.model : session.model;
   return {
     directory: session.directory,
     providerSessionId: isMonitor ? session.monitorProviderSessionId : session.providerSessionId,
-    model: session.model,
+    model,
     sandboxMode: effectiveCodex.sandboxMode,
     approvalPolicy: effectiveCodex.approvalPolicy,
     networkAccessEnabled: effectiveCodex.networkAccessEnabled,
     webSearchMode: effectiveCodex.webSearchMode,
-    modelReasoningEffort: config.codexReasoningEffort || void 0,
+    modelReasoningEffort: monitorEffort ?? (config.codexReasoningEffort || void 0),
     claudePermissionMode: resolveEffectiveClaudePermissionMode(session),
     systemPromptParts: isMonitor ? buildMonitorSystemPromptParts(session) : buildSystemPromptParts(session),
     abortController: controller,
@@ -1033,34 +1083,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 +1117,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 +1156,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,7 +1195,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;
+}
+async function recordPermissionDenial(session, toolName, reason, source) {
+  await getOutputPort().updateState(session.id, {
+    type: "permission_denied",
+    sessionId: session.id,
+    source: session.provider === "codex" ? "codex" : "claude",
+    confidence: "high",
+    timestamp: Date.now(),
+    metadata: { toolName, reason, source }
+  });
+  getOutputPort().queueDigest(session.id, {
+    kind: "denied",
+    text: `\u26D4 \u6743\u9650\u62D2\u7EDD\uFF1A${truncate(toolName, 40)} \u2014 ${truncate(reason, 80)}`
+  });
 }
 function waitForGateResolution(session, gateId) {
   console.log(`[SessionExecutor] gate:waiting sessionId=${session.id} gateId=${gateId}`);
@@ -1175,7 +1223,7 @@ function waitForGateResolution(session, gateId) {
       );
       resolve2(result);
     };
-    gateCoordinator.registerReceiptHandle(gateId, {
+    gateService.registerReceiptHandle(gateId, {
       type: session.provider === "codex" ? "codex" : "claude",
       sessionId: session.id,
       resolve: (action, source) => settle({ action, source }),
@@ -1202,6 +1250,80 @@ function createClaudePermissionHandler(session, _channel) {
     console.log(
       `[SessionExecutor] permission:request sessionId=${liveSession.id} tool=${toolName} action=${context.displayName || toolName}`
     );
+    const projection = stateMachine.getSnapshot(liveSession.id);
+    if (projection.batchApprovalMode) {
+      const gateId2 = `batch-${liveSession.id}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const timestamp = Date.now();
+      const displayName = context.displayName || toolName;
+      const batchAction = await new Promise((resolve2) => {
+        let settled = false;
+        const settle = (action) => {
+          if (settled) return;
+          settled = true;
+          resolve2(action);
+        };
+        const enqueueResult = enqueueBatchApproval(liveSession.id, {
+          gateId: gateId2,
+          toolUseID: context.toolUseID,
+          toolName: displayName,
+          detail,
+          timestamp,
+          resolve: settle
+        });
+        if (enqueueResult === "overflow") {
+          console.warn(
+            `[SessionExecutor] permission:batch-overflow sessionId=${liveSession.id} tool=${toolName} reason="queue at capacity"`
+          );
+          settle("reject");
+          return;
+        }
+        stateMachine.enqueuePendingApproval(liveSession.id, {
+          gateId: gateId2,
+          toolName: displayName,
+          detail,
+          timestamp
+        });
+        void getOutputPort().updateState(liveSession.id, {
+          type: "batch_approval_changed",
+          sessionId: liveSession.id,
+          source: liveSession.provider === "codex" ? "codex" : "claude",
+          confidence: "high",
+          timestamp,
+          metadata: {
+            enabled: true,
+            pendingApprovals: stateMachine.getSnapshot(liveSession.id).pendingApprovals
+          }
+        }).catch(() => {
+        });
+        getOutputPort().queueDigest(liveSession.id, {
+          kind: "batch",
+          text: `\u5DF2\u5165\u6279\u91CF\u5BA1\u6279\u961F\u5217\uFF1A${truncate(toolName, 40)}`
+        });
+        const onAbort = () => {
+          settle("reject");
+          removeBatchApproval(liveSession.id, gateId2);
+          stateMachine.removePendingApproval(liveSession.id, gateId2);
+        };
+        if (context.signal.aborted) onAbort();
+        else context.signal.addEventListener("abort", onAbort, { once: true });
+      });
+      if (batchAction === "approve") {
+        console.log(
+          `[SessionExecutor] permission:batch-approved sessionId=${liveSession.id} tool=${toolName}`
+        );
+        return { behavior: "allow", toolUseID: context.toolUseID };
+      }
+      console.log(
+        `[SessionExecutor] permission:batch-rejected sessionId=${liveSession.id} tool=${toolName}`
+      );
+      await recordPermissionDenial(liveSession, toolName, "\u6279\u91CF\u62D2\u7EDD", "user");
+      return {
+        behavior: "deny",
+        message: "\u6279\u91CF\u62D2\u7EDD",
+        interrupt: true,
+        toolUseID: context.toolUseID
+      };
+    }
     await getOutputPort().handleAwaitingHuman(liveSession.id, detail, { source: "claude" });
     const currentSession = refreshSession(liveSession);
     const gateId = currentSession.activeHumanGateId;
@@ -1242,9 +1364,11 @@ function createClaudePermissionHandler(session, _channel) {
     if (resolved.action === "approve") {
       return { behavior: "allow", toolUseID: context.toolUseID };
     }
+    const denyReason = resolved.source === "timeout" ? "\u5BA1\u6279\u8D85\u65F6\uFF085 \u5206\u949F\uFF09" : resolved.source === "terminal" ? "\u5DF2\u5728\u7EC8\u7AEF\u62D2\u7EDD" : "\u5DF2\u5728 Discord \u62D2\u7EDD";
+    await recordPermissionDenial(currentSession, toolName, denyReason, resolved.source);
     return {
       behavior: "deny",
-      message: resolved.source === "timeout" ? "\u5BA1\u6279\u8D85\u65F6\uFF085 \u5206\u949F\uFF09" : resolved.source === "terminal" ? "\u5DF2\u5728\u7EC8\u7AEF\u62D2\u7EDD" : "\u5DF2\u5728 Discord \u62D2\u7EDD",
+      message: denyReason,
       interrupt: true,
       toolUseID: context.toolUseID
     };
@@ -1259,7 +1383,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) => ({
@@ -1569,6 +1693,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 +2004,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 +2083,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 +2110,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 +2176,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}`
   );
@@ -2031,7 +2288,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,166 +2398,31 @@ function getExpandableContent(id) {
   return expandableStore.get(id)?.content;
 }
 
-// ../bot/src/output-handler.ts
-import { existsSync } from "fs";
-
-// ../bot/src/codex-renderer.ts
-import { EmbedBuilder } from "discord.js";
-
-// ../bot/src/subagent-manager.ts
-import {
-  ChannelType,
-  ThreadAutoArchiveDuration
-} from "discord.js";
-
-// ../bot/src/discord/delivery-notices.ts
-function getDeliveryPolicy() {
-  return {
-    textChunkLimit: config.textChunkLimit ?? 2e3,
-    chunkMode: config.chunkMode ?? "length",
-    replyToMode: config.replyToMode ?? "first",
-    ackReaction: config.ackReaction ?? "\u{1F440}"
-  };
-}
-async function sendSystemNotice(channel, sessionId, text, replyToMessageId) {
-  if (!text.trim()) return;
-  const plan = buildDeliveryPlan({
-    sessionId,
-    chatId: channel.id,
-    text,
-    files: [],
-    mode: "system_notice",
-    replyToMessageId,
-    policy: getDeliveryPolicy()
-  });
-  try {
-    await deliver(channel, plan);
-  } catch {
-  }
-}
-
-// ../bot/src/subagent-manager.ts
-var SUBAGENT_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
-function canSpawnSubagent(parentSession) {
-  return parentSession.subagentDepth < config.maxSubagentDepth;
-}
-async function spawnSubagent(parentSession, label, provider, sessionChannel) {
-  if (!canSpawnSubagent(parentSession)) {
-    console.warn(`[SubagentManager] Depth limit hit for session ${parentSession.id} (max depth ${config.maxSubagentDepth})`);
-    throw new Error(
-      `Max subagent depth (${config.maxSubagentDepth}) reached. Cannot spawn further subagents.`
-    );
+// ../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 threadName = `[sub:${provider}] ${label}`.slice(0, 100);
-  const thread = await sessionChannel.threads.create({
-    name: threadName,
-    type: ChannelType.PublicThread,
-    autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-    reason: `Subagent spawned by session ${parentSession.id}`
-  });
-  const session = await createSession({
-    channelId: thread.id,
-    // Subagent's primary ID is the Thread
-    categoryId: parentSession.categoryId,
-    projectName: parentSession.projectName,
-    agentLabel: label,
-    provider,
-    directory: parentSession.directory,
-    type: "subagent",
-    parentChannelId: parentSession.channelId,
-    // Parent session's TextChannel
-    subagentDepth: parentSession.subagentDepth + 1,
-    mode: parentSession.mode,
-    claudePermissionMode: provider === "claude" ? parentSession.claudePermissionMode : void 0
-  });
-  console.log(`[SubagentManager] Spawned subagent "${label}" session ${session.id} thread ${thread.id} (depth ${session.subagentDepth}, parent ${parentSession.id})`);
-  return session;
-}
-async function archiveSubagent(session, thread, summary) {
-  if (summary) {
-    await sendSystemNotice(thread, session.id, `*\u5B50\u4EFB\u52A1\u5B8C\u6210\uFF1A${summary}*`);
-  }
-  try {
-    await thread.setArchived(true, "Subagent task completed");
-  } catch (error) {
-    console.warn(`[SubagentManager] Failed to archive thread ${thread.id} for subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  try {
-    await endSession(session.id);
-    console.log(`[SubagentManager] Archived subagent ${session.id} thread ${thread.id}${summary ? ` \u2014 ${summary}` : ""}`);
-  } catch (error) {
-    console.warn(`[SubagentManager] Failed to end session for subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function getSubagents(parentSession) {
-  return getAllSessions().filter(
-    (s) => s.type === "subagent" && s.parentChannelId === parentSession.channelId
-  );
-}
-async function runSubagentWatchdog(getThread) {
-  const now = Date.now();
-  const checked = /* @__PURE__ */ new Set();
-  let archived = 0;
-  let errors = 0;
-  for (const session of getSubagentSessions()) {
-    if (checked.has(session.id)) continue;
-    checked.add(session.id);
-    const idle = now - session.lastActivity;
-    if (idle < SUBAGENT_IDLE_TIMEOUT_MS) continue;
+  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 thread = getThread(session.channelId);
-    if (!thread) {
-      await endSession(session.id).catch((e) => console.warn(`[SubagentWatchdog] Failed to end orphaned subagent ${session.id}: ${e.message}`));
-      console.log(`[SubagentWatchdog] Ended orphaned subagent ${session.id} \u2014 thread ${session.channelId} not found`);
-      continue;
-    }
-    try {
-      await archiveSubagent(session, thread, "Idle timeout reached.");
-      archived += 1;
-    } catch (error) {
-      console.error(`[SubagentWatchdog] Failed to archive idle subagent ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
-      errors += 1;
-    }
-  }
-  console.log(`[SubagentWatchdog] Watchdog run: checked ${checked.size} subagents, archived ${archived}, errors ${errors}`);
-}
-async function autoSpawnSubagentThread(parentSession, taskId, description, sessionChannel) {
-  if (parentSession.type === "subagent") return null;
-  if (!canSpawnSubagent(parentSession)) return null;
-  const threadName = `[task] ${description}`.slice(0, 100);
-  const thread = await sessionChannel.threads.create({
-    name: threadName,
-    type: ChannelType.PublicThread,
-    autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-    reason: `Auto-created for task ${taskId} in session ${parentSession.id}`
-  });
-  let session;
-  try {
-    session = await createSession({
-      channelId: thread.id,
-      categoryId: parentSession.categoryId,
-      projectName: parentSession.projectName,
-      agentLabel: description,
-      provider: parentSession.provider,
-      directory: parentSession.directory,
-      type: "subagent",
-      parentChannelId: parentSession.channelId,
-      subagentDepth: (parentSession.subagentDepth || 0) + 1,
-      mode: parentSession.mode,
-      claudePermissionMode: parentSession.provider === "claude" ? parentSession.claudePermissionMode : void 0
+    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
     });
-  } catch (err) {
-    console.warn(`[SubagentManager] createSession failed for auto-spawned task ${taskId}, deleting orphan thread ${thread.id}: ${err instanceof Error ? err.message : String(err)}`);
-    await thread.delete("Session creation failed").catch(
-      (deleteErr) => console.warn(`[SubagentManager] Failed to delete orphan thread ${thread.id}: ${deleteErr instanceof Error ? deleteErr.message : String(deleteErr)}`)
-    );
-    throw err;
   }
-  console.log(`[SubagentManager] Auto-spawned thread for task ${taskId} session ${session.id} thread ${thread.id}`);
-  return { threadId: thread.id, session };
-}
-function getSubagentSessions() {
-  return getAllSessions().filter((s) => s.type === "subagent");
+  return { abandoned, candidates };
 }
 
 // ../bot/src/output/message-streamer.ts
@@ -2431,67 +2553,30 @@ var MessageStreamer = class {
   }
 };
 
-// ../bot/src/output/interaction-controls.ts
-import {
-  ActionRowBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-  StringSelectMenuBuilder,
-  EmbedBuilder as EmbedBuilder2
-} from "discord.js";
-function resolveEffectiveClaudePermissionMode2(currentMode, claudePermissionMode) {
-  if (!claudePermissionMode) return void 0;
-  return currentMode === "auto" ? "bypass" : claudePermissionMode;
-}
-function makeModeButtons(sessionId, currentMode, claudePermissionMode) {
-  const modes = [
-    { id: "auto", label: "\u26A1 \u81EA\u52A8\u6A21\u5F0F" },
-    { id: "plan", label: "\u{1F4CB} \u8BA1\u5212\u6A21\u5F0F" },
-    { id: "normal", label: "\u{1F6E1}\uFE0F \u666E\u901A\u6A21\u5F0F" },
-    { id: "monitor", label: "\u{1F9E0} \u76D1\u63A7\u6A21\u5F0F" }
-  ];
-  const row = new ActionRowBuilder();
-  for (const m of modes) {
-    row.addComponents(
-      new ButtonBuilder().setCustomId(`mode:${sessionId}:${m.id}`).setLabel(m.id === currentMode ? `\u2713 ${m.label}` : m.label).setStyle(m.id === currentMode ? ButtonStyle.Success : ButtonStyle.Secondary).setDisabled(false)
-    );
-  }
-  const effectiveClaudePermissionMode = resolveEffectiveClaudePermissionMode2(
-    currentMode,
-    claudePermissionMode
-  );
-  if (effectiveClaudePermissionMode) {
-    const permLabel = effectiveClaudePermissionMode === "bypass" ? "\u26A1 \u7ED5\u8FC7\u6743\u9650" : "\u{1F6E1}\uFE0F \u9700\u8981\u786E\u8BA4";
-    row.addComponents(
-      new ButtonBuilder().setCustomId(`perm-info:${sessionId}`).setLabel(permLabel).setStyle(
-        effectiveClaudePermissionMode === "bypass" ? ButtonStyle.Danger : ButtonStyle.Success
-      ).setDisabled(true)
-    );
-  }
-  return row;
-}
-function shouldSuppressCommandExecution(command) {
-  return command.toLowerCase().includes("total-recall");
-}
-
 // ../bot/src/output-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 +2591,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 +2636,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 +2696,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,
@@ -2934,7 +2834,7 @@ async function archiveSessionsById(guild, sessionIds, summary = "Bulk cleanup fr
     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;
       continue;
@@ -2976,10 +2876,10 @@ async function reconcileSessionRecordsWithGuild(guild) {
 }
 
 // ../bot/src/session-sync.ts
-import { ChannelType as ChannelType2 } from "discord.js";
+import { ChannelType } from "discord.js";
 
 // ../bot/src/codex-session-discovery.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { readFile, open } from "fs/promises";
 import { glob } from "fs/promises";
 import { join, resolve, sep } from "path";
@@ -3008,7 +2908,7 @@ function parseUpdatedAt(value) {
 }
 async function readSessionIndex(codexHome = join(homedir(), ".codex")) {
   const indexPath = join(codexHome, "session_index.jsonl");
-  if (!existsSync2(indexPath)) return [];
+  if (!existsSync(indexPath)) return [];
   let content;
   try {
     content = await readFile(indexPath, "utf-8");
@@ -3078,7 +2978,7 @@ async function fileMatchesSessionId(file, id) {
 }
 async function findSessionFileById(id, codexHome = join(homedir(), ".codex")) {
   const sessionsDir = join(codexHome, "sessions");
-  if (!existsSync2(sessionsDir)) return null;
+  if (!existsSync(sessionsDir)) return null;
   if (await isRipgrepAvailable()) {
     try {
       const { stdout } = await execFileAsync(
@@ -3252,12 +3152,12 @@ function stopSync() {
 }
 async function findOrCreateSessionChannel(guild, category, provider, providerSessionId, fallbackName) {
   const existing = category.children.cache.find(
-    (channel) => channel.type === ChannelType2.GuildText && typeof channel.topic === "string" && channel.topic.includes(`Provider Session: ${providerSessionId}`)
+    (channel) => channel.type === ChannelType.GuildText && typeof channel.topic === "string" && channel.topic.includes(`Provider Session: ${providerSessionId}`)
   );
   if (existing) return existing;
   return guild.channels.create({
     name: fallbackName,
-    type: ChannelType2.GuildText,
+    type: ChannelType.GuildText,
     parent: category.id,
     topic: `${provider} session (synced) | Provider Session: ${providerSessionId}`
   }).then((channel) => {
@@ -3308,11 +3208,11 @@ async function runSync(client2) {
     );
     let createdThisRun = 0;
     try {
-      const claudeSdk = await import("./sdk-V7A7IF7F.js");
+      const claudeSdk = await import("./sdk-C3D6X4EB.js");
       for (const project of projects) {
         if (createdThisRun >= MAX_SESSIONS_PER_SYNC) break;
         const category = guild.channels.cache.get(project.discordCategoryId);
-        if (!category || category.type !== ChannelType2.GuildCategory) {
+        if (!category || category.type !== ChannelType.GuildCategory) {
           recordSkip("categoryMissing");
           continue;
         }
@@ -3403,7 +3303,7 @@ async function runSync(client2) {
         continue;
       }
       const category = guild.channels.cache.get(project.discordCategoryId);
-      if (!category || category.type !== ChannelType2.GuildCategory) {
+      if (!category || category.type !== ChannelType.GuildCategory) {
         recordSkip("categoryMissing");
         continue;
       }
@@ -3446,6 +3346,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 +3440,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 +3694,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 existsSync2, chmodSync } from "fs";
 
 // ../bot/src/session-discovery.ts
 async function discoverAndRegisterSession(client2, params) {
@@ -3832,7 +3741,7 @@ function startIpcServer(client2) {
   discordClient = client2;
   const socketPath = config.socketPath;
   activeSocketPath = socketPath;
-  if (existsSync3(socketPath)) {
+  if (existsSync2(socketPath)) {
     try {
       unlinkSync(socketPath);
     } catch {
@@ -3871,6 +3780,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) => {
@@ -3886,7 +3804,7 @@ function stopIpcServer() {
     server.close();
     server = null;
   }
-  if (activeSocketPath && existsSync3(activeSocketPath)) {
+  if (activeSocketPath && existsSync2(activeSocketPath)) {
     try {
       unlinkSync(activeSocketPath);
     } catch {
@@ -3941,7 +3859,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 +3879,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);
+  const result = gateService.notifyTerminalResolved(data.gateId, data.action);
   if (!result.success) {
     console.warn(`[IpcServer] Gate resolution failed: ${result.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) {
@@ -4265,7 +4183,7 @@ function stopHealthMonitor() {
 
 // ../bot/src/message-handler.ts
 import {
-  ChannelType as ChannelType3
+  ChannelType as ChannelType2
 } from "discord.js";
 
 // ../bot/src/discord/inbound-envelope.ts
@@ -4332,7 +4250,7 @@ function stopMessageHandler() {
 async function handleMessage(message) {
   if (message.author.bot) return;
   const channel = message.channel;
-  const isSessionChannel3 = channel.type === ChannelType3.GuildText;
+  const isSessionChannel3 = channel.type === ChannelType2.GuildText;
   const isSubagentThread = channel.isThread();
   if (!isSessionChannel3 && !isSubagentThread) return;
   const session = getSessionByChannel(channel.id);
@@ -4421,7 +4339,7 @@ async function handleMessage(message) {
 // ../bot/src/commands.ts
 import { REST, Routes } from "discord.js";
 import { createHash } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join3 } from "path";
 
 // ../bot/src/command-definitions/project-command.ts
@@ -4548,7 +4466,16 @@ function buildAgentCommand() {
         { name: "\u5F00\u542F", value: "on" }
       )
     )
-  ).addSubcommand((sub) => sub.setName("continue").setDescription("\u7EE7\u7EED\u5F53\u524D\u4F1A\u8BDD\u7684\u751F\u6210"));
+  ).addSubcommand((sub) => sub.setName("continue").setDescription("\u7EE7\u7EED\u5F53\u524D\u4F1A\u8BDD\u7684\u751F\u6210")).addSubcommand(
+    (sub) => sub.setName("batch").setDescription("\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F\uFF08\u5EF6\u540E\u6240\u6709\u5DE5\u5177\u5BA1\u6279\u81F3\u4E00\u6B21\u6027\u5904\u7406\uFF09").addStringOption(
+      (opt) => opt.setName("action").setDescription("\u5F00\u5173 / \u4E00\u952E\u6279\u51C6 / \u4E00\u952E\u62D2\u7EDD").setRequired(true).addChoices(
+        { name: "\u5F00\u542F\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F", value: "on" },
+        { name: "\u5173\u95ED\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F", value: "off" },
+        { name: "\u6279\u51C6\u961F\u5217\u4E2D\u7684\u5168\u90E8\u5DE5\u5177\u8C03\u7528", value: "approve-all" },
+        { name: "\u62D2\u7EDD\u961F\u5217\u4E2D\u7684\u5168\u90E8\u5DE5\u5177\u8C03\u7528", value: "reject-all" }
+      )
+    )
+  );
 }
 
 // ../bot/src/command-definitions/subagent-command.ts
@@ -4590,7 +4517,7 @@ function computeCommandsHash(body) {
 }
 function readStoredHash() {
   try {
-    if (existsSync4(HASH_FILE)) {
+    if (existsSync3(HASH_FILE)) {
       return readFileSync2(HASH_FILE, "utf-8").trim();
     }
   } catch {
@@ -4625,13 +4552,13 @@ async function registerCommands() {
 // ../bot/src/bot-services-orchestrator.ts
 async function findOrCreateLogChannel(guild) {
   const existing = guild.channels.cache.find(
-    (ch) => ch.name === "bot-logs" && ch.type === ChannelType4.GuildText && !ch.parentId
+    (ch) => ch.name === "bot-logs" && ch.type === ChannelType3.GuildText && !ch.parentId
   );
   if (existing) return existing;
   try {
     return await guild.channels.create({
       name: "bot-logs",
-      type: ChannelType4.GuildText,
+      type: ChannelType3.GuildText,
       reason: "Auto-created by workspacecord for bot logs"
     });
   } catch {
@@ -4656,7 +4583,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 +4596,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 result;
+    try {
+      result = await reconcileAndCollectAutoResumeCandidates(config.monitorAutoResumePolicy);
+    } catch (err) {
+      console.error("[MonitorAutoResume] reconcile failed:", err);
+      return;
+    }
+    if (result.abandoned.length > 0) {
+      logBuffer2.log(
+        `Marked ${result.abandoned.length} orphan monitor run(s) as abandoned on startup.`
+      );
+    }
+    if (result.candidates.length === 0) return;
+    logBuffer2.log(
+      `Auto-resuming ${result.candidates.length} monitor session(s) (policy=${config.monitorAutoResumePolicy}).`
+    );
+    for (const candidate of result.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 result = gateService.reconcileOnStartup(config.gateRestartPolicy);
+    for (const { gateId, discordMessageId } of result.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 +4661,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 (result.resumed.length > 0) {
+      logBuffer2.log(
+        `Resumed ${result.resumed.length} pending gate(s) across restart (policy=resume-pending).`
+      );
+    }
+    if (result.invalidated.length > 0) {
+      logBuffer2.log(`Closed ${result.invalidated.length} orphan/overdue gate(s) on startup.`);
+    }
   }
   #registerServices(client2, logBuffer2, presence) {
     this.#serviceBus.register({ name: "message-handler", start() {
@@ -4720,7 +4696,7 @@ 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-RL2A3QZB.js");
         const g = client2.guilds.cache.first();
         if (!g) return false;
         const result = await registerLocalSession2(
@@ -4768,8 +4744,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));
@@ -4796,7 +4772,7 @@ var BotServicesOrchestrator = class {
 };
 
 // ../engine/src/bot-locks.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
 import { join as join5 } from "path";
 var LOCK_FILE = join5(config.dataDir, "bot.lock");
 var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
@@ -4809,7 +4785,7 @@ function isProcessRunning(pid) {
   }
 }
 function acquireLock() {
-  if (!existsSync5(LOCK_FILE)) {
+  if (!existsSync4(LOCK_FILE)) {
     const data2 = { pid: process.pid, startedAt: Date.now() };
     writeFileSync2(LOCK_FILE, JSON.stringify(data2), "utf-8");
     return true;
@@ -4839,7 +4815,7 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    if (!existsSync5(LOCK_FILE)) return;
+    if (!existsSync4(LOCK_FILE)) return;
     const raw = readFileSync3(LOCK_FILE, "utf-8").trim();
     const data = JSON.parse(raw);
     if (data.pid === process.pid) {
@@ -4851,13 +4827,13 @@ function releaseLock() {
 
 // ../bot/src/command-handlers-modules/project-handlers.ts
 import {
-  ChannelType as ChannelType6,
-  EmbedBuilder as EmbedBuilder3
+  ChannelType as ChannelType5,
+  EmbedBuilder
 } from "discord.js";
 
 // ../bot/src/command-handlers-shared.ts
 import {
-  ChannelType as ChannelType5
+  ChannelType as ChannelType4
 } from "discord.js";
 var logFn = console.log;
 function setLogger(fn) {
@@ -4884,7 +4860,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-CLI4WDII.js");
   if (typeof registerExistingStatusCard2 !== "function") {
     log(`[panel-adapter] registerExistingStatusCard \u672A\u66B4\u9732\uFF0Csession=${sessionId}`);
     return false;
@@ -5004,7 +4980,7 @@ function resolveCleanupCurrentChannelId(interaction) {
 }
 function findControlChannel(guild, categoryId) {
   const existing = guild.channels.cache.find(
-    (channel) => channel.type === ChannelType5.GuildText && channel.parentId === categoryId && channel.name === CONTROL_CHANNEL_NAME
+    (channel) => channel.type === ChannelType4.GuildText && channel.parentId === categoryId && channel.name === CONTROL_CHANNEL_NAME
   );
   return existing ?? null;
 }
@@ -5012,7 +4988,7 @@ async function resolveOrCreateControlChannel(interaction, guild, categoryId, sto
   const currentChannel = interaction.channel;
   if (storedControlChannelId) {
     const existing = guild.channels.cache.get(storedControlChannelId);
-    if (existing?.type === ChannelType5.GuildText) {
+    if (existing?.type === ChannelType4.GuildText) {
       return existing;
     }
   }
@@ -5028,7 +5004,7 @@ async function resolveOrCreateControlChannel(interaction, guild, categoryId, sto
   }
   const created = await guild.channels.create({
     name: CONTROL_CHANNEL_NAME,
-    type: ChannelType5.GuildText,
+    type: ChannelType4.GuildText,
     parent: categoryId,
     topic: "Use /agent spawn here to create new agent sessions",
     reason: `Project control channel created for ${interaction.user.tag}`
@@ -5101,7 +5077,7 @@ async function handleProjectSetup(interaction) {
     try {
       const historyForum = await guild.channels.create({
         name: "history",
-        type: ChannelType6.GuildForum,
+        type: ChannelType5.GuildForum,
         parent: categoryId,
         topic: "Archived agent sessions for this project",
         reason: "Created by workspacecord for session archiving"
@@ -5119,7 +5095,7 @@ async function handleProjectSetup(interaction) {
   setControlChannelId(categoryId, interaction.channelId);
   const controlInfo = `
 \u2022 \u63A7\u5236\u9891\u9053\uFF1A<#${interaction.channelId}>`;
-  const embed = new EmbedBuilder3().setColor(3066993).setTitle(`\u2705 \u9879\u76EE\u5C31\u7EEA\uFF1A${project.name}`).addFields(
+  const embed = new EmbedBuilder().setColor(3066993).setTitle(`\u2705 \u9879\u76EE\u5C31\u7EEA\uFF1A${project.name}`).addFields(
     { name: "\u5206\u7C7B", value: `**${categoryName}**`, inline: true },
     { name: "\u76EE\u5F55", value: `\`${project.directory}\``, inline: true }
   ).setDescription(
@@ -5147,7 +5123,7 @@ async function handleProjectInfo(interaction) {
   }
   const sessions = getSessionsByCategory(categoryId);
   const activeSessions = sessions.filter((s) => s.type === "persistent");
-  const embed = new EmbedBuilder3().setColor(3447003).setTitle(`\u{1F4C1} \u9879\u76EE\uFF1A${project.name}`).addFields(
+  const embed = new EmbedBuilder().setColor(3447003).setTitle(`\u{1F4C1} \u9879\u76EE\uFF1A${project.name}`).addFields(
     { name: "\u76EE\u5F55", value: `\`${project.directory}\``, inline: false },
     { name: "\u6D3B\u8DC3\u4F1A\u8BDD", value: `${activeSessions.length}`, inline: true },
     { name: "\u6280\u80FD", value: `${project.skills.length}`, inline: true },
@@ -5324,11 +5300,11 @@ ${lines.join("\n")}`, ephemeral: true });
 
 // ../bot/src/command-handlers-modules/agent-handlers.ts
 import {
-  ActionRowBuilder as ActionRowBuilder2,
-  ButtonBuilder as ButtonBuilder2,
-  ButtonStyle as ButtonStyle2,
-  ChannelType as ChannelType7,
-  EmbedBuilder as EmbedBuilder4
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ChannelType as ChannelType6,
+  EmbedBuilder as EmbedBuilder2
 } from "discord.js";
 
 // ../engine/src/agent-cleanup-request-store.ts
@@ -5406,6 +5382,8 @@ async function handleAgent(interaction) {
       return handleAgentPermissions(interaction);
     case "continue":
       return handleAgentContinue(interaction);
+    case "batch":
+      return handleAgentBatch(interaction);
     default:
       await interaction.reply({ content: `\u672A\u77E5\u5B50\u547D\u4EE4\uFF1A${sub}`, ephemeral: true });
   }
@@ -5458,7 +5436,7 @@ async function handleAgentSpawn(interaction) {
   try {
     sessionChannel = await guild.channels.create({
       name: channelName,
-      type: ChannelType7.GuildText,
+      type: ChannelType6.GuildText,
       parent: categoryId,
       topic: `[${PROVIDER_LABELS[provider]}] ${label}`,
       reason: `Agent session spawned by ${interaction.user.tag}`
@@ -5489,7 +5467,7 @@ async function handleAgentSpawn(interaction) {
   if (mode !== "auto") {
     setMode(session.id, mode);
   }
-  const statusEmbed = new EmbedBuilder4().setColor(PROVIDER_COLORS[provider]).setTitle("\u{1F4A4} \u5F85\u547D").setDescription("\u7B49\u5F85\u9996\u6761\u6D88\u606F").addFields({
+  const statusEmbed = new EmbedBuilder2().setColor(PROVIDER_COLORS[provider]).setTitle("\u{1F4A4} \u5F85\u547D").setDescription("\u7B49\u5F85\u9996\u6761\u6D88\u606F").addFields({
     name: "\u6743\u9650",
     value: getSessionPermissionSummary(session),
     inline: false
@@ -5511,7 +5489,7 @@ async function handleAgentSpawn(interaction) {
   }
   setStatusCardBinding(session.id, { messageId: statusMessage.id });
   log(`[panel-adapter] \u72B6\u6001\u5361\u5DF2\u6CE8\u518C\uFF0Csession=${session.id}`);
-  const embed = new EmbedBuilder4().setColor(3066993).setTitle(`\u2705 Agent \u5DF2\u521B\u5EFA\uFF1A${label}`).addFields(
+  const embed = new EmbedBuilder2().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 },
@@ -5552,7 +5530,7 @@ async function handleAgentList(interaction) {
     const status = s.isGenerating ? "\u{1F504} \u6267\u884C\u4E2D" : "\u{1F4A4} \u7A7A\u95F2";
     return `${status} | \`${s.agentLabel}\` | ${s.provider} | <#${s.channelId}> | ${formatRelative(s.lastActivity)}`;
   });
-  const embed = new EmbedBuilder4().setColor(3447003).setTitle(`Agent \u4F1A\u8BDD\uFF08${sessions.length}\uFF09`).setDescription(lines.join("\n"));
+  const embed = new EmbedBuilder2().setColor(3447003).setTitle(`Agent \u4F1A\u8BDD\uFF08${sessions.length}\uFF09`).setDescription(lines.join("\n"));
   await interaction.reply({ embeds: [embed], ephemeral: true });
 }
 async function handleAgentCleanup(interaction) {
@@ -5597,9 +5575,9 @@ async function handleAgentCleanup(interaction) {
     candidateSessionIds: preview.archiveCandidates.map((session) => session.id)
   });
   const components = [
-    new ActionRowBuilder2().addComponents(
-      new ButtonBuilder2().setCustomId(`cleanup:confirm:${request.id}`).setLabel("\u786E\u8BA4\u5F52\u6863").setStyle(ButtonStyle2.Danger),
-      new ButtonBuilder2().setCustomId(`cleanup:cancel:${request.id}`).setLabel("\u53D6\u6D88").setStyle(ButtonStyle2.Secondary)
+    new ActionRowBuilder().addComponents(
+      new ButtonBuilder().setCustomId(`cleanup:confirm:${request.id}`).setLabel("\u786E\u8BA4\u5F52\u6863").setStyle(ButtonStyle.Danger),
+      new ButtonBuilder().setCustomId(`cleanup:cancel:${request.id}`).setLabel("\u53D6\u6D88").setStyle(ButtonStyle.Secondary)
     )
   ];
   await interaction.reply({
@@ -5736,7 +5714,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}
@@ -5763,9 +5741,93 @@ async function handleAgentContinue(interaction) {
   await interaction.editReply("\u7EE7\u7EED\u4E2D...");
   await executeSessionContinue(session, channel);
 }
+async function handleAgentBatch(interaction) {
+  const channel = interaction.channel;
+  if (!channel) {
+    await interaction.reply({ content: "\u65E0\u9891\u9053\u4E0A\u4E0B\u6587\u3002", ephemeral: true });
+    return;
+  }
+  const session = getSessionByChannel(channel.id);
+  if (!session) {
+    await interaction.reply({ content: "\u6B64\u9891\u9053\u6CA1\u6709\u6D3B\u8DC3\u7684\u4F1A\u8BDD\u3002", ephemeral: true });
+    return;
+  }
+  if (session.provider !== "claude") {
+    await interaction.reply({
+      content: "\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F\u76EE\u524D\u4EC5\u652F\u6301 Claude \u4F1A\u8BDD\u3002Codex \u8BF7\u4F7F\u7528 `/agent permissions codex-approval` \u914D\u7F6E\u3002",
+      ephemeral: true
+    });
+    return;
+  }
+  const action = interaction.options.getString("action", true);
+  const source = "claude";
+  if (action === "on") {
+    if (!shouldUseClaudePermissionHandler(session)) {
+      const hint = session.mode === "auto" ? "\u5F53\u524D\u4F1A\u8BDD\u662F `auto` \u6A21\u5F0F\uFF0C\u5DE5\u5177\u4E0D\u8D70\u5BA1\u6279 hook\u3002\u8BF7\u5148 `/agent mode mode:normal` \u518D\u5F00\u542F\u6279\u91CF\u5BA1\u6279\u3002" : "\u5F53\u524D\u4F1A\u8BDD\u7684 Claude \u6743\u9650\u6A21\u5F0F\u4E3A `bypass`\uFF0C\u5DE5\u5177\u4E0D\u8D70\u5BA1\u6279 hook\u3002\u8BF7\u5148 `/agent permissions claude-permissions:normal`\u3002";
+      await interaction.reply({ content: `\u26A0\uFE0F \u65E0\u6CD5\u5F00\u542F\u6279\u91CF\u5BA1\u6279\uFF1A${hint}`, ephemeral: true });
+      return;
+    }
+    await updateSessionState(session.id, {
+      type: "batch_approval_changed",
+      sessionId: session.id,
+      source,
+      confidence: "high",
+      timestamp: Date.now(),
+      metadata: { enabled: true }
+    });
+    await interaction.reply({
+      content: "\u2705 \u5DF2\u5F00\u542F\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F\u3002\u540E\u7EED\u6743\u9650\u8BF7\u6C42\u5C06\u6392\u961F\uFF0C\u4F7F\u7528 `/agent batch action:approve-all` \u6216 `reject-all` \u7EDF\u4E00\u5904\u7406\u3002",
+      ephemeral: true
+    });
+    return;
+  }
+  if (action === "off") {
+    const pending = getBatchApprovalCount(session.id);
+    drainBatchApprovals(session.id, "reject");
+    await updateSessionState(session.id, {
+      type: "batch_approval_changed",
+      sessionId: session.id,
+      source,
+      confidence: "high",
+      timestamp: Date.now(),
+      metadata: { enabled: false }
+    });
+    await interaction.reply({
+      content: `\u2705 \u5DF2\u5173\u95ED\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F${pending > 0 ? `\uFF0C\u961F\u5217\u4E2D ${pending} \u6761\u5F85\u6279\u8BF7\u6C42\u5DF2\u6309\u62D2\u7EDD\u5904\u7406\u3002` : "\u3002"}`,
+      ephemeral: true
+    });
+    return;
+  }
+  if (action === "approve-all" || action === "reject-all") {
+    const projection = stateMachine.getSnapshot(session.id);
+    if (!projection.batchApprovalMode) {
+      await interaction.reply({
+        content: "\u6279\u91CF\u5BA1\u6279\u6A21\u5F0F\u672A\u542F\u7528\u3002\u5148\u7528 `/agent batch action:on` \u5F00\u542F\u3002",
+        ephemeral: true
+      });
+      return;
+    }
+    const batchAction = action === "approve-all" ? "approve" : "reject";
+    const count2 = drainBatchApprovals(session.id, batchAction);
+    await updateSessionState(session.id, {
+      type: "batch_approval_changed",
+      sessionId: session.id,
+      source,
+      confidence: "high",
+      timestamp: Date.now(),
+      metadata: { enabled: true, pendingApprovals: [] }
+    });
+    await interaction.reply({
+      content: count2 === 0 ? "\u961F\u5217\u4E2D\u6CA1\u6709\u5F85\u6279\u51C6\u7684\u8BF7\u6C42\u3002" : `\u2705 \u5DF2${batchAction === "approve" ? "\u6279\u51C6" : "\u62D2\u7EDD"} ${count2} \u6761\u5F85\u6279\u8BF7\u6C42\u3002`,
+      ephemeral: true
+    });
+    return;
+  }
+  await interaction.reply({ content: `\u672A\u77E5\u52A8\u4F5C\uFF1A${action}`, ephemeral: true });
+}
 
 // ../bot/src/command-handlers-modules/subagent-handlers.ts
-import { EmbedBuilder as EmbedBuilder5 } from "discord.js";
+import { EmbedBuilder as EmbedBuilder3 } from "discord.js";
 async function handleSubagent(interaction) {
   if (!assertUserAllowed(interaction)) return;
   const sub = interaction.options.getSubcommand();
@@ -5805,7 +5867,7 @@ async function handleSubagentRun(interaction) {
   }
   try {
     const subSession = await spawnSubagent(session, label, provider, sessionChannel);
-    const embed = new EmbedBuilder5().setColor(15965202).setTitle(`\u{1F916} \u5B50\u4EFB\u52A1\u5DF2\u521B\u5EFA\uFF1A${label}`).addFields(
+    const embed = new EmbedBuilder3().setColor(15965202).setTitle(`\u{1F916} \u5B50\u4EFB\u52A1\u5DF2\u521B\u5EFA\uFF1A${label}`).addFields(
       { name: "\u5B50\u533A", value: `<#${subSession.channelId}>`, inline: true },
       { name: "\u63D0\u4F9B\u5546", value: PROVIDER_LABELS[provider], inline: true },
       { name: "\u5D4C\u5957\u6DF1\u5EA6", value: `${subSession.subagentDepth}`, inline: true }
@@ -12774,24 +12836,20 @@ async function handleShellKill(interaction) {
   });
 }
 
-// ../bot/src/button-handler.ts
-import "discord.js";
-
 // ../bot/src/button-handler-actions.ts
 import {
-  ActionRowBuilder as ActionRowBuilder3,
-  StringSelectMenuBuilder as StringSelectMenuBuilder2
+  ActionRowBuilder as ActionRowBuilder2,
+  StringSelectMenuBuilder
 } from "discord.js";
 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, {
@@ -12838,7 +12896,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,12 +12914,12 @@ 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 result = await gateService.resolveFromDiscord(
     activeGate.id,
     action === "approve" ? "approve" : "reject"
   );
@@ -12872,8 +12930,8 @@ async function handleAwaitingHumanButton(interaction) {
     });
     return true;
   }
+  stateMachine.setHumanResolved(sessionId, true);
   updateSession(sessionId, {
-    humanResolved: true,
     currentInteractionMessageId: void 0,
     activeHumanGateId: void 0
   });
@@ -12929,7 +12987,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;
@@ -13036,7 +13094,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 +13111,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 +13132,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;
@@ -13089,7 +13147,7 @@ async function handleSelectMenuAction(interaction) {
         if (!("components" in row)) return row;
         const comp = asComponentLike(row.components?.[0]);
         if (comp?.customId !== customId) return row;
-        const menu = new StringSelectMenuBuilder2().setCustomId(customId).setPlaceholder(`\u5DF2\u9009\u62E9\uFF1A${selected.slice(0, 80)}`);
+        const menu = new StringSelectMenuBuilder().setCustomId(customId).setPlaceholder(`\u5DF2\u9009\u62E9\uFF1A${selected.slice(0, 80)}`);
         for (const opt of comp.options || []) {
           menu.addOptions({
             label: opt.label,
@@ -13098,7 +13156,7 @@ async function handleSelectMenuAction(interaction) {
             default: opt.value === selected
           });
         }
-        return new ActionRowBuilder3().addComponents(menu);
+        return new ActionRowBuilder2().addComponents(menu);
       });
       await original.edit({ components: updatedComponents });
     } catch {
@@ -13113,7 +13171,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 +13190,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 +13209,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
@@ -13290,7 +13375,7 @@ async function startBot() {
     const guild = client.guilds.cache.first();
     if (guild) {
       serviceContainer.logChannel = guild.channels.cache.find(
-        (ch) => ch.name === "bot-logs" && ch.type === ChannelType8.GuildText && !ch.parentId
+        (ch) => ch.name === "bot-logs" && ch.type === ChannelType7.GuildText && !ch.parentId
       ) ?? serviceContainer.logChannel;
       logBuffer.setChannel(serviceContainer.logChannel);
     }
@@ -13356,7 +13441,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-7G5YWKJU.js");
     const args = [action || "list"].filter(Boolean);
     if (key) args.push(key);
     if (value) args.push(value);
@@ -13364,12 +13449,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-ALKDLRMZ.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-AT4HXAGU.js");
     await handleAttachment([action || "fetch"]);
   });
   cli.command("daemon <action>", "Manage background service").action(async (action) => {
@@ -13377,7 +13462,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-CLGG4CVY.js");
     const parsed = this.options;
     const rawArgs = [];
     for (const [key, value] of Object.entries(parsed)) {