@ycodium-ai/agent-grok 0.2.3598 → 0.2.3608

package/dist/index.js

@@ -77,7 +77,9 @@ var GROK_CARD = {
     nativeModeSwitch: true,
     // 压缩走 CLI 宣告过的 `/compact` 命令（见 `compactContext`），进度与结果由执行器按
     // 压缩生命周期事件报；CLI 没宣告这条命令时 `compactContext` 拒绝，不退回发文本。
-    contextCompaction: "native"
+    contextCompaction: "native",
+    // 子 agent 经父会话上的 subagent_* 通知报成 task.*（grokSubagents.ts）。
+    reportsSpawnedAgents: true
   },
   // 凭据由 CLI 自己保管在 `<GROK_HOME>/auth.json`，宿主读它只认 `/token`。
   credentialSources: [
@@ -204,13 +206,13 @@ function createApprovalGate(input2) {
   };
   const settleAll = (outcome) => {
     const entries = list();
-    const settled = [];
+    const settled2 = [];
     for (const entry of entries) {
       if (settle2(entry, outcome)) {
-        settled.push(entry);
+        settled2.push(entry);
       }
     }
-    return settled;
+    return settled2;
   };
   return {
     add,
@@ -651,13 +653,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(text3) {
-  if (text3.length <= TOOL_CALL_CONTENT_MAX_CHARS) {
-    return text3;
+function boundTailText(text4, limit = TOOL_CALL_CONTENT_MAX_CHARS) {
+  if (text4.length <= limit) {
+    return text4;
   }
-  const tail = text3.slice(text3.length - TOOL_CALL_CONTENT_MAX_CHARS);
+  const tail = text4.slice(text4.length - limit);
   return `${TOOL_CALL_CONTENT_TRUNCATION_MARKER}${tail}`;
 }
+var boundToolCallOutputText = (text4) => boundTailText(text4);
 var RAW_OUTPUT_TEXT_FIELDS = ["content", "stdout", "stderr", "output"];
 function boundToolCallRawOutput(rawOutput) {
   if (!isRecord(rawOutput)) {
@@ -687,9 +690,9 @@ function extractTextContentFromToolCallContent(content) {
   const typed = content;
   const chunks = [];
   for (const entry of typed) {
-    const text3 = toolCallContentText(entry)?.trim();
-    if (text3) {
-      chunks.push(text3);
+    const text4 = toolCallContentText(entry)?.trim();
+    if (text4) {
+      chunks.push(text4);
     }
   }
   if (chunks.length === 0) {
@@ -769,6 +772,7 @@ function makeToolCallState(input2, options) {
     ...status ? { status } : {},
     ...command ? { command } : {},
     ...presentation?.detail ? { detail: presentation.detail } : {},
+    ...textContent ? { contentText: textContent } : {},
     data
   };
 }
@@ -779,6 +783,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 } : {},
@@ -786,6 +791,7 @@ function mergeToolCallState(previous, next) {
     ...status ? { status } : {},
     ...command ? { command } : {},
     ...detail ? { detail } : {},
+    ...contentText ? { contentText } : {},
     data: {
       ...previous?.data,
       ...next.data
@@ -1063,11 +1069,11 @@ function parseSessionUpdateEvent(params) {
       const contentType = content?.["type"];
       const streamKind = kind === "agent_thought_chunk" ? "reasoning_text" : "assistant_text";
       if (contentType === "text") {
-        const text3 = typeof content?.["text"] === "string" ? content["text"] : "";
-        if (text3.length > 0) {
+        const text4 = typeof content?.["text"] === "string" ? content["text"] : "";
+        if (text4.length > 0) {
           events.push({
             _tag: "ContentDelta",
-            text: text3,
+            text: text4,
             streamKind,
             rawPayload: params
           });
@@ -1100,9 +1106,9 @@ function parseSessionUpdateEvent(params) {
     case "compaction_summary_chunk": {
       const compactionId = readAcpText(upd, "compactionId");
       const content = isRecord(upd["content"]) ? upd["content"] : void 0;
-      const text3 = content?.["type"] === "text" ? content["text"] : void 0;
-      if (compactionId === void 0 || typeof text3 !== "string" || text3.length === 0) break;
-      events.push({ _tag: "CompactionSummaryChunk", compactionId, text: text3 });
+      const text4 = content?.["type"] === "text" ? content["text"] : void 0;
+      if (compactionId === void 0 || typeof text4 !== "string" || text4.length === 0) break;
+      events.push({ _tag: "CompactionSummaryChunk", compactionId, text: text4 });
       break;
     }
     default:
@@ -1332,6 +1338,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, record4] of records) {
+      if (!active(record4.observed)) continue;
+      protectedIds.add(id);
+      let parent = record4.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, record4) => {
+    records.set(sessionId, record4);
+    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",
@@ -2598,14 +2652,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count2 = units;
+  let count3 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count2--;
+      count3--;
       i++;
     }
   }
-  return count2;
+  return count3;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -6960,8 +7014,8 @@ function az_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getBelarusianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -9608,8 +9662,8 @@ function hu_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count2, one, many) {
-  return Math.abs(count2) === 1 ? one : many;
+function getArmenianPlural(count3, one, many) {
+  return Math.abs(count3) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -10693,8 +10747,8 @@ function ko_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text3) => {
-  return text3.charAt(0).toUpperCase() + text3.slice(1);
+var capitalizeFirstCharacter = (text4) => {
+  return text4.charAt(0).toUpperCase() + text4.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -12347,8 +12401,8 @@ function ro_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getRussianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -17988,8 +18042,8 @@ function rewriteKeyNames(ctx) {
       bySchema.set(entry.schema, entry);
   }
   const rewrites = /* @__PURE__ */ new Map();
-  for (const record3 of pendingRecords.get(ctx) ?? []) {
-    const seen = ctx.seen.get(record3);
+  for (const record4 of pendingRecords.get(ctx) ?? []) {
+    const seen = ctx.seen.get(record4);
     const names = (seen?.def ?? seen?.schema)?.propertyNames;
     if (!names || names === true || rewrites.has(names))
       continue;
@@ -23289,9 +23343,9 @@ var Connection = class {
       return;
     }
     const responseBatch = isResponseBatch(batch);
-    const responseCount = responseBatch ? 0 : batch.reduce((count2, message) => count2 + (isNotificationMessage(message) ? 0 : 1), 0);
+    const responseCount = responseBatch ? 0 : batch.reduce((count3, message) => count3 + (isNotificationMessage(message) ? 0 : 1), 0);
     let remaining = responseCount;
-    let remainingNotifications = batch.reduce((count2, message) => count2 + (isNotificationMessage(message) ? 1 : 0), 0);
+    let remainingNotifications = batch.reduce((count3, message) => count3 + (isNotificationMessage(message) ? 1 : 0), 0);
     let responseSent = false;
     const responses = [];
     const sendResponsesIfReady = async () => {
@@ -25054,8 +25108,8 @@ function createAcpConnection(options) {
     }
     await dispatchMessage(value);
   };
-  const pullEnqueued = async (count2) => {
-    for (let i = 0; i < count2; i += 1) {
+  const pullEnqueued = async (count3) => {
+    for (let i = 0; i < count3; i += 1) {
       const { value, done } = await incoming.read();
       if (done || value === void 0) {
         return;
@@ -25314,7 +25368,9 @@ function createExecutorLifecycle({
   eventStream,
   onInputDead,
   shared,
-  promptResults
+  promptResults,
+  settleToolSubagents,
+  settleSessionEnded
 }) {
   const cancel = async (turnId) => {
     failIfDisposed();
@@ -25334,8 +25390,8 @@ function createExecutorLifecycle({
       await promptResults.wait(targetTurnId);
       if (targetTurnId !== void 0 && shared.activeTurnId !== targetTurnId && !interruptedTurnIds.has(targetTurnId))
         return;
-      const settled = await waitForPromptIdle(cancelGraceMs);
-      if (!settled) {
+      const settled2 = await waitForPromptIdle(cancelGraceMs);
+      if (!settled2) {
         throw new AcpExecutorCancelTimeoutError();
       }
       if (targetTurnId !== void 0 && isLive(started.generation)) {
@@ -25345,6 +25401,7 @@ function createExecutorLifecycle({
             shared.promptsInFlight = 0;
             shared.activeTurnId = void 0;
             shared.status = "ready";
+            settleToolSubagents("turn-interrupted", targetTurnId);
             emit({
               type: "turn.completed",
               ...stamp(),
@@ -25378,7 +25435,7 @@ function createExecutorLifecycle({
         "Cannot compact while a turn or another compaction is running"
       );
     }
-    const record3 = {
+    const record4 = {
       snapshotId: randomId(),
       trigger: "manual",
       startedAtMs: nowMs(),
@@ -25388,7 +25445,7 @@ function createExecutorLifecycle({
       adopted: false
     };
     await promptMutex.acquire();
-    shared.manualCompaction = record3;
+    shared.manualCompaction = record4;
     const emitSessionState = (state) => {
       emit({
         type: "session.state.changed",
@@ -25401,7 +25458,7 @@ function createExecutorLifecycle({
     try {
       failIfDisposed();
       emitSessionState("compacting");
-      emitCompactionState(record3, "compacting");
+      emitCompactionState(record4, "compacting");
       let response;
       try {
         response = await sendPromptRpc(started.sessionId, [
@@ -25415,13 +25472,13 @@ function createExecutorLifecycle({
       if (response.stopReason === "cancelled") {
         return;
       }
-      if (!record3.finished) {
-        record3.finished = true;
-        emitCompactionState(record3, "compacted");
+      if (!record4.finished) {
+        record4.finished = true;
+        emitCompactionState(record4, "compacted");
       }
     } finally {
       for (const [agentId, tracked] of compactions) {
-        if (tracked === record3) compactions.delete(agentId);
+        if (tracked === record4) compactions.delete(agentId);
       }
       shared.manualCompaction = void 0;
       promptMutex.release();
@@ -25456,6 +25513,7 @@ function createExecutorLifecycle({
       shared.abortLocalPrompt?.();
       promptResults.finishUnreceived();
       await promptResults.wait();
+      settleSessionEnded();
       emit({
         type: "session.exited",
         ...stamp(),
@@ -25508,10 +25566,10 @@ function selectAutoApprovedAcpPermissionOption(request) {
 }
 function parseAcpResumeCursor(raw, schemaVersion) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
-  const record3 = raw;
-  if (record3["schemaVersion"] !== schemaVersion) return void 0;
-  if (typeof record3["sessionId"] !== "string" || !record3["sessionId"].trim()) return void 0;
-  return { sessionId: record3["sessionId"].trim() };
+  const record4 = raw;
+  if (record4["schemaVersion"] !== schemaVersion) return void 0;
+  if (typeof record4["sessionId"] !== "string" || !record4["sessionId"].trim()) return void 0;
+  return { sessionId: record4["sessionId"].trim() };
 }
 function acpPromptSettlementBelongsToContext(input2) {
   return input2.liveAcpSessionId === input2.expectedAcpSessionId && (input2.liveActiveTurnId === input2.turnId || input2.liveSessionActiveTurnId === input2.turnId);
@@ -25520,18 +25578,18 @@ function isAcpRequestPermissionParams(value) {
   if (typeof value !== "object" || value === null) {
     return false;
   }
-  const record3 = value;
-  if (typeof record3["sessionId"] !== "string") {
+  const record4 = value;
+  if (typeof record4["sessionId"] !== "string") {
     return false;
   }
-  const toolCall = record3["toolCall"];
+  const toolCall = record4["toolCall"];
   if (typeof toolCall !== "object" || toolCall === null) {
     return false;
   }
   if (typeof toolCall["toolCallId"] !== "string") {
     return false;
   }
-  return Array.isArray(record3["options"]);
+  return Array.isArray(record4["options"]);
 }
 
 // ../../packages/ycodium-acp-executor/src/failureCategory.ts
@@ -25559,6 +25617,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,
@@ -25578,7 +25934,8 @@ function createExecutorPrompt({
   applyRequestedModel,
   notifyPromptSettled,
   shared,
-  promptResults
+  promptResults,
+  settleToolSubagents
 }) {
   const settleTurn = (input2) => {
     if (!isLive(input2.expectedGeneration) || input2.record.finished) {
@@ -25602,6 +25959,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(),
@@ -25619,7 +25980,7 @@ function createExecutorPrompt({
     promptResults.forget(input2.turnId);
     return true;
   };
-  const sendPromptRpc = async (sessionId, promptParts, onWritten, record3) => {
+  const sendPromptRpc = async (sessionId, promptParts, onWritten, record4) => {
     const settlementHooks = hooks.promptSettlement;
     const promptKey = settlementHooks === void 0 ? void 0 : randomId();
     const pending = connection.begin(
@@ -25629,7 +25990,7 @@ function createExecutorPrompt({
         prompt: promptParts,
         ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
       },
-      record3?.promptId
+      record4?.promptId
     );
     void pending.written.then(onWritten, () => void 0);
     const promptRpc = pending.response;
@@ -25641,10 +26002,10 @@ function createExecutorPrompt({
         promptKey,
         sessionId,
         settle: settleEarly,
-        ...record3 === void 0 ? {} : {
-          onResponse: (response) => promptResults.receive(record3.promptId, response),
-          onError: () => promptResults.reject(record3.promptId),
-          hasResult: () => record3.response !== void 0
+        ...record4 === void 0 ? {} : {
+          onResponse: (response) => promptResults.receive(record4.promptId, response),
+          onError: () => promptResults.reject(record4.promptId),
+          hasResult: () => record4.response !== void 0
         }
       };
       try {
@@ -25672,11 +26033,11 @@ function createExecutorPrompt({
     failIfPromptUnavailable();
     const started = requireStarted();
     let sessionId = started.sessionId;
-    let record3;
+    let record4;
     const settle2 = (rest) => settleTurn({
       expectedGeneration: started.generation,
       expectedSessionId: sessionId,
-      record: record3,
+      record: record4,
       ...rest
     });
     let turnId;
@@ -25689,7 +26050,7 @@ function createExecutorPrompt({
         randomId
       );
       shared.promptsInFlight += 1;
-      record3 = promptResults.add(
+      record4 = promptResults.add(
         {
           promptId: randomId(),
           sessionId: started.sessionId,
@@ -25718,9 +26079,9 @@ function createExecutorPrompt({
     const promptParts = input2.prompt ?? (input2.text !== void 0 ? [{ type: "text", text: input2.text }] : [{ type: "text", text: "" }]);
     let contextWindow;
     const finishPrompt = () => {
-      if (!isLive(started.generation) || record3.finished) throw new AcpExecutorDisposedError();
-      const response2 = record3.response;
-      if (record3.interrupted || response2 === void 0) {
+      if (!isLive(started.generation) || record4.finished) throw new AcpExecutorDisposedError();
+      const response2 = record4.response;
+      if (record4.interrupted || response2 === void 0) {
         settle2({ turnId, stopReason: "cancelled", state: "cancelled" });
         return { threadId: options.threadId, turnId, stopReason: "cancelled" };
       }
@@ -25769,7 +26130,7 @@ function createExecutorPrompt({
           });
           shared.modelSelectionState = applied.state;
           sessionId = applied.sessionId;
-          record3.sessionId = applied.sessionId;
+          record4.sessionId = applied.sessionId;
         } catch (error62) {
           const failureCategory = readAcpFailureCategory(error62);
           if (failureCategory === "model-unavailable") {
@@ -25801,7 +26162,7 @@ function createExecutorPrompt({
             written = true;
             input2.onDispatched?.(turnId);
           },
-          record3
+          record4
         );
       } catch (error62) {
         if (shared.disposed) {
@@ -25841,7 +26202,7 @@ function createExecutorPrompt({
     if (turnId === void 0) {
       throw new AcpExecutorError("internal", "ACP prompt settled without a turn id");
     }
-    if (record3.finished) throw new AcpExecutorDisposedError();
+    if (record4.finished) throw new AcpExecutorDisposedError();
     if (hooks.readContextWindow !== void 0) {
       try {
         contextWindow = await hooks.readContextWindow({
@@ -25877,7 +26238,7 @@ function createPromptResults({
   const prompts = /* @__PURE__ */ new Map();
   const add = (identity, finish) => {
     const { promise: done, resolve: resolve2 } = Promise.withResolvers();
-    const record3 = {
+    const record4 = {
       ...identity,
       finish,
       done,
@@ -25886,49 +26247,49 @@ function createPromptResults({
       interrupted: false,
       finished: false
     };
-    prompts.set(record3.promptId, record3);
-    return record3;
+    prompts.set(record4.promptId, record4);
+    return record4;
   };
   const receive = (promptId, response) => {
-    const record3 = prompts.get(promptId);
-    if (!record3 || record3.finished || record3.rejected || record3.response !== void 0) return;
-    if (shared.disposed || shared.generation !== record3.generation || shared.sessionId !== record3.sessionId)
+    const record4 = prompts.get(promptId);
+    if (!record4 || record4.finished || record4.rejected || record4.response !== void 0) return;
+    if (shared.disposed || shared.generation !== record4.generation || shared.sessionId !== record4.sessionId)
       return;
-    record3.response = response;
+    record4.response = response;
   };
   const reject = (promptId) => {
-    const record3 = prompts.get(promptId);
-    if (record3 && record3.response === void 0) record3.rejected = true;
+    const record4 = prompts.get(promptId);
+    if (record4 && record4.response === void 0) record4.rejected = true;
   };
   const stop = (turnId) => {
-    for (const record3 of prompts.values()) {
-      if (!record3.finished && (turnId === void 0 || record3.turnId === turnId) && record3.response === void 0) {
-        record3.interrupted = true;
+    for (const record4 of prompts.values()) {
+      if (!record4.finished && (turnId === void 0 || record4.turnId === turnId) && record4.response === void 0) {
+        record4.interrupted = true;
       }
     }
   };
-  const complete = (record3) => {
-    record3.finished = true;
-    record3.resolve();
+  const complete = (record4) => {
+    record4.finished = true;
+    record4.resolve();
   };
-  const hasInterrupted = (turnId) => [...prompts.values()].some((record3) => record3.turnId === turnId && record3.interrupted);
+  const hasInterrupted = (turnId) => [...prompts.values()].some((record4) => record4.turnId === turnId && record4.interrupted);
   const forget = (turnId) => {
-    for (const [id, record3] of prompts) {
-      if (record3.turnId === turnId) {
-        complete(record3);
+    for (const [id, record4] of prompts) {
+      if (record4.turnId === turnId) {
+        complete(record4);
         prompts.delete(id);
       }
     }
   };
   const wait = async (turnId, includeUnreceived = false) => {
     const claimed = [...prompts.values()].filter(
-      (record3) => !record3.finished && (includeUnreceived || record3.response !== void 0) && (turnId === void 0 || record3.turnId === turnId)
+      (record4) => !record4.finished && (includeUnreceived || record4.response !== void 0) && (turnId === void 0 || record4.turnId === turnId)
     );
     if (claimed.length === 0) return;
     let timer;
     try {
       const drained = await Promise.race([
-        Promise.all(claimed.map((record3) => record3.done)).then(() => true),
+        Promise.all(claimed.map((record4) => record4.done)).then(() => true),
         new Promise((resolve2) => {
           timer = setTimeout(
             () => resolve2(false),
@@ -25938,19 +26299,19 @@ function createPromptResults({
       ]);
       if (drained) return;
       options.log?.warn?.("ACP result settlement timed out", { threadId: options.threadId });
-      for (const record3 of claimed) if (!record3.finished) record3.finish();
+      for (const record4 of claimed) if (!record4.finished) record4.finish();
     } finally {
       clearTimeout(timer);
     }
   };
   const finishUnreceived = () => {
     const claimedTurns = new Set(
-      [...prompts.values()].filter((record3) => !record3.finished && record3.response !== void 0).map((record3) => record3.turnId)
+      [...prompts.values()].filter((record4) => !record4.finished && record4.response !== void 0).map((record4) => record4.turnId)
     );
-    for (const record3 of prompts.values()) {
-      if (!record3.finished && record3.response === void 0) {
-        if (claimedTurns.has(record3.turnId)) record3.finish();
-        else complete(record3);
+    for (const record4 of prompts.values()) {
+      if (!record4.finished && record4.response === void 0) {
+        if (claimedTurns.has(record4.turnId)) record4.finish();
+        else complete(record4);
       }
     }
   };
@@ -26490,11 +26851,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;
@@ -26576,6 +26945,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) {
@@ -26586,7 +26969,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
@@ -26703,7 +27086,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
@@ -26727,7 +27116,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,
@@ -26737,7 +27126,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,
@@ -26752,7 +27141,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
@@ -26937,6 +27326,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, record4) {
+  return {
+    taskType: "subagent",
+    rosterKind: "subagent",
+    nativeSessionId: childId,
+    timelineBypass: true,
+    ...record4.title === void 0 ? {} : { title: record4.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 record4 = registry2.get(childId);
+    if (record4 === void 0) {
+      record4 = {
+        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, record4);
+    }
+    record4.turnId ??= ctx.turnId;
+    if (!ctx.silent) {
+      if (title !== void 0 && title !== record4.title || description !== void 0 && description !== record4.description) {
+        record4.pendingMetadata = true;
+      }
+    }
+    if (title !== void 0) record4.title = title;
+    if (description !== void 0) record4.description = description;
+    if (state.status !== void 0) record4.observed = state.status;
+    if (ctx.silent) return [];
+    const linkage2 = childLinkage(childId, record4);
+    const turn = record4.turnId === void 0 ? {} : { turnId: record4.turnId };
+    const events = [];
+    if (!record4.announced && state.status === void 0) return events;
+    if (!record4.announced) {
+      record4.announced = true;
+      record4.pendingMetadata = false;
+      events.push({
+        type: "task.started",
+        ...turn,
+        payload: {
+          taskId: childId,
+          ...linkage2,
+          ...record4.description === void 0 ? {} : { description: record4.description }
+        }
+      });
+    }
+    const statusChanged = state.status !== void 0 && (state.status !== record4.reported || record4.pendingMetadata || state.error !== void 0 && state.error !== record4.reportedError);
+    if (statusChanged) {
+      record4.pendingMetadata = false;
+      record4.reported = state.status;
+      record4.reportedError = state.status === "failed" ? state.error ?? record4.reportedError : void 0;
+      events.push({
+        type: "task.updated",
+        ...turn,
+        payload: {
+          taskId: childId,
+          status: state.status,
+          ...state.error === void 0 ? {} : { error: state.error },
+          ...record4.description === void 0 ? {} : { description: record4.description },
+          ...linkage2
+        }
+      });
+    }
+    return events;
+  };
+  const settleSessionEnded = () => {
+    const events = [];
+    for (const [childId, record4] of registry2.entries()) {
+      const last = record4.reported ?? record4.observed;
+      if (!record4.announced || last !== "running" && last !== "waiting") continue;
+      record4.reported = "idle";
+      record4.observed = "idle";
+      events.push({
+        type: "task.updated",
+        ...record4.turnId === void 0 ? {} : { turnId: record4.turnId },
+        payload: {
+          taskId: childId,
+          status: "idle",
+          outcomeUnknown: true,
+          ...record4.description === void 0 ? {} : { description: record4.description },
+          ...childLinkage(childId, record4)
+        }
+      });
+    }
+    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;
@@ -26955,8 +27465,10 @@ function createExecutorUpdates({
   shared
 }) {
   const shownToolCallIds = /* @__PURE__ */ new Set();
-  const emitCompactionState = (record3, state) => {
-    const summary = record3.summary?.trim() ?? "";
+  const markChildSession = shared.childSessions.mark;
+  const subagentSessions = options.subagentSessions === true ? createSubagentSessionTracker(shared.childSessions) : void 0;
+  const emitCompactionState = (record4, state) => {
+    const summary = record4.summary?.trim() ?? "";
     const truncated = summary.length > COMPACTION_SUMMARY_MAX_CHARS;
     emit({
       type: "thread.state.changed",
@@ -26967,9 +27479,9 @@ function createExecutorUpdates({
       payload: {
         state,
         compaction: {
-          compactionId: record3.snapshotId,
-          trigger: record3.trigger,
-          ...state === "compacted" ? { durationMs: Math.max(0, nowMs() - record3.startedAtMs) } : {},
+          compactionId: record4.snapshotId,
+          trigger: record4.trigger,
+          ...state === "compacted" ? { durationMs: Math.max(0, nowMs() - record4.startedAtMs) } : {},
           ...summary.length > 0 ? {
             summary: truncated ? summary.slice(0, COMPACTION_SUMMARY_MAX_CHARS) : summary,
             ...truncated ? { summaryTruncated: true } : {}
@@ -26979,13 +27491,13 @@ function createExecutorUpdates({
     });
   };
   const applyCompactionUpdate = (event) => {
-    let record3 = compactions.get(event.compactionId);
-    if (record3 === void 0) {
+    let record4 = compactions.get(event.compactionId);
+    if (record4 === void 0) {
       if (shared.manualCompaction !== void 0 && !shared.manualCompaction.adopted) {
         shared.manualCompaction.adopted = true;
-        record3 = shared.manualCompaction;
+        record4 = shared.manualCompaction;
       } else {
-        record3 = {
+        record4 = {
           snapshotId: randomId(),
           trigger: "automatic",
           startedAtMs: nowMs(),
@@ -26995,25 +27507,25 @@ function createExecutorUpdates({
           adopted: false
         };
       }
-      compactions.set(event.compactionId, record3);
+      compactions.set(event.compactionId, record4);
     }
-    if (event.summary !== void 0) record3.summary = event.summary ?? void 0;
+    if (event.summary !== void 0) record4.summary = event.summary ?? void 0;
     switch (event.status) {
       case "in_progress":
-        if (!record3.announced) {
-          record3.announced = true;
-          emitCompactionState(record3, "compacting");
+        if (!record4.announced) {
+          record4.announced = true;
+          emitCompactionState(record4, "compacting");
         }
         return;
       case "completed":
-        record3.announced = true;
-        record3.finished = true;
+        record4.announced = true;
+        record4.finished = true;
         compactions.delete(event.compactionId);
-        emitCompactionState(record3, "compacted");
+        emitCompactionState(record4, "compacted");
         return;
       case "failed":
       case "cancelled":
-        record3.finished = true;
+        record4.finished = true;
         compactions.delete(event.compactionId);
         emit({
           type: "runtime.warning",
@@ -27040,6 +27552,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) {
@@ -27066,43 +27602,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
           })
@@ -27118,9 +27650,9 @@ function createExecutorUpdates({
         continue;
       }
       if (event._tag === "CompactionSummaryChunk") {
-        const record3 = compactions.get(event.compactionId);
-        if (record3 !== void 0 && !record3.finished) {
-          record3.summary = (record3.summary ?? "") + event.text;
+        const record4 = compactions.get(event.compactionId);
+        if (record4 !== void 0 && !record4.finished) {
+          record4.summary = (record4.summary ?? "") + event.text;
         }
         continue;
       }
@@ -27179,7 +27711,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
@@ -27328,7 +27889,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({
@@ -27358,7 +27922,14 @@ function createAcpExecutor(options) {
     promptMutex,
     shared
   });
-  const { emitCompactionState, handleSessionUpdate } = createExecutorUpdates({
+  const {
+    emitCompactionState,
+    receiveSessionUpdate,
+    receiveExtensionNotification,
+    settleToolSubagents,
+    settleSessionEnded,
+    toolSubagentsMayRun
+  } = createExecutorUpdates({
     emit,
     stamp,
     options,
@@ -27421,11 +27992,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) {
@@ -27481,6 +28052,7 @@ function createAcpExecutor(options) {
   });
   const { sendPromptRpc, prompt } = createExecutorPrompt({
     promptResults,
+    settleToolSubagents,
     isLive,
     closeActiveAssistantSegment,
     emit,
@@ -27505,6 +28077,8 @@ function createAcpExecutor(options) {
     dispose: disposeLifecycle
   } = createExecutorLifecycle({
     promptResults,
+    settleToolSubagents,
+    settleSessionEnded,
     failIfDisposed,
     requireStarted,
     interruptedTurnIds,
@@ -27553,6 +28127,7 @@ function createAcpExecutor(options) {
     setNativeMode,
     compact,
     openToolCalls: () => readOpenToolCalls(toolCalls, shared.activeTurnId),
+    toolSubagentsMayRun,
     dispose: (exitCode) => {
       disposeOnce ??= (async () => {
         try {
@@ -27769,7 +28344,13 @@ async function openAcpProbeHandshake(input2) {
   });
   try {
     const initializeResult = await withProbeTimeout(
-      connection.request("initialize", acpInitializePayload(input2.clientInfo)),
+      connection.request(
+        "initialize",
+        acpInitializePayload(
+          input2.clientInfo,
+          acpCapabilityOverrides({ subagentSessions: input2.subagentSessions })
+        )
+      ),
       input2.requestTimeoutMs,
       "ACP probe request 'initialize'",
       input2.signal
@@ -27795,13 +28376,13 @@ function parseCliVersion(output2) {
 }
 async function collectCappedText(stream, maxBytes) {
   const decoder = new TextDecoder();
-  let text3 = "";
+  let text4 = "";
   let total = 0;
   for await (const chunk of stream) {
     total += chunk.byteLength;
-    if (total <= maxBytes) text3 += decoder.decode(chunk, { stream: true });
+    if (total <= maxBytes) text4 += decoder.decode(chunk, { stream: true });
   }
-  return { text: text3 + decoder.decode(), overflowed: total > maxBytes };
+  return { text: text4 + decoder.decode(), overflowed: total > maxBytes };
 }
 async function collectProbeProcess(child, input2) {
   const stdinClosed = Promise.resolve().then(() => child.closeStdin());
@@ -27831,8 +28412,8 @@ async function collectProbeProcess(child, input2) {
     } catch {
       await child.kill("SIGKILL");
     }
-    const settled = await Promise.allSettled([term, ...tasks]);
-    const termination = settled[0];
+    const settled2 = await Promise.allSettled([term, ...tasks]);
+    const termination = settled2[0];
     if (termination?.status === "rejected") throw termination.reason;
   })();
   try {
@@ -27969,7 +28550,7 @@ function readDeviceCodeOutput(stdout, onText) {
   const outputWentQuiet = new Promise((resolve2) => {
     onQuiet = resolve2;
   });
-  const text3 = (async () => {
+  const text4 = (async () => {
     const decoder = new TextDecoder();
     for await (const chunk of stdout) {
       const piece = decoder.decode(chunk, { stream: true });
@@ -27990,7 +28571,7 @@ function readDeviceCodeOutput(stdout, onText) {
     let silentCap;
     await Promise.race([
       codeFound,
-      text3.then(() => void 0),
+      text4.then(() => void 0),
       outputWentQuiet,
       new Promise((resolve2) => {
         silentCap = setTimeout(resolve2, SILENT_CAP_MS);
@@ -28007,7 +28588,7 @@ function readDeviceCodeOutput(stdout, onText) {
       ...verificationUrl === void 0 ? {} : { verificationUrl }
     };
   })();
-  return { text: text3, code };
+  return { text: text4, code };
 }
 
 // src/grokHome.ts
@@ -28021,8 +28602,8 @@ import * as NodeFS2 from "node:fs";
 import * as NodePath3 from "node:path";
 var AUTH_FILE_NAME = "auth.json";
 var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var readString2 = (record3, key) => {
-  const value = record3[key];
+var readString2 = (record4, key) => {
+  const value = record4[key];
   if (typeof value !== "string") return void 0;
   const trimmed3 = value.trim();
   return trimmed3.length > 0 ? trimmed3 : void 0;
@@ -28064,9 +28645,9 @@ var unreadableProbe = (exists) => ({
   name: void 0,
   expiresAt: void 0
 });
-var joinName = (record3) => {
-  const first = readString2(record3, "first_name");
-  const last = readString2(record3, "last_name");
+var joinName = (record4) => {
+  const first = readString2(record4, "first_name");
+  const last = readString2(record4, "last_name");
   const joined = [first, last].filter((part) => part !== void 0).join(" ");
   return joined.length > 0 ? joined : void 0;
 };
@@ -28187,7 +28768,7 @@ function makeGrokSignIn(input2) {
       });
       const output2 = readDeviceCodeOutput(
         handle.stdout,
-        (text3) => host.log.info("sign-in output", { text: text3 })
+        (text4) => host.log.info("sign-in output", { text: text4 })
       );
       const operationId = `grok-sign-in-${Date.now().toString(36)}-${operations.size}`;
       let closing;
@@ -28214,15 +28795,15 @@ function makeGrokSignIn(input2) {
       await operations.get(operationId)?.close();
     },
     verify: async (signal) => {
-      const active = [...operations.values()];
+      const active2 = [...operations.values()];
       try {
-        for (const operation of active) {
+        for (const operation of active2) {
           const code = await raceAbort(operation.handle.exited, signal);
           if (code !== 0) throw new Error(`Grok sign-in exited with code ${String(code)}`);
         }
         return await input2.probe(signal);
       } finally {
-        await Promise.all(active.map((operation) => operation.close()));
+        await Promise.all(active2.map((operation) => operation.close()));
       }
     }
   };
@@ -28255,9 +28836,9 @@ var parseJson = (raw) => {
   }
 };
 var extractGrokToken = (auth) => {
-  const record3 = asObject(auth);
-  if (record3 === null) return null;
-  for (const [key, value] of Object.entries(record3)) {
+  const record4 = asObject(auth);
+  if (record4 === null) return null;
+  for (const [key, value] of Object.entries(record4)) {
     if (!key.startsWith(GROK_ISSUER_PREFIX)) continue;
     const nestedKey = asString3(asObject(value)?.["key"]);
     if (nestedKey !== null) return nestedKey;
@@ -28472,8 +29053,8 @@ var GROK_EMPTY_PLAN_TEXT = "The agent exited plan mode without writing a plan.";
 var isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var trimmed = (value) => {
   if (typeof value !== "string") return void 0;
-  const text3 = value.trim();
-  return text3.length > 0 ? text3 : void 0;
+  const text4 = value.trim();
+  return text4.length > 0 ? text4 : void 0;
 };
 function parseXAiExitPlanModeParams(params) {
   const candidates = [params, ...isRecord9(params) ? [params["params"]] : []];
@@ -28519,11 +29100,11 @@ function makeXAiExitPlanModeResponse(params, resolution) {
   if (resolution.kind === "cancelled") return abandoned();
   const answer = resolution.answers[params.toolCallId];
   const selected = typeof answer === "string" ? answer : Array.isArray(answer) && answer.length === 1 && typeof answer[0] === "string" ? answer[0] : void 0;
-  const text3 = trimmed(selected);
-  if (text3 === void 0) return abandoned();
-  if (text3 === GROK_PLAN_APPROVE_OPTION_ID) return { outcome: "approved" };
-  if (text3 === GROK_PLAN_ABANDON_OPTION_ID) return abandoned();
-  return { outcome: "request_changes", feedback: text3 };
+  const text4 = trimmed(selected);
+  if (text4 === void 0) return abandoned();
+  if (text4 === GROK_PLAN_APPROVE_OPTION_ID) return { outcome: "approved" };
+  if (text4 === GROK_PLAN_ABANDON_OPTION_ID) return abandoned();
+  return { outcome: "request_changes", feedback: text4 };
 }
 
 // src/grokReasoningEffort.ts
@@ -28533,8 +29114,8 @@ import { REASONING_OPTION_LABEL, reasoningEffortShortLabel } from "@ycodium-ai/p
 var isRecord10 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var trimmed2 = (value) => {
   if (typeof value !== "string") return void 0;
-  const text3 = value.trim();
-  return text3.length > 0 ? text3 : void 0;
+  const text4 = value.trim();
+  return text4.length > 0 ? text4 : void 0;
 };
 
 // src/grokReasoningEffort.ts
@@ -28576,6 +29157,11 @@ function grokReasoningEffortArgs(effort) {
 // src/grokBackgroundTasks.ts
 var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 var text2 = (value) => typeof value === "string" ? value.trim() || void 0 : void 0;
+var isSubagentCommand = (command) => command !== void 0 && /^\[subagent[:\]]/.test(command);
+var taskResults = (output2) => {
+  const results = record2(output2["MultiResult"])["results"];
+  return (Array.isArray(results) ? results : [output2["Result"]]).map(record2);
+};
 var lifecycle = (status, exitCode) => {
   switch (text2(status)?.toLowerCase()) {
     case "pending":
@@ -28640,9 +29226,7 @@ function buildGrokBackgroundTaskEvents(input2) {
     const command = text2(output2["command"]);
     if (id && command) start(id, "shell", command.split("\n")[0].slice(0, 200), toolCallId);
   } else if (output2["type"] === "TaskOutput" || output2["type"] === "KillTask") {
-    const results = record2(output2["MultiResult"])["results"];
-    for (const value of Array.isArray(results) ? results : [output2["Result"]]) {
-      const result = record2(value);
+    for (const result of taskResults(output2)) {
       const id = text2(result["task_id"]);
       if (!id) continue;
       if (output2["type"] === "KillTask") {
@@ -28654,7 +29238,7 @@ function buildGrokBackgroundTaskEvents(input2) {
       }
       const command = text2(result["command"]);
       const status = lifecycle(result["status"], result["exit_code"]);
-      if (!command || !status || command.startsWith("[subagent:")) continue;
+      if (!command || !status || isSubagentCommand(command)) continue;
       const task = start(id, /^\[monitor[:\]]/.test(command) ? "monitor" : "shell", command);
       const summary = text2(result["output"])?.split("\n").find((line) => line.trim())?.trim();
       if (status === "running") {
@@ -28705,6 +29289,281 @@ function grokImageArtifacts(rawOutput) {
   return [{ path, name: filename, ...linkBase !== void 0 ? { linkBase } : {} }];
 }
 
+// src/grokSubagents.ts
+var SPAWN_TOOL = "spawn_subagent";
+var SPAWN_ACK_ID = /^subagent_id:\s*(\S+)\s*$/m;
+var MACHINE_BLOCKS = /<subagent_(meta|result)>[\s\S]*?<\/subagent_\1>/g;
+var ordinal = (attemptId) => {
+  const match = attemptId === void 0 ? null : /^at(\d+)\./.exec(attemptId);
+  return match === null ? void 0 : Number(match[1]);
+};
+var MAX_SUMMARY_CHARS = 8e3;
+var MAX_EARLY_FINISHES = 32;
+var FALLBACK_TITLE = "Subagent";
+var NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
+  "x.ai/session_notification",
+  "x.ai/session/update"
+]);
+var record3 = (value) => isRecord10(value) ? value : {};
+var text3 = trimmed2;
+var count2 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+var replyText = (value) => {
+  const reply = typeof value === "string" ? value.replace(MACHINE_BLOCKS, "").trim() : "";
+  if (reply.length === 0) return void 0;
+  return reply.length > MAX_SUMMARY_CHARS ? `${reply.slice(0, MAX_SUMMARY_CHARS - 1)}\u2026` : reply;
+};
+var settled = (status) => {
+  const state = lifecycle(status, void 0);
+  return state === "running" ? void 0 : state;
+};
+var usageOf = (update) => {
+  const totalTokens = count2(update["tokens_used"]);
+  if (!totalTokens) return void 0;
+  const toolUses = count2(update["tool_call_count"] ?? update["tool_calls"]);
+  const durationMs = count2(update["duration_ms"]);
+  return {
+    totalTokens,
+    ...toolUses === void 0 ? {} : { toolUses },
+    ...durationMs === void 0 ? {} : { durationMs }
+  };
+};
+var mergeFinal = (first, next) => first === void 0 ? next : {
+  outcome: first.outcome,
+  // 不同终态的说明（比如取消原因）不能填进已锁定的结局。
+  summary: first.summary ?? (next.outcome === first.outcome ? next.summary : void 0),
+  usage: first.usage ?? next.usage
+};
+function createGrokSubagents() {
+  const agents = /* @__PURE__ */ new Map();
+  const spawnCalls = /* @__PURE__ */ new Set();
+  const earlyFinishes = /* @__PURE__ */ new Map();
+  let tick = 0;
+  const linkage2 = (agent) => {
+    const identity = agent.current.identity;
+    return {
+      taskId: agent.id,
+      taskType: "subagent",
+      rosterKind: "subagent",
+      timelineBypass: true,
+      title: identity.title,
+      nativeSessionId: identity.nativeSessionId,
+      ...identity.role === void 0 ? {} : { role: identity.role },
+      ...identity.model === void 0 ? {} : { model: identity.model }
+    };
+  };
+  const attribution = (agent, turnId) => agent.current.turnId !== void 0 && agent.current.turnId === turnId ? { turnId } : {};
+  const running = (agent, turnId) => ({
+    type: "task.updated",
+    ...attribution(agent, turnId),
+    payload: { ...linkage2(agent), status: "running", description: agent.current.identity.title }
+  });
+  const completed = (agent, final, turnId) => ({
+    type: "task.completed",
+    ...attribution(agent, turnId),
+    payload: {
+      ...linkage2(agent),
+      status: final.outcome,
+      ...final.summary === void 0 ? {} : { summary: final.summary },
+      ...final.usage === void 0 ? {} : { typedUsage: final.usage }
+    }
+  });
+  const earlyKey = (id, attemptId) => `${id}|${attemptId ?? ""}`;
+  const withEarlyFinish = (agent, events, turnId) => {
+    const key = earlyKey(agent.id, agent.current.id);
+    const early = earlyFinishes.get(key);
+    if (early === void 0) return events;
+    earlyFinishes.delete(key);
+    agent.current.final = early.final;
+    return [...events, completed(agent, early.final, turnId)];
+  };
+  const onSpawned = (update, ctx) => {
+    const turnId = ctx.turnId;
+    const id = text3(update["subagent_id"]);
+    if (id === void 0) return [];
+    const childSessionId = text3(update["child_session_id"]);
+    if (childSessionId !== void 0) ctx.markChildSession(childSessionId);
+    const attemptId = text3(update["attempt_id"]);
+    const incoming = {
+      title: text3(update["description"]) ?? text3(update["subagent_type"]) ?? FALLBACK_TITLE,
+      role: text3(update["subagent_type"]),
+      model: text3(update["model"]),
+      nativeSessionId: text3(update["child_session_id"])
+    };
+    const newAttempt = (identity) => ({
+      id: attemptId,
+      startedAt: ++tick,
+      identity,
+      turnId,
+      final: void 0,
+      progressKey: void 0
+    });
+    const agent = agents.get(id);
+    if (agent === void 0) {
+      const attempt = newAttempt({ ...incoming, nativeSessionId: incoming.nativeSessionId ?? id });
+      const created = { id, current: attempt, seen: /* @__PURE__ */ new Set() };
+      if (attemptId !== void 0) created.seen.add(attemptId);
+      agents.set(id, created);
+      return withEarlyFinish(
+        created,
+        [
+          {
+            type: "task.started",
+            ...attribution(created, turnId),
+            payload: { ...linkage2(created), description: incoming.title }
+          },
+          running(created, turnId)
+        ],
+        turnId
+      );
+    }
+    const isNew = attemptId !== void 0 && !agent.seen.has(attemptId);
+    const have = ordinal(agent.current.id);
+    const got = ordinal(attemptId);
+    const ordered = have !== void 0 && got !== void 0;
+    if (isNew && (ordered ? got <= have : agent.current.final === void 0)) {
+      agent.seen.add(attemptId);
+      earlyFinishes.delete(earlyKey(id, attemptId));
+      return [];
+    }
+    if (isNew) {
+      const early = earlyFinishes.get(earlyKey(id, attemptId));
+      if (!ordered && early !== void 0 && early.at < agent.current.startedAt) {
+        agent.seen.add(attemptId);
+        earlyFinishes.delete(earlyKey(id, attemptId));
+        return [];
+      }
+      agent.seen.add(attemptId);
+      const before2 = agent.current.identity;
+      agent.current = newAttempt({
+        title: incoming.title,
+        role: incoming.role ?? before2.role,
+        model: incoming.model ?? before2.model,
+        nativeSessionId: incoming.nativeSessionId ?? before2.nativeSessionId
+      });
+      return withEarlyFinish(agent, [running(agent, turnId)], turnId);
+    }
+    const known = agent.current;
+    if (attemptId !== void 0 && known.id !== attemptId || known.final !== void 0) return [];
+    const before = JSON.stringify(linkage2(agent));
+    for (const [key, value] of Object.entries(incoming)) {
+      if (value !== void 0) Object.assign(known.identity, { [key]: value });
+    }
+    if (JSON.stringify(linkage2(agent)) === before) return [];
+    return [
+      {
+        type: "task.progress",
+        ...attribution(agent, turnId),
+        payload: { ...linkage2(agent), description: known.identity.title }
+      }
+    ];
+  };
+  const isCurrent = (agent, attemptId) => attemptId === void 0 || agent.current.id === attemptId;
+  const onProgress = (update, turnId) => {
+    const agent = agents.get(text3(update["subagent_id"]) ?? "");
+    if (agent === void 0 || !isCurrent(agent, text3(update["attempt_id"]))) return [];
+    const attempt = agent.current;
+    if (attempt.final !== void 0) return [];
+    const tools = Array.isArray(update["tools_used"]) ? update["tools_used"] : [];
+    const lastToolName = text3(tools.at(-1));
+    const usage = usageOf(update);
+    const key = [
+      usage?.totalTokens,
+      usage?.toolUses,
+      count2(update["turn_count"]),
+      lastToolName
+    ].join("|");
+    if (key === attempt.progressKey) return [];
+    attempt.progressKey = key;
+    return [
+      {
+        type: "task.progress",
+        ...attribution(agent, turnId),
+        payload: {
+          ...linkage2(agent),
+          description: attempt.identity.title,
+          ...usage === void 0 ? {} : { typedUsage: usage },
+          ...lastToolName === void 0 ? {} : { lastToolName }
+        }
+      }
+    ];
+  };
+  const onFinished = (update, turnId) => {
+    const id = text3(update["subagent_id"]);
+    const outcome = settled(update["status"]);
+    if (id === void 0 || outcome === void 0) return [];
+    const attemptId = text3(update["attempt_id"]);
+    const reply = replyText(update["output"]);
+    const reason = text3(update["error"]);
+    const final = {
+      outcome,
+      summary: outcome === "completed" ? reply : outcome === "failed" ? reason ?? reply : reason,
+      usage: usageOf(update)
+    };
+    const agent = agents.get(id);
+    if (agent !== void 0) {
+      if (attemptId === void 0 || agent.current.id === attemptId) {
+        return finishCurrent(agent, final, turnId);
+      }
+      if (agent.seen.has(attemptId)) return [];
+    }
+    const key = earlyKey(id, attemptId);
+    const first = earlyFinishes.get(key);
+    earlyFinishes.set(key, { final: mergeFinal(first?.final, final), at: first?.at ?? ++tick });
+    if (earlyFinishes.size > MAX_EARLY_FINISHES) {
+      earlyFinishes.delete(earlyFinishes.keys().next().value);
+    }
+    return [];
+  };
+  const finishCurrent = (agent, final, turnId) => {
+    const attempt = agent.current;
+    const merged = mergeFinal(attempt.final, final);
+    const changed = attempt.final === void 0 || merged.summary !== attempt.final.summary || merged.usage !== attempt.final.usage;
+    attempt.final = merged;
+    return changed ? [completed(agent, merged, turnId)] : [];
+  };
+  const fromEnvelope = (params, ctx) => {
+    const envelope = record3(params);
+    if (record3(envelope["_meta"])["isReplay"] === true) return void 0;
+    const sessionId = text3(envelope["sessionId"]);
+    if (ctx.sessionId !== void 0 && sessionId !== ctx.sessionId) return void 0;
+    const update = record3(envelope["update"]);
+    switch (update["sessionUpdate"]) {
+      case "subagent_spawned":
+        return onSpawned(update, ctx);
+      case "subagent_progress":
+        return onProgress(update, ctx.turnId);
+      case "subagent_finished":
+        return onFinished(update, ctx.turnId);
+      default:
+        return void 0;
+    }
+  };
+  return {
+    onExtensionNotification: (method, params, ctx) => NOTIFICATION_METHODS.has(method.startsWith("_") ? method.slice(1) : method) ? fromEnvelope(params, ctx) : void 0,
+    onSessionUpdate: (notification, ctx) => ctx.foreign ? void 0 : fromEnvelope(notification, ctx),
+    handlesToolCall: (input2) => {
+      if (!spawnCalls.has(input2.toolCallId) && (record3(record3(input2.meta)["x.ai/tool"])["name"] === SPAWN_TOOL || record3(input2.rawInput)["variant"] === "Task")) {
+        spawnCalls.add(input2.toolCallId);
+      }
+      if (!spawnCalls.has(input2.toolCallId)) return false;
+      if (input2.status !== "completed" && input2.status !== "failed") return true;
+      if (input2.status === "failed") return false;
+      const output2 = record3(input2.rawOutput);
+      const ack = typeof output2["text"] === "string" ? SPAWN_ACK_ID.exec(output2["text"]) : null;
+      return output2["type"] === "SubagentCompleted" && text3(output2["subagent_id"]) !== void 0 || output2["type"] === "Text" && ack !== null;
+    },
+    onSessionEnded: () => {
+      const events = [];
+      for (const agent of agents.values()) {
+        if (agent.current.final !== void 0) continue;
+        agent.current.final = { outcome: "stopped", summary: void 0, usage: void 0 };
+        events.push({ type: "task.updated", payload: { ...linkage2(agent), status: "cancelled" } });
+      }
+      return events;
+    }
+  };
+}
+
 // src/grokSupport.ts
 import { modelSelectionStringOption } from "@ycodium-ai/plugin-api/executor";
 var GROK_NATIVE_MODE_BY_RUNTIME_MODE = {
@@ -28917,12 +29776,12 @@ function extractXAiAskUserQuestions(params) {
 var answerValues = (answer) => {
   if (Array.isArray(answer)) {
     return answer.flatMap((entry) => {
-      const text4 = trimmed2(entry);
-      return text4 === void 0 ? [] : [text4];
+      const text5 = trimmed2(entry);
+      return text5 === void 0 ? [] : [text5];
     });
   }
-  const text3 = trimmed2(answer);
-  return text3 === void 0 ? [] : [text3];
+  const text4 = trimmed2(answer);
+  return text4 === void 0 ? [] : [text4];
 };
 function makeXAiAskUserQuestionResponse(params, answers) {
   const normalized = params.questions.flatMap((question) => {
@@ -29585,6 +30444,7 @@ var createGrokInstance = (config2, host) => {
       const requestedModelId = modelIdFromSelection(input2.modelSelection);
       let initializeResult;
       const backgroundTasks = /* @__PURE__ */ new Map();
+      const subagents = createGrokSubagents();
       const turnUsage = createGrokTurnUsageCollector(grokPromptSettlement);
       const executor = createAcpExecutor({
         readable,
@@ -29606,6 +30466,7 @@ var createGrokInstance = (config2, host) => {
         authMethodId: resolveGrokAuthMethodId,
         hooks: {
           promptSettlement: turnUsage.settlement,
+          // 派发子 agent 的调用由子 agent 名单接管，不再画成普通工具。
           onToolCallUpdated: (update) => ({
             events: buildGrokBackgroundTaskEvents({
               tasks: backgroundTasks,
@@ -29615,8 +30476,12 @@ var createGrokInstance = (config2, host) => {
               toolCallStatus: update.status,
               turnId: update.turnId
             }),
-            artifacts: grokImageArtifacts(update.rawOutput)
+            artifacts: grokImageArtifacts(update.rawOutput),
+            ...subagents.handlesToolCall(update) ? { handled: true } : {}
           }),
+          onExtensionNotification: subagents.onExtensionNotification,
+          onSessionUpdate: subagents.onSessionUpdate,
+          onSessionEnded: subagents.onSessionEnded,
           onExtensionRequest: async (method, params, ctx) => {
             if (XAI_EXIT_PLAN_MODE_METHODS.includes(method)) {
               const plan = parseXAiExitPlanModeParams(params);
@@ -29831,7 +30696,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-grok",
-  apiVersion: 48,
+  apiVersion: 49,
   executors,
   activate(ctx) {
     ctx.log.info("grok executor ready");