@downcity/plugins 1.0.216 → 1.0.233

package/src/chat/runtime/ChatQueueWorker.ts

@@ -8,7 +8,7 @@
  */
 
 import type { Logger } from "@downcity/agent";
-import type { AgentContext } from "@downcity/agent";
+import type { PluginContext } from "@downcity/agent";
 import type { ChatQueueWorkerConfig } from "@/chat/types/ChatQueueWorker.js";
 import type { ChatQueueItem } from "@/chat/types/ChatQueue.js";
 import type { SessionMutation } from "@downcity/agent";
@@ -17,9 +17,6 @@ import {
   getSharedChatQueueStore,
 } from "./ChatQueue.js";
 import { getChatSender } from "./ChatSendRegistry.js";
-import {
-  pickLastSuccessfulChatSendText,
-} from "@downcity/agent";
 import {
   buildChannelErrorText,
   collectInitialBurstItems,
@@ -42,15 +39,15 @@ type LaneState = {
 };
 
 type TurnObservation = {
-  turnId: string;
-  sessionId: string;
-  messageId?: string;
+  turn_id: string;
+  session_id: string;
+  message_id?: string;
   typing: { stop: () => void };
 };
 
 export class ChatQueueWorker {
   private readonly logger: Logger;
-  private readonly context: AgentContext;
+  private readonly context: PluginContext;
   private readonly config: ChatQueueWorkerConfig;
   private readonly queueStore: ChatQueueStorePort;
 
@@ -63,7 +60,7 @@ export class ChatQueueWorker {
 
   constructor(params: {
     logger: Logger;
-    context: AgentContext;
+    context: PluginContext;
     queueStore?: ChatQueueStorePort;
     config?: Partial<ChatQueueWorkerConfig>;
   }) {
@@ -134,7 +131,7 @@ export class ChatQueueWorker {
 
   private async kick(): Promise<void> {
     if (this.stopped) return;
-    while (this.runningTotal < this.config.maxConcurrency) {
+    while (this.runningTotal < this.config.max_concurrency) {
       const lane = this.pickNextRunnableLane();
       if (!lane) return;
 
@@ -170,8 +167,8 @@ export class ChatQueueWorker {
    * - 只对支持显式取消的 runtime 生效（主要是 ACP）。
    * - 失败不影响正常排队；worker 仍会走串行兜底。
    */
-  private async requestTurnCancelIfSupported(sessionId: string): Promise<void> {
-    const sessionKey = String(sessionId || "").trim();
+  private async requestTurnCancelIfSupported(session_id: string): Promise<void> {
+    const sessionKey = String(session_id || "").trim();
     if (!sessionKey) return;
     try {
       // ACP executor removed; cancel is no longer supported through session executor port.
@@ -187,7 +184,7 @@ export class ChatQueueWorker {
     const control = item.control;
     if (!control) return false;
     if (control.type === "clear") {
-      this.queueStore.clear(item.sessionId);
+      this.queueStore.clear(item.session_id);
       return true;
     }
     return false;
@@ -222,8 +219,8 @@ export class ChatQueueWorker {
           ...(typeof item.targetType === "string" && item.targetType
             ? { chatType: item.targetType }
             : {}),
-          ...(typeof item.messageId === "string" && item.messageId
-            ? { messageId: item.messageId }
+          ...(typeof item.message_id === "string" && item.message_id
+            ? { message_id: item.message_id }
             : {}),
         });
       } catch {
@@ -251,9 +248,9 @@ export class ChatQueueWorker {
    * - 若 direct 未送达，则立刻回退到普通 channel 文本发送。
    */
   private async dispatchAssistantStepMessage(params: {
-    sessionId: string;
+    session_id: string;
     text: string;
-    messageId?: string;
+    message_id?: string;
   }): Promise<boolean> {
     const stepText = String(params.text || "").trim();
     if (!stepText) return false;
@@ -261,7 +258,7 @@ export class ChatQueueWorker {
     const dispatchedDirectly = await dispatchAssistantTextDirect({
       logger: this.logger,
       context: this.context,
-      sessionId: params.sessionId,
+      session_id: params.session_id,
       assistantText: stepText,
       phase: "step",
     });
@@ -272,9 +269,9 @@ export class ChatQueueWorker {
     return await dispatchTextToChannel({
       logger: this.logger,
       context: this.context,
-      sessionId: params.sessionId,
+      session_id: params.session_id,
       text: stepText,
-      messageId: params.messageId,
+      message_id: params.message_id,
       phase: "step",
     });
   }
@@ -290,8 +287,8 @@ export class ChatQueueWorker {
       return;
     }
 
-    const serviceContext = this.requireContext(first.sessionId);
-    this.ensureLaneSessionSubscription(lane, first.sessionId);
+    const serviceContext = this.requireContext(first.session_id);
+    this.ensureLaneSessionSubscription(lane, first.session_id);
 
     let clearRequested = false;
     const initialBurstItems = await collectInitialBurstItems({
@@ -315,16 +312,16 @@ export class ChatQueueWorker {
     }
 
     if (clearRequested) {
-      this.queueStore.clear(first.sessionId);
+      this.queueStore.clear(first.session_id);
     }
   }
 
   private ensureLaneSessionSubscription(
     lane: LaneState,
-    sessionId: string,
+    session_id: string,
   ): void {
     if (lane.unsubscribeSessionEvents) return;
-    const session = this.requireContext(sessionId);
+    const session = this.requireContext(session_id);
     lane.unsubscribeSessionEvents = session.subscribe((event) => {
       void this.handleLaneSessionEvent(lane, event);
     });
@@ -358,13 +355,13 @@ export class ChatQueueWorker {
 
     try {
       await this.dispatchAssistantStepMessage({
-        sessionId: observation.sessionId,
+        session_id: observation.session_id,
         text: segment_text,
-        messageId: observation.messageId,
+        message_id: observation.message_id,
       });
     } catch (error) {
       this.logger.warn("ChatQueueWorker assistant step dispatch failed", {
-        sessionId: observation.sessionId,
+        session_id: observation.session_id,
         error: String(error),
       });
     }
@@ -384,9 +381,9 @@ export class ChatQueueWorker {
         return;
       }
       const observation: TurnObservation = {
-        turnId: turn.id,
-        sessionId: item.sessionId,
-        messageId: item.messageId,
+        turn_id: turn.id,
+        session_id: item.session_id,
+        message_id: item.message_id,
         typing: this.startTypingHeartbeat(item),
       };
       params.lane.turnObservers.set(turn.id, observation);
@@ -412,15 +409,15 @@ export class ChatQueueWorker {
     } catch (error) {
       const channelErrorText = buildChannelErrorText(error);
       this.logger.error("ChatQueueWorker prompt submit failed", {
-        sessionId: item.sessionId,
+        session_id: item.session_id,
         error: String(error),
       });
       await dispatchTextToChannel({
         logger: this.logger,
         context: this.context,
-        sessionId: item.sessionId,
+        session_id: item.session_id,
         text: channelErrorText,
-        messageId: item.messageId,
+        message_id: item.message_id,
         phase: "error",
       });
     }
@@ -430,29 +427,26 @@ export class ChatQueueWorker {
     observation: TurnObservation,
     result: AgentSessionTurnResult,
   ): Promise<void> {
-    const stopReason = String(
-      result.assistantMessage?.metadata?.extra?.stopReason || "",
-    ).trim();
-    if (stopReason === "cancelled") {
+    if (String(result.error || "").trim().toLowerCase() === "cancelled") {
       return;
     }
 
     if (!result.success) {
       const resultErrorText =
-        pickLastSuccessfulChatSendText(result.assistantMessage) ||
+        result.text ||
         result.error ||
         "Execution failed";
       const channelErrorText = buildChannelErrorText(resultErrorText);
       this.logger.error("ChatQueueWorker turn finished with failure", {
-        sessionId: observation.sessionId,
+        session_id: observation.session_id,
         error: result.error || resultErrorText,
       });
       await dispatchTextToChannel({
         logger: this.logger,
         context: this.context,
-        sessionId: observation.sessionId,
+        session_id: observation.session_id,
         text: channelErrorText,
-        messageId: observation.messageId,
+        message_id: observation.message_id,
         phase: "error",
       });
       return;
@@ -465,7 +459,7 @@ export class ChatQueueWorker {
    * 关键点（中文）
    * - 在使用点显式校验，避免隐藏依赖来源。
    */
-  private requireContext(sessionId: string) {
-    return this.context.sessions.runtime(sessionId);
+  private requireContext(session_id: string) {
+    return this.context.sessions.runtime(session_id);
   }
 }

package/src/chat/runtime/ChatQueueWorkerSupport.ts

@@ -21,31 +21,31 @@ const BURST_MERGE_POLL_INTERVAL_MS = 20;
 export function normalizeChatQueueWorkerConfig(
   input?: Partial<ChatQueueWorkerConfig>,
 ): ChatQueueWorkerConfig {
-  const maxConcurrency =
-    typeof input?.maxConcurrency === "number" && Number.isFinite(input.maxConcurrency)
-      ? Math.max(1, Math.min(32, Math.floor(input.maxConcurrency)))
+  const max_concurrency =
+    typeof input?.max_concurrency === "number" && Number.isFinite(input.max_concurrency)
+      ? Math.max(1, Math.min(32, Math.floor(input.max_concurrency)))
       : 2;
 
-  const mergeDebounceMs =
-    typeof input?.mergeDebounceMs === "number" &&
-    Number.isFinite(input.mergeDebounceMs)
-      ? Math.max(0, Math.min(60_000, Math.floor(input.mergeDebounceMs)))
+  const merge_debounce_ms =
+    typeof input?.merge_debounce_ms === "number" &&
+    Number.isFinite(input.merge_debounce_ms)
+      ? Math.max(0, Math.min(60_000, Math.floor(input.merge_debounce_ms)))
       : DEFAULT_MERGE_DEBOUNCE_MS;
 
-  const mergeMaxWaitMs =
-    typeof input?.mergeMaxWaitMs === "number" &&
-    Number.isFinite(input.mergeMaxWaitMs)
-      ? Math.max(0, Math.min(120_000, Math.floor(input.mergeMaxWaitMs)))
+  const merge_max_wait_ms =
+    typeof input?.merge_max_wait_ms === "number" &&
+    Number.isFinite(input.merge_max_wait_ms)
+      ? Math.max(0, Math.min(120_000, Math.floor(input.merge_max_wait_ms)))
       : DEFAULT_MERGE_MAX_WAIT_MS;
 
-  return { maxConcurrency, mergeDebounceMs, mergeMaxWaitMs };
+  return { max_concurrency, merge_debounce_ms, merge_max_wait_ms };
 }
 
 /**
  * 判断是否启用“启动前消息合并”。
  */
 export function isBurstMergeEnabled(config: ChatQueueWorkerConfig): boolean {
-  return config.mergeDebounceMs > 0 && config.mergeMaxWaitMs > 0;
+  return config.merge_debounce_ms > 0 && config.merge_max_wait_ms > 0;
 }
 
 /**
@@ -91,7 +91,7 @@ export function buildChannelErrorText(error: unknown): string {
 }
 
 /**
- * 等待一小段时间，让同 lane 的连续消息尽量在一次 run 前合并。
+ * 等待一小段时间，让同 lane 的连续消息尽量在一次队列处理前合并。
  */
 export async function collectInitialBurstItems(params: {
   laneKey: string;
@@ -110,11 +110,11 @@ export async function collectInitialBurstItems(params: {
     const now = Date.now();
     const idleMs = now - lastInboundAt;
     const elapsedMs = now - startedAt;
-    if (idleMs >= params.config.mergeDebounceMs) break;
-    if (elapsedMs >= params.config.mergeMaxWaitMs) break;
+    if (idleMs >= params.config.merge_debounce_ms) break;
+    if (elapsedMs >= params.config.merge_max_wait_ms) break;
 
-    const remainingDebounceMs = params.config.mergeDebounceMs - idleMs;
-    const remainingMaxWaitMs = params.config.mergeMaxWaitMs - elapsedMs;
+    const remainingDebounceMs = params.config.merge_debounce_ms - idleMs;
+    const remainingMaxWaitMs = params.config.merge_max_wait_ms - elapsedMs;
     const sleepMs = Math.max(
       1,
       Math.min(

package/src/chat/runtime/ChatSendActionInput.ts

@@ -12,8 +12,8 @@ import type { JsonObject, JsonValue } from "@downcity/agent";
 import type { PluginActionCommandInput } from "@downcity/agent";
 import type { ChatSendActionPayload } from "@/chat/types/ChatPluginActionPayload.js";
 import {
-  buildChatMessageText,
-  parseChatMessageMarkup,
+  build_chat_message_text,
+  parse_chat_message_markup,
 } from "@downcity/agent";
 import { parseChatSendOptionsFromMetadata } from "@/chat/runtime/ChatSendMetadata.js";
 import {
@@ -101,43 +101,43 @@ function parseChatSendTextProtocol(params: {
   explicitReplyToMessage?: boolean;
   explicitMessageId?: string;
 }): ChatSendActionPayload {
-  const parsed = parseChatMessageMarkup(normalizeChatSendText(params.rawText));
+  const parsed = parse_chat_message_markup(normalizeChatSendText(params.rawText));
   const metadataOptions = parseChatSendOptionsFromMetadata({
     metadata: parsed.metadata,
     strict: true,
   });
 
-  const delayMs =
+  const delay_ms =
     typeof params.explicitDelayMs === "number"
       ? params.explicitDelayMs
-      : metadataOptions.delayMs;
-  const sendAtMs =
+      : metadataOptions.delay_ms;
+  const send_at_ms =
     typeof params.explicitSendAtMs === "number"
       ? params.explicitSendAtMs
-      : metadataOptions.sendAtMs;
-  if (typeof delayMs === "number" && typeof sendAtMs === "number") {
+      : metadataOptions.send_at_ms;
+  if (typeof delay_ms === "number" && typeof send_at_ms === "number") {
     throw new Error("`delay` and `time` cannot be used together.");
   }
 
-  const chatKey = resolveChatKey({
-    chatKey: params.explicitChatKey || metadataOptions.chatKey,
+  const chat_key = resolveChatKey({
+    chat_key: params.explicitChatKey || metadataOptions.chat_key,
   });
-  const messageId = String(
-    params.explicitMessageId || metadataOptions.messageId || "",
+  const message_id = String(
+    params.explicitMessageId || metadataOptions.message_id || "",
   ).trim();
-  const replyToMessage =
+  const reply_to_message =
     params.explicitReplyToMessage === true ||
-    metadataOptions.replyToMessage === true;
+    metadataOptions.reply_to_message === true;
 
   return {
-    text: buildChatMessageText({
+    text: build_chat_message_text({
       segments: parsed.segments,
     }),
-    ...(chatKey ? { chatKey } : {}),
-    ...(typeof delayMs === "number" ? { delayMs } : {}),
-    ...(typeof sendAtMs === "number" ? { sendAtMs } : {}),
-    ...(replyToMessage ? { replyToMessage: true } : {}),
-    ...(messageId ? { messageId } : {}),
+    ...(chat_key ? { chat_key } : {}),
+    ...(typeof delay_ms === "number" ? { delay_ms } : {}),
+    ...(typeof send_at_ms === "number" ? { send_at_ms } : {}),
+    ...(reply_to_message ? { reply_to_message: true } : {}),
+    ...(message_id ? { message_id } : {}),
   };
 }
 
@@ -177,39 +177,39 @@ export async function mapChatSendCommandInput(
 
   const delayRaw = getStringOpt(input.opts, "delay");
   const timeRaw = getStringOpt(input.opts, "time");
-  const replyToMessage = getBooleanOpt(input.opts, "reply");
-  const messageId = getStringOpt(input.opts, "messageId");
-  const delayMs = delayRaw
+  const reply_to_message = getBooleanOpt(input.opts, "reply");
+  const message_id = getStringOpt(input.opts, "message_id");
+  const delay_ms = delayRaw
     ? parseNonNegativeIntOptionOrThrow(delayRaw, "delay")
     : undefined;
-  const sendAtMs = timeRaw ? parseSendTimeOptionOrThrow(timeRaw, "time") : undefined;
-  if (typeof delayMs === "number" && typeof sendAtMs === "number") {
+  const send_at_ms = timeRaw ? parseSendTimeOptionOrThrow(timeRaw, "time") : undefined;
+  if (typeof delay_ms === "number" && typeof send_at_ms === "number") {
     throw new Error("`--delay` and `--time` cannot be used together.");
   }
   const payload = parseChatSendTextProtocol({
     rawText: text,
-    explicitChatKey: getStringOpt(input.opts, "chatKey"),
-    ...(typeof delayMs === "number" ? { explicitDelayMs: delayMs } : {}),
-    ...(typeof sendAtMs === "number" ? { explicitSendAtMs: sendAtMs } : {}),
-    ...(replyToMessage ? { explicitReplyToMessage: true } : {}),
-    ...(messageId ? { explicitMessageId: messageId } : {}),
+    explicitChatKey: getStringOpt(input.opts, "chat_key"),
+    ...(typeof delay_ms === "number" ? { explicitDelayMs: delay_ms } : {}),
+    ...(typeof send_at_ms === "number" ? { explicitSendAtMs: send_at_ms } : {}),
+    ...(reply_to_message ? { explicitReplyToMessage: true } : {}),
+    ...(message_id ? { explicitMessageId: message_id } : {}),
   });
-  const chatKey = resolveChatKey({
-    chatKey: payload.chatKey,
+  const chat_key = resolveChatKey({
+    chat_key: payload.chat_key,
   });
-  if (!chatKey) {
+  if (!chat_key) {
     throw new Error(
-      "Missing chatKey. Provide --chat-key or ensure DC_CTX_CHAT_KEY is injected in current shell context.",
+      "Missing chat_key. Provide --chat-key or ensure DC_CTX_CHAT_KEY is injected in current shell context.",
     );
   }
 
   return {
     text: payload.text,
-    chatKey,
-    ...(typeof payload.delayMs === "number" ? { delayMs: payload.delayMs } : {}),
-    ...(typeof payload.sendAtMs === "number" ? { sendAtMs: payload.sendAtMs } : {}),
-    ...(payload.replyToMessage === true ? { replyToMessage: true } : {}),
-    ...(payload.messageId ? { messageId: payload.messageId } : {}),
+    chat_key,
+    ...(typeof payload.delay_ms === "number" ? { delay_ms: payload.delay_ms } : {}),
+    ...(typeof payload.send_at_ms === "number" ? { send_at_ms: payload.send_at_ms } : {}),
+    ...(payload.reply_to_message === true ? { reply_to_message: true } : {}),
+    ...(payload.message_id ? { message_id: payload.message_id } : {}),
   };
 }
 
@@ -221,9 +221,9 @@ export function mapChatSendApiInput(body: JsonValue): ChatSendActionPayload {
     throw new Error("Invalid JSON body");
   }
   const payload = body as JsonObject;
-  const delayRaw = payload.delayMs ?? payload.delay;
-  const timeRaw = payload.sendAtMs ?? payload.sendAt ?? payload.time;
-  const replyRaw = payload.replyToMessage ?? payload.reply;
+  const delayRaw = payload.delay_ms ?? payload.delay;
+  const timeRaw = payload.send_at_ms ?? payload.sendAt ?? payload.time;
+  const replyRaw = payload.reply_to_message ?? payload.reply;
   const delayText =
     typeof delayRaw === "string" || typeof delayRaw === "number"
       ? String(delayRaw).trim()
@@ -232,24 +232,24 @@ export function mapChatSendApiInput(body: JsonValue): ChatSendActionPayload {
     typeof timeRaw === "string" || typeof timeRaw === "number"
       ? String(timeRaw).trim()
       : "";
-  const delayMs = delayText
-    ? parseNonNegativeIntOptionOrThrow(delayText, "delayMs")
+  const delay_ms = delayText
+    ? parseNonNegativeIntOptionOrThrow(delayText, "delay_ms")
     : undefined;
-  const sendAtMs = timeText
-    ? parseSendTimeOptionOrThrow(timeText, "sendAtMs")
+  const send_at_ms = timeText
+    ? parseSendTimeOptionOrThrow(timeText, "send_at_ms")
     : undefined;
-  if (typeof delayMs === "number" && typeof sendAtMs === "number") {
-    throw new Error("`delayMs` and `sendAtMs` cannot be used together.");
+  if (typeof delay_ms === "number" && typeof send_at_ms === "number") {
+    throw new Error("`delay_ms` and `send_at_ms` cannot be used together.");
   }
   return parseChatSendTextProtocol({
     rawText: String(payload.text ?? ""),
     explicitChatKey:
-      typeof payload.chatKey === "string" ? payload.chatKey.trim() : undefined,
-    ...(typeof delayMs === "number" ? { explicitDelayMs: delayMs } : {}),
-    ...(typeof sendAtMs === "number" ? { explicitSendAtMs: sendAtMs } : {}),
+      typeof payload.chat_key === "string" ? payload.chat_key.trim() : undefined,
+    ...(typeof delay_ms === "number" ? { explicitDelayMs: delay_ms } : {}),
+    ...(typeof send_at_ms === "number" ? { explicitSendAtMs: send_at_ms } : {}),
     ...(replyRaw === true ? { explicitReplyToMessage: true } : {}),
-    ...(typeof payload.messageId === "string" || typeof payload.messageId === "number"
-      ? { explicitMessageId: String(payload.messageId).trim() }
+    ...(typeof payload.message_id === "string" || typeof payload.message_id === "number"
+      ? { explicitMessageId: String(payload.message_id).trim() }
       : {}),
   });
 }

package/src/chat/runtime/ChatSendMetadata.ts

@@ -2,7 +2,7 @@
  * Chat send frontmatter metadata 解析工具。
  *
  * 关键点（中文）
- * - frontmatter 中的字段语义与 `downcity chat send` 参数保持一致。
+ * - frontmatter 中的字段语义与 Chat send action 输入保持一致。
  * - direct 模式也复用同一解析逻辑，避免 metadata 协议分叉。
  */
 
@@ -133,38 +133,38 @@ export function parseChatSendOptionsFromMetadata(params: {
       : {};
   const strict = params.strict === true;
 
-  const chatKey = normalizeText(
-    pickMetadataValue(metadata, ["chatKey", "chat-key"]),
+  const chat_key = normalizeText(
+    pickMetadataValue(metadata, ["chat_key", "chat-key"]),
   );
-  const delayMs = parseNonNegativeInt(
-    pickMetadataValue(metadata, ["delayMs", "delay-ms", "delay"]),
+  const delay_ms = parseNonNegativeInt(
+    pickMetadataValue(metadata, ["delay_ms", "delay-ms", "delay"]),
     "delay",
     strict,
   );
-  const sendAtMs = parseSendAtMs(
-    pickMetadataValue(metadata, ["sendAtMs", "send-at-ms", "sendAt", "send-at", "time"]),
+  const send_at_ms = parseSendAtMs(
+    pickMetadataValue(metadata, ["send_at_ms", "send-at-ms", "sendAt", "send-at", "time"]),
     "time",
     strict,
   );
-  if (typeof delayMs === "number" && typeof sendAtMs === "number") {
+  if (typeof delay_ms === "number" && typeof send_at_ms === "number") {
     throw new Error("`delay` and `time` cannot be used together.");
   }
 
   const explicitMessageId = parseOptionalMessageId(
-    pickMetadataValue(metadata, ["messageId", "message-id"]),
+    pickMetadataValue(metadata, ["message_id", "message-id"]),
   );
   const replyRaw = pickMetadataValue(metadata, ["reply"]);
   const replyAsBoolean = parseBoolean(replyRaw);
   const replyAsMessageId =
     explicitMessageId || (replyAsBoolean === undefined ? parseOptionalMessageId(replyRaw) : undefined);
-  const replyToMessage =
+  const reply_to_message =
     replyAsBoolean === true || typeof replyAsMessageId === "string";
 
   return {
-    ...(chatKey ? { chatKey } : {}),
-    ...(typeof delayMs === "number" ? { delayMs } : {}),
-    ...(typeof sendAtMs === "number" ? { sendAtMs } : {}),
-    ...(replyToMessage ? { replyToMessage: true } : {}),
-    ...(typeof replyAsMessageId === "string" ? { messageId: replyAsMessageId } : {}),
+    ...(chat_key ? { chat_key } : {}),
+    ...(typeof delay_ms === "number" ? { delay_ms } : {}),
+    ...(typeof send_at_ms === "number" ? { send_at_ms } : {}),
+    ...(reply_to_message ? { reply_to_message: true } : {}),
+    ...(typeof replyAsMessageId === "string" ? { message_id: replyAsMessageId } : {}),
   };
 }

package/src/chat/runtime/ChatSendRegistry.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - tool（如 `chat_send`）通过 dispatcher 把消息发回对应平台
- * - dispatcher 本身不关心 chatKey/history，只关心“怎么把一段 text 发出去”
+ * - dispatcher 本身不关心 chat_key/history，只关心“怎么把一段 text 发出去”
  */
 import type {
   ChatDispatchChannel,

package/src/chat/runtime/ChatSessionDelete.ts

@@ -1,19 +1,19 @@
 /**
- * ChatSessionDelete：按 sessionId 彻底删除 chat 会话数据。
+ * ChatSessionDelete：按 session_id 彻底删除 chat 会话数据。
  *
  * 关键点（中文）
  * - 删除路由映射（`.downcity/channel/meta.json`）
- * - 删除 chat 审计目录（`.downcity/chat/<sessionId>/`）
- * - 删除 core session 目录（`.downcity/agents/<agentId>/sessions/<sessionId>/`）
+ * - 删除 chat 审计目录（`.downcity/chat/<session_id>/`）
+ * - 删除 core session 目录（`.downcity/agents/<agent_id>/sessions/<session_id>/`）
  * - 清理运行中 agent 与队列，避免残留任务继续执行
  */
 
-import type { AgentContext } from "@downcity/agent";
+import type { PluginContext } from "@downcity/agent";
 import { resolveChatQueueStore } from "@/chat/runtime/ChatQueue.js";
 import { clean_chat_storage } from "@/chat/runtime/ChatStorage.js";
 
-function normalizeSessionId(sessionId: string): string {
-  return String(sessionId || "").trim();
+function normalizeSessionId(session_id: string): string {
+  return String(session_id || "").trim();
 }
 
 /**
@@ -23,39 +23,39 @@ function normalizeSessionId(sessionId: string): string {
  * - 幂等：目标不存在时返回 success + deleted=false，避免上层重试复杂化。
  */
 export async function deleteChatSessionById(params: {
-  context: AgentContext;
-  sessionId: string;
+  context: PluginContext;
+  session_id: string;
 }): Promise<{
   success: boolean;
-  sessionId: string;
+  session_id: string;
   deleted: boolean;
   removedMeta: boolean;
   removedChatDir: boolean;
   removedSessionDir: boolean;
   error?: string;
 }> {
-  const sessionId = normalizeSessionId(params.sessionId);
-  if (!sessionId) {
+  const session_id = normalizeSessionId(params.session_id);
+  if (!session_id) {
     return {
       success: false,
-      sessionId: "",
+      session_id: "",
       deleted: false,
       removedMeta: false,
       removedChatDir: false,
       removedSessionDir: false,
-      error: "Missing sessionId",
+      error: "Missing session_id",
     };
   }
 
   try {
     // 关键点（中文）：先停执行，再删文件，避免删除过程中仍有任务写入。
-    resolveChatQueueStore(params.context).clear(sessionId);
+    resolveChatQueueStore(params.context).clear(session_id);
 
     const chat_result = await clean_chat_storage({
-      root_path: params.context.rootPath,
-      session_id: sessionId,
+      root_path: params.context.workspace_path,
+      session_id: session_id,
     });
-    const removed_session_dir = await params.context.sessions.remove(sessionId);
+    const removed_session_dir = await params.context.sessions.remove(session_id);
 
     const deleted =
       chat_result.removed_route ||
@@ -64,7 +64,7 @@ export async function deleteChatSessionById(params: {
 
     return {
       success: true,
-      sessionId,
+      session_id,
       deleted,
       removedMeta: chat_result.removed_route,
       removedChatDir: chat_result.removed_chat_dir,
@@ -73,7 +73,7 @@ export async function deleteChatSessionById(params: {
   } catch (error) {
     return {
       success: false,
-      sessionId,
+      session_id,
       deleted: false,
       removedMeta: false,
       removedChatDir: false,