@ycodium-ai/agent-kimi 0.2.3576 → 0.2.3608

package/dist/index.js

@@ -49,7 +49,9 @@ var KIMI_CARD = {
     // `nativeModeSwitch`。kimi `acp` 的 `session/set_mode plan` 实测回 `{}` 并推
     // `current_mode_update`，不存在的 modeId 被 `-32602 Unknown modeId` 拒掉。
     runtimeModeSwitch: "in-session",
-    nativeModeSwitch: true
+    nativeModeSwitch: true,
+    // 内置 `Agent` 工具调用经 `task.*` 报（见 `subagents.ts`）；后台子 agent 的结束 ACP 不报。
+    reportsSpawnedAgents: true
   },
   credentialSources: [],
   diagnostics: [],
@@ -302,8 +304,8 @@ function asTrimmedString(value) {
   if (typeof value !== "string") {
     return void 0;
   }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
+  const trimmed2 = value.trim();
+  return trimmed2.length > 0 ? trimmed2 : void 0;
 }
 function readAcpText(source, key) {
   return asTrimmedString(source?.[key]);
@@ -334,12 +336,12 @@ function normalizeCommandValue(value) {
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
 function stripTrailingExitCode(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
+  const trimmed2 = value?.trim();
+  if (!trimmed2) {
     return void 0;
   }
-  const match = /^(?<output>[\s\S]*?)(?:\s*<exited with exit code \d+>)\s*$/iu.exec(trimmed);
-  const output2 = match?.groups?.output?.trim() ?? trimmed;
+  const match = /^(?<output>[\s\S]*?)(?:\s*<exited with exit code \d+>)\s*$/iu.exec(trimmed2);
+  const output2 = match?.groups?.output?.trim() ?? trimmed2;
   return output2.length > 0 ? output2 : void 0;
 }
 function extractCommandFromTitle(title) {
@@ -429,11 +431,11 @@ function extractPrimaryPath(data) {
   return paths[0];
 }
 function normalizeEquivalentValue(value) {
-  const trimmed = asTrimmedString(value);
-  if (!trimmed) {
+  const trimmed2 = asTrimmedString(value);
+  if (!trimmed2) {
     return void 0;
   }
-  return trimmed.replace(/\s+/gu, " ").replace(/\s+(?:complete|completed|started)\s*$/iu, "").trim();
+  return trimmed2.replace(/\s+/gu, " ").replace(/\s+(?:complete|completed|started)\s*$/iu, "").trim();
 }
 function isEquivalent(left, right) {
   const normalizedLeft = normalizeEquivalentValue(left)?.toLowerCase();
@@ -587,13 +589,14 @@ function extractToolCallCommand(rawInput, title) {
 }
 var TOOL_CALL_CONTENT_MAX_CHARS = 8e3;
 var TOOL_CALL_CONTENT_TRUNCATION_MARKER = "[Earlier output truncated]\n\n";
-function boundToolCallOutputText(text) {
-  if (text.length <= TOOL_CALL_CONTENT_MAX_CHARS) {
+function boundTailText(text, limit = TOOL_CALL_CONTENT_MAX_CHARS) {
+  if (text.length <= limit) {
     return text;
   }
-  const tail = text.slice(text.length - TOOL_CALL_CONTENT_MAX_CHARS);
+  const tail = text.slice(text.length - limit);
   return `${TOOL_CALL_CONTENT_TRUNCATION_MARKER}${tail}`;
 }
+var boundToolCallOutputText = (text) => boundTailText(text);
 var RAW_OUTPUT_TEXT_FIELDS = ["content", "stdout", "stderr", "output"];
 function boundToolCallRawOutput(rawOutput) {
   if (!isRecord(rawOutput)) {
@@ -705,6 +708,7 @@ function makeToolCallState(input2, options) {
     ...status ? { status } : {},
     ...command ? { command } : {},
     ...presentation?.detail ? { detail: presentation.detail } : {},
+    ...textContent ? { contentText: textContent } : {},
     data
   };
 }
@@ -715,6 +719,7 @@ function mergeToolCallState(previous, next) {
   const status = next.status ?? previous?.status;
   const command = next.command ?? previous?.command;
   const detail = next.detail ?? previous?.detail;
+  const contentText = "content" in next.data ? next.contentText : previous?.contentText;
   return {
     toolCallId: next.toolCallId,
     ...kind ? { kind } : {},
@@ -722,6 +727,7 @@ function mergeToolCallState(previous, next) {
     ...status ? { status } : {},
     ...command ? { command } : {},
     ...detail ? { detail } : {},
+    ...contentText ? { contentText } : {},
     data: {
       ...previous?.data,
       ...next.data
@@ -1268,6 +1274,54 @@ function retainToolCallUpdate(toolCalls, next, seen) {
   return { nextToolCall, decision };
 }
 
+// ../../packages/ycodium-acp-executor/src/executor/child-sessions.ts
+var CHILD_LIMIT = 256;
+var active = (status) => status === "running" || status === "waiting";
+function createChildSessionRegistry(limit = CHILD_LIMIT) {
+  const records = /* @__PURE__ */ new Map();
+  const evictOne = (keep) => {
+    const protectedIds = /* @__PURE__ */ new Set();
+    for (const [id, record2] of records) {
+      if (!active(record2.observed)) continue;
+      protectedIds.add(id);
+      let parent = record2.parentAgentId;
+      while (parent !== void 0 && !protectedIds.has(parent)) {
+        protectedIds.add(parent);
+        parent = records.get(parent)?.parentAgentId;
+      }
+    }
+    for (const id of records.keys()) {
+      if (id === keep || protectedIds.has(id)) continue;
+      records.delete(id);
+      return;
+    }
+  };
+  const add = (sessionId, record2) => {
+    records.set(sessionId, record2);
+    if (records.size > limit) evictOne(sessionId);
+  };
+  return {
+    has: (sessionId) => records.has(sessionId),
+    get: (sessionId) => records.get(sessionId),
+    mark: (sessionId) => {
+      if (records.has(sessionId)) return;
+      add(sessionId, {
+        turnId: void 0,
+        title: void 0,
+        description: void 0,
+        parentAgentId: void 0,
+        observed: void 0,
+        reported: void 0,
+        reportedError: void 0,
+        announced: false,
+        pendingMetadata: false
+      });
+    },
+    add,
+    entries: () => records.entries()
+  };
+}
+
 // ../../node_modules/.pnpm/@agentclientprotocol+sdk@1.4.0_zod@4.6.5/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 var AGENT_METHODS = {
   initialize: "initialize",
@@ -4108,23 +4162,23 @@ function canParseURL(input2) {
     return false;
   }
 }
-function validateURL(trimmed, def) {
+function validateURL(trimmed2, def) {
   if (!("normalize" in def) && !("hostname" in def) && !("protocol" in def)) {
-    return canParseURL(trimmed) || URL_UNPARSEABLE;
+    return canParseURL(trimmed2) || URL_UNPARSEABLE;
   }
-  return parseURLObject(trimmed, def);
+  return parseURLObject(trimmed2, def);
 }
-function parseURLObject(trimmed, def) {
-  if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(trimmed)) {
+function parseURLObject(trimmed2, def) {
+  if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(trimmed2)) {
     return URL_BAD_FORMAT;
   }
   try {
     if (typeof URL !== "undefined") {
       const URLStatic = URL;
       if (typeof URLStatic.parse === "function")
-        return URLStatic.parse(trimmed) ?? URL_UNPARSEABLE;
+        return URLStatic.parse(trimmed2) ?? URL_UNPARSEABLE;
     }
-    return new URL(trimmed);
+    return new URL(trimmed2);
   } catch {
     return URL_UNPARSEABLE;
   }
@@ -4145,8 +4199,8 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
     try {
-      const trimmed = payload.value.trim();
-      const url2 = validateURL(trimmed, def);
+      const trimmed2 = payload.value.trim();
+      const url2 = validateURL(trimmed2, def);
       if (url2 === URL_BAD_FORMAT) {
         payload.issues.push({
           code: "invalid_format",
@@ -4169,7 +4223,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
         return;
       }
       if (url2 === true) {
-        payload.value = stripTabAndNewline(trimmed);
+        payload.value = stripTabAndNewline(trimmed2);
         return;
       }
       if (def.hostname && !urlHostnameOk(url2, def.hostname)) {
@@ -4194,7 +4248,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
           continue: !def.abort
         });
       }
-      payload.value = def.normalize ? url2.href : stripTabAndNewline(trimmed);
+      payload.value = def.normalize ? url2.href : stripTabAndNewline(trimmed2);
       return;
     } catch (_) {
       payload.issues.push({
@@ -24796,12 +24850,12 @@ function asBytes(chunk) {
   throw new TypeError("ACP readable produced a non-byte chunk");
 }
 function isEnqueueableLine(lineBytes) {
-  const trimmed = textDecoder.decode(lineBytes).trim();
-  if (!trimmed) {
+  const trimmed2 = textDecoder.decode(lineBytes).trim();
+  if (!trimmed2) {
     return false;
   }
   try {
-    const parsed = JSON.parse(trimmed);
+    const parsed = JSON.parse(trimmed2);
     return typeof parsed === "object" && parsed !== null;
   } catch {
     return false;
@@ -25002,9 +25056,9 @@ function createAcpConnection(options) {
   const handleChunk = async (bytes) => {
     const lines = lineBuffer.push(bytes);
     for (const line of lines) {
-      const trimmed = textDecoder.decode(line).trim();
-      if (trimmed) {
-        log({ direction: "incoming", stage: "raw", payload: trimmed });
+      const trimmed2 = textDecoder.decode(line).trim();
+      if (trimmed2) {
+        log({ direction: "incoming", stage: "raw", payload: trimmed2 });
       }
     }
     const expected = lines.filter(isEnqueueableLine).length;
@@ -25041,9 +25095,9 @@ function createAcpConnection(options) {
     enqueueInbound(async () => {
       const last = lineBuffer.flush();
       if (last) {
-        const trimmed = textDecoder.decode(last).trim();
-        if (trimmed) {
-          log({ direction: "incoming", stage: "raw", payload: trimmed });
+        const trimmed2 = textDecoder.decode(last).trim();
+        if (trimmed2) {
+          log({ direction: "incoming", stage: "raw", payload: trimmed2 });
         }
       }
       const expected = last && isEnqueueableLine(last) ? 1 : 0;
@@ -25250,7 +25304,9 @@ function createExecutorLifecycle({
   eventStream,
   onInputDead,
   shared,
-  promptResults
+  promptResults,
+  settleToolSubagents,
+  settleSessionEnded
 }) {
   const cancel = async (turnId) => {
     failIfDisposed();
@@ -25281,6 +25337,7 @@ function createExecutorLifecycle({
             shared.promptsInFlight = 0;
             shared.activeTurnId = void 0;
             shared.status = "ready";
+            settleToolSubagents("turn-interrupted", targetTurnId);
             emit({
               type: "turn.completed",
               ...stamp(),
@@ -25392,6 +25449,7 @@ function createExecutorLifecycle({
       shared.abortLocalPrompt?.();
       promptResults.finishUnreceived();
       await promptResults.wait();
+      settleSessionEnded();
       emit({
         type: "session.exited",
         ...stamp(),
@@ -25495,6 +25553,304 @@ var acpPromptFailureCategory = (error62, input2) => {
   return error62 instanceof AcpConnectionClosedError ? acpTransportIfEstablished(input2.sessionEstablished, input2.disposed) : void 0;
 };
 
+// ../../packages/ycodium-acp-executor/src/tool-subagents.ts
+var EXCLUDED = /* @__PURE__ */ Symbol("excluded");
+var sealedHidden = (entry) => ({
+  sealed: true,
+  keepToolRow: false,
+  turnId: entry.turnId,
+  kind: entry.kind,
+  taskId: entry.taskId,
+  facts: entry.facts
+});
+function toolSubagentSettlementOfTurn(state, failureCategory) {
+  if (state === "cancelled") return "turn-interrupted";
+  return state === "failed" && failureCategory === "transport" ? "session-ended" : "turn-ended";
+}
+var sameFacts = (a, b) => a.title === b.title && a.description === b.description && a.summary === b.summary && a.role === b.role && a.model === b.model && a.effort === b.effort && a.rosterKind === b.rosterKind;
+function linkage(taskId, toolCallId, facts) {
+  return {
+    taskId,
+    taskType: "subagent",
+    toolUseId: toolCallId,
+    title: facts.title,
+    ...facts.role === void 0 ? {} : { role: facts.role },
+    ...facts.model === void 0 ? {} : { model: facts.model },
+    ...facts.effort === void 0 ? {} : { effort: facts.effort },
+    ...facts.rosterKind === void 0 ? {} : { rosterKind: facts.rosterKind }
+  };
+}
+var isEntry = (value) => value !== EXCLUDED && !("sealed" in value);
+function createToolSubagentTracker(spec) {
+  const calls = /* @__PURE__ */ new Map();
+  const agentTasks = /* @__PURE__ */ new Map();
+  const rememberAgent = (ref, taskId, facts) => {
+    agentTasks.set(ref, { taskId, facts });
+  };
+  const turnOf = (turnId) => turnId === void 0 ? {} : { turnId };
+  const onToolCallUpdated = (call) => {
+    const tracked = calls.get(call.toolCallId);
+    if (tracked === EXCLUDED) return void 0;
+    if (tracked !== void 0 && !isEntry(tracked)) {
+      const late = spec.resolve?.(call, tracked.kind, { known: true, background: false });
+      if (late !== void 0 && late.type !== "hold" && late.agentRef !== void 0) {
+        rememberAgent(late.agentRef, tracked.taskId, tracked.facts);
+      }
+      const repeatedTerminal = call.status === "completed" || call.status === "failed";
+      const events2 = [];
+      const final = tracked.final;
+      if (repeatedTerminal && final !== void 0 && final.summary === void 0 && late?.type === "final" && late.status === final.status && late.summary !== void 0) {
+        final.summary = late.summary;
+        events2.push({
+          type: "task.completed",
+          ...turnOf(tracked.turnId),
+          payload: {
+            ...linkage(tracked.taskId, call.toolCallId, tracked.facts),
+            status: final.status,
+            summary: late.summary
+          }
+        });
+      }
+      return {
+        events: events2,
+        handled: !tracked.keepToolRow || repeatedTerminal,
+        ...turnOf(tracked.turnId)
+      };
+    }
+    let known = tracked;
+    let kind;
+    if (known === void 0) {
+      const recognized = spec.recognize(call);
+      if (recognized === void 0) return void 0;
+      if (recognized === "exclude") {
+        calls.set(call.toolCallId, EXCLUDED);
+        return void 0;
+      }
+      kind = recognized;
+    } else {
+      kind = known.kind;
+    }
+    const resolution = spec.resolve?.(call, kind, {
+      known: known?.announced === true,
+      background: known?.background ?? false
+    });
+    if (known?.phase === "idle" && resolution?.type !== "final") {
+      if (resolution?.type === "background" && resolution.agentRef !== void 0) {
+        rememberAgent(resolution.agentRef, known.taskId, known.facts);
+      }
+      return { events: [], handled: true };
+    }
+    let carriedTurn;
+    if (known === void 0 || !known.announced) {
+      if (resolution === void 0 && !(spec.ready?.(call, kind) ?? true)) {
+        if (known === void 0) {
+          calls.set(call.toolCallId, {
+            kind,
+            taskId: call.toolCallId,
+            turnId: call.turnId,
+            facts: spec.facts(call, kind, void 0),
+            phase: "open",
+            status: void 0,
+            background: false,
+            announced: false
+          });
+        }
+        return { events: [], handled: true };
+      }
+      carriedTurn = known?.turnId;
+      calls.delete(call.toolCallId);
+      known = void 0;
+    }
+    const events = [];
+    const ref = known === void 0 ? spec.resumes?.(call, kind) : void 0;
+    const prior = ref === void 0 ? void 0 : agentTasks.get(ref);
+    const facts = spec.facts(call, kind, prior?.facts ?? known?.facts);
+    const turnId = known?.turnId ?? carriedTurn ?? call.turnId;
+    const turn = turnOf(turnId);
+    let entry;
+    if (known !== void 0) {
+      entry = known;
+    } else if (prior !== void 0) {
+      for (const [id, other] of calls) {
+        if (other === EXCLUDED || other.taskId !== prior.taskId) continue;
+        if (isEntry(other)) calls.set(id, sealedHidden(other));
+        else if (other.final !== void 0) {
+          const { final: _superseded, ...rest } = other;
+          calls.set(id, rest);
+        }
+      }
+      entry = {
+        kind,
+        taskId: prior.taskId,
+        turnId,
+        facts,
+        phase: "open",
+        status: "running",
+        background: false,
+        announced: true
+      };
+      calls.set(call.toolCallId, entry);
+      events.push({
+        type: "task.updated",
+        ...turn,
+        payload: {
+          ...linkage(entry.taskId, call.toolCallId, facts),
+          description: facts.description,
+          status: "running"
+        }
+      });
+    } else {
+      entry = {
+        kind,
+        taskId: call.toolCallId,
+        turnId,
+        facts,
+        phase: "open",
+        status: void 0,
+        background: false,
+        announced: true
+      };
+      calls.set(call.toolCallId, entry);
+      if (spec.announce === "started") {
+        events.push({
+          type: "task.started",
+          ...turn,
+          payload: {
+            ...linkage(entry.taskId, call.toolCallId, facts),
+            description: facts.description
+          }
+        });
+      }
+    }
+    const seen = known !== void 0 || prior !== void 0;
+    const wasStatus = entry.status;
+    entry.turnId = turnId;
+    if (resolution?.type === "hold") {
+      entry.facts = facts;
+      return { events, handled: true };
+    }
+    if (resolution?.type === "background") {
+      entry.facts = resolution.role === void 0 ? facts : { ...facts, role: resolution.role };
+      if (!entry.background) {
+        events.push({
+          type: "task.updated",
+          ...turn,
+          payload: {
+            ...linkage(entry.taskId, call.toolCallId, entry.facts),
+            status: "running",
+            isBackgrounded: true
+          }
+        });
+      }
+      entry.background = true;
+      entry.status = "running";
+      if (resolution.agentRef !== void 0)
+        rememberAgent(resolution.agentRef, entry.taskId, entry.facts);
+      return { events, handled: true };
+    }
+    if (resolution?.type === "final") {
+      const finalFacts = resolution.role === void 0 ? facts : { ...facts, role: resolution.role };
+      const keepToolRow = resolution.keepToolRow === true;
+      const base = linkage(entry.taskId, call.toolCallId, finalFacts);
+      if (resolution.agentRef !== void 0)
+        rememberAgent(resolution.agentRef, entry.taskId, finalFacts);
+      calls.set(call.toolCallId, {
+        sealed: true,
+        keepToolRow,
+        ...keepToolRow && (resolution.status === "completed" || resolution.status === "failed") ? { final: { status: resolution.status, summary: resolution.summary } } : {},
+        turnId,
+        kind,
+        taskId: entry.taskId,
+        facts: finalFacts
+      });
+      if (resolution.status === "completed" || resolution.status === "failed") {
+        events.push({
+          type: "task.completed",
+          ...turn,
+          payload: {
+            ...base,
+            status: resolution.status,
+            ...resolution.summary === void 0 ? {} : { summary: resolution.summary }
+          }
+        });
+      } else {
+        events.push({
+          type: "task.updated",
+          ...turn,
+          payload: {
+            ...base,
+            status: resolution.status,
+            ...resolution.status === "idle" ? { outcomeUnknown: true } : {},
+            ...resolution.description === void 0 ? {} : { description: resolution.description },
+            ...resolution.timelineBypass === true ? { timelineBypass: true } : {}
+          }
+        });
+      }
+      return { events, handled: !keepToolRow, ...turn };
+    }
+    const status = call.status === "pending" && wasStatus !== "running" ? "pending" : "running";
+    const changed = !seen && spec.announce === "progress" ? true : seen && (wasStatus !== status || !sameFacts(entry.facts, facts));
+    entry.facts = facts;
+    entry.status = status;
+    if (changed) {
+      events.push({
+        type: "task.progress",
+        ...turn,
+        payload: {
+          ...linkage(entry.taskId, call.toolCallId, facts),
+          description: facts.description,
+          ...facts.summary === void 0 ? {} : { summary: facts.summary },
+          status
+        }
+      });
+    }
+    return { events, handled: true };
+  };
+  const settle2 = (settlement, turnId) => {
+    const events = [];
+    for (const [toolCallId, entry] of calls) {
+      if (!isEntry(entry)) continue;
+      if (settlement !== "session-ended" && turnId !== void 0 && entry.turnId !== void 0 && entry.turnId !== turnId) {
+        continue;
+      }
+      const interrupted = settlement === "turn-interrupted";
+      const ended = settlement === "session-ended" || interrupted && spec.interruptedMayStillRun !== true;
+      if (!entry.announced) {
+        if (ended) calls.set(toolCallId, sealedHidden(entry));
+        else entry.phase = "idle";
+        continue;
+      }
+      const base = linkage(entry.taskId, toolCallId, entry.facts);
+      const turn = turnOf(entry.turnId);
+      if (ended) {
+        events.push({ type: "task.updated", ...turn, payload: { ...base, status: "cancelled" } });
+        calls.set(toolCallId, sealedHidden(entry));
+        continue;
+      }
+      if (entry.phase === "idle") continue;
+      const note = spec.endNote({ interrupted, background: entry.background });
+      events.push({
+        type: "task.updated",
+        ...turn,
+        payload: {
+          ...base,
+          status: "idle",
+          outcomeUnknown: true,
+          description: note.description,
+          ...note.timelineBypass === true ? { timelineBypass: true } : {}
+        }
+      });
+      entry.phase = "idle";
+    }
+    return events;
+  };
+  const mayStillRun = () => {
+    for (const entry of calls.values()) if (isEntry(entry)) return true;
+    return false;
+  };
+  return { onToolCallUpdated, settle: settle2, mayStillRun };
+}
+
 // ../../packages/ycodium-acp-executor/src/executor/prompt.ts
 function createExecutorPrompt({
   isLive,
@@ -25514,7 +25870,8 @@ function createExecutorPrompt({
   applyRequestedModel,
   notifyPromptSettled,
   shared,
-  promptResults
+  promptResults,
+  settleToolSubagents
 }) {
   const settleTurn = (input2) => {
     if (!isLive(input2.expectedGeneration) || input2.record.finished) {
@@ -25538,6 +25895,10 @@ function createExecutorPrompt({
       shared.status = "ready";
     }
     const interrupted = promptResults.hasInterrupted(input2.turnId);
+    settleToolSubagents(
+      toolSubagentSettlementOfTurn(interrupted ? "cancelled" : input2.state, input2.failureCategory),
+      input2.turnId
+    );
     emit({
       type: "turn.completed",
       ...stamp(),
@@ -26426,11 +26787,19 @@ function acpInitializePayload(clientInfo, overrides) {
         writeTextFile: false,
         ...overrides?.fs
       },
-      terminal: overrides?.terminal ?? false
+      terminal: overrides?.terminal ?? false,
+      ...overrides?.subagents === true ? { subagents: {} } : {}
     },
     clientInfo
   };
 }
+function acpCapabilityOverrides(input2) {
+  const rest = {
+    ...input2.clientCapabilities
+  };
+  delete rest.subagents;
+  return input2.subagentSessions === true ? { ...rest, subagents: true } : rest;
+}
 
 // ../../packages/ycodium-acp-executor/src/refreshDeadline.ts
 var MODEL_CATALOG_REFRESH_TIMEOUT_MS = 9e4;
@@ -26530,6 +26899,20 @@ function createExecutorSession({
   failIfDisposed,
   shared
 }) {
+  const requestSession = async (method, params) => {
+    const knownSessionId = params["sessionId"];
+    if (typeof knownSessionId === "string") shared.ownSessionIds.add(knownSessionId);
+    shared.sessionOpensInFlight += 1;
+    try {
+      const result = await connection.request(method, params);
+      const sessionId = result?.sessionId;
+      if (typeof sessionId === "string" && sessionId.length > 0)
+        shared.ownSessionIds.add(sessionId);
+      return result;
+    } finally {
+      shared.sessionOpensInFlight -= 1;
+    }
+  };
   const openFreshSession = async (expectedGeneration) => {
     const initialized = shared.initializeResult;
     if (initialized === void 0) {
@@ -26540,7 +26923,7 @@ function createExecutorSession({
       initialized.agentCapabilities
     );
     const additionalDirectories = options.additionalDirectories !== void 0 && options.additionalDirectories.length > 0 ? { additionalDirectories: options.additionalDirectories } : {};
-    const created = await connection.request("session/new", {
+    const created = await requestSession("session/new", {
       cwd: options.cwd,
       mcpServers,
       ...additionalDirectories
@@ -26657,7 +27040,13 @@ function createExecutorSession({
     return applyOnce(input2.state, input2.acpSessionId, input2.setup, false);
   };
   const startOnce = async (expectedGeneration) => {
-    const initializePayload = acpInitializePayload(options.clientInfo, options.clientCapabilities);
+    const initializePayload = acpInitializePayload(
+      options.clientInfo,
+      acpCapabilityOverrides({
+        clientCapabilities: options.clientCapabilities,
+        subagentSessions: options.subagentSessions
+      })
+    );
     const initialized = await connection.request(
       "initialize",
       initializePayload
@@ -26681,7 +27070,7 @@ function createExecutorSession({
     let setup;
     let nextSessionId;
     if (options.resumeSessionId && options.resumeMethod === "session/resume") {
-      setup = await connection.request("session/resume", {
+      setup = await requestSession("session/resume", {
         sessionId: options.resumeSessionId,
         cwd: options.cwd,
         mcpServers,
@@ -26691,7 +27080,7 @@ function createExecutorSession({
     } else if (options.resumeSessionId) {
       shared.sessionLoadInFlight = true;
       try {
-        setup = await connection.request("session/load", {
+        setup = await requestSession("session/load", {
           sessionId: options.resumeSessionId,
           cwd: options.cwd,
           mcpServers,
@@ -26706,7 +27095,7 @@ function createExecutorSession({
       });
       nextSessionId = options.resumeSessionId;
     } else {
-      const created = await connection.request("session/new", {
+      const created = await requestSession("session/new", {
         cwd: options.cwd,
         mcpServers,
         ...additionalDirectories
@@ -26891,6 +27280,127 @@ function createExecutorSettlement({
   return { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification };
 }
 
+// ../../packages/ycodium-acp-executor/src/executor/subagent-sessions.ts
+function parseState(raw) {
+  if (!isRecord(raw)) return { status: void 0, error: void 0 };
+  const state = raw["state"];
+  if (state === "running") return { status: "running", error: void 0 };
+  if (state === "requires_action") return { status: "waiting", error: void 0 };
+  if (state !== "idle") return { status: void 0, error: void 0 };
+  const stopReason = raw["stopReason"];
+  const error62 = isRecord(raw["error"]) ? asTrimmedString(raw["error"]["message"]) : void 0;
+  if (stopReason === "error" || isRecord(raw["error"])) return { status: "failed", error: error62 };
+  if (stopReason === "cancelled") return { status: "cancelled", error: void 0 };
+  return { status: "idle", error: void 0 };
+}
+function childLinkage(childId, record2) {
+  return {
+    taskType: "subagent",
+    rosterKind: "subagent",
+    nativeSessionId: childId,
+    timelineBypass: true,
+    ...record2.title === void 0 ? {} : { title: record2.title }
+  };
+}
+function createSubagentSessionTracker(registry2) {
+  const observe = (notification, ctx) => {
+    const update = notification.update;
+    if (!isRecord(update) || update["sessionUpdate"] !== "subagent_update") return [];
+    const childId = asTrimmedString(update["sessionId"]);
+    if (childId === void 0 || ctx.ownSessionIds.has(childId)) return [];
+    const outerId = notification.sessionId;
+    const nested = registry2.has(outerId);
+    if (ctx.foreign && !nested) return [];
+    if (outerId === childId) return [];
+    const title = asTrimmedString(update["title"]);
+    const description = asTrimmedString(update["description"]);
+    const state = parseState(update["state"]);
+    let record2 = registry2.get(childId);
+    if (record2 === void 0) {
+      record2 = {
+        turnId: ctx.turnId,
+        title,
+        description,
+        parentAgentId: nested ? outerId : void 0,
+        observed: state.status,
+        reported: void 0,
+        reportedError: void 0,
+        // 重放里恢复的身份：宿主早有这一行，不再发 started。
+        announced: ctx.silent,
+        pendingMetadata: false
+      };
+      registry2.add(childId, record2);
+    }
+    record2.turnId ??= ctx.turnId;
+    if (!ctx.silent) {
+      if (title !== void 0 && title !== record2.title || description !== void 0 && description !== record2.description) {
+        record2.pendingMetadata = true;
+      }
+    }
+    if (title !== void 0) record2.title = title;
+    if (description !== void 0) record2.description = description;
+    if (state.status !== void 0) record2.observed = state.status;
+    if (ctx.silent) return [];
+    const linkage2 = childLinkage(childId, record2);
+    const turn = record2.turnId === void 0 ? {} : { turnId: record2.turnId };
+    const events = [];
+    if (!record2.announced && state.status === void 0) return events;
+    if (!record2.announced) {
+      record2.announced = true;
+      record2.pendingMetadata = false;
+      events.push({
+        type: "task.started",
+        ...turn,
+        payload: {
+          taskId: childId,
+          ...linkage2,
+          ...record2.description === void 0 ? {} : { description: record2.description }
+        }
+      });
+    }
+    const statusChanged = state.status !== void 0 && (state.status !== record2.reported || record2.pendingMetadata || state.error !== void 0 && state.error !== record2.reportedError);
+    if (statusChanged) {
+      record2.pendingMetadata = false;
+      record2.reported = state.status;
+      record2.reportedError = state.status === "failed" ? state.error ?? record2.reportedError : void 0;
+      events.push({
+        type: "task.updated",
+        ...turn,
+        payload: {
+          taskId: childId,
+          status: state.status,
+          ...state.error === void 0 ? {} : { error: state.error },
+          ...record2.description === void 0 ? {} : { description: record2.description },
+          ...linkage2
+        }
+      });
+    }
+    return events;
+  };
+  const settleSessionEnded = () => {
+    const events = [];
+    for (const [childId, record2] of registry2.entries()) {
+      const last = record2.reported ?? record2.observed;
+      if (!record2.announced || last !== "running" && last !== "waiting") continue;
+      record2.reported = "idle";
+      record2.observed = "idle";
+      events.push({
+        type: "task.updated",
+        ...record2.turnId === void 0 ? {} : { turnId: record2.turnId },
+        payload: {
+          taskId: childId,
+          status: "idle",
+          outcomeUnknown: true,
+          ...record2.description === void 0 ? {} : { description: record2.description },
+          ...childLinkage(childId, record2)
+        }
+      });
+    }
+    return events;
+  };
+  return { observe, settleSessionEnded };
+}
+
 // ../../packages/ycodium-acp-executor/src/executor/updates.ts
 var COMPACTION_SUMMARY_MAX_CHARS = 8e3;
 var SHOWN_TOOL_CALL_LIMIT = 256;
@@ -26909,6 +27419,8 @@ function createExecutorUpdates({
   shared
 }) {
   const shownToolCallIds = /* @__PURE__ */ new Set();
+  const markChildSession = shared.childSessions.mark;
+  const subagentSessions = options.subagentSessions === true ? createSubagentSessionTracker(shared.childSessions) : void 0;
   const emitCompactionState = (record2, state) => {
     const summary = record2.summary?.trim() ?? "";
     const truncated = summary.length > COMPACTION_SUMMARY_MAX_CHARS;
@@ -26994,6 +27506,30 @@ function createExecutorUpdates({
       return;
     }
   };
+  const emitTaskEvents = (taskEvents) => {
+    for (const taskEvent of taskEvents ?? []) {
+      emit({
+        type: taskEvent.type,
+        ...stamp(),
+        provider: options.provider,
+        threadId: options.threadId,
+        ...taskEvent.turnId !== void 0 ? { turnId: taskEvent.turnId } : {},
+        payload: taskEvent.payload
+      });
+    }
+  };
+  const toolSubagents = hooks.toolSubagents === void 0 ? void 0 : createToolSubagentTracker(hooks.toolSubagents);
+  const settleToolSubagents = (settlement, turnId) => emitTaskEvents(toolSubagents?.settle(settlement, turnId));
+  const settleSessionEnded = () => {
+    settleToolSubagents("session-ended");
+    emitTaskEvents(subagentSessions?.settleSessionEnded());
+    emitTaskEvents(hooks.onSessionEnded?.());
+  };
+  const observeContext = () => ({
+    turnId: shared.activeTurnId,
+    sessionId: shared.sessionId,
+    markChildSession
+  });
   const handleSessionUpdate = (params) => {
     const parsed = parseSessionUpdateEvent(params);
     if (parsed.modeId && shared.modeState) {
@@ -27020,43 +27556,39 @@ function createExecutorUpdates({
           rawTitle: params.update.title,
           nowMs
         });
-        const hookResult = hooks.onToolCallUpdated?.({
+        const hasToolHooks = toolSubagents !== void 0 || hooks.onToolCallUpdated !== void 0;
+        const call = !hasToolHooks ? void 0 : {
           toolCallId: nextToolCall.toolCallId,
           status: nextToolCall.status,
           title: nextToolCall.title,
           kind: nextToolCall.kind,
           rawInput: nextToolCall.data["rawInput"],
           rawOutput: nextToolCall.data["rawOutput"],
+          contentText: nextToolCall.contentText,
           meta: params.update._meta,
           turnId: shared.activeTurnId
-        });
-        const taskEvents = hookResult === void 0 ? [] : "events" in hookResult ? hookResult.events : hookResult;
+        };
+        const hookResult = call === void 0 ? void 0 : toolSubagents?.onToolCallUpdated(call) ?? hooks.onToolCallUpdated?.(call);
         const handledByHook = hookResult !== void 0 && "events" in hookResult && hookResult.handled === true;
-        for (const taskEvent of taskEvents) {
-          emit({
-            type: taskEvent.type,
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            ...taskEvent.turnId !== void 0 ? { turnId: taskEvent.turnId } : {},
-            payload: taskEvent.payload
-          });
-        }
+        emitTaskEvents(
+          hookResult === void 0 ? [] : "events" in hookResult ? hookResult.events : hookResult
+        );
         if (nextToolCall.status === "completed" && hookResult && "artifacts" in hookResult)
           emitArtifacts(hookResult.artifacts ?? [], nextToolCall.toolCallId);
         if (handledByHook || !decision.emit) {
           continue;
         }
+        const toolTurnId = (hookResult !== void 0 && "events" in hookResult ? hookResult.turnId : void 0) ?? shared.activeTurnId;
         if (!shownToolCallIds.has(nextToolCall.toolCallId)) {
           rememberShownToolCall(nextToolCall.toolCallId);
-          closeActiveAssistantSegment(shared.activeTurnId);
+          if (toolTurnId === shared.activeTurnId) closeActiveAssistantSegment(shared.activeTurnId);
         }
         emit(
           makeAcpToolCallEvent({
             stamp: stamp(),
             provider: options.provider,
             threadId: options.threadId,
-            turnId: shared.activeTurnId,
+            turnId: toolTurnId,
             toolCall: nextToolCall,
             rawPayload: event.rawPayload
           })
@@ -27133,7 +27665,36 @@ function createExecutorUpdates({
       }
     }
   };
-  return { emitCompactionState, handleSessionUpdate };
+  const receiveSessionUpdate = (params) => {
+    const foreign = !shared.ownSessionIds.has(params.sessionId) && (shared.childSessions.has(params.sessionId) || shared.sessionOpensInFlight === 0 && shared.ownSessionIds.size > 0);
+    emitTaskEvents(
+      subagentSessions?.observe(params, {
+        turnId: shared.activeTurnId,
+        foreign,
+        ownSessionIds: shared.ownSessionIds,
+        silent: shared.sessionLoadInFlight
+      })
+    );
+    if (!shared.sessionLoadInFlight) {
+      if (hooks.onSessionUpdate) {
+        emitTaskEvents(hooks.onSessionUpdate(params, { ...observeContext(), foreign }));
+      }
+    }
+    if (!foreign) handleSessionUpdate(params);
+  };
+  const receiveExtensionNotification = (method, params) => {
+    if (shared.sessionLoadInFlight || !hooks.onExtensionNotification) return;
+    const result = hooks.onExtensionNotification(method, params, observeContext());
+    if (Array.isArray(result)) emitTaskEvents(result);
+  };
+  return {
+    emitCompactionState,
+    receiveSessionUpdate,
+    receiveExtensionNotification,
+    settleToolSubagents,
+    settleSessionEnded,
+    toolSubagentsMayRun: () => toolSubagents?.mayStillRun() ?? false
+  };
 }
 
 // ../../packages/ycodium-acp-executor/src/openCommands.ts
@@ -27282,7 +27843,10 @@ function createAcpExecutor(options) {
     abortLocalPrompt: void 0,
     connectionClosed: false,
     sessionLoadInFlight: false,
-    droppedReplayUpdates: 0
+    droppedReplayUpdates: 0,
+    ownSessionIds: /* @__PURE__ */ new Set(),
+    childSessions: createChildSessionRegistry(),
+    sessionOpensInFlight: 0
   };
   const interruptedTurnIds = /* @__PURE__ */ new Set();
   const approvals = createApprovalGate({
@@ -27312,7 +27876,14 @@ function createAcpExecutor(options) {
     promptMutex,
     shared
   });
-  const { emitCompactionState, handleSessionUpdate } = createExecutorUpdates({
+  const {
+    emitCompactionState,
+    receiveSessionUpdate,
+    receiveExtensionNotification,
+    settleToolSubagents,
+    settleSessionEnded,
+    toolSubagentsMayRun
+  } = createExecutorUpdates({
     emit,
     stamp,
     options,
@@ -27375,11 +27946,11 @@ function createAcpExecutor(options) {
       if (notification.method === "session/update") {
         const params = notification.params;
         const transformed = hooks.transformSessionUpdate ? hooks.transformSessionUpdate(params) : params;
-        if (transformed !== void 0) handleSessionUpdate(transformed);
+        if (transformed !== void 0) receiveSessionUpdate(transformed);
         return;
       }
       if (settleFromNotification(notification.method, notification.params)) return;
-      void hooks.onExtensionNotification?.(notification.method, notification.params);
+      receiveExtensionNotification(notification.method, notification.params);
     },
     onRequest: async (method, params) => {
       if (method === CLIENT_METHODS.session_request_permission) {
@@ -27435,6 +28006,7 @@ function createAcpExecutor(options) {
   });
   const { sendPromptRpc, prompt } = createExecutorPrompt({
     promptResults,
+    settleToolSubagents,
     isLive,
     closeActiveAssistantSegment,
     emit,
@@ -27459,6 +28031,8 @@ function createAcpExecutor(options) {
     dispose: disposeLifecycle
   } = createExecutorLifecycle({
     promptResults,
+    settleToolSubagents,
+    settleSessionEnded,
     failIfDisposed,
     requireStarted,
     interruptedTurnIds,
@@ -27507,6 +28081,7 @@ function createAcpExecutor(options) {
     setNativeMode,
     compact,
     openToolCalls: () => readOpenToolCalls(toolCalls, shared.activeTurnId),
+    toolSubagentsMayRun,
     dispose: (exitCode) => {
       disposeOnce ??= (async () => {
         try {
@@ -27849,11 +28424,11 @@ function parseKimiContextWindow(contents) {
   let usedTokens;
   let maxTokens;
   for (const line of contents.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
+    const trimmed2 = line.trim();
+    if (trimmed2.length === 0) continue;
     let record2;
     try {
-      record2 = JSON.parse(trimmed);
+      record2 = JSON.parse(trimmed2);
     } catch {
       continue;
     }
@@ -28399,13 +28974,13 @@ function kimiProbeModels(stdout) {
   if (!isRecord9(models)) return void 0;
   const out = [];
   for (const [slug, entry] of Object.entries(models)) {
-    const trimmed = slug.trim();
-    if (trimmed.length === 0 || !isRecord9(entry)) continue;
+    const trimmed2 = slug.trim();
+    if (trimmed2.length === 0 || !isRecord9(entry)) continue;
     const name = asString4(entry["displayName"]);
     const contextWindow = positiveInt2(entry["maxContextSize"]);
     const effort = kimiEffortDescriptor(entry);
     out.push({
-      slug: trimmed,
+      slug: trimmed2,
       ...name === void 0 ? {} : { name },
       ...contextWindow === void 0 ? {} : { contextWindow },
       ...effort === void 0 ? {} : { capabilities: { optionDescriptors: [effort] } }
@@ -28549,6 +29124,134 @@ function acpSessionModeToApply(requestedNativeModeId, startedModeId) {
   return requestedNativeModeId !== void 0 && requestedNativeModeId !== startedModeId ? requestedNativeModeId : void 0;
 }
 
+// src/subagents.ts
+var SUBAGENT_TITLE = "Kimi subagent";
+var SWARM_TITLE = "Kimi agent swarm";
+var FOREGROUND_ENDED_DESCRIPTION = "Turn ended before Kimi reported this agent's result.";
+var BACKGROUND_ENDED_DESCRIPTION = "Running in the background. Kimi does not report when it finishes.";
+var SINGLE_TITLE = /^Launching (background )?(\S+) agent: ([\s\S]*)$/u;
+var SWARM_TITLE_PREFIX = "Launching agent swarm: ";
+var isRecord10 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var trimmed = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+function classify(input2) {
+  if (input2.kind !== void 0 && input2.kind !== "other") return void 0;
+  const title = input2.title;
+  if (title === void 0) return void 0;
+  if (title === "AgentSwarm" || title.startsWith(SWARM_TITLE_PREFIX)) return "swarm";
+  return title === "Agent" || SINGLE_TITLE.test(title) ? "subagent" : void 0;
+}
+function requestedModel(value) {
+  const model = trimmed(value);
+  return model === "primary" ? void 0 : model;
+}
+function describe3(kind, input2, previous) {
+  const raw = isRecord10(input2.rawInput) ? input2.rawInput : {};
+  if (kind === "swarm") {
+    const fromTitle = input2.title?.startsWith(SWARM_TITLE_PREFIX) ? trimmed(input2.title.slice(SWARM_TITLE_PREFIX.length)) : void 0;
+    return {
+      title: SWARM_TITLE,
+      description: trimmed(raw["description"]) ?? fromTitle ?? previous?.description ?? SWARM_TITLE
+    };
+  }
+  const match = input2.title === void 0 ? null : SINGLE_TITLE.exec(input2.title);
+  const title = trimmed(raw["description"]) ?? trimmed(match?.[3]) ?? previous?.title;
+  const role = match?.[2] ?? trimmed(raw["subagent_type"]) ?? previous?.role;
+  const model = requestedModel(raw["model"]) ?? previous?.model;
+  return {
+    title: title ?? SUBAGENT_TITLE,
+    description: title ?? SUBAGENT_TITLE,
+    ...role === void 0 ? {} : { role },
+    ...model === void 0 ? {} : { model }
+  };
+}
+function splitResult(text) {
+  const lines = text.split(/\r?\n/u);
+  const header = /* @__PURE__ */ new Map();
+  let index = 0;
+  for (; index < lines.length; index += 1) {
+    const match = /^([a-z_]+): ?(.*)$/u.exec(lines[index] ?? "");
+    if (match === null) break;
+    header.set(match[1] ?? "", match[2] ?? "");
+  }
+  return { header, body: lines.slice(index).join("\n").trim() };
+}
+function stripTrailingHints(body) {
+  const cuts = ["\nresume_hint: ", "\nnext_step: "].map((marker) => body.lastIndexOf(marker)).filter((position) => position >= 0);
+  return (cuts.length === 0 ? body : body.slice(0, Math.min(...cuts))).trim();
+}
+function parseAgentResult(text, isError) {
+  if (text === void 0)
+    return {
+      kind: isError ? "failed" : "completed",
+      summary: void 0,
+      role: void 0,
+      agentId: void 0
+    };
+  const { header, body } = splitResult(text);
+  const role = trimmed(header.get("actual_subagent_type"));
+  const agentId = trimmed(header.get("agent_id"));
+  const status = header.get("status");
+  if (status === "running" && header.has("task_id")) {
+    return { kind: "background", summary: void 0, role, agentId };
+  }
+  if (isError || status === "failed") {
+    return {
+      kind: header.get("stop_reason") === "cancelled" ? "cancelled" : "failed",
+      summary: trimmed(stripTrailingHints(body)) ?? trimmed(text),
+      role,
+      agentId
+    };
+  }
+  const marker = "[summary]";
+  const content = body.startsWith(marker) ? body.slice(marker.length) : body;
+  const answer = trimmed(stripTrailingHints(content));
+  const notice = trimmed(header.get("notice"));
+  const summary = [notice === void 0 ? void 0 : `notice: ${notice}`, answer].filter((part) => part !== void 0).join("\n\n");
+  return { kind: "completed", summary: trimmed(summary), role, agentId };
+}
+function parseSwarmResult(text, isError) {
+  const inner = text === void 0 ? void 0 : /<summary>([\s\S]*?)<\/summary>/u.exec(text)?.[1];
+  return {
+    kind: isError ? "failed" : "completed",
+    summary: trimmed(inner) ?? trimmed(text),
+    role: void 0,
+    agentId: void 0
+  };
+}
+function resolveOutcome(call, kind) {
+  if (call.status !== "completed" && call.status !== "failed") return void 0;
+  const text = typeof call.rawOutput === "string" ? trimmed(call.rawOutput) : void 0;
+  const isError = call.status === "failed";
+  if (text === void 0 && !isError) return void 0;
+  const outcome = kind === "swarm" ? parseSwarmResult(text, isError) : parseAgentResult(text, isError);
+  const ids = {
+    ...outcome.role === void 0 ? {} : { role: outcome.role },
+    ...outcome.agentId === void 0 ? {} : { agentRef: outcome.agentId }
+  };
+  if (outcome.kind === "background") return { type: "background", ...ids };
+  return {
+    type: "final",
+    status: outcome.kind,
+    keepToolRow: true,
+    ...ids,
+    ...outcome.kind === "cancelled" || outcome.summary === void 0 ? {} : { summary: boundTailText(outcome.summary) }
+  };
+}
+var asKind = (kind) => kind === "swarm" ? "swarm" : "subagent";
+var kimiToolSubagents = {
+  recognize: classify,
+  // 首帧没有入参：等带参数的那一帧再判断是新 agent 还是续接。
+  ready: (call) => call.rawInput !== void 0,
+  facts: (call, kind, previous) => describe3(asKind(kind), call, previous),
+  announce: "started",
+  resolve: (call, kind) => resolveOutcome(call, asKind(kind)),
+  resumes: (call, kind) => {
+    if (asKind(kind) !== "subagent" || !isRecord10(call.rawInput)) return void 0;
+    return trimmed(call.rawInput["resume"]);
+  },
+  endNote: ({ background }) => background ? { description: BACKGROUND_ENDED_DESCRIPTION, timelineBypass: true } : { description: FOREGROUND_ENDED_DESCRIPTION }
+};
+
 // src/kimiInstance.ts
 var RESUME_SCHEMA_VERSION = 1;
 var CLIENT_INFO = { name: "ycodium-agent-kimi", version: "0.1.0" };
@@ -28631,6 +29334,7 @@ function kimiHooks(recipe) {
   const homePath = resolveHomePath(recipe);
   return {
     permissionUserInput: kimiPermissionUserInput,
+    toolSubagents: kimiToolSubagents,
     readContextWindow: ({ sessionId }) => readKimiContextWindow({ homePath, acpSessionId: sessionId })
   };
 }
@@ -28798,9 +29502,7 @@ var createKimiInstance = (config2, host) => {
         ...resume === void 0 ? {} : { resumeSessionId: resume.sessionId }
       });
       const forwarding = (async () => {
-        for await (const event of executor.events) {
-          events.push(event);
-        }
+        for await (const event of executor.events) events.push(event);
       })();
       try {
         throwIfStartAborted(signal);
@@ -28970,7 +29672,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-kimi",
-  apiVersion: 47,
+  apiVersion: 49,
   executors,
   activate(ctx) {
     ctx.log.info("Kimi Code executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-kimi",
-  "version": "0.2.3576",
+  "version": "0.2.3608",
   "description": "Kimi Code executor: runs `kimi acp` over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3576",
-    "ycodium-acp-executor": "0.2.3576",
+    "ycodium-acp-executor": "0.2.3608",
+    "@ycodium-ai/plugin-api": "0.2.3608",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {