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

package/app/renderer-extension.js

@@ -23538,6 +23538,640 @@ ${error51.stderrTail}`] : []
     return () => style.remove();
   }
 
+  // src/renderer-subagent-thread-model.ts
+  function isRecord7(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function nonBlank(value) {
+    return typeof value === "string" && value.trim().length > 0;
+  }
+  function threadFromReadResult(value, expectedThreadId) {
+    if (!isRecord7(value)) return null;
+    const directThread = isRecord7(value.thread) ? value.thread : null;
+    const nestedThread = isRecord7(value.result) && isRecord7(value.result.thread) ? value.result.thread : null;
+    const thread = directThread ?? nestedThread;
+    if (!thread) return null;
+    if (expectedThreadId && (!nonBlank(thread.id) || thread.id.trim() !== expectedThreadId)) {
+      return null;
+    }
+    return thread;
+  }
+  function rendererThreadRequestTarget() {
+    if (typeof window === "undefined") return null;
+    const policy = window.__codexhostDraftPrewarmPolicyV1;
+    if (typeof policy?.requestTarget !== "function") return null;
+    try {
+      const target = policy.requestTarget();
+      return isRecord7(target) && typeof target.sendRequest === "function" ? target : null;
+    } catch {
+      return null;
+    }
+  }
+  function isParentComposerModelLabel(model) {
+    const head = model.includes(" \xB7 ") ? model.split(" \xB7 ")[0]?.trim() ?? "" : model;
+    if (!head) return false;
+    if (/^(grok|gpt|o\d|claude|codex)/i.test(head)) return false;
+    return model.includes(" \xB7 ");
+  }
+  function usableThreadModel(value) {
+    if (!nonBlank(value) || isParentComposerModelLabel(value)) return void 0;
+    return value.trim();
+  }
+  function subagentThreadModelFromReadResult(value, expectedThreadId) {
+    const thread = threadFromReadResult(value, expectedThreadId);
+    if (!thread) return null;
+    const model = usableThreadModel(thread.model) ?? usableThreadModel(thread.latestModel) ?? usableThreadModel(thread.resolvedModelLabel);
+    const reasoningEffort = usableThreadModel(thread.reasoningEffort) ?? usableThreadModel(thread.latestReasoningEffort);
+    if (!model && !reasoningEffort) return null;
+    return {
+      ...model ? { model } : {},
+      ...reasoningEffort ? { reasoningEffort } : {}
+    };
+  }
+  async function readSubagentThreadModelFromTarget(target, threadId) {
+    const result = await target.sendRequest("thread/read", {
+      threadId,
+      includeTurns: false
+    });
+    return subagentThreadModelFromReadResult(result, threadId);
+  }
+  async function readRendererSubagentThreadModel(threadId) {
+    const target = rendererThreadRequestTarget();
+    if (!target) return null;
+    return readSubagentThreadModelFromTarget(target, threadId);
+  }
+  function subagentStatusFromReadResult(value, expectedThreadId) {
+    const thread = threadFromReadResult(value, expectedThreadId);
+    if (!thread) return null;
+    const threadStatus = isRecord7(thread.status) && nonBlank(thread.status.type) ? thread.status.type : void 0;
+    if (threadStatus === "systemError") return "failed";
+    const turns = Array.isArray(thread.turns) ? thread.turns : [];
+    const lastTurn = [...turns].reverse().find(isRecord7);
+    const turnStatus = lastTurn && nonBlank(lastTurn.status) ? lastTurn.status : void 0;
+    if (turnStatus === "completed") return "completed";
+    if (turnStatus === "failed") return "failed";
+    if (turnStatus === "interrupted" || turnStatus === "cancelled") return "interrupted";
+    if (turnStatus === "inProgress" || turnStatus === "running") return "running";
+    if (turnStatus === "pending" || turnStatus === "queued") return "waiting";
+    if (threadStatus === "active") return "running";
+    return null;
+  }
+  async function readRendererSubagentStatus(threadId) {
+    const target = rendererThreadRequestTarget();
+    if (!target) return null;
+    const result = await target.sendRequest("thread/read", {
+      threadId,
+      includeTurns: true
+    });
+    return subagentStatusFromReadResult(result, threadId);
+  }
+  function createSubagentThreadModelResolver(options) {
+    const models = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Set();
+    const attempts = /* @__PURE__ */ new Map();
+    const retryTimers = /* @__PURE__ */ new Map();
+    const maxAttempts = options.maxAttempts ?? 3;
+    const retryDelayMs = options.retryDelayMs ?? 1e3;
+    let disposed = false;
+    const ensure = (threadId) => {
+      if (disposed || !threadId || models.has(threadId) || pending.has(threadId)) return;
+      const attempt = (attempts.get(threadId) ?? 0) + 1;
+      if (attempt > maxAttempts) return;
+      attempts.set(threadId, attempt);
+      pending.add(threadId);
+      void options.read(threadId).then(
+        (snapshot) => {
+          if (disposed) return;
+          if (snapshot) {
+            models.set(threadId, snapshot);
+            attempts.delete(threadId);
+            options.onUpdate();
+            return;
+          }
+          if (attempt >= maxAttempts || retryTimers.has(threadId)) return;
+          retryTimers.set(
+            threadId,
+            setTimeout(() => {
+              retryTimers.delete(threadId);
+              ensure(threadId);
+            }, retryDelayMs)
+          );
+        },
+        () => {
+          if (disposed || attempt >= maxAttempts || retryTimers.has(threadId)) return;
+          retryTimers.set(
+            threadId,
+            setTimeout(() => {
+              retryTimers.delete(threadId);
+              ensure(threadId);
+            }, retryDelayMs)
+          );
+        }
+      ).finally(() => {
+        pending.delete(threadId);
+      });
+    };
+    return {
+      get(threadId) {
+        return models.get(threadId);
+      },
+      ensure,
+      refresh() {
+        if (disposed) return;
+        for (const threadId of [...attempts.keys()]) {
+          if (pending.has(threadId) || retryTimers.has(threadId)) continue;
+          attempts.delete(threadId);
+          ensure(threadId);
+        }
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        for (const timer of retryTimers.values()) clearTimeout(timer);
+        retryTimers.clear();
+        pending.clear();
+        attempts.clear();
+        models.clear();
+      }
+    };
+  }
+  function createSubagentThreadStatusResolver(options) {
+    const statuses = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Set();
+    const attempts = /* @__PURE__ */ new Map();
+    const maxAttempts = options.maxAttempts ?? 3;
+    let disposed = false;
+    const ensure = (threadId) => {
+      const current = statuses.get(threadId);
+      if (disposed || !threadId || pending.has(threadId) || current === "completed" || current === "failed" || current === "interrupted") {
+        return;
+      }
+      const attempt = (attempts.get(threadId) ?? 0) + 1;
+      if (attempt > maxAttempts) return;
+      attempts.set(threadId, attempt);
+      pending.add(threadId);
+      void options.read(threadId).then((status) => {
+        if (disposed || !status) return;
+        statuses.set(threadId, status);
+        if (status === "completed" || status === "failed" || status === "interrupted") {
+          attempts.delete(threadId);
+        }
+        options.onUpdate();
+      }).catch(() => {
+      }).finally(() => {
+        pending.delete(threadId);
+      });
+    };
+    return {
+      get(threadId) {
+        return statuses.get(threadId);
+      },
+      ensure,
+      refresh() {
+        if (disposed) return;
+        for (const threadId of /* @__PURE__ */ new Set([...statuses.keys(), ...attempts.keys()])) {
+          const status = statuses.get(threadId);
+          if (status === "completed" || status === "failed" || status === "interrupted") continue;
+          attempts.delete(threadId);
+          ensure(threadId);
+        }
+      },
+      dispose() {
+        disposed = true;
+        statuses.clear();
+        attempts.clear();
+        pending.clear();
+      }
+    };
+  }
+
+  // src/renderer-subagent-row-meta.ts
+  var SUBAGENT_ROW_META_ATTRIBUTE = "data-codexhost-subagent-meta";
+  var SUBAGENT_ROW_COPY_ATTRIBUTE = "data-codexhost-subagent-copy";
+  var SUBAGENT_ITEM_BUTTON_SELECTOR = 'button[data-slot="thread-summary-panel-item-button"]';
+  var SUBAGENT_ITEM_LABEL_SELECTOR = '[data-slot="thread-summary-panel-item-label"]';
+  function isRecord8(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function nonBlank2(value) {
+    return typeof value === "string" && value.trim().length > 0;
+  }
+  function isDomElement(value) {
+    return typeof Element !== "undefined" && value instanceof Element;
+  }
+  function isHtmlElement(value) {
+    return typeof HTMLElement !== "undefined" && value instanceof HTMLElement;
+  }
+  function isParentComposerModelLabel2(model) {
+    const trimmed = model?.trim();
+    if (!trimmed) return false;
+    const head = trimmed.includes(" \xB7 ") ? trimmed.split(" \xB7 ")[0]?.trim() ?? "" : trimmed;
+    if (!head) return false;
+    if (/^(grok|gpt|o\d|claude|codex)/i.test(head)) return false;
+    return trimmed.includes(" \xB7 ");
+  }
+  function usableModel(value) {
+    if (!nonBlank2(value) || isParentComposerModelLabel2(value)) return void 0;
+    return value.trim();
+  }
+  function prettySubagentStatus(status) {
+    switch (status) {
+      case "active":
+      case "running":
+      case "working":
+        return "\u8FDB\u884C\u4E2D";
+      case "waiting":
+      case "pending":
+      case "pendingInit":
+        return "\u7B49\u5F85\u4E2D";
+      case "done":
+      case "completed":
+        return "\u5DF2\u5B8C\u6210";
+      case "failed":
+      case "errored":
+        return "\u5931\u8D25";
+      case "interrupted":
+        return "\u5DF2\u4E2D\u65AD";
+      default:
+        return void 0;
+    }
+  }
+  function prettySubagentEffort(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) return void 0;
+    const lower = trimmed.toLowerCase();
+    if (lower === "xhigh") return "xHigh";
+    if (lower === "ultra") return "\u8D85\u9AD8";
+    return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+  }
+  function prettySubagentModel(model) {
+    const trimmed = model.trim();
+    if (!trimmed || isParentComposerModelLabel2(trimmed)) return "";
+    if (trimmed.includes(" \xB7 ")) return trimmed;
+    const slash = trimmed.lastIndexOf("/");
+    const id = slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+    if (id.toLowerCase().startsWith("grok")) {
+      return id.replace(/^grok[-_]?/iu, "Grok ").replace(/\s+/gu, " ").trim();
+    }
+    if (!id.trimStart().toLowerCase().startsWith("gpt")) return trimmed;
+    const joiner = /^gpt-\d/iu.test(id.trimStart()) ? " " : "-";
+    return id.split(/(\s+)/u).map((part) => {
+      if (part.trim().length === 0) return part;
+      return part.split("-").map((token, index) => {
+        if (token.toLowerCase() === "gpt") return "GPT";
+        if (token.toLowerCase() === "oai") return "OAI";
+        if (index > 0 && token.length > 0) {
+          return `${token[0]?.toUpperCase() ?? ""}${token.slice(1)}`;
+        }
+        return token;
+      }).join(joiner).replace(/^GPT (?=\d)/u, "GPT-");
+    }).join("");
+  }
+  function includesEffort(label, effort) {
+    return new RegExp(`(?:^|\xB7\\s*)${effort.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}$`, "iu").test(
+      label
+    );
+  }
+  function formatSubagentRowMeta(row) {
+    const raw = usableModel(row.spawnModel) ?? usableModel(row.model) ?? "";
+    const model = raw ? prettySubagentModel(raw) : "";
+    const effort = prettySubagentEffort(row.reasoningEffort);
+    const modelLine = model && effort && !includesEffort(model, effort) ? `${model} \xB7 ${effort}` : model || effort;
+    const parts = [prettySubagentStatus(row.status), modelLine].filter(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    return parts.length > 0 ? parts.join(" \xB7 ") : void 0;
+  }
+  function contribute(target, source, allowUnscopedModel = false) {
+    const sourceId = nonBlank2(source.conversationId) ? source.conversationId.trim() : Array.isArray(source.receiverThreadIds) && nonBlank2(source.receiverThreadIds[0]) ? source.receiverThreadIds[0].trim() : void 0;
+    if (target.conversationId && sourceId && sourceId !== target.conversationId) return;
+    if (nonBlank2(source.displayName) && !target.displayName) {
+      target.displayName = source.displayName.trim();
+    }
+    if (sourceId && !target.conversationId) target.conversationId = sourceId;
+    const childModelSource = allowUnscopedModel || source.type === "collabAgentToolCall" || target.conversationId && nonBlank2(source.id) && source.id.trim() === target.conversationId;
+    if (childModelSource) {
+      const spawn = usableModel(source.spawnModel);
+      const model = usableModel(source.model) ?? usableModel(source.modelLabel) ?? usableModel(source.latestModel);
+      if (spawn && !target.spawnModel) target.spawnModel = spawn;
+      if (model && !usableModel(target.model)) target.model = model;
+      if (nonBlank2(source.reasoningEffort) && !target.reasoningEffort) {
+        target.reasoningEffort = source.reasoningEffort.trim();
+      }
+      if (nonBlank2(source.latestReasoningEffort) && !target.reasoningEffort) {
+        target.reasoningEffort = source.latestReasoningEffort.trim();
+      }
+    }
+    if (nonBlank2(source.agentRole) && !target.agentRole) {
+      target.agentRole = source.agentRole.trim();
+    }
+    if (nonBlank2(source.status) && !target.status) {
+      target.status = source.status.trim();
+    }
+    if (isRecord8(source.agentState) && nonBlank2(source.agentState.status) && !target.status) {
+      target.status = source.agentState.status.trim();
+    }
+    if (isRecord8(source.agentsStates) && target.conversationId) {
+      const state = source.agentsStates[target.conversationId];
+      if (isRecord8(state) && nonBlank2(state.status) && !target.status) {
+        target.status = state.status.trim();
+      }
+    }
+  }
+  function collabMatches(item, conversationId) {
+    if (item.type !== "collabAgentToolCall" || item.tool !== "spawnAgent") return false;
+    if (!conversationId) return true;
+    if (Array.isArray(item.receiverThreadIds) && item.receiverThreadIds.includes(conversationId)) {
+      return true;
+    }
+    return isRecord8(item.agentsStates) && conversationId in item.agentsStates;
+  }
+  function harvestFromValue(value, target) {
+    if (!isRecord8(value)) return;
+    contribute(target, value);
+    const nested = [
+      isRecord8(value.row) ? value.row : null,
+      isRecord8(value.backgroundAgent) ? value.backgroundAgent : null,
+      isRecord8(value.item) ? value.item : null,
+      isRecord8(value.item) && isRecord8(value.item.backgroundAgent) ? value.item.backgroundAgent : null,
+      isRecord8(value.thread) && (!target.conversationId || nonBlank2(value.thread.id) && value.thread.id.trim() === target.conversationId) ? value.thread : null,
+      isRecord8(value.childConversation) ? value.childConversation : null
+    ];
+    for (const source of nested) {
+      if (source) contribute(target, source);
+    }
+    if (!target.conversationId) return;
+    const items = Array.isArray(value.items) ? value.items : Array.isArray(value.turns) ? value.turns.flatMap(
+      (turn) => isRecord8(turn) && Array.isArray(turn.items) ? turn.items : []
+    ) : [];
+    for (const item of items) {
+      if (!isRecord8(item)) continue;
+      if (collabMatches(item, target.conversationId)) contribute(target, item, true);
+    }
+  }
+  function finalizeRow(target) {
+    if (!nonBlank2(target.displayName)) return null;
+    if (!nonBlank2(target.conversationId) && !nonBlank2(target.spawnModel) && !nonBlank2(target.model) && !nonBlank2(target.status)) {
+      return null;
+    }
+    const spawnModel = usableModel(target.spawnModel);
+    const model = usableModel(target.model);
+    return {
+      displayName: target.displayName.trim(),
+      ...spawnModel ? { spawnModel } : {},
+      ...model ? { model } : {},
+      ...nonBlank2(target.reasoningEffort) ? { reasoningEffort: target.reasoningEffort.trim() } : {},
+      ...nonBlank2(target.agentRole) ? { agentRole: target.agentRole.trim() } : {},
+      ...nonBlank2(target.status) ? { status: target.status.trim() } : {},
+      ...nonBlank2(target.conversationId) ? { conversationId: target.conversationId.trim() } : {}
+    };
+  }
+  function withResolvedThreadModel(row, thread) {
+    const spawn = usableModel(row.spawnModel);
+    const model = spawn ?? usableModel(row.model) ?? usableModel(thread.model);
+    const reasoningEffort = row.reasoningEffort ?? (nonBlank2(thread.reasoningEffort) ? thread.reasoningEffort.trim() : void 0);
+    return {
+      displayName: row.displayName,
+      ...row.conversationId ? { conversationId: row.conversationId } : {},
+      ...row.status ? { status: row.status } : {},
+      ...row.agentRole ? { agentRole: row.agentRole } : {},
+      ...spawn ? { spawnModel: spawn } : {},
+      ...model ? { model } : {},
+      ...reasoningEffort ? { reasoningEffort } : {}
+    };
+  }
+  function withResolvedThreadStatus(row, status) {
+    return { ...row, status };
+  }
+  function resolveSubagentRow(row, modelResolver, statusResolver) {
+    if (!row.conversationId) return row;
+    const resolvedStatus = statusResolver?.get(row.conversationId);
+    let enriched = resolvedStatus ? withResolvedThreadStatus(row, resolvedStatus) : row;
+    const visibleStatus = prettySubagentStatus(enriched.status);
+    if (!visibleStatus || visibleStatus === "\u8FDB\u884C\u4E2D" || visibleStatus === "\u7B49\u5F85\u4E2D") {
+      statusResolver?.ensure(row.conversationId);
+    }
+    const resolvedModel = modelResolver?.get(row.conversationId);
+    if (resolvedModel) enriched = withResolvedThreadModel(enriched, resolvedModel);
+    const currentModel = usableModel(enriched.spawnModel) ?? usableModel(enriched.model);
+    const modelIncludesEffort = Boolean(currentModel?.includes(" \xB7 "));
+    if (!currentModel || !enriched.reasoningEffort && !modelIncludesEffort) {
+      modelResolver?.ensure(row.conversationId);
+    }
+    return enriched;
+  }
+  function subagentRowMetaFromProps(value) {
+    const target = {};
+    harvestFromValue(value, target);
+    return finalizeRow(target);
+  }
+  function fiberFromElement(element) {
+    const names = Object.getOwnPropertyNames(element).filter(
+      (name2) => name2.startsWith("__reactFiber$")
+    );
+    const name = names[0];
+    if (!name) return null;
+    const fiber = Object.getOwnPropertyDescriptor(element, name)?.value ?? element[name];
+    return isRecord8(fiber) ? fiber : null;
+  }
+  function metaFromFiberProps(fiber) {
+    if (!fiber) return null;
+    return subagentRowMetaFromProps(fiber.memoizedProps) ?? subagentRowMetaFromProps(fiber.pendingProps);
+  }
+  function mergeRow(base, next) {
+    if (!base) return next;
+    if (!next) return base;
+    if (base.conversationId && next.conversationId && base.conversationId !== next.conversationId) {
+      return base;
+    }
+    const spawnModel = usableModel(base.spawnModel) ?? usableModel(next.spawnModel);
+    const model = usableModel(base.model) ?? usableModel(next.model);
+    const reasoningEffort = base.reasoningEffort ?? next.reasoningEffort;
+    const agentRole = base.agentRole ?? next.agentRole;
+    const status = base.status ?? next.status;
+    const conversationId = base.conversationId ?? next.conversationId;
+    return {
+      displayName: base.displayName || next.displayName,
+      ...spawnModel ? { spawnModel } : {},
+      ...model ? { model } : {},
+      ...reasoningEffort ? { reasoningEffort } : {},
+      ...agentRole ? { agentRole } : {},
+      ...status ? { status } : {},
+      ...conversationId ? { conversationId } : {}
+    };
+  }
+  function metaFromDescendants(start) {
+    if (!start || !isRecord8(start.child)) return null;
+    const stack = [start.child];
+    const seen = /* @__PURE__ */ new Set();
+    let found = null;
+    let steps = 0;
+    while (stack.length > 0 && steps < 40) {
+      const fiber = stack.pop();
+      if (!fiber || seen.has(fiber)) continue;
+      seen.add(fiber);
+      steps += 1;
+      found = mergeRow(found, metaFromFiberProps(fiber));
+      if (isRecord8(fiber.child)) stack.push(fiber.child);
+      if (isRecord8(fiber.sibling)) stack.push(fiber.sibling);
+    }
+    return found;
+  }
+  function subagentRowMetaFromElement(element) {
+    let fiber = fiberFromElement(element);
+    let found = metaFromDescendants(fiber);
+    for (let depth = 0; fiber && depth < 12; depth += 1) {
+      found = mergeRow(found, metaFromFiberProps(fiber));
+      fiber = isRecord8(fiber.return) ? fiber.return : null;
+    }
+    return found;
+  }
+  function findNameNode(element) {
+    const label = element.querySelector(SUBAGENT_ITEM_LABEL_SELECTOR);
+    return label ?? element;
+  }
+  function createMetaNode(ownerDocument) {
+    const meta3 = ownerDocument.createElement("span");
+    meta3.setAttribute(SUBAGENT_ROW_META_ATTRIBUTE, "true");
+    meta3.style.display = "block";
+    meta3.style.maxWidth = "100%";
+    meta3.style.fontSize = "11px";
+    meta3.style.lineHeight = "1.35";
+    meta3.style.color = "var(--text-tertiary, #8a8a8a)";
+    meta3.style.whiteSpace = "normal";
+    return meta3;
+  }
+  function ensureColumnCopy(nameNode) {
+    const parent = nameNode.parentElement;
+    if (parent?.getAttribute(SUBAGENT_ROW_COPY_ATTRIBUTE) === "true") {
+      const existing = parent.querySelector(`[${SUBAGENT_ROW_META_ATTRIBUTE}]`);
+      if (existing) return { copy: parent, meta: existing };
+      const meta4 = createMetaNode(nameNode.ownerDocument);
+      parent.append(meta4);
+      return { copy: parent, meta: meta4 };
+    }
+    const copy = nameNode.ownerDocument.createElement("span");
+    copy.setAttribute(SUBAGENT_ROW_COPY_ATTRIBUTE, "true");
+    copy.style.display = "flex";
+    copy.style.flexDirection = "column";
+    copy.style.alignItems = "flex-start";
+    copy.style.justifyContent = "center";
+    copy.style.minWidth = "0";
+    copy.style.flex = "1";
+    copy.style.overflow = "hidden";
+    nameNode.style.maxWidth = "100%";
+    nameNode.style.minWidth = "0";
+    nameNode.replaceWith(copy);
+    copy.append(nameNode);
+    const meta3 = createMetaNode(nameNode.ownerDocument);
+    copy.append(meta3);
+    return { copy, meta: meta3 };
+  }
+  function decorateSubagentRow(element, resolver, statusResolver) {
+    const label = element.querySelector(SUBAGENT_ITEM_LABEL_SELECTOR);
+    const harvested = subagentRowMetaFromElement(element) ?? (label ? subagentRowMetaFromElement(label) : null);
+    if (!harvested) return false;
+    const row = resolveSubagentRow(harvested, resolver, statusResolver);
+    const text = formatSubagentRowMeta(row);
+    const nameNode = findNameNode(element);
+    if (!nameNode || !text) {
+      element.querySelector(`[${SUBAGENT_ROW_META_ATTRIBUTE}]`)?.remove();
+      return false;
+    }
+    const { meta: meta3 } = ensureColumnCopy(nameNode);
+    if (meta3.textContent !== text) meta3.textContent = text;
+    return true;
+  }
+  function decorateSubagentRows(root, resolver, statusResolver) {
+    if (typeof root.querySelectorAll !== "function") return 0;
+    const buttons = root.querySelectorAll(SUBAGENT_ITEM_BUTTON_SELECTOR);
+    let decorated = 0;
+    for (const element of buttons) {
+      if (!isHtmlElement(element)) continue;
+      if (decorateSubagentRow(element, resolver, statusResolver)) decorated += 1;
+    }
+    return decorated;
+  }
+  function isOwnMetaMutation(mutations) {
+    return mutations.every((mutation) => {
+      const nodes = [...mutation.addedNodes, ...mutation.removedNodes, mutation.target];
+      return nodes.every((node) => {
+        if (!isDomElement(node)) return mutation.type === "characterData";
+        return node.getAttribute?.(SUBAGENT_ROW_META_ATTRIBUTE) === "true" || node.getAttribute?.(SUBAGENT_ROW_COPY_ATTRIBUTE) === "true" || Boolean(node.closest?.(`[${SUBAGENT_ROW_META_ATTRIBUTE}]`)) || Boolean(node.closest?.(`[${SUBAGENT_ROW_COPY_ATTRIBUTE}]`));
+      });
+    });
+  }
+  function installRendererSubagentRowMeta(root) {
+    const owner = root ?? (typeof document !== "undefined" && typeof Element !== "undefined" ? document : void 0);
+    if (!owner || typeof MutationObserver === "undefined" || typeof Element === "undefined" || typeof document === "undefined") {
+      return { refresh() {
+      }, dispose() {
+      } };
+    }
+    let disposed = false;
+    let scanScheduled = false;
+    let mutating = false;
+    let debounce;
+    const scan = () => {
+      scanScheduled = false;
+      if (disposed) return;
+      mutating = true;
+      try {
+        decorateSubagentRows(owner, resolver, statusResolver);
+      } finally {
+        mutating = false;
+      }
+    };
+    const schedule = () => {
+      if (disposed || mutating || scanScheduled) return;
+      scanScheduled = true;
+      if (debounce !== void 0) clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        debounce = void 0;
+        scan();
+      }, 250);
+    };
+    const resolver = createSubagentThreadModelResolver({
+      read: readRendererSubagentThreadModel,
+      onUpdate: schedule
+    });
+    const statusResolver = createSubagentThreadStatusResolver({
+      read: readRendererSubagentStatus,
+      onUpdate: schedule
+    });
+    const observer = new MutationObserver((mutations) => {
+      if (mutating || isOwnMetaMutation(mutations)) return;
+      schedule();
+    });
+    observer.observe(owner, { childList: true, subtree: true });
+    schedule();
+    return {
+      refresh() {
+        resolver.refresh();
+        statusResolver.refresh();
+        schedule();
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        if (debounce !== void 0) clearTimeout(debounce);
+        observer.disconnect();
+        resolver.dispose();
+        statusResolver.dispose();
+        if (isDomElement(owner) || typeof Document !== "undefined" && owner instanceof Document) {
+          for (const copy of owner.querySelectorAll(`[${SUBAGENT_ROW_COPY_ATTRIBUTE}]`)) {
+            const label = copy.querySelector(SUBAGENT_ITEM_LABEL_SELECTOR);
+            if (label && copy.parentElement) copy.replaceWith(label);
+            else copy.remove();
+          }
+          for (const meta3 of owner.querySelectorAll(`[${SUBAGENT_ROW_META_ATTRIBUTE}]`)) {
+            meta3.remove();
+          }
+        }
+      }
+    };
+  }
+
   // src/renderer-permission-mode-preference.ts
   var CLAUDE_PERMISSION_MODE_PREFERENCE_KEY = "codexhost.claude-code.permission-mode.v1";
   function rendererStorage() {
@@ -23575,11 +24209,11 @@ ${error51.stderrTail}`] : []
       return null;
     }
   }
