@codexhost/cli-darwin-x64 0.6.1 → 0.7.0

package/app/plugins/grok/plugin.mjs

@@ -19938,8 +19938,13 @@ function resolveGrokExecutable(input = {}) {
     throw new GrokExecutableError("Grok CLI is not installed");
   return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path3.resolve(resolution.executable);
 }
-function grokInvocation(command, platform = process.platform) {
-  return commandInvocation(command, ["agent", "--no-leader", "stdio"], process.env, platform);
+function grokInvocation(command, platform = process.platform, modelId) {
+  const arguments_ = ["agent", "--no-leader"];
+  const trimmed = modelId?.trim();
+  if (trimmed)
+    arguments_.push("--model", trimmed);
+  arguments_.push("stdio");
+  return commandInvocation(command, arguments_, process.env, platform);
 }
 
 // dist/grok-fork.js
@@ -20930,6 +20935,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}`);
@@ -20992,6 +21300,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;
@@ -21012,6 +21404,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);
@@ -21036,6 +21432,9 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
         retryable: false
       }
     } : { status: "succeeded" };
+    if (status === "completed") {
+      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;
@@ -21103,6 +21502,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") {
@@ -21177,23 +21578,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" });
@@ -21218,11 +21695,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);
@@ -21240,10 +21717,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;
@@ -21406,7 +21883,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) {
@@ -21427,7 +21904,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"]));
@@ -21466,7 +21943,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) {
@@ -21478,7 +21955,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);
@@ -21516,7 +21993,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) {
@@ -21528,10 +22005,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);
 }
@@ -21688,9 +22165,18 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function acpToolName(update, metadata) {
+  if (!isRecord10(update))
+    return void 0;
+  if (typeof update.name === "string" && update.name.length > 0)
+    return update.name;
+  const meta3 = isRecord10(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord10(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);
 }
@@ -21744,7 +22230,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord9(error53) || error53.code !== "ESRCH")
+    if (!isRecord10(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
@@ -21769,6 +22255,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":
@@ -21780,30 +22269,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:
@@ -21832,7 +22325,7 @@ async function readNativeSignals(options, sessionId) {
   }
 }
 function isMissingFile(error53) {
-  return isRecord9(error53) && error53.code === "ENOENT";
+  return isRecord10(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
@@ -21855,7 +22348,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) || isRecord9(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord10(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -21867,10 +22360,10 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord9(parsed))
+    if (!isRecord10(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord9(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path8.resolve(info.cwd) : path8.resolve(decodeURIComponent(entry.name));
+    const cwd = isRecord10(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,
@@ -21903,12 +22396,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord9(record2) || !isRecord9(record2.params))
+    if (!isRecord10(record2) || !isRecord10(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord9(params.update))
+    if (params.sessionId !== sessionId || !isRecord10(params.update))
       continue;
-    const metadata = isRecord9(params._meta) ? params._meta : void 0;
+    const metadata = isRecord10(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -21926,6 +22419,7 @@ var GrokAcpTransport = class {
   #initialize = null;
   #replay = null;
   #sessionId = null;
+  #startupModelId;
   #stderrTail = "";
   constructor(options) {
     this.#options = {
@@ -21982,6 +22476,8 @@ var GrokAcpTransport = class {
     if (this.#sessionId || this.#closed)
       throw new Error("Grok ACP Transport cannot be opened twice");
     try {
+      if (input.kind === "create")
+        this.#startupModelId = input.modelId;
       const initialize = await this.#ensureInitialized();
       const connection = this.#connection;
       if (!connection)
@@ -22107,7 +22603,7 @@ var GrokAcpTransport = class {
       ...this.#options.command ? { command: this.#options.command } : {},
       environment: this.#options.environment ?? process.env
     });
-    const invocation = grokInvocation(executable);
+    const invocation = grokInvocation(executable, process.platform, this.#startupModelId);
     const child = spawn(invocation.command, invocation.arguments, {
       cwd: this.#options.cwd,
       env: { ...process.env, ...this.#options.environment },
@@ -22210,7 +22706,7 @@ var GrokAcpTransport = class {
       modelId,
       ...reasoningEffort ? { reasoningEffort } : {}
     });
-    if (!isRecord9(response) || !isRecord9(response._meta) || !isRecord9(response._meta.model)) {
+    if (!isRecord10(response) || !isRecord10(response._meta) || !isRecord10(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -22253,7 +22749,7 @@ var GrokAcpTransport = class {
   #handleUpdate(notification) {
     if (this.#sessionId && notification.sessionId !== this.#sessionId)
       return;
-    const metadata = isRecord9(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord10(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -22268,7 +22764,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord9(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord10(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -22285,8 +22781,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 isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -22298,7 +22986,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord10(candidate) || !nonBlank(candidate.label))
+    if (!isRecord11(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -22309,7 +22997,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord10(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord11(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -22320,12 +23008,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord10(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord11(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord10(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord11(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);
@@ -22360,10 +23048,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord10(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord11(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord10(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord11(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model;
@@ -22387,7 +23075,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 isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -22395,10 +23083,13 @@ function finitePercent(value) {
     return void 0;
   return Math.min(100, Math.max(0, value));
 }
-function nonNegativeNumber(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+function nonNegativeCentValue(value) {
+  if (!isRecord12(value))
     return void 0;
-  return value;
+  const amount = value.val === void 0 ? 0 : value.val;
+  if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
+    return void 0;
+  return amount;
 }
 function grokHome(environment) {
   return environment.GROK_HOME ?? path9.join(environment.HOME ?? environment.USERPROFILE ?? os4.homedir(), ".grok");
@@ -22417,7 +23108,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord11(entry) || typeof entry.product !== "string")
+    if (!isRecord12(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
@@ -22425,31 +23116,41 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord11(value) || !isRecord11(value.config))
+  if (!isRecord12(value) || !isRecord12(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord11(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord12(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const periodType = periodTypeFrom(period?.type);
   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 = isRecord11(config2.onDemandCap) ? nonNegativeNumber(config2.onDemandCap.val) : void 0;
-  const onDemandUsed = isRecord11(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);
+  let usedPercent = finitePercent(config2.creditUsagePercent);
+  if (config2.creditUsagePercent === void 0) {
+    const monthlyLimit = nonNegativeCentValue(config2.monthlyLimit);
+    const used = nonNegativeCentValue(config2.used);
+    if (config2.monthlyLimit !== void 0 && monthlyLimit === void 0 || config2.used !== void 0 && used === void 0)
+      return null;
+    if (monthlyLimit !== void 0 && monthlyLimit > 0) {
+      usedPercent = Math.min(100, (used ?? 0) / monthlyLimit * 100);
+    } else if (periodType !== "unknown" && resetsAt !== void 0 && Number.isFinite(Date.parse(resetsAt))) {
+      usedPercent = 0;
+    }
+  }
   if (usedPercent === void 0)
     return null;
   const productUsage = productUsageFrom(config2.productUsage);
   return {
     usedPercent,
-    periodType: periodTypeFrom(period?.type),
+    periodType,
     fetchedAt,
     ...resetsAt ? { resetsAt } : {},
     ...productUsage ? { productUsage } : {}
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord11(auth))
+  if (!isRecord12(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord11(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::")) && isRecord12(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 (!isRecord11(value) || typeof value.key !== "string")
+    if (!isRecord12(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -22520,7 +23221,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -22537,7 +23238,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -22564,7 +23265,7 @@ function usageFromPrompt(response) {
   return response.usage ? usageFromNative(response.usage) : null;
 }
 function usageFromSignals(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return null;
   try {
     return parseHostUsage({
@@ -22584,7 +23285,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -22661,7 +23362,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord12(update.cost) ? update.cost : null;
+      const cost = isRecord13(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -22702,7 +23403,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;
@@ -22902,6 +23604,7 @@ var GrokHarnessSession = class {
       compactionContextWindow: void 0,
       compactionTerminal: null,
       tools: /* @__PURE__ */ new Map(),
+      subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
       cancellationRequested: false,
@@ -22976,6 +23679,7 @@ var GrokHarnessSession = class {
       compactionContextWindow: void 0,
       compactionTerminal: null,
       tools: /* @__PURE__ */ new Map(),
+      subagents: this.#createSubagents(),
       completedItems: [],
       approvals: /* @__PURE__ */ new Map(),
       cancellationRequested: false,
@@ -23204,6 +23908,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") {
@@ -23310,9 +24018,36 @@ var GrokHarnessSession = class {
       update: { type: "text.append", text }
     });
   }
+  #createSubagents() {
+    return new GrokSubagentLifecycle({
+      newItemId: () => hostItemIdSchema.parse(this.#randomUUID()),
+      emit: (event) => this.#event(event)
+    });
+  }
   #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 = grokSubagentModel(event.rawInput);
+      active.subagents.start(active.command.turnId, {
+        callId: event.callId,
+        operation,
+        description: grokSubagentDescription(event.rawInput, event.title),
+        ...prompt ? { prompt } : {},
+        ...role ? { role } : {},
+        ...model ? { model } : {},
+        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,
@@ -23331,6 +24066,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;
@@ -23386,6 +24149,7 @@ var GrokHarnessSession = class {
     this.#completeItem(active, tool.item, outcome);
     if (status !== "completed")
       return;
+    this.#completeWatchedSubagents(active, tool.item, content, rawOutput);
     const changes = projectGrokFileChanges(content, this.#cwd);
     if (!changes)
       return;
@@ -23397,6 +24161,51 @@ 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) {
+    active.subagents.bindNativeId(active.command.turnId, {
+      nativeSubagentId: event.nativeSubagentId,
+      ...event.description ? { description: event.description } : {},
+      ...event.role ? { role: event.role } : {},
+      ...event.model ? { model: event.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) {
@@ -23463,6 +24272,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;
@@ -23545,6 +24355,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;
@@ -23748,7 +24591,11 @@ var GrokAdapter = class {
           kind: "resume",
           sessionId: parsedRef.data.nativeSessionId,
           permissionModeId: requestedPermissionModeId
-        } : { kind: "create", permissionModeId: requestedPermissionModeId });
+        } : {
+          kind: "create",
+          permissionModeId: requestedPermissionModeId,
+          ...input.kind === "create" && input.model ? { modelId: input.model.id } : {}
+        });
       }
       if (!opened) {
         await transport.close().catch(() => void 0);