@liberseek/boft-cli-win32-arm64 0.6.3 → 0.6.5

package/app/plugins/grok/plugin.mjs

@@ -19685,6 +19685,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -20990,6 +20996,309 @@ function hasGrokToolProjection(projection) {
   return projection.output !== void 0 || projection.exitCode !== void 0;
 }
 
+// dist/grok-subagent.js
+var SPAWN_TOOL_NAMES = /* @__PURE__ */ new Set(["spawn_subagent", "spawn_agent", "task"]);
+var SEND_TOOL_NAMES = /* @__PURE__ */ new Set(["send_subagent_message"]);
+var WAIT_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "get_command_or_subagent_output",
+  "get_task_output",
+  "wait_tasks"
+]);
+var KILL_TOOL_NAMES = /* @__PURE__ */ new Set(["kill_command_or_subagent", "kill_task"]);
+var DESCRIPTION_LIMIT = 500;
+var SUMMARY_LIMIT = 2e3;
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function idField(value, key) {
+  if (!isRecord5(value))
+    return void 0;
+  const field = value[key];
+  if (typeof field === "string") {
+    const trimmed = field.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (typeof field === "number" && Number.isFinite(field))
+    return String(field);
+  return void 0;
+}
+function stringField2(value, key) {
+  if (!isRecord5(value) || typeof value[key] !== "string")
+    return void 0;
+  const trimmed = value[key].trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function bounded(value, limit) {
+  if (!value)
+    return void 0;
+  return value.slice(0, limit);
+}
+function toolId(name, title) {
+  return grokToolName(name, title).toLowerCase();
+}
+function collectIds(value) {
+  const ids = [];
+  const push = (entry) => {
+    if (typeof entry === "string" && entry.trim().length > 0)
+      ids.push(entry.trim());
+    else if (typeof entry === "number" && Number.isFinite(entry))
+      ids.push(String(entry));
+  };
+  push(idField(value, "task_id"));
+  push(idField(value, "subagent_id"));
+  if (isRecord5(value)) {
+    const list = value.task_ids ?? value.subagent_ids;
+    if (Array.isArray(list)) {
+      for (const entry of list)
+        push(entry);
+    } else {
+      push(list);
+    }
+  }
+  return [...new Set(ids)];
+}
+function grokSubagentOperation(name, title, rawInput) {
+  const id = toolId(name, title);
+  if (WAIT_TOOL_NAMES.has(id) || KILL_TOOL_NAMES.has(id))
+    return null;
+  if (SEND_TOOL_NAMES.has(id))
+    return "send";
+  if (SPAWN_TOOL_NAMES.has(id))
+    return "spawn";
+  if (isRecord5(rawInput) && rawInput.variant === "Task")
+    return "spawn";
+  return null;
+}
+function grokSubagentWaitIds(name, title, rawInput) {
+  if (!WAIT_TOOL_NAMES.has(toolId(name, title)) && !KILL_TOOL_NAMES.has(toolId(name, title))) {
+    return [];
+  }
+  return collectIds(rawInput);
+}
+function grokSubagentKill(name, title) {
+  return KILL_TOOL_NAMES.has(toolId(name, title));
+}
+function grokSubagentDescription(rawInput, title, fallback = "Grok Subagent") {
+  return bounded(stringField2(rawInput, "description"), DESCRIPTION_LIMIT) ?? bounded(stringField2(rawInput, "name"), DESCRIPTION_LIMIT) ?? (title && !SPAWN_TOOL_NAMES.has(title.toLowerCase()) && !SEND_TOOL_NAMES.has(title.toLowerCase()) ? bounded(title, DESCRIPTION_LIMIT) : void 0) ?? fallback;
+}
+function grokSubagentPrompt(rawInput) {
+  return bounded(stringField2(rawInput, "prompt") ?? stringField2(rawInput, "message"), SUMMARY_LIMIT);
+}
+function grokSubagentRole(rawInput) {
+  return bounded(stringField2(rawInput, "subagent_type") ?? stringField2(rawInput, "agent_type") ?? stringField2(rawInput, "type"), DESCRIPTION_LIMIT);
+}
+function grokSubagentBackground(rawInput) {
+  if (!isRecord5(rawInput))
+    return true;
+  if (rawInput.background === false || rawInput.run_in_background === false)
+    return false;
+  return true;
+}
+function grokSubagentModel(rawInput) {
+  return bounded(stringField2(rawInput, "model"), DESCRIPTION_LIMIT);
+}
+function grokNativeSubagentId(...candidates) {
+  const fromKey = (key) => {
+    for (const candidate of candidates) {
+      const value = idField(candidate, key);
+      if (value)
+        return value;
+    }
+    return void 0;
+  };
+  const fromText = (pattern) => {
+    for (const candidate of candidates) {
+      const text = extractText(candidate);
+      const match = text?.match(pattern);
+      if (match?.[1])
+        return match[1].trim();
+    }
+    return void 0;
+  };
+  return fromKey("subagent_id") ?? fromText(/subagent_id:\s*([^\s]+)/i) ?? fromKey("task_id") ?? fromKey("id") ?? fromText(/task_id:\s*([^\s]+)/i) ?? fromText(/task_ids=\["([^"]+)"\]/);
+}
+function grokSubagentResultSummary(...candidates) {
+  for (const candidate of candidates) {
+    const text = extractText(candidate);
+    if (text)
+      return bounded(text, SUMMARY_LIMIT);
+  }
+  return void 0;
+}
+function grokSubagentEventFromUpdate(update) {
+  if (!isRecord5(update) || typeof update.sessionUpdate !== "string")
+    return null;
+  const nativeSubagentId = idField(update, "subagent_id") ?? idField(update, "child_session_id");
+  if (!nativeSubagentId)
+    return null;
+  if (update.sessionUpdate === "subagent_spawned") {
+    const description = bounded(stringField2(update, "description"), DESCRIPTION_LIMIT);
+    const role = bounded(stringField2(update, "subagent_type") ?? stringField2(update, "role"), DESCRIPTION_LIMIT);
+    const model = bounded(stringField2(update, "model"), DESCRIPTION_LIMIT);
+    return {
+      type: "subagent.spawned",
+      nativeSubagentId,
+      ...description ? { description } : {},
+      ...role ? { role } : {},
+      ...model ? { model } : {}
+    };
+  }
+  if (update.sessionUpdate === "subagent_finished") {
+    const mapped = mapTaskStatus(typeof update.status === "string" ? update.status : void 0);
+    if (!mapped || mapped === "running" || mapped === "pending")
+      return null;
+    const status = mapped === "failed" ? "failed" : mapped === "interrupted" ? "interrupted" : "completed";
+    const resultSummary = bounded(typeof update.output === "string" ? update.output.trim() : void 0, SUMMARY_LIMIT);
+    return {
+      type: "subagent.finished",
+      nativeSubagentId,
+      status,
+      ...resultSummary ? { resultSummary } : {}
+    };
+  }
+  return null;
+}
+function grokSubagentWaitSettlements(input) {
+  const ids = grokSubagentWaitIds(input.name, input.title, input.rawInput);
+  if (grokSubagentKill(input.name, input.title)) {
+    return ids.map((id) => ({ id, status: "interrupted" }));
+  }
+  if (ids.length === 0)
+    return [];
+  const resultEntries = taskOutputResults(input.rawOutput);
+  if (resultEntries.length > 0) {
+    const settled = [];
+    for (const result of resultEntries) {
+      const id = idField(result, "task_id") ?? idField(result, "subagent_id");
+      const status = mapTaskStatus(typeof result.status === "string" ? result.status : void 0);
+      if (!id || !status || status === "running" || status === "pending")
+        continue;
+      const resultSummary = bounded(typeof result.output === "string" ? result.output.trim() : void 0, SUMMARY_LIMIT);
+      settled.push({ id, status, ...resultSummary ? { resultSummary } : {} });
+    }
+    return settled;
+  }
+  const fromText = taskOutputTextSettlements(input.rawOutput, input.content, ids);
+  if (fromText.length > 0)
+    return fromText;
+  const overall = mapTaskStatus(taskOutputStatus(input.rawOutput, input.content));
+  if (!overall || overall === "running" || overall === "pending")
+    return [];
+  return ids.map((id) => ({ id, status: overall }));
+}
+function taskOutputResults(rawOutput) {
+  if (!isRecord5(rawOutput))
+    return [];
+  if (Array.isArray(rawOutput.results)) {
+    return rawOutput.results.filter(isRecord5);
+  }
+  const nested = firstRecord(rawOutput.MultiResult, rawOutput.multiResult, rawOutput.multi_result);
+  if (nested && Array.isArray(nested.results)) {
+    return nested.results.filter(isRecord5);
+  }
+  const single = firstRecord(rawOutput.Result, rawOutput.result);
+  if (single)
+    return [single];
+  if (typeof rawOutput.status === "string")
+    return [rawOutput];
+  return [];
+}
+function firstRecord(...values) {
+  for (const value of values) {
+    if (isRecord5(value))
+      return value;
+  }
+  return void 0;
+}
+function taskOutputTextSettlements(rawOutput, content, ids) {
+  const text = extractText(content) ?? extractText(rawOutput);
+  if (!text)
+    return [];
+  const settled = [];
+  const pattern = /---\s*Task\s+(\S+)\s+\[(completed|failed|interrupted|cancelled|canceled)\]\s*---/gi;
+  for (const match of text.matchAll(pattern)) {
+    const id = match[1]?.trim();
+    const status = mapTaskStatus(match[2]);
+    if (!id || !status || status === "running" || status === "pending")
+      continue;
+    if (!ids.includes(id))
+      continue;
+    settled.push({ id, status });
+  }
+  return settled;
+}
+function taskOutputStatus(rawOutput, content) {
+  if (isRecord5(rawOutput) && typeof rawOutput.status === "string")
+    return rawOutput.status;
+  const text = extractText(content) ?? extractText(rawOutput);
+  if (!text)
+    return void 0;
+  if (/<subagent_meta>|<subagent_result>/i.test(text))
+    return "completed";
+  if (/\bstatus["']?\s*[:=]\s*["']?completed/i.test(text))
+    return "completed";
+  if (/\bstatus["']?\s*[:=]\s*["']?failed/i.test(text))
+    return "failed";
+  if (/\bstatus["']?\s*[:=]\s*["']?(cancelled|canceled|interrupted)/i.test(text)) {
+    return "interrupted";
+  }
+  if (/\bstill running\b|\bstatus["']?\s*[:=]\s*["']?(running|pending|in_progress)/i.test(text)) {
+    return "running";
+  }
+  return void 0;
+}
+function mapTaskStatus(status) {
+  if (!status)
+    return void 0;
+  switch (status.toLowerCase()) {
+    case "completed":
+    case "succeeded":
+    case "success":
+      return "completed";
+    case "failed":
+    case "error":
+    case "errored":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+    case "interrupted":
+      return "interrupted";
+    case "running":
+    case "pending":
+    case "in_progress":
+    case "inprogress":
+      return "running";
+    default:
+      return void 0;
+  }
+}
+function extractText(value, depth = 0) {
+  if (depth > 6)
+    return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.flatMap((entry) => {
+      const text = extractText(entry, depth + 1);
+      return text ? [text] : [];
+    });
+    const joined = parts.join("\n").trim();
+    return joined.length > 0 ? joined : void 0;
+  }
+  if (!isRecord5(value))
+    return void 0;
+  if (typeof value.text === "string" && value.text.trim().length > 0)
+    return value.text.trim();
+  if (typeof value.output === "string" && value.output.trim().length > 0) {
+    return value.output.trim();
+  }
+  if (value.content !== void 0)
+    return extractText(value.content, depth + 1);
+  return void 0;
+}
+
 // dist/grok-history.js
 function stableId(kind, turn, index) {
   return hostItemIdSchema.parse(`grok-history-${kind}-${turn}-${index}`);
@@ -21052,6 +21361,90 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
   let reasoning = null;
   const tools = /* @__PURE__ */ new Map();
   const mediaRoots = grokMediaResolveRoots(cwd, sessionDirectory);
+  const subagents = /* @__PURE__ */ new Map();
+  const subagentAliases = /* @__PURE__ */ new Map();
+  const rememberSubagentAlias = (callId, nativeId) => {
+    subagentAliases.set(callId, callId);
+    if (nativeId)
+      subagentAliases.set(nativeId, callId);
+  };
+  const completeHistorySubagent = (callId, status, content, rawOutput, rawInput) => {
+    const current = subagents.get(callId);
+    const currentAgent = current?.subagents[0];
+    if (!current || !currentAgent)
+      return;
+    const nativeSubagentId = grokNativeSubagentId(rawInput, rawOutput, content) ?? currentAgent.nativeSubagentId;
+    rememberSubagentAlias(callId, nativeSubagentId);
+    const summary = grokSubagentResultSummary(content, rawOutput);
+    const failed = status === "failed";
+    const keepRunning = !failed && (currentAgent.background === true || current.operation === "send");
+    const item = {
+      ...current,
+      subagents: [
+        {
+          ...currentAgent,
+          status: failed ? "failed" : keepRunning ? "running" : "completed",
+          ...nativeSubagentId ? { nativeSubagentId, subagentId: nativeSubagentId } : {},
+          ...summary ? { resultSummary: summary } : {}
+        }
+      ]
+    };
+    if (keepRunning) {
+      subagents.set(callId, item);
+      return;
+    }
+    subagents.delete(callId);
+    items.push({
+      item,
+      outcome: failed ? {
+        status: "failed",
+        error: {
+          code: "nativeFailure",
+          message: "Grok Subagent delegation failed",
+          retryable: false
+        }
+      } : { status: "succeeded" }
+    });
+  };
+  const settleWatchedSubagents = (name, rawInput, content, rawOutput) => {
+    const summary = grokSubagentResultSummary(content, rawOutput);
+    for (const settlement of grokSubagentWaitSettlements({
+      ...name ? { name, title: name } : {},
+      rawInput,
+      content,
+      rawOutput
+    })) {
+      const spawnId = subagentAliases.get(settlement.id);
+      const item = spawnId ? subagents.get(spawnId) : void 0;
+      if (!item?.subagents[0])
+        continue;
+      if (spawnId)
+        subagents.delete(spawnId);
+      const resultSummary = settlement.resultSummary ?? summary;
+      items.push({
+        item: {
+          ...item,
+          subagents: [
+            {
+              ...item.subagents[0],
+              status: settlement.status,
+              nativeSubagentId: item.subagents[0].nativeSubagentId ?? settlement.id,
+              subagentId: item.subagents[0].nativeSubagentId ?? settlement.id,
+              ...resultSummary ? { resultSummary } : {}
+            }
+          ]
+        },
+        outcome: settlement.status === "failed" ? {
+          status: "failed",
+          error: {
+            code: "nativeFailure",
+            message: "Grok Subagent delegation failed",
+            retryable: false
+          }
+        } : settlement.status === "interrupted" ? { status: "cancelled", reason: "Cancelled by user" } : { status: "succeeded" }
+      });
+    }
+  };
   const completeAgent = () => {
     if (!agent || agent.text.length === 0)
       return;
@@ -21072,6 +21465,10 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
       items.push({ item: tool, outcome: { status: "succeeded" } });
     }
     tools.clear();
+    for (const item of subagents.values()) {
+      items.push({ item, outcome: { status: "succeeded" } });
+    }
+    subagents.clear();
   };
   const applyToolProjection = (callId, content, rawOutput) => {
     const tool = tools.get(callId);
@@ -21096,6 +21493,7 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
         retryable: false
       }
     } : { status: "succeeded" };
+    settleWatchedSubagents(tool.type === "toolExecution" ? tool.toolName : tool.command, tool.type === "toolExecution" ? tool.arguments : void 0, content, rawOutput);
     items.push({ item: tool, outcome });
     if (status !== "completed")
       return;
@@ -21163,6 +21561,8 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
       agent = null;
       reasoning = null;
       tools.clear();
+      subagents.clear();
+      subagentAliases.clear();
       continue;
     }
     if (event.type === "user.text") {
@@ -21237,23 +21637,99 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
     } else if (event.type === "tool.call") {
       completeReasoning();
       completeAgent();
-      tools.set(event.callId, startGrokToolItem({
-        itemId: stableId("tool", turnIndex, ++messageIndex),
-        name: event.name,
-        title: event.title,
-        kind: event.kind,
-        rawInput: event.rawInput,
-        cwd
-      }));
-      applyToolProjection(event.callId, event.content, event.rawOutput);
-      if (event.status === "completed" || event.status === "failed") {
-        completeTool(event.callId, event.status, event.content, event.rawOutput);
+      const operation = grokSubagentOperation(event.name, event.title, event.rawInput);
+      if (operation) {
+        const nativeSubagentId = grokNativeSubagentId(event.rawInput, event.rawOutput, event.content);
+        rememberSubagentAlias(event.callId, nativeSubagentId);
+        const prompt = grokSubagentPrompt(event.rawInput);
+        const role = grokSubagentRole(event.rawInput);
+        const model = grokSubagentModel(event.rawInput);
+        subagents.set(event.callId, {
+          type: "subagentDelegation",
+          itemId: stableId("subagent", turnIndex, ++messageIndex),
+          operation,
+          ...prompt ? { prompt } : {},
+          subagents: [
+            {
+              subagentId: nativeSubagentId ?? event.callId,
+              ...nativeSubagentId ? { nativeSubagentId } : {},
+              description: grokSubagentDescription(event.rawInput, event.title),
+              ...role ? { role } : {},
+              ...model ? { model } : {},
+              background: grokSubagentBackground(event.rawInput),
+              status: "running"
+            }
+          ]
+        });
+        if (event.status === "completed" || event.status === "failed") {
+          completeHistorySubagent(event.callId, event.status, event.content, event.rawOutput, event.rawInput);
+        }
+      } else {
+        tools.set(event.callId, startGrokToolItem({
+          itemId: stableId("tool", turnIndex, ++messageIndex),
+          name: event.name,
+          title: event.title,
+          kind: event.kind,
+          rawInput: event.rawInput,
+          cwd
+        }));
+        applyToolProjection(event.callId, event.content, event.rawOutput);
+        if (event.status === "completed" || event.status === "failed") {
+          completeTool(event.callId, event.status, event.content, event.rawOutput);
+        }
       }
     } else if (event.type === "tool.update") {
-      applyToolProjection(event.callId, event.content, event.rawOutput);
-      if (event.status === "completed" || event.status === "failed") {
-        completeTool(event.callId, event.status, event.content, event.rawOutput);
+      if (subagents.has(event.callId)) {
+        const current = subagents.get(event.callId);
+        if (current?.subagents[0]) {
+          const nativeSubagentId = grokNativeSubagentId(event.rawInput, event.rawOutput, event.content) ?? current.subagents[0].nativeSubagentId;
+          rememberSubagentAlias(event.callId, nativeSubagentId);
+          subagents.set(event.callId, {
+            ...current,
+            subagents: [
+              {
+                ...current.subagents[0],
+                description: grokSubagentDescription(event.rawInput, event.title, current.subagents[0].description),
+                ...nativeSubagentId ? { nativeSubagentId, subagentId: nativeSubagentId } : {}
+              }
+            ]
+          });
+        }
+        if (event.status === "completed" || event.status === "failed") {
+          completeHistorySubagent(event.callId, event.status, event.content, event.rawOutput, event.rawInput);
+        }
+      } else {
+        applyToolProjection(event.callId, event.content, event.rawOutput);
+        if (event.status === "completed" || event.status === "failed") {
+          completeTool(event.callId, event.status, event.content, event.rawOutput);
+        }
+      }
+    } else if (event.type === "subagent.spawned") {
+      for (const [callId, current] of subagents) {
+        const agent2 = current.subagents[0];
+        if (!agent2)
+          continue;
+        const matchesId = agent2.nativeSubagentId === event.nativeSubagentId;
+        const matchesDescription = !agent2.nativeSubagentId && event.description !== void 0 && agent2.description === event.description;
+        if (!matchesId && !matchesDescription)
+          continue;
+        rememberSubagentAlias(callId, event.nativeSubagentId);
+        subagents.set(callId, {
+          ...current,
+          subagents: [
+            {
+              ...agent2,
+              nativeSubagentId: event.nativeSubagentId,
+              subagentId: event.nativeSubagentId,
+              ...event.role ? { role: event.role } : {},
+              ...event.model ? { model: event.model } : {}
+            }
+          ]
+        });
+        break;
       }
+    } else if (event.type === "subagent.finished") {
+      settleWatchedSubagents("get_command_or_subagent_output", { task_ids: [event.nativeSubagentId] }, event.resultSummary ? [event.resultSummary] : void 0, { task_id: event.nativeSubagentId, status: event.status, output: event.resultSummary });
     }
   }
   completeTurn({ status: "unknown", reason: "Grok Native history has no terminal signal" });
@@ -21278,11 +21754,11 @@ var GROK_SESSION_DELETE_METHOD = "_x.ai/session/delete";
 function error51(code, message, retryable = false) {
   return { code, message, retryable };
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isGrokMethodNotFound(error53) {
-  if (isRecord5(error53) && error53.code === -32601)
+  if (isRecord6(error53) && error53.code === -32601)
     return true;
   const message = error53 instanceof Error ? error53.message : String(error53);
   return /method not found/iu.test(message);
@@ -21300,10 +21776,10 @@ function buildGrokForkParams(input) {
   };
 }
 function parseGrokForkResponse(value) {
-  if (!isRecord5(value) || value.error !== void 0)
+  if (!isRecord6(value) || value.error !== void 0)
     return null;
-  const payload = typeof value.newSessionId !== "string" && isRecord5(value.result) ? value.result : value;
-  if (!isRecord5(payload) || payload.error !== void 0)
+  const payload = typeof value.newSessionId !== "string" && isRecord6(value.result) ? value.result : value;
+  if (!isRecord6(payload) || payload.error !== void 0)
     return null;
   if (typeof payload.newSessionId !== "string" || payload.newSessionId.length === 0)
     return null;
@@ -21466,7 +21942,7 @@ var GROK_SESSION_UPDATE_EXTENSION_METHODS = [
   "_x.ai/session/update",
   "x.ai/session_notification"
 ];
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalNonNegativeInt(value) {
@@ -21487,7 +21963,7 @@ function isGrokExtensionSessionUpdateMethod(method) {
   return GROK_SESSION_UPDATE_EXTENSION_METHODS.includes(method);
 }
 function grokCompactionEventFromUpdate(update) {
-  if (!isRecord6(update) || typeof update.sessionUpdate !== "string")
+  if (!isRecord7(update) || typeof update.sessionUpdate !== "string")
     return null;
   const tokensUsed = optionalNonNegativeInt(firstPresent(update, ["tokensUsed", "tokens_used"]));
   const contextWindowTokens = optionalNonNegativeInt(firstPresent(update, ["contextWindowTokens", "contextWindow", "context_window"]));
@@ -21526,7 +22002,7 @@ function grokCompactionEventFromUpdate(update) {
 // dist/grok-manual-compaction.js
 var GROK_COMPACT_CONVERSATION_METHOD = "x.ai/compact_conversation";
 var GROK_COMPACT_CONVERSATION_FALLBACK_METHOD = "_x.ai/compact_conversation";
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalNonNegativeInt2(value) {
@@ -21538,7 +22014,7 @@ function optionalErrorMessage2(value) {
 function parseGrokCompactResult(value, cancelled = false) {
   if (cancelled)
     return { outcome: "cancelled" };
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return { outcome: "succeeded" };
   const tokensBefore = optionalNonNegativeInt2(value.tokensBefore ?? value.tokens_before);
   const tokensAfter = optionalNonNegativeInt2(value.tokensAfter ?? value.tokens_after);
@@ -21576,7 +22052,7 @@ var GROK_REWIND_EXECUTE_METHOD = "_x.ai/rewind/execute";
 function error52(code, message, retryable = false) {
   return { code, message, retryable };
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function buildGrokRewindParams(input) {
@@ -21588,10 +22064,10 @@ function buildGrokRewindParams(input) {
   };
 }
 function parseGrokRewindResponse(value) {
-  if (!isRecord8(value))
+  if (!isRecord9(value))
     return null;
-  const payload = typeof value.success !== "boolean" && isRecord8(value.result) ? value.result : value;
-  if (!isRecord8(payload) || typeof payload.success !== "boolean")
+  const payload = typeof value.success !== "boolean" && isRecord9(value.result) ? value.result : value;
+  if (!isRecord9(payload) || typeof payload.success !== "boolean")
     return null;
   return rewindPayload(payload);
 }
@@ -21701,10 +22177,10 @@ async function rewindGrokLastTurn(input) {
 
 // dist/grok-plan-review.js
 var GROK_PLAN_DECISION_ID = "plan-decision";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function stringField2(value, ...keys) {
+function stringField3(value, ...keys) {
   for (const key of keys) {
     const field = value[key];
     if (typeof field === "string" && field.length > 0)
@@ -21713,12 +22189,12 @@ function stringField2(value, ...keys) {
   return void 0;
 }
 function parseGrokExitPlanModeParams(params) {
-  if (!isRecord9(params))
+  if (!isRecord10(params))
     return null;
-  const nested = isRecord9(params.input) ? params.input : params;
-  const plan = stringField2(nested, "planContent", "plan_content", "plan") ?? stringField2(params, "planContent", "plan_content", "plan") ?? null;
-  const planFilePath = stringField2(nested, "planFilePath", "plan_file_path") ?? stringField2(params, "planFilePath", "plan_file_path");
-  const sessionId = stringField2(params, "sessionId", "session_id");
+  const nested = isRecord10(params.input) ? params.input : params;
+  const plan = stringField3(nested, "planContent", "plan_content", "plan") ?? stringField3(params, "planContent", "plan_content", "plan") ?? null;
+  const planFilePath = stringField3(nested, "planFilePath", "plan_file_path") ?? stringField3(params, "planFilePath", "plan_file_path");
+  const sessionId = stringField3(params, "sessionId", "session_id");
   return {
     plan,
     ...sessionId ? { sessionId } : {},
@@ -21782,10 +22258,10 @@ var GROK_ACP_CLIENT_CAPABILITIES = {
     "x.ai/exit_plan_mode": true
   }
 };
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function stringField3(value, ...keys) {
+function stringField4(value, ...keys) {
   for (const key of keys) {
     const field = value[key];
     if (typeof field === "string" && field.length > 0)
@@ -21811,22 +22287,22 @@ function isGrokExitPlanModeMethod(method) {
 function questionsPayload(params) {
   if (Array.isArray(params.questions))
     return params.questions;
-  if (isRecord10(params.input) && Array.isArray(params.input.questions))
+  if (isRecord11(params.input) && Array.isArray(params.input.questions))
     return params.input.questions;
-  if (isRecord10(params.askUserQuestion) && Array.isArray(params.askUserQuestion.questions)) {
+  if (isRecord11(params.askUserQuestion) && Array.isArray(params.askUserQuestion.questions)) {
     return params.askUserQuestion.questions;
   }
   return void 0;
 }
 function parseOption(value, labels) {
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return null;
-  const label = stringField3(value, "label");
+  const label = stringField4(value, "label");
   if (!label || labels.has(label))
     return null;
   labels.add(label);
-  const description = stringField3(value, "description");
-  const preview = stringField3(value, "preview");
+  const description = stringField4(value, "description");
+  const preview = stringField4(value, "preview");
   const combined = [description, preview].filter((part) => part !== void 0);
   return {
     label,
@@ -21834,9 +22310,9 @@ function parseOption(value, labels) {
   };
 }
 function parseQuestion(value, questions) {
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return null;
-  const question = stringField3(value, "question");
+  const question = stringField4(value, "question");
   if (!question || questions.has(question))
     return null;
   if (!Array.isArray(value.options) || value.options.length === 0)
@@ -21850,7 +22326,7 @@ function parseQuestion(value, questions) {
     options.push(parsed);
   }
   questions.add(question);
-  const header = stringField3(value, "header");
+  const header = stringField4(value, "header");
   return {
     question,
     ...header ? { header } : {},
@@ -21859,7 +22335,7 @@ function parseQuestion(value, questions) {
   };
 }
 function parseGrokAskUserQuestionParams(params) {
-  if (!isRecord10(params))
+  if (!isRecord11(params))
     return null;
   const rawQuestions = questionsPayload(params);
   if (!Array.isArray(rawQuestions) || rawQuestions.length === 0)
@@ -21872,7 +22348,7 @@ function parseGrokAskUserQuestionParams(params) {
       return null;
     questions.push(parsed);
   }
-  const sessionId = stringField3(params, "sessionId", "session_id");
+  const sessionId = stringField4(params, "sessionId", "session_id");
   const timeoutMs = optionalTimeoutMs(params);
   return {
     questions,
@@ -21974,9 +22450,18 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function acpToolName(update, metadata) {
+  if (!isRecord12(update))
+    return void 0;
+  if (typeof update.name === "string" && update.name.length > 0)
+    return update.name;
+  const meta3 = isRecord12(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord12(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
+  return tool && typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
+}
 function errorText(error53) {
   return error53 instanceof Error ? error53.message : String(error53);
 }
@@ -22030,7 +22515,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord11(error53) || error53.code !== "ESRCH")
+    if (!isRecord12(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
@@ -22055,6 +22540,9 @@ function transportEvent(update, metadata) {
   const compaction = grokCompactionEventFromUpdate(extension);
   if (compaction)
     return compaction;
+  const subagent = grokSubagentEventFromUpdate(extension);
+  if (subagent)
+    return subagent;
   switch (update.sessionUpdate) {
     case "user_message_chunk":
     case "agent_message_chunk":
@@ -22066,30 +22554,34 @@ function transportEvent(update, metadata) {
         text: update.content.text,
         ...update.messageId ? { messageId: update.messageId } : {}
       };
-    case "tool_call":
+    case "tool_call": {
+      const name = acpToolName(update, metadata);
       return {
         type: "tool.call",
         callId: update.toolCallId,
         title: update.title,
-        ...update.name ? { name: update.name } : {},
+        ...name ? { name } : {},
         ...update.kind ? { kind: update.kind } : {},
         ...update.status ? { status: update.status } : {},
         ...update.rawInput !== void 0 ? { rawInput: update.rawInput } : {},
         ...update.rawOutput !== void 0 ? { rawOutput: update.rawOutput } : {},
         ...update.content ? { content: update.content } : {}
       };
-    case "tool_call_update":
+    }
+    case "tool_call_update": {
+      const name = acpToolName(update, metadata);
       return {
         type: "tool.update",
         callId: update.toolCallId,
         ...update.title !== void 0 ? { title: update.title } : {},
-        ...update.name !== void 0 ? { name: update.name } : {},
+        ...name ? { name } : {},
         ...update.kind !== void 0 ? { kind: update.kind } : {},
         ...update.status !== void 0 ? { status: update.status } : {},
         ...update.rawInput !== void 0 ? { rawInput: update.rawInput } : {},
         ...update.rawOutput !== void 0 ? { rawOutput: update.rawOutput } : {},
         ...update.content !== void 0 ? { content: update.content } : {}
       };
+    }
     case "usage_update":
       return { type: "usage", update, ...metadata ? { metadata } : {} };
     default:
@@ -22118,7 +22610,7 @@ async function readNativeSignals(options, sessionId) {
   }
 }
 function isMissingFile(error53) {
-  return isRecord11(error53) && error53.code === "ENOENT";
+  return isRecord12(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
@@ -22141,7 +22633,7 @@ async function locateGrokNativeSession(options, sessionId) {
     try {
       summaryRaw = await readFile(path8.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
-      if (isMissingFile(error53) || isRecord11(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord12(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -22153,10 +22645,10 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord11(parsed))
+    if (!isRecord12(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord11(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path8.resolve(info.cwd) : path8.resolve(decodeURIComponent(entry.name));
+    const cwd = isRecord12(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path8.resolve(info.cwd) : path8.resolve(decodeURIComponent(entry.name));
     const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path8.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
@@ -22189,12 +22681,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord11(record2) || !isRecord11(record2.params))
+    if (!isRecord12(record2) || !isRecord12(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord11(params.update))
+    if (params.sessionId !== sessionId || !isRecord12(params.update))
       continue;
-    const metadata = isRecord11(params._meta) ? params._meta : void 0;
+    const metadata = isRecord12(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -22497,7 +22989,7 @@ var GrokAcpTransport = class {
       modelId,
       ...reasoningEffort ? { reasoningEffort } : {}
     });
-    if (!isRecord11(response) || !isRecord11(response._meta) || !isRecord11(response._meta.model)) {
+    if (!isRecord12(response) || !isRecord12(response._meta) || !isRecord12(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -22540,7 +23032,7 @@ var GrokAcpTransport = class {
   #handleUpdate(notification) {
     if (this.#sessionId && notification.sessionId !== this.#sessionId)
       return;
-    const metadata = isRecord11(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord12(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -22555,7 +23047,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord11(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord12(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -22582,8 +23074,200 @@ var GrokAcpTransport = class {
   }
 };
 
+// dist/grok-subagent-lifecycle.js
+function subagentFailure() {
+  return {
+    code: "nativeFailure",
+    message: "Grok Subagent delegation failed",
+    retryable: false
+  };
+}
+var GrokSubagentLifecycle = class {
+  #emit;
+  #newItemId;
+  #delegations = /* @__PURE__ */ new Map();
+  #callIdByNativeId = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#emit = options.emit;
+    this.#newItemId = options.newItemId;
+  }
+  get size() {
+    return this.#delegations.size;
+  }
+  has(callId) {
+    return this.#delegations.has(callId);
+  }
+  nativeSubagentId(callId) {
+    return this.#delegations.get(callId)?.item.subagents[0]?.nativeSubagentId;
+  }
+  start(turnId, input) {
+    if (this.#delegations.has(input.callId)) {
+      throw new Error("Grok Subagent delegation started more than once");
+    }
+    this.#callIdByNativeId.set(input.callId, input.callId);
+    if (input.nativeSubagentId)
+      this.#callIdByNativeId.set(input.nativeSubagentId, input.callId);
+    const subagent = {
+      subagentId: input.nativeSubagentId ?? input.callId,
+      ...input.nativeSubagentId ? { nativeSubagentId: input.nativeSubagentId } : {},
+      description: input.description,
+      ...input.role ? { role: input.role } : {},
+      ...input.model ? { model: input.model } : {},
+      ...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {},
+      background: input.background,
+      status: "running"
+    };
+    const item = {
+      type: "subagentDelegation",
+      itemId: this.#newItemId(),
+      operation: input.operation,
+      ...input.prompt ? { prompt: input.prompt } : {},
+      subagents: [subagent]
+    };
+    this.#delegations.set(input.callId, { callId: input.callId, item });
+    this.#emit({ type: "item.started", turnId, item });
+    this.#emitState(subagent);
+    return subagent;
+  }
+  bindNativeId(turnId, input) {
+    for (const [callId, active] of this.#delegations) {
+      const current = active.item.subagents[0];
+      if (!current)
+        continue;
+      if (current.nativeSubagentId === input.nativeSubagentId) {
+        return this.update(turnId, callId, input);
+      }
+    }
+    for (const [callId, active] of this.#delegations) {
+      const current = active.item.subagents[0];
+      if (!current || current.nativeSubagentId)
+        continue;
+      if (input.description && current.description === input.description) {
+        return this.update(turnId, callId, input);
+      }
+    }
+    return void 0;
+  }
+  update(turnId, callId, patch) {
+    const active = this.#delegations.get(callId);
+    if (!active)
+      return void 0;
+    const current = active.item.subagents[0];
+    if (!current)
+      throw new Error("Grok Subagent delegation has no Agent state");
+    if (patch.nativeSubagentId)
+      this.#callIdByNativeId.set(patch.nativeSubagentId, callId);
+    const nativeSubagentId = patch.nativeSubagentId ?? current.nativeSubagentId;
+    const subagent = {
+      ...current,
+      ...nativeSubagentId ? { nativeSubagentId, subagentId: nativeSubagentId } : {},
+      ...patch.description ? { description: patch.description } : {},
+      ...patch.role ? { role: patch.role } : {},
+      ...patch.model ? { model: patch.model } : {},
+      ...patch.reasoningEffort ? { reasoningEffort: patch.reasoningEffort } : {},
+      ...patch.resultSummary ? { resultSummary: patch.resultSummary } : {},
+      ...patch.status ? { status: patch.status } : {}
+    };
+    active.item = { ...active.item, subagents: [subagent] };
+    this.#emit({
+      type: "item.updated",
+      turnId,
+      itemId: active.item.itemId,
+      update: { type: "subagents.replace", subagents: active.item.subagents }
+    });
+    this.#emitState(subagent);
+    return subagent;
+  }
+  completeSpawn(turnId, callId, input) {
+    const active = this.#delegations.get(callId);
+    const background = input.background ?? active?.item.subagents[0]?.background ?? true;
+    const keepRunning = !input.failed && !input.cancellationRequested && (background || active?.item.operation === "send");
+    if (keepRunning) {
+      return this.update(turnId, callId, {
+        status: "running",
+        ...input.nativeSubagentId ? { nativeSubagentId: input.nativeSubagentId } : {},
+        ...input.resultSummary ? { resultSummary: input.resultSummary } : {}
+      });
+    }
+    return this.complete(turnId, callId, { ...input, keepRunning: false });
+  }
+  completeByNativeId(turnId, nativeSubagentId, input) {
+    const callId = this.#callIdByNativeId.get(nativeSubagentId) ?? this.#callIdForNative(nativeSubagentId);
+    if (callId && this.#delegations.has(callId)) {
+      return this.complete(turnId, callId, { ...input, nativeSubagentId });
+    }
+    const status = input.status ?? (input.cancellationRequested ? "interrupted" : input.failed ? "failed" : "completed");
+    this.#emit({
+      type: "subagent.state.changed",
+      nativeSubagentId,
+      status,
+      ...input.resultSummary ? { resultSummary: input.resultSummary } : {}
+    });
+    return void 0;
+  }
+  complete(turnId, callId, input) {
+    const active = this.#delegations.get(callId);
+    if (!active)
+      return void 0;
+    this.#delegations.delete(callId);
+    const current = active.item.subagents[0];
+    if (!current)
+      throw new Error("Grok Subagent delegation has no Agent state");
+    const status = input.status ?? (input.cancellationRequested ? "interrupted" : input.failed ? "failed" : input.keepRunning ? "running" : "completed");
+    const nativeSubagentId = input.nativeSubagentId ?? current.nativeSubagentId;
+    if (nativeSubagentId)
+      this.#callIdByNativeId.set(nativeSubagentId, callId);
+    const subagent = {
+      ...current,
+      status,
+      ...nativeSubagentId ? { nativeSubagentId, subagentId: nativeSubagentId } : {},
+      ...input.resultSummary ? { resultSummary: input.resultSummary } : {}
+    };
+    const item = { ...active.item, subagents: [subagent] };
+    this.#emit({
+      type: "item.updated",
+      turnId,
+      itemId: item.itemId,
+      update: { type: "subagents.replace", subagents: item.subagents }
+    });
+    const outcome = input.cancellationRequested ? { status: "cancelled", reason: "Cancelled by user" } : input.failed ? { status: "failed", error: subagentFailure() } : { status: "succeeded" };
+    this.#emit({ type: "item.completed", turnId, snapshot: { item, outcome } });
+    this.#emitState(subagent);
+    return subagent;
+  }
+  finalize(turnId, outcome) {
+    for (const [callId, active] of this.#delegations) {
+      this.#delegations.delete(callId);
+      const current = active.item.subagents[0];
+      if (!current)
+        continue;
+      const status = outcome.status === "succeeded" ? current.status : outcome.status === "cancelled" ? "interrupted" : "failed";
+      const item = { ...active.item, subagents: [{ ...current, status }] };
+      this.#emit({ type: "item.completed", turnId, snapshot: { item, outcome } });
+      this.#emitState({ ...current, status });
+    }
+  }
+  #callIdForNative(nativeSubagentId) {
+    for (const [callId, active] of this.#delegations) {
+      if (active.item.subagents[0]?.nativeSubagentId === nativeSubagentId)
+        return callId;
+    }
+    return void 0;
+  }
+  #emitState(subagent) {
+    if (!subagent.nativeSubagentId)
+      return;
+    this.#emit({
+      type: "subagent.state.changed",
+      nativeSubagentId: subagent.nativeSubagentId,
+      status: subagent.status,
+      ...subagent.resultSummary ? { resultSummary: subagent.resultSummary } : {}
+    });
+  }
+};
+
 // dist/grok-models.js
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -22595,7 +23279,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord12(candidate) || !nonBlank(candidate.label))
+    if (!isRecord13(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -22606,7 +23290,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord12(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord13(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -22617,12 +23301,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord12(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord13(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord12(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord13(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (typeof metadata.totalContextTokens === "number" && Number.isSafeInteger(metadata.totalContextTokens) && metadata.totalContextTokens > 0) {
       contextWindowTokensByModel.set(ref.data.id, metadata.totalContextTokens);
@@ -22657,10 +23341,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord12(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord13(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord12(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord13(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model;
@@ -22684,7 +23368,7 @@ import os4 from "node:os";
 import path9 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -22714,7 +23398,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord13(entry) || typeof entry.product !== "string")
+    if (!isRecord14(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
@@ -22722,13 +23406,13 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord13(value) || !isRecord13(value.config))
+  if (!isRecord14(value) || !isRecord14(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord13(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord14(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
-  const onDemandCap = isRecord13(config2.onDemandCap) ? nonNegativeNumber(config2.onDemandCap.val) : void 0;
-  const onDemandUsed = isRecord13(config2.onDemandUsed) ? nonNegativeNumber(config2.onDemandUsed.val) : void 0;
+  const onDemandCap = isRecord14(config2.onDemandCap) ? nonNegativeNumber(config2.onDemandCap.val) : void 0;
+  const onDemandUsed = isRecord14(config2.onDemandUsed) ? nonNegativeNumber(config2.onDemandUsed.val) : void 0;
   const usedPercent = finitePercent(config2.creditUsagePercent) ?? (onDemandCap !== void 0 && onDemandCap > 0 && onDemandUsed !== void 0 ? Math.min(100, Math.max(0, onDemandUsed / onDemandCap * 100)) : void 0);
   if (usedPercent === void 0)
     return null;
@@ -22742,11 +23426,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord13(auth))
+  if (!isRecord14(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord13(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord14(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord13(value) || typeof value.key !== "string")
+    if (!isRecord14(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -22818,7 +23502,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -22835,7 +23519,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return null;
   const nativeInputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -22864,7 +23548,7 @@ function usageFromPrompt(response) {
   return response.usage ? usageFromNative(response.usage) : null;
 }
 function usageFromSignals(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return null;
   try {
     return parseHostUsage({
@@ -22884,7 +23568,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -22961,7 +23645,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord14(update.cost) ? update.cost : null;
+      const cost = isRecord15(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -23002,7 +23686,8 @@ function capabilitiesForModels(modelState) {
       selectPermissionMode: true,
       permissionModeScope: "atCreate"
     },
-    history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true }
+    history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
+    subagents: { observe: true, readTranscript: true }
   };
 }
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
@@ -23203,6 +23888,7 @@ var GrokHarnessSession = class {
       compactionContextWindow: void 0,
       compactionTerminal: null,
       tools: /* @__PURE__ */ new Map(),
+      subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
       questions: /* @__PURE__ */ new Map(),
@@ -23278,6 +23964,7 @@ var GrokHarnessSession = class {
       compactionContextWindow: void 0,
       compactionTerminal: null,
       tools: /* @__PURE__ */ new Map(),
+      subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
       questions: /* @__PURE__ */ new Map(),
@@ -23607,6 +24294,10 @@ var GrokHarnessSession = class {
       this.#startTool(active, event);
     else if (event.type === "tool.update")
       this.#updateTool(active, event);
+    else if (event.type === "subagent.spawned")
+      this.#bindSpawnedSubagent(active, event);
+    else if (event.type === "subagent.finished")
+      this.#finishNativeSubagent(active, event);
     else if (event.type === "compaction.started")
       this.#startCompaction(active, event);
     else if (event.type === "compaction.completed") {
@@ -23713,9 +24404,44 @@ var GrokHarnessSession = class {
       update: { type: "text.append", text }
     });
   }
+  #createSubagents() {
+    return new GrokSubagentLifecycle({
+      newItemId: () => hostItemIdSchema.parse(this.#randomUUID()),
+      emit: (event) => this.#event(event)
+    });
+  }
+  #subagentModelLabel(modelId) {
+    const id = modelId ?? this.#state.effectiveModel?.id;
+    if (!id)
+      return void 0;
+    return this.#modelState.catalog.models.find((model) => model.ref.id === id)?.label ?? id;
+  }
   #startTool(active, event) {
     this.#completeReasoning(active, { status: "succeeded" });
     this.#completeAgent(active, { status: "succeeded" });
+    const operation = grokSubagentOperation(event.name, event.title, event.rawInput);
+    if (operation) {
+      const prompt = grokSubagentPrompt(event.rawInput);
+      const role = grokSubagentRole(event.rawInput);
+      const nativeSubagentId = grokNativeSubagentId(event.rawInput);
+      const model = this.#subagentModelLabel(grokSubagentModel(event.rawInput));
+      const reasoningEffort = this.#state.effectiveThinkingOptionId;
+      active.subagents.start(active.command.turnId, {
+        callId: event.callId,
+        operation,
+        description: grokSubagentDescription(event.rawInput, event.title),
+        ...prompt ? { prompt } : {},
+        ...role ? { role } : {},
+        ...model ? { model } : {},
+        ...reasoningEffort ? { reasoningEffort } : {},
+        background: grokSubagentBackground(event.rawInput),
+        ...nativeSubagentId ? { nativeSubagentId } : {}
+      });
+      if (event.status === "completed" || event.status === "failed") {
+        this.#completeSubagentTool(active, event.callId, event.status, event);
+      }
+      return;
+    }
     let item = startGrokToolItem({
       itemId: hostItemIdSchema.parse(this.#randomUUID()),
       name: event.name,
@@ -23734,6 +24460,34 @@ var GrokHarnessSession = class {
     }
   }
   #updateTool(active, event) {
+    if (!active.subagents.has(event.callId) && !active.tools.has(event.callId) && grokSubagentOperation(event.name, event.title, event.rawInput)) {
+      this.#startTool(active, {
+        type: "tool.call",
+        callId: event.callId,
+        title: event.title ?? "Grok Subagent",
+        ...event.name ? { name: event.name } : {},
+        ...event.kind ? { kind: event.kind } : {},
+        ...event.status ? { status: event.status } : {},
+        ...event.rawInput !== void 0 ? { rawInput: event.rawInput } : {},
+        ...event.rawOutput !== void 0 ? { rawOutput: event.rawOutput } : {},
+        ...event.content ? { content: event.content } : {}
+      });
+      return;
+    }
+    if (active.subagents.has(event.callId)) {
+      if (event.status === "completed" || event.status === "failed") {
+        this.#completeSubagentTool(active, event.callId, event.status, event);
+        return;
+      }
+      const role = grokSubagentRole(event.rawInput);
+      const nativeSubagentId = grokNativeSubagentId(event.rawInput, event.rawOutput, event.content);
+      active.subagents.update(active.command.turnId, event.callId, {
+        ...event.title ? { description: grokSubagentDescription(event.rawInput, event.title) } : {},
+        ...role ? { role } : {},
+        ...nativeSubagentId ? { nativeSubagentId } : {}
+      });
+      return;
+    }
     const tool = active.tools.get(event.callId);
     if (!tool)
       return;
@@ -23787,6 +24541,7 @@ var GrokHarnessSession = class {
       }
     } : { status: "succeeded" };
     this.#completeItem(active, tool.item, outcome);
+    this.#completeWatchedSubagents(active, tool.item, content, rawOutput);
     if (status !== "completed")
       return;
     const changes = projectGrokFileChanges(content, this.#cwd);
@@ -23800,6 +24555,52 @@ var GrokHarnessSession = class {
     this.#event({ type: "item.started", turnId: active.command.turnId, item: fileItem });
     this.#completeItem(active, fileItem, { status: "succeeded" });
   }
+  #completeSubagentTool(active, callId, status, event) {
+    const nativeSubagentId = grokNativeSubagentId(event.rawInput, event.rawOutput, event.content);
+    const resultSummary = grokSubagentResultSummary(event.content, event.rawOutput);
+    active.subagents.completeSpawn(active.command.turnId, callId, {
+      failed: status === "failed",
+      cancellationRequested: active.cancellationRequested,
+      ...nativeSubagentId ? { nativeSubagentId } : {},
+      ...resultSummary ? { resultSummary } : {}
+    });
+  }
+  #completeWatchedSubagents(active, item, content, rawOutput) {
+    const name = item.type === "toolExecution" ? item.toolName : item.command;
+    const rawInput = item.type === "toolExecution" ? item.arguments : void 0;
+    const resultSummary = grokSubagentResultSummary(content, rawOutput);
+    for (const settlement of grokSubagentWaitSettlements({
+      name,
+      title: name,
+      rawInput,
+      content,
+      rawOutput
+    })) {
+      active.subagents.completeByNativeId(active.command.turnId, settlement.id, {
+        failed: settlement.status === "failed",
+        cancellationRequested: active.cancellationRequested || settlement.status === "interrupted",
+        status: settlement.status,
+        ...settlement.resultSummary ? { resultSummary: settlement.resultSummary } : resultSummary ? { resultSummary } : {}
+      });
+    }
+  }
+  #bindSpawnedSubagent(active, event) {
+    const model = event.model ? this.#subagentModelLabel(event.model) : void 0;
+    active.subagents.bindNativeId(active.command.turnId, {
+      nativeSubagentId: event.nativeSubagentId,
+      ...event.description ? { description: event.description } : {},
+      ...event.role ? { role: event.role } : {},
+      ...model ? { model } : {}
+    });
+  }
+  #finishNativeSubagent(active, event) {
+    active.subagents.completeByNativeId(active.command.turnId, event.nativeSubagentId, {
+      failed: event.status === "failed",
+      cancellationRequested: active.cancellationRequested || event.status === "interrupted",
+      status: event.status,
+      ...event.resultSummary ? { resultSummary: event.resultSummary } : {}
+    });
+  }
   #completeAgent(active, outcome) {
     const item = active.agent;
     if (item && active.rawAgentText.length > 0) {
@@ -23863,6 +24664,7 @@ var GrokHarnessSession = class {
     const itemOutcome = outcome;
     this.#completeReasoning(active, itemOutcome);
     this.#completeAgent(active, itemOutcome);
+    active.subagents.finalize(active.command.turnId, itemOutcome);
     if (active.compactionItem) {
       this.#completeItem(active, active.compactionItem, itemOutcome);
       active.compactionItem = null;
@@ -23940,6 +24742,39 @@ var GrokHarnessSession = class {
 var GrokAdapter = class {
   commandCatalog = grokCommandCatalog;
   harnessId = grokHarnessId;
+  subagents = {
+    readSnapshot: async (input) => {
+      if (input.parent.harnessId !== this.harnessId || input.nativeSubagentId.trim().length === 0) {
+        return {
+          ok: false,
+          error: {
+            code: "invalidRequest",
+            message: "Grok Subagent reference is invalid",
+            retryable: false
+          }
+        };
+      }
+      try {
+        const location = await locateGrokNativeSession(this.#environment ? { environment: this.#environment } : {}, input.nativeSubagentId);
+        const cwd = location?.cwd ?? input.cwd;
+        const history = await readGrokNativeHistory(this.#environment ? { cwd, environment: this.#environment } : { cwd }, input.nativeSubagentId);
+        return {
+          ok: true,
+          value: mapGrokReplay(
+            history,
+            this.harnessId,
+            // Host Subagent records keep the parent Native Session identity.
+            input.parent.nativeSessionId,
+            cwd,
+            [],
+            this.#toolOutputLimit
+          )
+        };
+      } catch (error53) {
+        return { ok: false, error: normalizeError(error53, "protocolError") };
+      }
+    }
+  };
   #closeTimeoutMs;
   #dependencies;
   #environment;