@dotobokuri/fleet-console 1.66.0 → 1.67.0

package/dist/fleet-plugins/terminal/routes.mjs

@@ -20603,18 +20603,25 @@ function withheldClaudeSkillStub(name, tokens, budget) {
 var CLAUDE_WEB_SEARCH_TOOL_NAME = "WebSearch";
 var ANTHROPIC_WEB_SEARCH_TOOL_NAME = "web_search";
 var ANTHROPIC_WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
-function isClaudeWebSearchTool(tool) {
-  return tool.type === ANTHROPIC_WEB_SEARCH_TOOL_TYPE || tool.name === CLAUDE_WEB_SEARCH_TOOL_NAME || tool.name === ANTHROPIC_WEB_SEARCH_TOOL_NAME;
+var CLAUDE_WEB_SEARCH_TOOL_IDENTIFIERS = [
+  CLAUDE_WEB_SEARCH_TOOL_NAME,
+  ANTHROPIC_WEB_SEARCH_TOOL_NAME,
+  ANTHROPIC_WEB_SEARCH_TOOL_TYPE
+];
+function matchesToolIdentifier(tool, identifiers) {
+  return typeof tool.name === "string" && identifiers.has(tool.name) || typeof tool.type === "string" && identifiers.has(tool.type);
 }
-function isClaudeWebSearchToolChoice(choice) {
-  return choice?.type === "tool" && (choice.name === CLAUDE_WEB_SEARCH_TOOL_NAME || choice.name === ANTHROPIC_WEB_SEARCH_TOOL_NAME);
+function matchesToolChoice(choice, identifiers) {
+  return choice?.type === "tool" && typeof choice.name === "string" && identifiers.has(choice.name);
 }
-function omitClaudeWebSearchTools(request) {
+function omitClaudeClientTools(request, names) {
+  const identifiers = new Set(names);
+  if (identifiers.size === 0) return { request, changed: false };
   const tools = request.tools;
-  const kept = tools?.filter((tool) => !isClaudeWebSearchTool(tool));
+  const kept = tools?.filter((tool) => !matchesToolIdentifier(tool, identifiers));
   const toolsChanged = tools !== void 0 && kept !== void 0 && kept.length !== tools.length;
   const choice = request.tool_choice;
-  const choiceChanged = isClaudeWebSearchToolChoice(choice);
+  const choiceChanged = matchesToolChoice(choice, identifiers);
   if (!toolsChanged && !choiceChanged) {
     return { request, changed: false };
   }
@@ -20633,6 +20640,42 @@ function omitClaudeWebSearchTools(request) {
     changed: true
   };
 }
+var CLAUDE_USAGE_LIMIT_DIRECTIVE = /^\s*\[Usage limit [^\]]*\]\s*$/;
+function stripClaudeUsageLimitDirectives(messages) {
+  let removed = 0;
+  const kept = [];
+  for (const message of messages) {
+    const stripped = stripUsageLimitBlocks(message);
+    removed += stripped.removed;
+    if (stripped.message !== null) kept.push(stripped.message);
+  }
+  if (removed === 0) return { messages, changed: false, removed: 0 };
+  const last = kept[kept.length - 1];
+  if (last === void 0 || last.role === "assistant") {
+    return { messages, changed: false, removed: 0 };
+  }
+  return { messages: kept, changed: true, removed };
+}
+function stripUsageLimitBlocks(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return isClaudeUsageLimitDirective(content) ? { message: null, removed: 1 } : { message, removed: 0 };
+  }
+  if (!Array.isArray(content)) return { message, removed: 0 };
+  const kept = content.filter(
+    (block) => !(isClaudeTextBlock(block) && isClaudeUsageLimitDirective(block.text))
+  );
+  const removed = content.length - kept.length;
+  if (removed === 0) return { message, removed: 0 };
+  if (kept.length === 0) return { message: null, removed };
+  return { message: { ...message, content: kept }, removed };
+}
+function isClaudeUsageLimitDirective(text2) {
+  return CLAUDE_USAGE_LIMIT_DIRECTIVE.test(text2);
+}
+function omitClaudeWebSearchTools(request) {
+  return omitClaudeClientTools(request, CLAUDE_WEB_SEARCH_TOOL_IDENTIFIERS);
+}
 var benchmarks_default = {
   version: 2,
   sources: {
@@ -26241,22 +26284,42 @@ function parseXaiEventStream(body, options, functionCallTimeoutMs) {
     functionCallTimeoutMs
   );
 }
+var XAI_ASSEMBLY_DEADLINE = /* @__PURE__ */ Symbol("xai-assembly-deadline");
 async function* assembleXaiFunctionCalls(source, controller, timeoutMs) {
   const iterator = source[Symbol.asyncIterator]();
   const pending = /* @__PURE__ */ new Map();
+  let snapshot;
   let completedNormally = false;
   try {
     while (true) {
       const deadlineAt = earliestXaiFunctionCallDeadline(pending);
-      const result = deadlineAt === void 0 ? await iterator.next() : await nextXaiEventBeforeDeadline(iterator, deadlineAt, controller, timeoutMs);
+      const result = deadlineAt === void 0 ? await iterator.next() : await nextXaiEventBeforeDeadline(iterator, deadlineAt);
+      if (result === XAI_ASSEMBLY_DEADLINE) {
+        yield* salvageXaiPendingCalls(
+          pending,
+          snapshot,
+          `function call assembly exceeded ${timeoutMs}ms`,
+          controller
+        );
+        completedNormally = true;
+        return;
+      }
       if (result.done) {
         if (pending.size > 0) {
-          throw incompleteXaiFunctionCall("stream ended before function call output_item.done");
+          yield* salvageXaiPendingCalls(
+            pending,
+            snapshot,
+            "stream ended before function call output_item.done",
+            controller
+          );
         }
         completedNormally = true;
         return;
       }
       const event = result.value;
+      if (event.type === "response.created") {
+        snapshot = event.response;
+      }
       if (event.type === "response.completed" && pending.size > 0) {
         throw incompleteXaiFunctionCall("response.completed arrived before function call output_item.done");
       }
@@ -26267,10 +26330,18 @@ async function* assembleXaiFunctionCalls(source, controller, timeoutMs) {
           // Each call gets a full timeout from its own added event. Waiting uses the
           // earliest active deadline, so a later parallel call is never shortened by
           // an earlier call's age.
-          deadlineAt: Date.now() + timeoutMs
+          deadlineAt: Date.now() + timeoutMs,
+          argumentsBuffer: ""
         });
         continue;
       }
+      if (event.type === "response.function_call_arguments.delta") {
+        const call = pending.get(xaiFunctionCallKey(event.output_index, event.item_id));
+        if (call !== void 0) {
+          call.argumentsBuffer += event.delta;
+        }
+        continue;
+      }
       if (event.type === "response.function_call_arguments.done") {
         const call = pending.get(xaiFunctionCallKey(event.output_index, event.item_id));
         if (call !== void 0) {
@@ -26316,24 +26387,60 @@ function earliestXaiFunctionCallDeadline(pending) {
   }
   return earliest;
 }
-async function nextXaiEventBeforeDeadline(iterator, deadlineAt, controller, timeoutMs) {
-  const remainingMs = deadlineAt - Date.now();
-  if (remainingMs <= 0) {
-    const error51 = incompleteXaiFunctionCall(`function call assembly exceeded ${timeoutMs}ms`);
+async function* salvageXaiPendingCalls(pending, snapshot, reason, controller) {
+  const salvageable = [...pending.values()].every(
+    (call) => completeXaiArguments(call) !== void 0
+  );
+  if (snapshot === void 0 || !salvageable) {
+    const error51 = incompleteXaiFunctionCall(reason);
     controller.abort(error51);
     throw error51;
   }
+  wireLog("xai-responses.function_call.salvaged", {
+    reason,
+    calls: pending.size
+  });
+  controller.abort(incompleteXaiFunctionCall(reason));
+  for (const [key, call] of pending) {
+    const args = completeXaiArguments(call) ?? "";
+    const item = { ...call.added.item, arguments: args };
+    yield call.added;
+    yield {
+      type: "response.function_call_arguments.done",
+      item_id: call.added.item.id,
+      output_index: call.added.output_index,
+      arguments: args
+    };
+    yield { type: "response.output_item.done", output_index: call.added.output_index, item };
+    pending.delete(key);
+  }
+  yield { type: "response.completed", response: { ...snapshot, usage: null } };
+}
+function completeXaiArguments(call) {
+  const candidate = call.argumentsDone?.arguments ?? call.argumentsBuffer;
+  if (candidate.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch {
+    return void 0;
+  }
+  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? candidate : void 0;
+}
+async function nextXaiEventBeforeDeadline(iterator, deadlineAt) {
+  const remainingMs = deadlineAt - Date.now();
+  if (remainingMs <= 0) {
+    return XAI_ASSEMBLY_DEADLINE;
+  }
   let timeout;
   const next = iterator.next();
   void next.catch(() => void 0);
   try {
     return await Promise.race([
       next,
-      new Promise((_, reject) => {
+      new Promise((resolve3) => {
         timeout = setTimeout(() => {
-          const error51 = incompleteXaiFunctionCall(`function call assembly exceeded ${timeoutMs}ms`);
-          controller.abort(error51);
-          reject(error51);
+          resolve3(XAI_ASSEMBLY_DEADLINE);
         }, remainingMs);
       })
     ]);
@@ -26368,6 +26475,10 @@ function parseEventFrame3(frame) {
   }
   return canonicalEvent3(parsed);
 }
+var XAI_EOS_SENTINEL = "<|eos|>";
+function withoutXaiSentinel(text2) {
+  return text2.includes(XAI_EOS_SENTINEL) ? text2.split(XAI_EOS_SENTINEL).join("") : text2;
+}
 function canonicalEvent3(value) {
   if (!isRecord7(value) || typeof value.type !== "string") {
     throw new UpstreamProtocolError("Grok CLI SSE event was not an object with a type");
@@ -26387,25 +26498,30 @@ function canonicalEvent3(value) {
         content_index: number32(value.content_index, "content_index"),
         part: {
           type: "output_text",
-          text: typeof part.text === "string" ? part.text : ""
+          text: typeof part.text === "string" ? withoutXaiSentinel(part.text) : ""
         }
       };
     }
-    case "response.output_text.delta":
+    case "response.output_text.delta": {
+      const delta = withoutXaiSentinel(string32(value.delta, "delta"));
+      if (delta.length === 0) {
+        return void 0;
+      }
       return {
         type: value.type,
         item_id: string32(value.item_id, "item_id"),
         output_index: number32(value.output_index, "output_index"),
         content_index: number32(value.content_index, "content_index"),
-        delta: string32(value.delta, "delta")
+        delta
       };
+    }
     case "response.output_text.done":
       return {
         type: value.type,
         item_id: string32(value.item_id, "item_id"),
         output_index: number32(value.output_index, "output_index"),
         content_index: number32(value.content_index, "content_index"),
-        text: string32(value.text, "text")
+        text: withoutXaiSentinel(string32(value.text, "text"))
       };
     case "response.reasoning_summary_text.delta":
     case "response.reasoning_text.delta":
@@ -26427,11 +26543,17 @@ function canonicalEvent3(value) {
         item
       };
     }
-    // Hold argument fragments until the Grok CLI proxy's partial-JSON behavior is observed.
-    // The `.done` event carries the complete argument object, which downstream treats as the
-    // remainder when nothing was streamed ahead of it.
+    // Fragments still never reach the client — the assembler absorbs them and the `.done`
+    // event carries the complete argument object. They are decoded rather than discarded
+    // because this proxy has been measured ending a stream with the whole argument object
+    // delivered as fragments and no terminal frame; the buffer is that turn's only copy.
     case "response.function_call_arguments.delta":
-      return void 0;
+      return {
+        type: value.type,
+        item_id: string32(value.item_id, "item_id"),
+        output_index: number32(value.output_index, "output_index"),
+        delta: string32(value.delta, "delta")
+      };
     case "response.function_call_arguments.done":
       return {
         type: value.type,
@@ -26901,6 +27023,10 @@ function isCursorNativeRedirectToolName(name) {
   const leaf = toolLeafName3(name).replace(/[_-]/g, "").toLowerCase();
   return ["grep", "bash", "shellcommand", "execcommand"].includes(leaf);
 }
+function isCursorWithheldToolName(name) {
+  const leaf = toolLeafName3(name).replace(/[_-]/g, "").toLowerCase();
+  return ["bash", "shellcommand", "execcommand"].includes(leaf);
+}
 function cursorNativeExecRedirect(exec2, tools, providerIdentifier) {
   const messageId = numberValue2(exec2.id ?? 0);
   const execId = stringValue2(exec2.execId) || `redirect-${messageId}`;
@@ -27112,22 +27238,23 @@ function grepArguments(tool, input) {
       args.path = input.path;
     }
     const optionMappings = [
-      [input.glob || void 0, "glob"],
-      [input.outputMode, "output_mode"],
-      [input.caseInsensitive ? true : void 0, "case_insensitive"],
-      [input.contextBefore, "context_before"],
-      [input.contextAfter, "context_after"],
-      [input.context, "context"],
-      [input.type, "type"],
-      [input.headLimit, "head_limit"],
-      [input.multiline ? true : void 0, "multiline"],
-      [input.sort, "sort"],
-      [input.sortAscending, "sort_ascending"],
-      [input.offset, "offset"]
+      [input.glob || void 0, ["glob"]],
+      [input.outputMode, ["output_mode"]],
+      [input.caseInsensitive ? true : void 0, ["-i", "case_insensitive"]],
+      [input.contextBefore, ["-B", "context_before"]],
+      [input.contextAfter, ["-A", "context_after"]],
+      [input.context, ["context", "-C"]],
+      [input.type, ["type"]],
+      [input.headLimit, ["head_limit"]],
+      [input.multiline ? true : void 0, ["multiline"]],
+      [input.sort, ["sort"]],
+      [input.sortAscending, ["sort_ascending"]],
+      [input.offset, ["offset"]]
     ];
-    for (const [value, key] of optionMappings) {
+    for (const [value, candidates] of optionMappings) {
       if (value === void 0) continue;
-      if (!schemaHasProperty(tool.inputSchemaValue, key)) return null;
+      const key = firstSchemaProperty(tool.inputSchemaValue, candidates);
+      if (key === void 0) return null;
       args[key] = value;
     }
     return args;
@@ -28746,7 +28873,7 @@ function applyCursorToolBudget(request) {
   const supportsDeferredLoading = declaredTools.some((tool) => isCursorToolSearchName(tool.name));
   const sourceTools = declaredTools.filter((tool) => {
     const explicitlySelected = referencedNames.has(tool.name) || cursorToolMatches(tool.name, selectedName);
-    if (isCursorNativeRedirectToolName(tool.name) && !explicitlySelected) return false;
+    if (isCursorWithheldToolName(tool.name) && !explicitlySelected) return false;
     return !supportsDeferredLoading || tool.defer_loading !== true || isCursorToolSearchName(tool.name) || explicitlySelected;
   });
   const wireTools = sourceTools.map(toCursorWireTool);
@@ -31146,6 +31273,63 @@ function bareModelName(model) {
   const prefix = `${GATEWAY_PROVIDER_NAMES[model.provider]}-`;
   return model.displayName.startsWith(prefix) ? model.displayName.slice(prefix.length) : model.displayName;
 }
+var codexRequestPolicy = {
+  provider: "codex",
+  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+};
+var cursorRequestPolicy = {
+  provider: "cursor",
+  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+};
+var kimiRequestPolicy = {
+  provider: "kimi",
+  shapeRequest: (request, steps) => steps.pruneSkillPayloads(request)
+};
+var opencodeGoRequestPolicy = {
+  provider: "opencode",
+  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+};
+var xaiRequestPolicy = {
+  provider: "xai",
+  shapeRequest: (request, steps) => steps.withholdWebSearchTools(steps.pruneSkillPayloads(request))
+};
+var POLICIES = {
+  codex: codexRequestPolicy,
+  cursor: cursorRequestPolicy,
+  kimi: kimiRequestPolicy,
+  // The provider id is `opencode`; its folder carries the `-go` subscription name.
+  opencode: opencodeGoRequestPolicy,
+  xai: xaiRequestPolicy
+};
+function resolveGatewayRequestPolicy(provider) {
+  return POLICIES[provider];
+}
+function applyGatewayRequestPolicy(request, target2, withheldSkills) {
+  const context = {
+    target: target2,
+    upstreamModel: upstreamModelId(target2),
+    withheldSkills
+  };
+  const policy = resolveGatewayRequestPolicy(target2.provider);
+  return policy.shapeRequest(request, buildPolicySteps(context), context);
+}
+function buildPolicySteps(context) {
+  return {
+    pruneSkillPayloads: (request) => {
+      const pruned = pruneClaudeSkillPayloads(request.messages, {
+        ...typeof context.target.contextWindow === "number" ? { contextWindow: context.target.contextWindow } : {},
+        model: context.upstreamModel,
+        withheld: context.withheldSkills
+      });
+      for (const skill of pruned.withheld) context.withheldSkills.add(skill.name);
+      return pruned.changed ? { ...request, messages: [...pruned.messages] } : request;
+    },
+    withholdWebSearchTools: (request) => {
+      const omitted = omitClaudeWebSearchTools(request);
+      return omitted.changed ? omitted.request : request;
+    }
+  };
+}
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
   "content-encoding",
@@ -31364,19 +31548,11 @@ function createAiGatewayRouter(deps) {
       writeAnthropicError(res, 403, "permission_error", `AI gateway model is not enabled: ${requested}`);
       return true;
     }
-    if (target2) {
-      const pruned = pruneClaudeSkillPayloads(body.messages, {
-        ...typeof target2.contextWindow === "number" ? { contextWindow: target2.contextWindow } : {},
-        model: upstreamModelId(target2),
-        withheld: withheldSkills
-      });
-      for (const skill of pruned.withheld) withheldSkills.add(skill.name);
-      if (pruned.changed) body = { ...body, messages: [...pruned.messages] };
-    }
-    if (target2 && target2.provider !== "kimi") {
-      const omitted = omitClaudeWebSearchTools(body);
-      if (omitted.changed) body = omitted.request;
+    const withoutUsageLimitDirectives = stripClaudeUsageLimitDirectives(body.messages);
+    if (withoutUsageLimitDirectives.changed) {
+      body = { ...body, messages: [...withoutUsageLimitDirectives.messages] };
     }
+    if (target2) body = applyGatewayRequestPolicy(body, target2, withheldSkills);
     let credential = "";
     let chatgptAccountId = "";
     if (target2?.provider === "cursor") {
@@ -32338,9 +32514,13 @@ function buildClaudeGatewayArgs(context) {
     ]),
     ...context.mcpServers.length > 0 ? ["--mcp-config", buildClaudeMcpConfig(context.mcpServers)] : [],
     ...buildSettingsArgs(context.skillOverrides),
+    ...buildSearchToolArgs(),
     "--dangerously-skip-permissions"
   ];
 }
+function buildSearchToolArgs() {
+  return ["--allowedTools", "Grep,Glob"];
+}
 function buildSettingsArgs(skillOverrides) {
   if (skillOverrides === void 0 || Object.keys(skillOverrides).length === 0) return [];
   return ["--settings", JSON.stringify({ skillOverrides })];
@@ -45850,7 +46030,8 @@ function normalizeAttentionReason(value) {
 }
 
 // ../fleet-plugins/terminal/server/agent-api/background-report.ts
-var NON_AGENT_BACKGROUND_TASK_TYPES = /* @__PURE__ */ new Set(["shell"]);
+var AGENT_BACKGROUND_TASK_TYPES = /* @__PURE__ */ new Set(["subagent", "teammate", "workflow"]);
+var NON_AGENT_BACKGROUND_TASK_TYPES = /* @__PURE__ */ new Set(["shell", "monitor"]);
 var NO_SETTLED_AGENT_IDS = /* @__PURE__ */ new Set();
 var NO_OPINION = { pending: void 0, settledAgentIds: void 0 };
 function readBackgroundHookReport(input, settledAgentIds = NO_SETTLED_AGENT_IDS) {
@@ -45867,29 +46048,36 @@ function readBackgroundHookReport(input, settledAgentIds = NO_SETTLED_AGENT_IDS)
   const selfAgentId = typeof payload.agent_id === "string" ? payload.agent_id : void 0;
   const listedIds = /* @__PURE__ */ new Set();
   let live = false;
-  let unreadable = false;
+  let workUnknown = false;
+  let listIncomplete = false;
   for (const task of tasks) {
     const entry = readTaskEntry(task);
     if (!entry) {
-      unreadable = true;
+      workUnknown = true;
+      listIncomplete = true;
       continue;
     }
     if (typeof entry.id === "string") listedIds.add(entry.id);
-    if (isLiveAgentWork(entry, selfAgentId, settledAgentIds)) live = true;
+    else listIncomplete = true;
+    const verdict = classifyBackgroundTask(entry, selfAgentId, settledAgentIds);
+    if (verdict === "live") live = true;
+    else if (verdict === "unreadable") workUnknown = true;
   }
-  if (!live && unreadable) return NO_OPINION;
+  if (!live && workUnknown) return NO_OPINION;
   return {
     pending: live,
-    settledAgentIds: nextSettledAgentIds({ settledAgentIds, selfAgentId, listedIds, listComplete: !unreadable })
+    settledAgentIds: nextSettledAgentIds({ settledAgentIds, selfAgentId, listedIds, listComplete: !listIncomplete })
   };
 }
 function readTaskEntry(task) {
   if (typeof task !== "object" || task === null || Array.isArray(task)) return null;
   return task;
 }
-function isLiveAgentWork(entry, selfAgentId, settledAgentIds) {
-  if (typeof entry.id === "string" && (entry.id === selfAgentId || settledAgentIds.has(entry.id))) return false;
-  return !(typeof entry.type === "string" && NON_AGENT_BACKGROUND_TASK_TYPES.has(entry.type));
+function classifyBackgroundTask(entry, selfAgentId, settledAgentIds) {
+  if (typeof entry.id === "string" && (entry.id === selfAgentId || settledAgentIds.has(entry.id))) return "not-agent-work";
+  if (typeof entry.type !== "string") return "unreadable";
+  if (AGENT_BACKGROUND_TASK_TYPES.has(entry.type)) return "live";
+  return NON_AGENT_BACKGROUND_TASK_TYPES.has(entry.type) ? "not-agent-work" : "unreadable";
 }
 function nextSettledAgentIds({
   settledAgentIds,
@@ -47643,6 +47831,16 @@ function createConsoleObservabilityStore(deps = {}) {
     if (clearsAttention) delete session.attentionPending;
     return toTerminalSessionInfo(session);
   }
+  function setTerminalSessionChatBackgroundPending(sessionId, pending) {
+    const session = terminalSessionsById.get(sessionId);
+    if (!session || session.chatActive !== true) return null;
+    if (session.backgroundPendingExpiry) {
+      clearTimeout(session.backgroundPendingExpiry);
+      delete session.backgroundPendingExpiry;
+    }
+    session.backgroundPending = pending;
+    return toTerminalSessionInfo(session);
+  }
   function setTerminalSessionChatAwaiting(sessionId, awaiting) {
     const session = terminalSessionsById.get(sessionId);
     if (!session || session.chatActive !== true) return null;
@@ -47764,6 +47962,7 @@ function createConsoleObservabilityStore(deps = {}) {
     getTerminalSessionSettledAgentIds,
     setTerminalSessionModelActivity,
     setTerminalSessionChatActive,
+    setTerminalSessionChatBackgroundPending,
     setTerminalSessionChatWorking,
     setTerminalSessionChatAwaiting,
     transitionTerminalSessionToDormant,
@@ -47971,7 +48170,9 @@ function eventsFromTranscriptLine(line, options) {
     const results = toolResultsFrom(line.message?.content, options);
     if (results.length > 0) return results;
     const text2 = readUserText(line.message?.content);
-    return text2 ? [{ kind: "dispatch", text: text2, ...atField }] : [];
+    if (text2 === null) return [];
+    if (isInjectedCarrier(line, text2)) return [{ kind: "turn-start", ...atField }];
+    return [{ kind: "dispatch", text: text2, ...atField }];
   }
   if (line.type === "assistant") {
     return eventsFromAssistantContent(line.message?.content, options);
@@ -48287,11 +48488,29 @@ function readUserText(content) {
   }
   return normalizeDispatchText(parts.join("\n"));
 }
+var INJECTED_TRANSCRIPT_TAGS = /* @__PURE__ */ new Set([
+  "task-notification",
+  "local-command-stdout",
+  "local-command-caveat",
+  "command-name",
+  "command-message",
+  "system-reminder",
+  "bash-input",
+  "bash-stdout"
+]);
+var LEADING_TAG_NAME = /^<([a-zA-Z][a-zA-Z0-9-]*)(?=[\s>])/;
+function isInjectedOrigin(origin) {
+  const kind = origin?.kind;
+  return typeof kind === "string" && kind.length > 0 && kind !== "human";
+}
+function isInjectedCarrier(line, text2) {
+  if (isInjectedOrigin(line.origin)) return true;
+  const tag = LEADING_TAG_NAME.exec(text2.trimStart())?.[1];
+  return tag !== void 0 && INJECTED_TRANSCRIPT_TAGS.has(tag);
+}
 function normalizeDispatchText(text2) {
   const trimmed = text2.trim();
-  if (trimmed.length === 0) return null;
-  if (trimmed.startsWith("<system-reminder>") || trimmed.startsWith("<command-name>")) return null;
-  return capText(trimmed);
+  return trimmed.length === 0 ? null : capText(trimmed);
 }
 function agentChatAskFromToolInput(name, id, input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return null;
@@ -48588,6 +48807,14 @@ var AgentChatSession = class {
    * 으로 남겨 두지 않고 거둬진 것으로 닫는다 — 화면이 없는 작업을 기다리게 두지 않기 위해서다.
    */
   liveJobs = /* @__PURE__ */ new Set();
+  /**
+   * 이미 결말을 낸 잡. 이름 붙은 에이전트는 다음 지시를 기다리며 세션에 상주하므로, 자기 결말을 낸
+   * 뒤에도 살아 있는 작업 목록에 계속 실려 온다(PTY 쪽 hook payload에서 실측된 것과 같은 registry다).
+   * 그 항목을 목록에 있다는 이유로 다시 살아 있는 작업으로 읽으면, 이 축에는 시한이 없으므로 세션이
+   * 끝날 때까지 유휴·입력 대기 전이가 통째로 막힌다. 기억은 목록이 지워 준다 — 더 이상 실리지 않는
+   * id는 registry에서 사라진 것이므로 버린다.
+   */
+  settledJobs = /* @__PURE__ */ new Set();
   /**
    * 중지 세대. 중지는 도는 턴 하나가 아니라 **그 시점의 큐 전체**를 끊어야 한다 — 큐에 밀려
    * 있던 턴이 중지 직후 태연히 시작하면, 사용자가 멈춘 것은 화면에서 멈추지 않는다. 각 턴은
@@ -48656,21 +48883,38 @@ var AgentChatSession = class {
       turnAt = null;
       lastAt = null;
     };
+    let pendingOpenAt;
+    const openPendingTurn = () => {
+      if (pendingOpenAt === void 0) return;
+      const at = pendingOpenAt;
+      pendingOpenAt = void 0;
+      closeReplayedTurn();
+      turns += 1;
+      turnAt = at;
+      this.push(at === null ? { kind: "turn-start" } : { kind: "turn-start", at });
+    };
     try {
       const raw = await promises.readFile(transcriptPath, "utf8");
       for (const line of raw.split("\n")) {
         if (line.trim().length === 0) continue;
         const mapped = chatReplayFromTranscriptLine(line, { cwd: this.seed.cwd, toolNames: this.toolNames });
         for (const event of mapped.events) {
+          if (event.kind === "turn-start") {
+            if (pendingOpenAt === void 0) pendingOpenAt = mapped.at ?? null;
+            continue;
+          }
           if (event.kind === "dispatch") {
+            pendingOpenAt = void 0;
             closeReplayedTurn();
             turns += 1;
             turnAt = mapped.at ?? null;
+          } else {
+            openPendingTurn();
           }
           this.rememberTool(event);
           this.push(event);
         }
-        if (mapped.events.length > 0 && mapped.at !== void 0) lastAt = mapped.at;
+        if (mapped.events.length > 0 && mapped.at !== void 0 && pendingOpenAt === void 0) lastAt = mapped.at;
       }
       closeReplayedTurn();
     } catch {
@@ -48839,11 +49083,7 @@ var AgentChatSession = class {
   /** 도구 이벤트가 지나갈 때 id→이름을 적어 둔다. 결과 요약 정책이 이 축 위에서 결정된다. */
   rememberTool(event) {
     if (event.kind === "job") {
-      this.jobKinds.set(event.id, event.jobKind);
-      if (this.jobKinds.size > JOB_KIND_CAP) {
-        const oldest = this.jobKinds.keys().next();
-        if (!oldest.done) this.jobKinds.delete(oldest.value);
-      }
+      this.rememberJobKind(event.id, event.jobKind);
       return;
     }
     if (event.kind !== "tool" && event.kind !== "tool-start") return;
@@ -48854,6 +49094,46 @@ var AgentChatSession = class {
       if (!oldest.done) this.toolNames.delete(oldest.value);
     }
   }
+  /**
+   * 잡 하나의 종류를 적는다. 긴 세션에서 무한히 자라지 않게 상한을 두고 오래된 것부터 버리되, 아직
+   * 살아 있는 잡은 건너뛴다 — 그 종류는 활동축이 지금 읽고 있고, 잃으면 축이 무의견으로 굳는다.
+   */
+  rememberJobKind(jobId, kind, incoming) {
+    this.jobKinds.set(jobId, kind);
+    if (this.jobKinds.size <= JOB_KIND_CAP) return;
+    for (const oldest of this.jobKinds.keys()) {
+      if (this.liveJobs.has(oldest) || incoming?.has(oldest) === true) continue;
+      this.jobKinds.delete(oldest);
+      return;
+    }
+  }
+  /**
+   * 살아 있는 작업 목록이 알려 준 종류를 적어 둔다.
+   *
+   * `background_tasks_changed`는 `task_type`을 싣고 오지만 스트림 이벤트(`jobs`)는 id만 나른다 —
+   * 화면은 종류를 이미 첫 등장(`job`)에서 받았기 때문이다. 활동축은 사정이 다르다: 셸을 세지
+   * 않으려면 이 목록에서 처음 본 잡의 종류도 알아야 하고, 그 값은 원본 메시지에만 있다.
+   */
+  rememberJobKinds(message) {
+    if (message.type !== "system" || message.subtype !== "background_tasks_changed") return;
+    const tasks = message.tasks;
+    if (!Array.isArray(tasks)) return;
+    const incoming = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!task || typeof task !== "object") continue;
+      const id = task.task_id;
+      if (typeof id !== "string" || id.length === 0) continue;
+      incoming.add(id);
+    }
+    for (const task of tasks) {
+      if (!task || typeof task !== "object") continue;
+      const id = task.task_id;
+      if (typeof id !== "string" || id.length === 0) continue;
+      const rawKind = task.task_type;
+      if (typeof rawKind !== "string") continue;
+      this.rememberJobKind(id, readJobKind(rawKind), incoming);
+    }
+  }
   /**
    * 결말 알림이 알려 준 출력 파일 경로를 적어 둔다.
    *
@@ -49236,6 +49516,7 @@ var AgentChatSession = class {
           if (this.latestSessionId !== this.reportedSessionId) this.syncProviderSessionOnce();
         }
         this.rememberJobOutput(message);
+        this.rememberJobKinds(message);
         this.trackLiveContext(message);
         for (const event of chatEventsFromSdkMessage(message, { cwd: this.seed.cwd, toolNames: this.toolNames })) {
           this.ingest(event);
@@ -49274,12 +49555,50 @@ var AgentChatSession = class {
   }
   /** 살아 있는 잡의 집합을 이벤트대로 따라간다. `jobs`는 세는 것이 아니라 통째로 갈아 끼운다. */
   trackJob(event) {
-    if (event.kind === "job") this.liveJobs.add(event.id);
-    else if (event.kind === "job-end") this.liveJobs.delete(event.id);
-    else if (event.kind === "jobs") {
+    if (event.kind === "job") {
+      this.liveJobs.add(event.id);
+      this.settledJobs.delete(event.id);
+    } else if (event.kind === "job-end") {
+      this.liveJobs.delete(event.id);
+      this.settledJobs.add(event.id);
+    } else if (event.kind === "jobs") {
       this.liveJobs.clear();
-      for (const id of event.ids) this.liveJobs.add(id);
+      for (const id of event.ids) {
+        if (!this.settledJobs.has(id)) this.liveJobs.add(id);
+      }
+      const listed = new Set(event.ids);
+      for (const id of [...this.settledJobs]) {
+        if (!listed.has(id)) this.settledJobs.delete(id);
+      }
+    } else return;
+    this.syncBackgroundPending();
+  }
+  /**
+   * 살아 있는 잡 목록을 활동축의 백그라운드 대기값으로 접는다.
+   *
+   * 세는 것은 에이전트 작업뿐이다 — 서브에이전트(이름 붙은 팀메이트 포함)와 워크플로우. PTY 어댑터가
+   * hook 목록에서 셸과 MCP 감시 작업을 빼는 것과 같은 계약이며, 이유도 같다: 사람이 기다리는 것은
+   * 자기 일을 대신 하는 에이전트이지 그 에이전트가 남긴 명령이 아니고, 그것까지 세면 긴 백그라운드
+   * 명령 하나가 세션을 유휴 밖에 세워 둔 채 유휴 휴면까지 막는다.
+   *
+   * 처음 보는 종류는 세지 않는다. PTY 쪽은 같은 자리에서 무의견으로 물러나지만 그 축에는 시한이
+   * 있어 무의견이 영원하지 않다 — 이 축에는 시한이 없으므로, 여기서 물러나면 상주하는 미지 잡 하나가
+   * 에이전트 작업이 다 끝난 뒤에도 배지를 영영 켜 둔다. 새 종류를 놓치는 쪽은 이 기능이 없던 상태로
+   * 돌아갈 뿐이고, 그 종류는 화면의 잡 목록에 `other`로 서서 눈에 띈다.
+   *
+   * 턴 경계는 여기서 보지 않는다. 턴이 도는 동안에도 값은 서지만, 읽는 쪽이 작업 중을 앞세우므로
+   * 화면에 나타나는 것은 턴이 닫힌 뒤부터다 — 그 순간이 곧 "남은 것은 백그라운드뿐"인 순간이다.
+   */
+  syncBackgroundPending() {
+    let pending = false;
+    for (const id of this.liveJobs) {
+      const kind = this.jobKinds.get(id);
+      if (kind === "agent" || kind === "workflow") {
+        pending = true;
+        break;
+      }
     }
+    this.seed.reportBackgroundPending(pending);
   }
   /**
    * 턴 하나를 연다. 화면의 스피너와 활동축이 같은 순간에 켜지는 자리다.
@@ -49313,6 +49632,7 @@ var AgentChatSession = class {
       ...end.answer === void 0 ? {} : { answer: end.answer }
     });
     this.abandonAsks("The turn ended before the question was answered.");
+    this.syncBackgroundPending();
     this.seed.reportActivity(false);
     this.liveContextTotal = null;
     const awaiting = this.awaitingTurn;
@@ -49358,6 +49678,8 @@ var AgentChatSession = class {
     }
     for (const id of [...this.liveJobs]) this.push({ kind: "job-end", id, status: "stopped" });
     this.liveJobs.clear();
+    this.settledJobs.clear();
+    this.syncBackgroundPending();
     this.settlingStoppedTurn = false;
     this.closeTurn({ ok: false });
     this.releaseTurnCloseWaiters();
@@ -51047,6 +51369,11 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         reportAwaiting: (awaiting) => {
           const updated = observability.setTerminalSessionChatAwaiting(node.id, awaiting);
           if (updated) observability.notifySessionUpdated(updated);
+        },
+        reportBackgroundPending: (pending) => {
+          const before = observability.getTerminalSessionInfo(node.id)?.backgroundPending === true;
+          const updated = observability.setTerminalSessionChatBackgroundPending(node.id, pending);
+          if (updated && before !== pending) observability.notifySessionUpdated(updated);
         }
       }
     };