-  function isRecord7(value) {
+  function isRecord9(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
   function parseExternalConfiguration(value) {
-    if (!isRecord7(value)) return void 0;
+    if (!isRecord9(value)) return void 0;
     const model = harnessModelRefSchema.safeParse(value.model);
     if (!model.success) return void 0;
     const thinkingOptionId = harnessThinkingOptionIdSchema.safeParse(value.thinkingOptionId);
@@ -23596,9 +24230,9 @@ ${error51.stderrTail}`] : []
       const raw = storage.getItem(RENDERER_NEW_THREAD_PREFERENCE_KEY);
       if (!raw) return void 0;
       const parsed = JSON.parse(raw);
-      if (!isRecord7(parsed) || parsed.version !== 1) return void 0;
+      if (!isRecord9(parsed) || parsed.version !== 1) return void 0;
       if (!KNOWN_RENDERER_AGENTS.some((agent) => agent === parsed.lastAgent)) return void 0;
-      const externalByAgent = isRecord7(parsed.externalByAgent) ? parsed.externalByAgent : {};
+      const externalByAgent = isRecord9(parsed.externalByAgent) ? parsed.externalByAgent : {};
       const parsedExternal = Object.fromEntries(
         KNOWN_RENDERER_AGENTS.filter(
           (agent) => agent !== "codex"
@@ -23674,7 +24308,7 @@ ${error51.stderrTail}`] : []
   var GET_LOCALE_OVERRIDE_URL = "vscode://codex/get-setting";
   var GET_LOCALE_INFO_URL = "vscode://codex/locale-info";
   var DEFAULT_LOCALE_REQUEST_TIMEOUT_MS = 750;
-  function isRecord8(value) {
+  function isRecord10(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
   function canonicalLocale(value) {
@@ -23696,7 +24330,7 @@ ${error51.stderrTail}`] : []
     return new DOMException("The operation was aborted", "AbortError");
   }
   function parseLocaleOverride(value) {
-    if (!isRecord8(value) || !("value" in value)) {
+    if (!isRecord10(value) || !("value" in value)) {
       throw new Error("Codex locale override response is malformed");
     }
     if (value.value === null) return { value: null };
@@ -23711,7 +24345,7 @@ ${error51.stderrTail}`] : []
     return locale;
   }
   function parseLocaleInfo(value) {
-    if (!isRecord8(value)) throw new Error("Codex locale info response is malformed");
+    if (!isRecord10(value)) throw new Error("Codex locale info response is malformed");
     return {
       ideLocale: optionalLocale(value.ideLocale, "IDE locale"),
       systemLocale: optionalLocale(value.systemLocale, "system locale")
@@ -23740,7 +24374,7 @@ ${error51.stderrTail}`] : []
       const onAbort = () => settle(() => reject(abortError2()));
       const onMessage = (event) => {
         const message2 = event.data;
-        if (!isRecord8(message2) || message2.type !== "fetch-response") return;
+        if (!isRecord10(message2) || message2.type !== "fetch-response") return;
         if (message2.requestId !== requestId) return;
         if (message2.responseType !== "success" || typeof message2.status !== "number" || message2.status < 200 || message2.status >= 300 || typeof message2.bodyJsonString !== "string") {
           settle(() => reject(new Error("Codex locale request failed")));
@@ -27393,6 +28027,7 @@ ${accounts_default}`;
     const existing = window.__codexhostRendererBindingProbeV1;
     if (existing) return existing;
     const disposeApprovalStyle = installRendererApprovalStyle(document);
+    const subagentRowMeta = installRendererSubagentRowMeta();
     const enabledAgents = [...new Set(options.enabledAgents ?? DEFAULT_RENDERER_AGENTS)];
     const enabledAgentSet = new Set(enabledAgents);
     const controller = new DraftAgentController({
@@ -29227,6 +29862,7 @@ ${accounts_default}`;
         if (disposed) return;
         disposed = true;
         disposeApprovalStyle();
+        subagentRowMeta.dispose();
         usageNotificationDispose?.();
         usageNotificationDispose = null;
         adapterDispose?.();