@ai-setting/roy-agent-cli 1.7.19 → 1.7.20

package/dist/index.js

@@ -1087,7 +1087,7 @@ var init_slash_command_popup = __esm(() => {
   });
 });
 
-// src/render/markdown.ts
+// src/render/markdown.js
 import { Marked } from "marked";
 import { highlight } from "cli-highlight";
 function setMarkdownEnabled(enabled) {
@@ -1496,7 +1496,8 @@ var init_markdown = __esm(() => {
   ANSI_CSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
 });
 
-// src/tui/Markdown.tsx
+// src/tui/Markdown.js
+import React2 from "react";
 import { Text as Text2 } from "ink";
 import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
 var Markdown = ({ text, width }) => {
@@ -1513,7 +1514,7 @@ var init_Markdown = __esm(() => {
   init_markdown();
 });
 
-// src/tui/theme.ts
+// src/tui/theme.js
 function shouldSuppressColors(env) {
   if (env.NO_COLOR && env.NO_COLOR !== "0" && env.NO_COLOR !== "false") {
     return true;
@@ -1557,14 +1558,11 @@ var init_theme = __esm(() => {
   };
 });
 
-// src/tui/StatusBar.tsx
+// src/tui/StatusBar.js
+import React3 from "react";
 import { Box as Box2, Text as Text3 } from "ink";
 import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
-var StatusBar = ({
-  model,
-  workdir,
-  tokenCount
-}) => {
+var StatusBar = ({ model, workdir, tokenCount }) => {
   const theme = getTheme();
   return /* @__PURE__ */ jsxDEV3(Box2, {
     borderStyle: "single",
@@ -1675,7 +1673,7 @@ __export(exports_repl_ink, {
   REPLInk: () => REPLInk,
   MultilineInput: () => MultilineInput
 });
-import * as React2 from "react";
+import * as React4 from "react";
 import { Box as Box3, Text as Text4, Static, useApp, useInput as useInput2 } from "ink";
 import { createLogger as createLogger5 } from "@ai-setting/roy-agent-core";
 import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
@@ -1700,7 +1698,7 @@ function REPLInk(props) {
     onEscape
   } = props;
   const { exit: appExit } = useApp();
-  const [messages, setMessages] = React2.useState(() => [
+  const [messages, setMessages] = React4.useState(() => [
     withMessageId({
       role: "system",
       kind: "welcome",
@@ -1708,47 +1706,47 @@ function REPLInk(props) {
     }),
     ...initialMessages.map(withMessageId)
   ]);
-  const [mode, setMode] = React2.useState(initialMode);
-  const [statusBarCtx, setStatusBarCtxState] = React2.useState({
+  const [mode, setMode] = React4.useState(initialMode);
+  const [statusBarCtx, setStatusBarCtxState] = React4.useState({
     mode: initialMode,
     cwd: initialStatusBarCtx.cwd ?? initialContext.cwd,
     gitBranch: initialStatusBarCtx.gitBranch,
     model: initialStatusBarCtx.model ?? initialContext.model
   });
-  const [inputValue, setInputValue] = React2.useState("");
-  const [popupIndex, setPopupIndex] = React2.useState(0);
-  const filteredCmds = React2.useMemo(() => {
+  const [inputValue, setInputValue] = React4.useState("");
+  const [popupIndex, setPopupIndex] = React4.useState(0);
+  const filteredCmds = React4.useMemo(() => {
     if (!/^\/\S*$/.test(inputValue))
       return [];
     return filterCommands(inputValue);
   }, [inputValue]);
   const showPopup = filteredCmds.length > 0;
-  React2.useEffect(() => {
+  React4.useEffect(() => {
     setPopupIndex(0);
   }, [filteredCmds]);
   const safePopupIndex = clampSelectedIndex(popupIndex, filteredCmds.length);
-  const handlePopupSelect = React2.useCallback((cmd) => {
+  const handlePopupSelect = React4.useCallback((cmd) => {
     multilineInputRef.current?.setBuffer(cmd.cmd + " ");
     setInputValue(cmd.cmd + " ");
   }, []);
-  const handlePopupClose = React2.useCallback(() => {
+  const handlePopupClose = React4.useCallback(() => {
     const current = multilineInputRef.current?.getBuffer() ?? "";
     const stripped = current.replace(/^\/+/, "");
     multilineInputRef.current?.setBuffer(stripped);
     setInputValue(stripped);
   }, []);
-  const handlePopupIndexChange = React2.useCallback((idx) => {
+  const handlePopupIndexChange = React4.useCallback((idx) => {
     setPopupIndex(idx);
   }, []);
-  const streamingIndexRef = React2.useRef(-1);
-  const lastFlushTsRef = React2.useRef(0);
+  const streamingIndexRef = React4.useRef(-1);
+  const lastFlushTsRef = React4.useRef(0);
   const STALE_STREAM_THRESHOLD_MS = 1000;
-  const multilineInputRef = React2.useRef(null);
-  const lastEscapeTsRef = React2.useRef(0);
-  const pendingDeltaRef = React2.useRef("");
-  const throttleTimerRef = React2.useRef(null);
-  const isFirstDeltaInStreamRef = React2.useRef(true);
-  const flushStreamingDelta = React2.useCallback(() => {
+  const multilineInputRef = React4.useRef(null);
+  const lastEscapeTsRef = React4.useRef(0);
+  const pendingDeltaRef = React4.useRef("");
+  const throttleTimerRef = React4.useRef(null);
+  const isFirstDeltaInStreamRef = React4.useRef(true);
+  const flushStreamingDelta = React4.useCallback(() => {
     const delta = pendingDeltaRef.current;
     pendingDeltaRef.current = "";
     throttleTimerRef.current = null;
@@ -1777,7 +1775,7 @@ function REPLInk(props) {
     });
     lastFlushTsRef.current = Date.now();
   }, []);
-  React2.useEffect(() => {
+  React4.useEffect(() => {
     return () => {
       if (throttleTimerRef.current !== null) {
         clearTimeout(throttleTimerRef.current);
@@ -1785,8 +1783,8 @@ function REPLInk(props) {
       }
     };
   }, []);
-  const apiRef = React2.useRef(null);
-  React2.useEffect(() => {
+  const apiRef = React4.useRef(null);
+  React4.useEffect(() => {
     const api = {
       appendMessage: (msg) => {
         setMessages((msgs) => [...msgs, withMessageId(msg)]);
@@ -1862,7 +1860,7 @@ function REPLInk(props) {
     apiRef.current = api;
     onReady?.(api);
   }, [appExit, onCommand, onReady]);
-  const handleEscapeCascade = React2.useCallback(() => {
+  const handleEscapeCascade = React4.useCallback(() => {
     const now = Date.now();
     if (now - lastEscapeTsRef.current < 100) {
       return;
@@ -1906,7 +1904,7 @@ function REPLInk(props) {
       }
     }
   });
-  const handleSubmit = React2.useCallback(async (value) => {
+  const handleSubmit = React4.useCallback(async (value) => {
     if (!value || value.trim() === "") {
       return;
     }
@@ -1935,7 +1933,7 @@ function REPLInk(props) {
       ]);
     }
   }, [onCommand, onSubmit]);
-  const staticItems = React2.useMemo(() => {
+  const staticItems = React4.useMemo(() => {
     if (messages.length <= 1)
       return [];
     return messages.slice(0, -1);
@@ -1943,8 +1941,8 @@ function REPLInk(props) {
   const tailMsg = messages.length > 0 ? messages[messages.length - 1] : null;
   const terminalWidth = process.stdout.columns ?? 80;
   const terminalHeight = process.stdout.rows ?? 24;
-  const dynamicTailBounds = React2.useMemo(() => computeDynamicTailBounds(terminalHeight, 12, showPopup), [terminalHeight, showPopup]);
-  const staticTailBounds = React2.useMemo(() => computeDynamicTailBounds(terminalHeight, 12, showPopup), [terminalHeight, showPopup]);
+  const dynamicTailBounds = React4.useMemo(() => computeDynamicTailBounds(terminalHeight, 12, showPopup), [terminalHeight, showPopup]);
+  const staticTailBounds = React4.useMemo(() => computeDynamicTailBounds(terminalHeight, 12, showPopup), [terminalHeight, showPopup]);
   const tailKey = messages.length > 0 ? tailMsg?.id ?? `tail-${messages.length - 1}` : "tail-empty";
   const statusBarModel = shortModel(statusBarCtx.model);
   const statusBarWorkdir = statusBarCtx.cwd;
@@ -2011,7 +2009,7 @@ function shortModel(model) {
 }
 async function renderInkREPL(props) {
   const ink = await import("ink");
-  const { waitUntilExit } = ink.render(React2.createElement(REPLInk, props));
+  const { waitUntilExit } = ink.render(React4.createElement(REPLInk, props));
   await waitUntilExit();
 }
 var MarkdownBounded, inkLogger, _msgIdCounter = 0, MultilineInput, MessageView;
@@ -2023,7 +2021,7 @@ var init_repl_ink = __esm(() => {
   init_Markdown();
   init_StatusBar();
   init_dynamic_tail();
-  MarkdownBounded = React2.memo(({ text, bounds, width }) => {
+  MarkdownBounded = React4.memo(({ text, bounds, width }) => {
     const out = renderBoundedAssistant(text, bounds, width);
     if (!out) {
       return null;
@@ -2033,16 +2031,16 @@ var init_repl_ink = __esm(() => {
     }, undefined, false, undefined, this);
   });
   inkLogger = createLogger5("repl-ink");
-  MultilineInput = React2.memo(React2.forwardRef(function MultilineInput2(props, ref) {
+  MultilineInput = React4.memo(React4.forwardRef(function MultilineInput2(props, ref) {
     const { onSubmit, placeholder, popupActive, onChange, onEscape } = props;
-    const [buffer, setBuffer] = React2.useState("");
-    const [cursor, setCursor] = React2.useState(0);
-    React2.useEffect(() => {
+    const [buffer, setBuffer] = React4.useState("");
+    const [cursor, setCursor] = React4.useState(0);
+    React4.useEffect(() => {
       if (popupActive || buffer.startsWith("/")) {
         onChange?.(buffer);
       }
     }, [buffer, onChange, popupActive]);
-    React2.useImperativeHandle(ref, () => ({
+    React4.useImperativeHandle(ref, () => ({
       clearBuffer: () => {
         setBuffer("");
         setCursor(0);
@@ -2280,7 +2278,7 @@ var init_repl_ink = __esm(() => {
       })
     }, undefined, false, undefined, this);
   }));
-  MessageView = React2.memo(function MessageView2({
+  MessageView = React4.memo(function MessageView2({
     msg,
     terminalWidth,
     tailBounds
@@ -9460,7 +9458,7 @@ class CliQuietModeService {
 // package.json
 var package_default = {
   name: "@ai-setting/roy-agent-cli",
-  version: "1.7.19",
+  version: "1.7.20",
   type: "module",
   description: "CLI for roy-agent - Non-interactive command execution",
   main: "./dist/index.js",
@@ -13641,27 +13639,25 @@ function createInteractiveCommand(externalEnvService) {
 var InteractiveCommand = createInteractiveCommand();
 
 // src/commands/run.ts
-import React6 from "react";
+import React9 from "react";
 import { render } from "ink";
 
-// src/RunTui.tsx
-import { useState as useState6, useCallback as useCallback4, useRef as useRef2, useEffect as useEffect5 } from "react";
+// src/RunTui.js
+import React8, { useState as useState6, useCallback as useCallback4, useRef as useRef2, useEffect as useEffect5 } from "react";
 import { Box as Box6, Text as Text8, useApp as useApp2 } from "ink";
 
-// src/tui/App.tsx
+// src/tui/App.js
 init_Markdown();
+import React6 from "react";
 import { Box as Box4, Static as Static2, Text as Text6 } from "ink";
 
-// src/tui/Spinner.tsx
+// src/tui/Spinner.js
 init_theme();
-import { useEffect as useEffect3, useState as useState3 } from "react";
+import React5, { useEffect as useEffect3, useState as useState3 } from "react";
 import { Text as Text5 } from "ink";
 import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
 var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-var Spinner = ({
-  label,
-  intervalMs = 80
-}) => {
+var Spinner = ({ label, intervalMs = 80 }) => {
   const [frame, setFrame] = useState3(0);
   const theme = getTheme();
   useEffect3(() => {
@@ -13685,7 +13681,7 @@ var Spinner = ({
   }, undefined, true, undefined, this);
 };
 
-// src/tui/App.tsx
+// src/tui/App.js
 init_StatusBar();
 init_theme();
 import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
@@ -13756,14 +13752,7 @@ var HistoryEntry = ({ item }) => {
     ]
   }, undefined, true, undefined, this);
 };
-var App = ({
-  history,
-  status,
-  model,
-  workdir,
-  streamingText,
-  tokenCount
-}) => {
+var App = ({ history, status, model, workdir, streamingText, tokenCount }) => {
   const theme = getTheme();
   return /* @__PURE__ */ jsxDEV6(Box4, {
     flexDirection: "column",
@@ -13830,22 +13819,15 @@ var App = ({
   }, undefined, true, undefined, this);
 };
 
-// src/tui/index.ts
+// src/tui/index.js
 init_Markdown();
 init_StatusBar();
 
-// src/tui/TextInput.tsx
-import { useEffect as useEffect4, useState as useState4 } from "react";
+// src/tui/TextInput.js
+import React7, { useEffect as useEffect4, useState as useState4 } from "react";
 import { Box as Box5, Text as Text7, useInput as useInput3 } from "ink";
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
-var TextInput = ({
-  label,
-  prefix,
-  onSubmit,
-  onCancel,
-  placeholder,
-  history = []
-}) => {
+var TextInput = ({ label, prefix, onSubmit, onCancel, placeholder, history = [] }) => {
   const [value, setValue] = useState4("");
   const [historyIndex, setHistoryIndex] = useState4(-1);
   const [draft, setDraft] = useState4("");
@@ -13935,11 +13917,12 @@ var TextInput = ({
   }, undefined, true, undefined, this);
 };
 
-// src/tui/index.ts
+// src/tui/index.js
 init_theme();
-init_welcome_card2();
 
-// src/tui/use-streaming-accumulator.ts
+// src/tui/welcome-card.js
+init_welcome_card();
+// src/tui/use-streaming-accumulator.js
 import { useCallback as useCallback3, useState as useState5 } from "react";
 function useStreamingAccumulator() {
   const [status, setStatus] = useState5("idle");
@@ -13973,10 +13956,10 @@ function useStreamingAccumulator() {
   return { status, streamingText, start, append, finish, fail };
 }
 
-// src/RunTui.tsx
+// src/RunTui.js
 init_markdown();
 
-// src/slash.ts
+// src/slash.js
 var CLEAR_SENTINEL = "__CLEAR__";
 function dispatchSlashCommand(raw, ctx) {
   const text = raw.trim();
@@ -14048,18 +14031,9 @@ function dispatchSlashCommand(raw, ctx) {
   }
 }
 
-// src/RunTui.tsx
+// src/RunTui.js
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
-var RunScreen = ({
-  handleQuery,
-  streamHandleQuery,
-  model,
-  workdir,
-  maxLines: initialMaxLines,
-  markdownEnabled: markdownEnabled2,
-  onExit,
-  onRegisterHandlers
-}) => {
+var RunScreen = ({ handleQuery, streamHandleQuery, model, workdir, maxLines: initialMaxLines, markdownEnabled: markdownEnabled2, onExit, onRegisterHandlers }) => {
   const [history, setHistory] = useState6([]);
   const [errorMessage, setErrorMessage] = useState6(null);
   const [maxLines, setMaxLines] = useState6(initialMaxLines);
@@ -14255,49 +14229,1088 @@ var RunTui_default = RunScreen;
 // src/commands/run.ts
 init_markdown();
 
-// src/commands/run-shutdown.ts
-import { TempFileManager as TempFileManager3 } from "@ai-setting/roy-agent-core/utils/temp-file-manager";
-async function shutdownRunSteps(deps) {
-  const {
-    lspManagerDispose,
-    pluginAdapterDispose,
-    stopEventHandler,
-    stopTaskEventHandler,
-    queryExecutor,
-    env,
-    envService,
-    shouldDisposeEnvService,
-    output,
-    logger: logger6
-  } = deps;
+// src/commands/shared/session-manager.js
+import { parseImageInput as parseImageInput3 } from "@ai-setting/roy-agent-core";
+
+class SessionManager2 {
+  sessionComponent;
+  output;
+  quiet;
+  attachedImagesMap = new Map;
+  constructor(options) {
+    this.sessionComponent = options.sessionComponent;
+    this.output = options.output;
+    this.quiet = options.quiet;
+  }
+  async init(sessionId, isContinue) {
+    let targetSessionId = sessionId;
+    let isNewSession = false;
+    if (isContinue && !targetSessionId) {
+      const activeSession = await this.sessionComponent.getActiveSession();
+      if (activeSession) {
+        targetSessionId = activeSession.id;
+        if (!this.quiet) {
+          this.output.info(`继续会话: ${activeSession.title} (${targetSessionId})`);
+        }
+      } else {
+        this.output.warn("没有找到上次会话，将创建新会话");
+      }
+    }
+    if (targetSessionId) {
+      await this.sessionComponent.setActiveSession(targetSessionId);
+      const session2 = await this.sessionComponent.get(targetSessionId);
+      if (session2) {
+        if (!this.quiet) {
+          this.output.info(`会话: ${session2.title} (${targetSessionId})`);
+        }
+      } else {
+        this.output.warn(`会话不存在: ${targetSessionId}，将创建新会话`);
+        targetSessionId = undefined;
+      }
+    }
+    if (!targetSessionId) {
+      const newSession = await this.sessionComponent.create({
+        title: `Session - ${new Date().toLocaleString("zh-CN")}`
+      });
+      targetSessionId = newSession.id;
+      isNewSession = true;
+      await this.sessionComponent.setActiveSession(targetSessionId);
+      if (!this.quiet) {
+        this.output.info(`创建新会话: ${newSession.title} (${targetSessionId})`);
+      }
+    }
+    this.clearAttachments();
+    const session = await this.sessionComponent.get(targetSessionId);
+    return {
+      sessionId: targetSessionId,
+      isNewSession,
+      sessionTitle: session?.title || "Unknown"
+    };
+  }
+  async switchSession(sessionId) {
+    return this.init(sessionId, false);
+  }
+  async getCurrentSession() {
+    return this.sessionComponent.getActiveSession();
+  }
+  async attachImage(rawPath) {
+    const normalized = rawPath.trim();
+    if (!normalized) {
+      throw new Error("attachImage: empty path");
+    }
+    const existing = this.attachedImagesMap.get(normalized);
+    if (existing) {
+      return existing;
+    }
+    const part = await parseImageInput3(normalized);
+    this.attachedImagesMap.set(normalized, part);
+    return part;
+  }
+  listAttachments() {
+    return Array.from(this.attachedImagesMap.values());
+  }
+  clearAttachments() {
+    this.attachedImagesMap.clear();
+  }
+  async getQueryPayload(text) {
+    if (this.attachedImagesMap.size === 0) {
+      return text;
+    }
+    return [
+      { type: "text", text },
+      ...this.listAttachments()
+    ];
+  }
+}
+
+// src/commands/shared/query-executor.js
+init_stream_output_service();
+import { ContextError as ContextError4, ErrorCodes as ErrorCodes4, TracedAs as TracedAs7 } from "@ai-setting/roy-agent-core";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+class QueryExecutor2 {
+  env;
+  sessionComponent;
+  output;
+  quiet;
+  silent = false;
+  streamService = null;
+  unsubscribe = null;
+  streamOptions = {
+    showReasoning: true,
+    showToolCalls: true,
+    showToolResults: false
+  };
+  _pendingContextConfig = null;
+  _pendingChunkCallback = undefined;
+  constructor(options) {
+    this.env = options.env;
+    this.sessionComponent = options.sessionComponent;
+    this.output = options.output;
+    this.quiet = options.quiet;
+    this.silent = options.silent ?? false;
+  }
+  initSummaryAgent(llmComponent, promptComponent) {
+    const session = this.sessionComponent;
+    if (typeof session.setSummaryComponents === "function") {
+      session.setSummaryComponents(promptComponent, llmComponent);
+    }
+  }
+  initStreamOutput(llmComponent, providerId = "minimax") {
+    if (llmComponent) {
+      const contextConfig = llmComponent.getContextThresholdConfig(providerId);
+      this._pendingContextConfig = contextConfig;
+    }
+  }
+  subscribeToEvents(options) {
+    this.streamOptions = options;
+    if (this.streamService) {
+      this.streamService.setOptions(options);
+    }
+    if (this.unsubscribe) {
+      return;
+    }
+    this.streamService = new StreamOutputService({
+      ...options,
+      silent: this.silent ?? false
+    });
+    if (this._pendingChunkCallback !== undefined) {
+      this.streamService.setChunkCallback(this._pendingChunkCallback);
+      this._pendingChunkCallback = undefined;
+    }
+    if (this._pendingContextConfig) {
+      this.streamService.setContextInfo(this._pendingContextConfig.contextWindow, this._pendingContextConfig.contextWindow * this._pendingContextConfig.thresholdRatio);
+      this._pendingContextConfig = null;
+    }
+    this.unsubscribe = this.env.subscribeTo([
+      "llm.start",
+      "llm.text",
+      "llm.reasoning",
+      "llm.completed",
+      "llm.error",
+      "tool.call",
+      "tool.result",
+      "tool.error",
+      "context.threshold_exceeded",
+      "context.compacting",
+      "context.compacted"
+    ], (event) => this.handleEvent(event));
+  }
+  setChunkCallback(cb) {
+    if (this.streamService) {
+      this.streamService.setChunkCallback(cb);
+    } else {
+      this._pendingChunkCallback = cb;
+    }
+  }
+  handleEvent(event) {
+    if (event.type === "context.threshold_exceeded" && !this.quiet) {
+      const payload = event.payload;
+      this.output.warn(`⚙ 上下文阈值 (${payload.totalTokens}/${payload.contextWindow})`);
+    }
+    if (event.type === "context.compacting" && !this.quiet) {
+      this.output.info("⚙ 压缩中...");
+    }
+    if (event.type === "context.compacted" && !this.quiet) {
+      this.output.success(`✓ 已压缩 (${event.payload.checkpointId})`);
+    }
+    this.streamService?.handleEvent(event);
+  }
+  async execute(message, sessionId, streamOptions, traceId, agentContext) {
+    const options = {
+      showReasoning: streamOptions?.showReasoning ?? this.streamOptions.showReasoning,
+      showToolCalls: streamOptions?.showToolCalls ?? this.streamOptions.showToolCalls,
+      showToolResults: streamOptions?.showToolResults ?? this.streamOptions.showToolResults
+    };
+    this.subscribeToEvents(options);
+    this.streamService?.reset();
+    if (!this.quiet) {
+      this.output.info(`执行: ${message}`);
+    }
+    const contextHandler = new ContextHandlerService(this.env, this.sessionComponent, { maxRetries: 1, autoCompact: true });
+    const { systemPrompt: agentContextSystemPrompt, eventSourceSystemPrompt: agentContextPreloadedPrompts, ...restAgentContext } = agentContext ?? {};
+    let eventSourceFinalPrompt;
+    if (typeof agentContextSystemPrompt === "string" && agentContextSystemPrompt.length > 0) {
+      eventSourceFinalPrompt = agentContextSystemPrompt;
+    } else if (typeof agentContextPreloadedPrompts === "string" && agentContextPreloadedPrompts.length > 0) {
+      eventSourceFinalPrompt = agentContextPreloadedPrompts;
+    }
+    const context = {
+      sessionId,
+      metadata: {
+        originalQuery: message,
+        traceId,
+        systemPrompt: eventSourceFinalPrompt
+      },
+      ...restAgentContext
+    };
+    let result;
+    try {
+      result = await contextHandler.handleQueryWithContext(message, context);
+    } catch (error) {
+      if (error instanceof ContextError4 && error.code === ErrorCodes4.CONTEXT_THRESHOLD_EXCEEDED) {
+        this.output.error(`上下文阈值超出限制: ${error.usage?.totalTokens}/${error.contextWindow}`);
+        this.output.info("请手动压缩会话: roy-agent sessions compact " + sessionId);
+      }
+      throw error;
+    }
+    if (!this.quiet) {
+      this.output.success("执行完成");
+    }
+    return result;
+  }
+  dispose() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+  }
+  getFullText() {
+    return this.streamService?.getFullText() ?? "";
+  }
+  getLastUsage() {
+    return this.streamService?.getUsageInfo() ?? null;
+  }
+  resetStream() {
+    this.streamService?.reset();
+  }
+  async compact(sessionId) {
+    try {
+      const envCore = this.env.getComponent("core");
+      if (envCore?.pushEnvEvent) {
+        envCore.pushEnvEvent({
+          type: "context.compacting",
+          metadata: { sessionId },
+          payload: {}
+        });
+      }
+      const result = await this.sessionComponent.compact(sessionId, {
+        summary: "Manual compact from interactive mode"
+      });
+      if (envCore?.pushEnvEvent) {
+        envCore.pushEnvEvent({
+          type: "context.compacted",
+          metadata: { sessionId },
+          payload: {
+            checkpointId: result.checkpoint.id,
+            messagesCompacted: result.deletedMessageCount
+          }
+        });
+      }
+      return {
+        success: true,
+        checkpoint: result.checkpoint,
+        deletedMessageCount: result.deletedMessageCount
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.output.error(`压缩失败: ${errorMessage}`);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+}
+__decorate([
+  TracedAs7("cli.query-executor.execute", { recordParams: true, log: true })
+], QueryExecutor2.prototype, "execute", null);
+
+// src/commands/interactive-event-sources.js
+import { TracedAs as TracedAs8 } from "@ai-setting/roy-agent-core";
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+async function startSingleEventSource2(eventSourceComponent, output, eventSourceId) {
+  return EventSourceStarter2.instance.runSingle(eventSourceComponent, output, eventSourceId);
+}
+async function startEventSources2(eventSourceIds, eventSourceComponent, output) {
+  return EventSourceStarter2.instance.run(eventSourceIds, eventSourceComponent, output);
+}
+
+class EventSourceStarter2 {
+  static instance = new EventSourceStarter2;
+  async run(eventSourceIds, eventSourceComponent, output) {
+    return startEventSourcesImpl2(eventSourceIds, eventSourceComponent, output);
+  }
+  async runSingle(eventSourceComponent, output, eventSourceId) {
+    return startSingleEventSourceImpl2(eventSourceComponent, output, eventSourceId);
+  }
+}
+__decorate2([
+  TracedAs8("interactive.startEventSources", { recordParams: false, log: false })
+], EventSourceStarter2.prototype, "run", null);
+__decorate2([
+  TracedAs8("interactive.startSingleEventSource", { recordParams: false, log: false })
+], EventSourceStarter2.prototype, "runSingle", null);
+async function startEventSourcesImpl2(eventSourceIds, eventSourceComponent, output) {
+  const results = [];
+  if (!eventSourceIds || eventSourceIds.length === 0) {
+    return { results, total: 0, successCount: 0, failedCount: 0 };
+  }
+  for (const id of eventSourceIds) {
+    if (!id)
+      continue;
+    const result = await startSingleEventSource2(eventSourceComponent, output, id);
+    results.push(result);
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failedCount = results.length - successCount;
+  if (results.length > 1) {
+    if (failedCount > 0) {
+      output.info(`
+✅ 成功启动 ${successCount}/${results.length} 个事件源`);
+    } else {
+      output.success(`
+✅ 成功启动 ${successCount}/${results.length} 个事件源`);
+    }
+  }
+  return { results, total: results.length, successCount, failedCount };
+}
+async function startSingleEventSourceImpl2(eventSourceComponent, output, eventSourceId) {
+  const sources = eventSourceComponent.list();
+  const matchedSource = sources.find((s) => s.id === eventSourceId || s.id.startsWith(eventSourceId));
+  if (!matchedSource) {
+    output.error(`❌ 事件源不存在: ${eventSourceId}`);
+    output.info(`可用的事件源:`);
+    for (const s of sources) {
+      output.info(`  - ${s.id.substring(0, 8)}: ${s.name} (${s.type})`);
+    }
+    return {
+      id: eventSourceId,
+      name: eventSourceId,
+      success: false,
+      status: "not_found",
+      error: `EventSource not found: ${eventSourceId}`
+    };
+  }
+  const actualId = matchedSource.id;
+  const status = eventSourceComponent.getStatus(actualId);
+  if (status === "running") {
+    output.info(`\uD83D\uDCE1 事件源 ${matchedSource.name} 已在运行中`);
+    return {
+      id: actualId,
+      name: matchedSource.name,
+      success: true,
+      status: "skipped"
+    };
+  }
+  try {
+    await eventSourceComponent.startSource(actualId);
+    const verifyStatus = eventSourceComponent.getStatus(actualId);
+    if (verifyStatus !== "running") {
+      const errMsg = `启动后状态异常: ${verifyStatus}`;
+      output.error(`❌ ${errMsg}`);
+      return {
+        id: actualId,
+        name: matchedSource.name,
+        success: false,
+        status: "failed",
+        error: errMsg
+      };
+    }
+    output.success(`\uD83D\uDCE1 已启动事件源: ${matchedSource.name} (${verifyStatus})`);
+    return {
+      id: actualId,
+      name: matchedSource.name,
+      success: true,
+      status: "started"
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    output.error(`❌ 启动事件源失败: ${matchedSource.name} - ${errMsg}`);
+    return {
+      id: actualId,
+      name: matchedSource.name,
+      success: false,
+      status: "failed",
+      error: errMsg
+    };
+  }
+}
+
+// src/commands/collect-event-source-system-prompts.js
+import { resolveBountyIMSystemPrompt as resolveBountyIMSystemPrompt2 } from "@ai-setting/roy-agent-core";
+function resolveSystemPromptForSource2(config) {
+  if (config.type === "bounty-im") {
+    const imServerUrl = config.imServerUrl || config.options && config.options.imServerUrl;
+    const address = config.address || config.options && config.options.address || "unknown";
+    return resolveBountyIMSystemPrompt2({
+      configSystemPrompt: config.systemPrompt,
+      currentAddress: address,
+      imServerUrl
+    });
+  }
+  return config.systemPrompt;
+}
+function collectEventSourceSystemPrompts2(eventSourceIds, eventSourceComponent) {
+  const result = [];
+  for (const id of eventSourceIds) {
+    const config = eventSourceComponent.get(id);
+    if (!config)
+      continue;
+    const prompt = resolveSystemPromptForSource2(config);
+    if (!prompt)
+      continue;
+    result.push({ id, type: config.type, prompt });
+  }
+  return result;
+}
+function joinResolvedSystemPrompts2(prompts) {
+  return prompts.map((p) => p.prompt).join(`
+
+---
+
+`);
+}
+
+// src/commands/act-agent-validation.js
+function validateActAgent2(agentComponent, agentName) {
+  if (!agentName || agentName === "default") {
+    return { valid: true };
+  }
+  if (!agentComponent?.getAgent(agentName)) {
+    return {
+      valid: false,
+      message: `Agent "${agentName}" 不存在`
+    };
+  }
+  return { valid: true };
+}
+function buildActAgentContext2(agentName) {
+  if (!agentName || agentName === "default") {
+    return;
+  }
+  return { agentType: agentName };
+}
+
+// src/commands/shared/event-handler.js
+import { TracedAs as TracedAs9 } from "@ai-setting/roy-agent-core";
+var __decorate3 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+class EventHandler2 {
+  env;
+  eventTypes;
+  onEvent;
+  onEventWithEnv;
+  formatter;
+  isIdle;
+  idleCheckInterval;
+  queue = [];
+  isProcessing = false;
+  isStopped = false;
+  unsubscribe = null;
+  sessionComponent = null;
+  activeEventSessionId = null;
+  constructor(options) {
+    this.env = options.env;
+    this.eventTypes = options.eventTypes;
+    this.onEvent = options.onEvent;
+    this.onEventWithEnv = options.onEventWithEnv;
+    this.formatter = options.formatter ?? new EventMessageFormatter;
+    this.isIdle = options.isIdle ?? (() => true);
+    this.idleCheckInterval = options.idleCheckInterval ?? 100;
+    this.sessionComponent = options.sessionComponent ?? null;
+  }
+  start() {
+    this.isStopped = false;
+    this.unsubscribe = this.env.subscribeAll((event) => {
+      if (this.matchesEventType(event.type)) {
+        this.handleEvent(event);
+      }
+    });
+    return () => this.stop();
+  }
+  matchesEventType(eventType) {
+    for (const pattern of this.eventTypes) {
+      if (this.matchPattern(eventType, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  matchPattern(eventType, pattern) {
+    if (pattern === "*")
+      return true;
+    if (pattern.endsWith(".*")) {
+      const prefix = pattern.slice(0, -2);
+      return eventType === prefix || eventType.startsWith(prefix + ".");
+    }
+    return eventType === pattern;
+  }
+  stop() {
+    this.isStopped = true;
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    this.queue = [];
+    this.isProcessing = false;
+    this.clearActiveSession();
+  }
+  handleEvent(event) {
+    if (this.isStopped) {
+      return;
+    }
+    const formatted = this.formatter.formatWithEvent(event);
+    this.enqueue(formatted);
+  }
+  enqueue(formattedEvent) {
+    if (this.isStopped) {
+      return;
+    }
+    this.queue.push(formattedEvent);
+    if (!this.isProcessing) {
+      this.processQueue();
+    }
+  }
+  getQueueLength() {
+    return this.queue.length;
+  }
+  isQueueEmpty() {
+    return this.queue.length === 0;
+  }
+  async processQueue() {
+    this.isProcessing = true;
+    const sessionId = await this.ensureActiveSession();
+    if (this.isStopped) {
+      this.clearActiveSession();
+      this.isProcessing = false;
+      return;
+    }
+    while (!this.isStopped && this.queue.length > 0) {
+      await this.waitForIdle();
+      if (this.isStopped) {
+        break;
+      }
+      const item = this.queue.shift();
+      if (!item) {
+        break;
+      }
+      if (sessionId) {
+        item.eventSessionId = sessionId;
+      }
+      try {
+        if (this.onEventWithEnv) {
+          await this.onEventWithEnv(item);
+          continue;
+        }
+        await this.onEvent(item.message);
+      } catch (error) {
+        console.error(`[EventHandler] 处理事件失败:`, error);
+      }
+    }
+    this.isProcessing = false;
+  }
+  async ensureActiveSession() {
+    if (!this.sessionComponent)
+      return null;
+    if (this.activeEventSessionId)
+      return this.activeEventSessionId;
+    const triggerSessionId = this.queue.map((item) => item.triggerSessionId).find((id) => !!id);
+    if (triggerSessionId) {
+      try {
+        const existing = await this.sessionComponent.get(triggerSessionId);
+        if (existing) {
+          if (this.isStopped) {
+            return null;
+          }
+          this.activeEventSessionId = existing.id;
+          await this.sessionComponent.setActiveSession(existing.id);
+          return existing.id;
+        }
+        console.warn(`[EventHandler] Parent session ${triggerSessionId} not found, trying global active session`);
+      } catch (error) {
+        console.error(`[EventHandler] Failed to lookup parent session ${triggerSessionId}:`, error);
+      }
+    }
+    try {
+      const activeId = this.sessionComponent.getActiveSessionId();
+      if (activeId) {
+        const existing = await this.sessionComponent.get(activeId);
+        if (existing) {
+          if (this.isStopped) {
+            return null;
+          }
+          this.activeEventSessionId = existing.id;
+          return existing.id;
+        }
+      }
+    } catch (error) {
+      console.error(`[EventHandler] Failed to lookup global active session:`, error);
+    }
+    return this.createNewEventSession();
+  }
+  async createNewEventSession() {
+    try {
+      const session = await this.sessionComponent.create({
+        title: `Event Session - ${new Date().toLocaleString()}`
+      });
+      if (this.isStopped) {
+        this.activeEventSessionId = null;
+        return null;
+      }
+      this.activeEventSessionId = session.id;
+      await this.sessionComponent.setActiveSession(session.id);
+      return session.id;
+    } catch (error) {
+      console.error(`[EventHandler] 创建事件 session 失败:`, error);
+      return null;
+    }
+  }
+  clearActiveSession() {
+    this.activeEventSessionId = null;
+  }
+  getActiveEventSessionId() {
+    return this.activeEventSessionId;
+  }
+  async waitForIdle() {
+    while (!this.isStopped && !this.isIdle()) {
+      await this.sleep(this.idleCheckInterval);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+__decorate3([
+  TracedAs9("cli.event-handler.handleEvent", { recordParams: true })
+], EventHandler2.prototype, "handleEvent", null);
+
+// src/commands/shared/task-event-handler.js
+import { createLogger as createLogger7 } from "@ai-setting/roy-agent-core";
+var logger6 = createLogger7("task-event-handler");
+var TASK_EVENTS2 = {
+  CREATED: "task.created",
+  UPDATED: "task.updated",
+  COMPLETED: "task.completed",
+  DELETED: "task.deleted",
+  OPERATION_ADDED: "task.operation_added",
+  DELEGATED: "task.delegated"
+};
+
+class TaskEventHandler2 {
+  env;
+  enabled;
+  unsubscribe = null;
+  constructor(options) {
+    this.env = options.env;
+    this.enabled = options.enabled ?? true;
+  }
+  start() {
+    if (!this.enabled) {
+      return () => {};
+    }
+    this.unsubscribe = this.env.subscribeAll((event) => {
+      if (event.type.startsWith("task.")) {
+        this.handleEvent(event);
+      }
+    });
+    logger6.info("[TaskEventHandler] Started");
+    return () => this.stop();
+  }
+  stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+      logger6.info("[TaskEventHandler] Stopped");
+    }
+  }
+  handleEvent(event) {
+    const payload = event.payload;
+    switch (event.type) {
+      case TASK_EVENTS2.CREATED:
+        this.logTaskCreated(payload);
+        break;
+      case TASK_EVENTS2.UPDATED:
+        this.logTaskUpdated(payload);
+        break;
+      case TASK_EVENTS2.COMPLETED:
+        this.logTaskCompleted(payload);
+        break;
+      case TASK_EVENTS2.DELETED:
+        this.logTaskDeleted(payload);
+        break;
+      case TASK_EVENTS2.OPERATION_ADDED:
+        this.logOperationAdded(payload);
+        break;
+      case TASK_EVENTS2.DELEGATED:
+        this.logTaskDelegated(payload);
+        break;
+      default:
+        logger6.info(`[${event.type}]`, payload);
+    }
+  }
+  logTaskCreated(payload) {
+    const task = payload.task;
+    logger6.info(`\uD83D\uDCDD Task created: #${task.id} - ${task.title}`);
+    logger6.info(`   Status: ${task.status}, Priority: ${task.priority}, Type: ${task.type || "normal"}`);
+    if (task.project_path) {
+      logger6.info(`   Project: ${task.project_path}`);
+    }
+    if (task.context) {
+      logger6.info(`   Context: ${task.context}`);
+    }
+  }
+  logTaskUpdated(payload) {
+    const task = payload.task;
+    const changes = payload.changes;
+    logger6.info(`✏️  Task updated: #${task.id} - ${task.title}`);
+    logger6.info(`   Status: ${task.status}, Priority: ${task.priority}, Type: ${task.type || "normal"}, Progress: ${task.progress}%`);
+    if (changes) {
+      logger6.info(`   Changes: ${JSON.stringify(changes)}`);
+    }
+  }
+  logTaskCompleted(payload) {
+    const task = payload.task;
+    logger6.info(`✅ Task completed: #${task.id} - ${task.title}`);
+    logger6.info(`   Progress: ${task.progress}%, Updated: ${task.updatedAt}`);
+  }
+  logTaskDeleted(payload) {
+    logger6.info(`\uD83D\uDDD1️  Task deleted: #${payload.taskId}`);
+  }
+  logOperationAdded(payload) {
+    const op = payload.operation;
+    logger6.info(`\uD83D\uDCCB Operation added to task #${payload.taskId}:`);
+    logger6.info(`   [${op.milestoneType}] ${op.milestoneTitle}`);
+    logger6.info(`   Session: ${op.sessionId}`);
+  }
+  logTaskDelegated(payload) {
+    logger6.info(`\uD83D\uDE80 Task delegated: #${payload.taskId}`);
+    logger6.info(`   Background: ${payload.backgroundTaskId}, Type: ${payload.subagentType}`);
+    logger6.info(`   ${payload.description}`);
+  }
+}
+
+// src/commands/shared/event-message-formatter.js
+var TaskEventTypes2 = {
+  TASK_STARTED: "task.background.started",
+  TASK_PROGRESS: "task.background.progress",
+  TASK_COMPLETED: "task.background.completed",
+  TASK_FAILED: "task.background.failed",
+  TASK_TIMEOUT: "task.background.timeout",
+  TASK_STOPPED: "task.background.stopped",
+  TASK_ASK_USER: "task.background.ask_user"
+};
+var EventSourceEventTypes2 = {
+  EVENT_SOURCE_STARTED: "event-source.started",
+  EVENT_SOURCE_STOPPED: "event-source.stopped",
+  EVENT_SOURCE_EVENT_PREFIX: "event-source.event."
+};
+
+class EventMessageFormatter2 {
+  prefix;
+  showTimestamp;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "[通知]";
+    this.showTimestamp = options.showTimestamp ?? false;
+  }
+  format(event) {
+    const { type, payload } = event;
+    switch (type) {
+      case TaskEventTypes2.TASK_STARTED:
+        return this.formatTaskStarted(payload);
+      case TaskEventTypes2.TASK_PROGRESS:
+        return this.formatTaskProgress(payload);
+      case TaskEventTypes2.TASK_COMPLETED:
+        return this.formatTaskCompleted(payload);
+      case TaskEventTypes2.TASK_FAILED:
+        return this.formatTaskFailed(payload);
+      case TaskEventTypes2.TASK_TIMEOUT:
+        return this.formatTaskTimeout(payload);
+      case TaskEventTypes2.TASK_STOPPED:
+        return this.formatTaskStopped(payload);
+      case TaskEventTypes2.TASK_ASK_USER:
+        return this.formatTaskAskUser(payload);
+      case EventSourceEventTypes2.EVENT_SOURCE_STARTED:
+        return this.formatEventSourceStarted(payload);
+      case EventSourceEventTypes2.EVENT_SOURCE_STOPPED:
+        return this.formatEventSourceStopped(payload);
+      default:
+        if (type.startsWith(EventSourceEventTypes2.EVENT_SOURCE_EVENT_PREFIX)) {
+          return this.formatEventSourceEvent(event);
+        }
+        return this.formatGeneric(event);
+    }
+  }
+  formatTaskStarted(payload) {
+    const desc = payload.description || "未命名任务";
+    return `${this.prefix} \uD83D\uDCE2 后台任务「${desc}」已启动`;
+  }
+  formatTaskProgress(payload) {
+    const desc = payload.description || "未命名任务";
+    const message = payload.progressMessage || "";
+    const taskId = payload.associatedTaskId;
+    let result = `${this.prefix} \uD83D\uDD04 后台任务「${desc}」`;
+    if (taskId !== undefined) {
+      result += `[Task #${taskId}] `;
+    }
+    result += `还在进行中，请耐心等待。需查询具体进度可调用 task_get / task_operation_list 等工具`;
+    if (message)
+      result += ` - ${message}`;
+    return result;
+  }
+  formatTaskCompleted(payload) {
+    const desc = payload.description || "未命名任务";
+    const result = payload.result;
+    const time = payload.executionTimeMs ? `(${this.formatDuration(payload.executionTimeMs)})` : "";
+    const bgProcessId = payload.backgroundTaskId || "";
+    const taskId = payload.associatedTaskId;
+    let message = `${this.prefix} ✅ 后台任务「${desc}」已完成 ${time}`;
+    if (bgProcessId) {
+      message += `
+bgprocess: ${bgProcessId}`;
+    }
+    if (taskId !== undefined) {
+      message += `
+Task #${taskId}`;
+    }
+    if (result) {
+      message += `
+结果: ${result}`;
+    }
+    message += this.appendSubSessionId(payload);
+    return message;
+  }
+  formatTaskFailed(payload) {
+    const desc = payload.description || "未命名任务";
+    const error = payload.error || "未知错误";
+    const time = payload.executionTimeMs ? `(${this.formatDuration(payload.executionTimeMs)})` : "";
+    const bgProcessId = payload.backgroundTaskId || "";
+    const taskId = payload.associatedTaskId;
+    let message = `${this.prefix} ❌ 后台任务「${desc}」失败 ${time}`;
+    if (bgProcessId) {
+      message += `
+bgprocess: ${bgProcessId}`;
+    }
+    if (taskId !== undefined) {
+      message += `
+Task #${taskId}`;
+    }
+    if (error) {
+      const truncatedError = error.length > 100 ? error.substring(0, 100) + "..." : error;
+      message += `
+错误: ${truncatedError}`;
+    }
+    message += this.appendSubSessionId(payload);
+    return message;
+  }
+  formatTaskTimeout(payload) {
+    const desc = payload.description || "未命名任务";
+    const time = payload.executionTimeMs ? `(${this.formatDuration(payload.executionTimeMs)})` : "";
+    const bgProcessId = payload.backgroundTaskId || "";
+    const taskId = payload.associatedTaskId;
+    let message = `${this.prefix} ⏱️ 后台任务「${desc}」超时 ${time}`;
+    if (bgProcessId) {
+      message += `
+bgprocess: ${bgProcessId}`;
+    }
+    if (taskId !== undefined) {
+      message += `
+Task #${taskId}`;
+    }
+    message += this.appendSubSessionId(payload);
+    return message;
+  }
+  formatTaskStopped(payload) {
+    const desc = payload.description || "未命名任务";
+    const time = payload.executionTimeMs ? `(${this.formatDuration(payload.executionTimeMs)})` : "";
+    const bgProcessId = payload.backgroundTaskId || "";
+    const taskId = payload.associatedTaskId;
+    let message = `${this.prefix} \uD83D\uDED1 后台任务「${desc}」已停止 ${time}`;
+    if (bgProcessId) {
+      message += `
+bgprocess: ${bgProcessId}`;
+    }
+    if (taskId !== undefined) {
+      message += `
+Task #${taskId}`;
+    }
+    message += this.appendSubSessionId(payload);
+    return message;
+  }
+  formatTaskAskUser(payload) {
+    const desc = payload.description || "未命名任务";
+    const bgProcessId = payload.backgroundTaskId || "";
+    const subSessionId = payload.subSessionId || "";
+    const query = payload.query || "(空问题)";
+    let message = `${this.prefix} ❓ 后台子代理「${desc}」请求用户输入`;
+    if (bgProcessId) {
+      message += `
+bgprocess: ${bgProcessId}`;
+    }
+    if (subSessionId) {
+      message += `
+subSessionId: ${subSessionId}`;
+    }
+    message += `
+
+${query}`;
+    if (payload.hints && payload.hints.length > 0) {
+      message += `
+
+[\uD83E\uDD16 Agent 操作提示]`;
+      for (const hint of payload.hints) {
+        message += `
+${hint}`;
+      }
+    }
+    return message;
+  }
+  appendSubSessionId(payload) {
+    if (payload.subSessionId) {
+      return `
+subSessionId: ${payload.subSessionId}`;
+    }
+    return "";
+  }
+  formatGeneric(event) {
+    return `${this.prefix} 收到事件: ${event.type}`;
+  }
+  formatEventSourceStarted(payload) {
+    return `${this.prefix} \uD83D\uDCE1 事件源「${payload.sourceId}」(类型: ${payload.sourceType}) 已启动`;
+  }
+  formatEventSourceStopped(payload) {
+    return `${this.prefix} \uD83D\uDCE1 事件源「${payload.sourceId}」(类型: ${payload.sourceType}) 已停止`;
+  }
+  formatEventSourceEvent(event) {
+    const payload = event.payload;
+    const sourceType = payload?.sourceType || "unknown";
+    const message = payload?.message || "";
+    if (message) {
+      return `[${sourceType}] ${message}`;
+    }
+    return `[${sourceType}] ${JSON.stringify(payload, null, 2)}`;
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${(ms / 1000).toFixed(1)}秒`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    return `${minutes}分${seconds}秒`;
+  }
+  formatWithEvent(event) {
+    const triggerSessionId = extractTriggerSessionId2(event);
+    return {
+      message: this.format(event),
+      envEvent: event,
+      triggerSessionId
+    };
+  }
+}
+function extractTriggerSessionId2(event) {
+  const triggerSessionId = event?.metadata?.trigger_session_id;
+  if (typeof triggerSessionId === "string" && triggerSessionId.length > 0) {
+    return triggerSessionId;
+  }
+  return;
+}
+
+// src/commands/lifecycle.js
+var DEFAULT_LOGGER2 = {
+  warn: (msg) => console.error(`[shutdown] ${msg}`)
+};
+function registerShutdownHandlers2(cleanup, options = {}) {
+  const logger7 = options.logger ?? DEFAULT_LOGGER2;
+  const exitCode = options.exitCode ?? 0;
+  const shutdownMessage = options.shutdownMessage ?? "Cleaning up...";
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    try {
+      logger7.debug?.(`[${signal}] ${shutdownMessage}`);
+    } catch {}
+    if (cleanup) {
+      try {
+        await cleanup();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        try {
+          logger7.warn(`Cleanup failed: ${message}`);
+        } catch {
+          try {
+            process.stderr.write(`[shutdown] Cleanup failed: ${message}
+`);
+          } catch {}
+        }
+      }
+    }
+    try {
+      process.exit(exitCode);
+    } catch {}
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return {
+    dispose: () => {
+      process.removeListener("SIGINT", shutdown);
+      process.removeListener("SIGTERM", shutdown);
+    }
+  };
+}
+
+// src/commands/run-shutdown.js
+import { TempFileManager as TempFileManager3 } from "@ai-setting/roy-agent-core/utils/temp-file-manager";
+async function shutdownRunSteps(deps) {
+  const { lspManagerDispose, pluginAdapterDispose, stopEventHandler, stopTaskEventHandler, queryExecutor, env, envService, shouldDisposeEnvService, output, logger: logger7 } = deps;
   try {
     stopEventHandler();
   } catch (err) {
-    logger6?.warn?.(`[Shutdown] EventHandler.stop failed: ${err}`);
+    logger7?.warn?.(`[Shutdown] EventHandler.stop failed: ${err}`);
   }
   try {
     stopTaskEventHandler();
   } catch (err) {
-    logger6?.warn?.(`[Shutdown] TaskEventHandler.stop failed: ${err}`);
+    logger7?.warn?.(`[Shutdown] TaskEventHandler.stop failed: ${err}`);
   }
   if (lspManagerDispose) {
     try {
       await lspManagerDispose();
     } catch (err) {
-      logger6?.warn?.(`[Shutdown] LSP Manager dispose failed: ${err}`);
+      logger7?.warn?.(`[Shutdown] LSP Manager dispose failed: ${err}`);
     }
   }
   if (pluginAdapterDispose) {
     try {
       await pluginAdapterDispose();
     } catch (err) {
-      logger6?.warn?.(`[Shutdown] PluginAdapter dispose failed: ${err}`);
+      logger7?.warn?.(`[Shutdown] PluginAdapter dispose failed: ${err}`);
     }
   }
   try {
     queryExecutor.dispose();
   } catch (err) {
-    logger6?.warn?.(`[Shutdown] QueryExecutor.dispose failed: ${err}`);
+    logger7?.warn?.(`[Shutdown] QueryExecutor.dispose failed: ${err}`);
   }
   try {
     const eventSourceComponent = env.getComponent("event-source");
@@ -14306,7 +15319,7 @@ async function shutdownRunSteps(deps) {
       if (sources && sources.length > 0) {
         for (const source of sources) {
           const status = eventSourceComponent.getStatus?.(source.id);
-          logger6?.debug?.(`[Shutdown] 检查事件源: ${source.id}, 状态: ${status}`);
+          logger7?.debug?.(`[Shutdown] 检查事件源: ${source.id}, 状态: ${status}`);
           if (status !== "stopped" && status !== "created") {
             try {
               await eventSourceComponent.stopSource(source.id);
@@ -14319,20 +15332,20 @@ async function shutdownRunSteps(deps) {
       }
     }
   } catch (err) {
-    logger6?.warn?.(`[Shutdown] EventSource cleanup failed: ${err}`);
+    logger7?.warn?.(`[Shutdown] EventSource cleanup failed: ${err}`);
   }
   if (shouldDisposeEnvService) {
     try {
       await envService.dispose();
     } catch (err) {
-      logger6?.warn?.(`[Shutdown] envService.dispose failed: ${err}`);
+      logger7?.warn?.(`[Shutdown] envService.dispose failed: ${err}`);
     }
   }
   try {
     await TempFileManager3.getInstance().cleanupAll();
-    logger6?.debug?.("[Shutdown] TempFileManager cleaned up");
+    logger7?.debug?.("[Shutdown] TempFileManager cleaned up");
   } catch (err) {
-    logger6?.warn?.(`[Shutdown] TempFileManager cleanup failed: ${err}`);
+    logger7?.warn?.(`[Shutdown] TempFileManager cleanup failed: ${err}`);
   }
 }
 
@@ -14358,14 +15371,14 @@ async function loadHandleQuery(options, hooks) {
   if (!sessionComponent) {
     throw new Error("Failed to create session component");
   }
-  const sessionManager = new SessionManager({
+  const sessionManager = new SessionManager2({
     sessionComponent,
     output,
     quiet: true
   });
   const sessionResult = await sessionManager.init(options.session, options.continue);
   const sessionId = sessionResult.sessionId;
-  const queryExecutor = new QueryExecutor({
+  const queryExecutor = new QueryExecutor2({
     env,
     sessionComponent,
     output,
@@ -14375,13 +15388,13 @@ async function loadHandleQuery(options, hooks) {
   let agentContext = undefined;
   if (options.agent && options.agent !== "default") {
     const agentComponent = env.getComponent("agent");
-    const validation = validateActAgent(agentComponent, options.agent);
+    const validation = validateActAgent2(agentComponent, options.agent);
     if (!validation.valid) {
       output.error(validation.message);
       output.info("提示: roy-agent agents list");
       process.exit(1);
     }
-    agentContext = buildActAgentContext(options.agent);
+    agentContext = buildActAgentContext2(options.agent);
   }
   let eventSourceSystemPrompt;
   const rawEventSourceIds = options.eventSource;
@@ -14393,9 +15406,9 @@ async function loadHandleQuery(options, hooks) {
       output.info("请确保 EventSourceComponent 已正确注册");
       process.exit(1);
     }
-    const summary = await startEventSources(eventSourceIds, eventSourceComponent, output);
-    const preloadedPrompts = collectEventSourceSystemPrompts(eventSourceIds, eventSourceComponent);
-    eventSourceSystemPrompt = preloadedPrompts.length > 0 ? joinResolvedSystemPrompts(preloadedPrompts) : undefined;
+    const summary = await startEventSources2(eventSourceIds, eventSourceComponent, output);
+    const preloadedPrompts = collectEventSourceSystemPrompts2(eventSourceIds, eventSourceComponent);
+    eventSourceSystemPrompt = preloadedPrompts.length > 0 ? joinResolvedSystemPrompts2(preloadedPrompts) : undefined;
     if (eventSourceIds.length === 1 && summary.failedCount > 0) {
       process.exit(1);
     }
@@ -14419,14 +15432,14 @@ async function loadHandleQuery(options, hooks) {
     }, undefined, mergedContext);
     return String(result ?? "");
   };
-  const taskEventHandler = new TaskEventHandler({
+  const taskEventHandler = new TaskEventHandler2({
     env,
     enabled: true
   });
-  const eventHandler = new EventHandler({
+  const eventHandler = new EventHandler2({
     env,
     eventTypes: ["task.background.*", "event-source.event.*"],
-    formatter: new EventMessageFormatter({ prefix: "[通知]" }),
+    formatter: new EventMessageFormatter2({ prefix: "[通知]" }),
     isIdle: hooks?.isIdle ?? (() => true),
     sessionComponent,
     onEvent: async (_message) => {},
@@ -14576,7 +15589,7 @@ function createRunCommand() {
         isIdle: () => runState.isIdle(),
         onNotification: (msg, envEvent) => runState.onNotification(msg, envEvent)
       });
-      const shutdownHandle = registerShutdownHandlers(async () => {
+      const shutdownHandle = registerShutdownHandlers2(async () => {
         await shutdownRunSteps({
           lspManagerDispose: null,
           pluginAdapterDispose: null,
@@ -14593,7 +15606,7 @@ function createRunCommand() {
       const streamHandleQuery = createStreamHandleQuery(queryExecutor, sessionId, argv, agentContext, eventSourceSystemPrompt);
       const stopEventHandler = eventHandler.start();
       const stopTaskEventHandler = taskEventHandler.start();
-      const { waitUntilExit } = render(React6.createElement(RunTui_default, {
+      const { waitUntilExit } = render(React9.createElement(RunTui_default, {
         handleQuery,
         streamHandleQuery,
         model: argv.model,
@@ -14630,23 +15643,15 @@ function createRunCommand() {
 var RunCommand = createRunCommand();
 
 // src/commands/chat.ts
-import React8 from "react";
+import React11 from "react";
 import { render as render2 } from "ink";
 
-// src/ChatTui.tsx
-import { useEffect as useEffect6, useRef as useRef3, useState as useState7 } from "react";
+// src/ChatTui.js
+import React10, { useEffect as useEffect6, useRef as useRef3, useState as useState7 } from "react";
 import { Box as Box7, useApp as useApp3 } from "ink";
 init_markdown();
 import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
-var ChatScreen = ({
-  handleQuery,
-  streamHandleQuery,
-  message,
-  model,
-  workdir,
-  maxLines,
-  markdownEnabled: markdownEnabled2
-}) => {
+var ChatScreen = ({ handleQuery, streamHandleQuery, message, model, workdir, maxLines, markdownEnabled: markdownEnabled2 }) => {
   const [history, setHistory] = useState7([
     { role: "user", content: message, id: "h-init-1" }
   ]);
@@ -14781,7 +15786,7 @@ function createChatCommand() {
       }
       const maxLines = Number.parseInt(argv.maxLines ?? "500", 10);
       const handleQuery = await loadHandleQuery2(argv);
-      const { waitUntilExit } = render2(React8.createElement(ChatTui_default, {
+      const { waitUntilExit } = render2(React11.createElement(ChatTui_default, {
         handleQuery,
         message: argv.message,
         model: argv.model,
@@ -23738,7 +24743,7 @@ var WorkflowAddCommand = {
           process.exit(1);
         }
         if (!agentComponent.getAgent("workflow-extract")) {
-          output.error("Built-in 'workflow-extract' agent is not available. ");
+          output.error("Built-in 'workflow-extract' agent is not available. This usually means the environment was not fully initialized.");
           process.exit(1);
         }
         const prompt = `## 任务
@@ -25742,7 +26747,7 @@ import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync
 import { join as join6, resolve } from "node:path";
 import { homedir as homedir4 } from "node:os";
 
-// src/commands/install/cleanup-stale-plugin-copies.ts
+// src/commands/install/cleanup-stale-plugin-copies.js
 import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync, cpSync } from "node:fs";
 import { join as join5 } from "node:path";
 import { homedir as nodeHomedir, tmpdir as nodeTmpdir } from "node:os";