@dotobokuri/fleet-console 1.65.0 → 1.67.0

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

@@ -20229,6 +20229,22 @@ function projectClaudeContextInputTokens(inputTokens, advertisedContextWindow, u
     Math.ceil(inputTokens * claudeCompactThreshold / providerCompactThreshold)
   );
 }
+function unprojectClaudeContextInputTokens(projectedTokens, advertisedContextWindow, claudeCoordinate, compactCeiling) {
+  if (!Number.isFinite(projectedTokens) || projectedTokens < 0) return projectedTokens;
+  const advertisedWindow = positiveContextWindow(advertisedContextWindow);
+  if (advertisedWindow === void 0) return projectedTokens;
+  if (claudeCoordinate !== CLAUDE_DEFAULT_CONTEXT_WINDOW && claudeCoordinate !== CLAUDE_COMPAT_CONTEXT_WINDOW) {
+    return projectedTokens;
+  }
+  const claudeCompactThreshold = claudeCoordinate - CLAUDE_COMPACT_RESERVE;
+  if (claudeCompactThreshold <= 0) return projectedTokens;
+  const providerCompactThreshold = compactThresholdTokens(advertisedWindow, compactCeiling);
+  if (providerCompactThreshold <= 0) return projectedTokens;
+  return Math.min(
+    advertisedWindow,
+    Math.round(projectedTokens * providerCompactThreshold / claudeCompactThreshold)
+  );
+}
 function compactThresholdTokens(window, compactCeiling) {
   if (!Number.isFinite(window) || window <= 0) return window;
   const percent2 = compactCeilingPercent(compactCeiling);
@@ -20587,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 };
   }
@@ -20617,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: {
@@ -20839,7 +20898,7 @@ var models_default = {
     codex: {
       name: "Codex",
       defaultModel: "gpt-5.6-sol",
-      source: "codex app-server model/list (codex-cli 0.147.0, observed 2026-08-11) for model/effort/service-tier and the unsuffixed 272000 defaults; Fleet catalog effort ladders are capped at max because harness launch capabilities are not model rungs; 2026-08-17 production Codex live observations added explicit 1M (1000000) variants on the same upstream bases",
+      source: "codex app-server model/list (codex-cli 0.147.0, observed 2026-08-11) for model/effort/service-tier and the unsuffixed 272000 defaults; Fleet catalog effort ladders are capped at max because harness launch capabilities are not model rungs; 2026-08-17 production Codex live observations added explicit 524K (524288) and explicit 1M (1000000) variants on the same upstream bases",
       models: [
         {
           modelId: "gpt-5.6-sol",
@@ -20967,6 +21026,135 @@ var models_default = {
           ],
           benchmarkKey: "gpt-5.6-luna"
         },
+        {
+          modelId: "gpt-5.6-sol-524k",
+          name: "GPT-5.6-Sol-524K",
+          capabilityClass: "flagship",
+          providerModelId: "gpt-5.6-sol",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-sol-524k"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-sol-524k-fast",
+          name: "GPT-5.6-Sol-524K-Fast",
+          capabilityClass: "flagship",
+          providerModelId: "gpt-5.6-sol",
+          serviceTier: "priority",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-sol-524k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-luna-524k",
+          name: "GPT-5.6-Luna-524K",
+          capabilityClass: "light",
+          providerModelId: "gpt-5.6-luna",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-luna-524k"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-luna-524k-fast",
+          name: "GPT-5.6-Luna-524K-Fast",
+          capabilityClass: "light",
+          providerModelId: "gpt-5.6-luna",
+          serviceTier: "priority",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-luna-524k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-terra-524k",
+          name: "GPT-5.6-Terra-524K",
+          capabilityClass: "standard",
+          providerModelId: "gpt-5.6-terra",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-terra-524k"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
+        },
+        {
+          modelId: "gpt-5.6-terra-524k-fast",
+          name: "GPT-5.6-Terra-524K-Fast",
+          capabilityClass: "standard",
+          providerModelId: "gpt-5.6-terra",
+          serviceTier: "priority",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-terra-524k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
+        },
         {
           modelId: "gpt-5.6-sol-1m",
           name: "GPT-5.6-Sol-1M",
@@ -26096,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");
       }
@@ -26122,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) {
@@ -26171,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);
       })
     ]);
@@ -26223,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");
@@ -26242,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":
@@ -26282,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,
@@ -26756,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}`;
@@ -26967,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;
@@ -28601,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);
@@ -31001,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",
@@ -31219,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") {
@@ -32193,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 })];
@@ -45705,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) {
@@ -45722,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,
@@ -47498,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;
@@ -47619,6 +47962,7 @@ function createConsoleObservabilityStore(deps = {}) {
     getTerminalSessionSettledAgentIds,
     setTerminalSessionModelActivity,
     setTerminalSessionChatActive,
+    setTerminalSessionChatBackgroundPending,
     setTerminalSessionChatWorking,
     setTerminalSessionChatAwaiting,
     transitionTerminalSessionToDormant,
@@ -47826,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);
@@ -48142,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;
@@ -48443,6 +48807,14 @@ var AgentChatSession = class {
    * 으로 남겨 두지 않고 거둬진 것으로 닫는다 — 화면이 없는 작업을 기다리게 두지 않기 위해서다.
    */
   liveJobs = /* @__PURE__ */ new Set();
+  /**
+   * 이미 결말을 낸 잡. 이름 붙은 에이전트는 다음 지시를 기다리며 세션에 상주하므로, 자기 결말을 낸
+   * 뒤에도 살아 있는 작업 목록에 계속 실려 온다(PTY 쪽 hook payload에서 실측된 것과 같은 registry다).
+   * 그 항목을 목록에 있다는 이유로 다시 살아 있는 작업으로 읽으면, 이 축에는 시한이 없으므로 세션이
+   * 끝날 때까지 유휴·입력 대기 전이가 통째로 막힌다. 기억은 목록이 지워 준다 — 더 이상 실리지 않는
+   * id는 registry에서 사라진 것이므로 버린다.
+   */
+  settledJobs = /* @__PURE__ */ new Set();
   /**
    * 중지 세대. 중지는 도는 턴 하나가 아니라 **그 시점의 큐 전체**를 끊어야 한다 — 큐에 밀려
    * 있던 턴이 중지 직후 태연히 시작하면, 사용자가 멈춘 것은 화면에서 멈추지 않는다. 각 턴은
@@ -48476,6 +48848,18 @@ var AgentChatSession = class {
    * 답은 턴이 끝난 뒤에 오므로(실측), 그 사이 새 턴이 시작했다면 그 값은 남의 턴 자리에 앉는다.
    */
   contextGeneration = 0;
+  /**
+   * control 요청이 하나 떠 있는가.
+   *
+   * 겹쳐 던지면 자식이 직렬로 처리한다 — 실측하면 요청 하나에 약 30초가 들고, 셋을 던진 마지막
+   * 답은 100초 뒤에 왔다. 그래서 앞선 요청이 살아 있는 동안에는 새로 던지지 않는다. 놓친 창은
+   * 다음 경계(턴 시작·턴 종료)가 다시 얻는다.
+   */
+  contextInFlight = false;
+  /** 턴이 도는 동안 흘러간 라이브 총량. 턴 경계에서 비운다. */
+  liveContextTotal = null;
+  /** 자식이 스냅숏에서 직접 말한 좌표. 도착하기 전에는 모델 id에서 유도한다. */
+  observedClaudeCoordinate = null;
   constructor(operationId, seed, createSdk) {
     this.operationId = operationId;
     this.seed = seed;
@@ -48499,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 {
@@ -48682,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;
@@ -48697,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);
+    }
+  }
   /**
    * 결말 알림이 알려 준 출력 파일 경로를 적어 둔다.
    *
@@ -48812,25 +49249,33 @@ var AgentChatSession = class {
     });
   }
   /**
-   * 턴이 시작하는 순간 자식에게 문맥 내역을 묻고, 답이 오면 그대로 저널에 싣는다.
+   * 자식에게 문맥 **내역**을 묻고, 답이 오면 저널에 싣는다. 두 경계에서 불린다 — 턴을 보내기
+   * 직전(`"start"`)과 턴이 닫힌 직후(`"end"`).
    *
-   * **이 한 번이 유일한 기회다**(실측). 자식은 턴이 시작되면 control 채널을 닫아, +0ms의 요청만
-   * 답을 받고 그 뒤의 요청은 턴이 10초를 돌든 전부 "Query closed before response received"로
-   * 끝난다. 주기적으로 물어 최신값을 좇는 설계는 이 자식에서 성립하지 않는다.
+   * 왕복이 느리다는 것이 이 배선의 전제다(실측 21~88초, 요청 하나에 약 30초, 직렬 큐). 그래서
+   * 총량은 이 채널에 맡기지 않고 `message_delta` usage가 진다. 여기서 얻는 것은 카테고리 분해 —
+   * 그것만은 control 채널이 유일한 출처다.
    *
-   * 그래서 값은 **이 턴이 시작될 때까지의** 문맥이다 — 방금 끝난 턴이 더한 몫은 다음 턴이
-   * 시작될 때 비로소 드러난다. 화면은 그 지연을 감추지 않는다.
+   * 턴 중에는 아예 묻지 않는다. 자식이 턴이 시작되면 control을 닫아 +0ms의 요청만 답을 받고
+   * 그 뒤는 전부 "Query closed before response received"로 끝난다(실측). 유휴 폴링도 하지 않는다 —
+   * 답은 오지만 요청마다 30초를 태우고 큐만 밀린다.
    *
    * 응답을 기다리지 않는 이유는 스트림 때문이다: 여기서 await하면 첫 메시지 소비가 그만큼 늦다.
-   * 늦게 도착한 답도 같은 턴의 시작 시점 값이므로, 그때 실어도 뜻이 달라지지 않는다.
    */
-  snapshotContextAtTurnStart(session) {
+  requestContextSnapshot(session, asOf) {
+    if (this.contextInFlight) return;
     const generation = ++this.contextGeneration;
+    this.contextInFlight = true;
+    const settle = (usage4) => {
+      this.contextInFlight = false;
+      if (usage4 && generation === this.contextGeneration) this.pushContext(usage4, asOf);
+    };
     try {
-      void session.getContextUsage().then((usage4) => {
-        if (usage4 && generation === this.contextGeneration) this.pushContext(usage4);
-      }, () => void 0);
+      void session.getContextUsage().then(settle, () => {
+        this.contextInFlight = false;
+      });
     } catch {
+      this.contextInFlight = false;
     }
   }
   /**
@@ -48844,25 +49289,100 @@ var AgentChatSession = class {
    * 예약분(자동 압축 여유)과 남은 자리는 **쓴 것이 아니다**. 같은 목록에 두면 합이 언제나 창
    * 전체가 되어 미터가 항상 100%를 가리킨다.
    */
-  pushContext(usage4) {
+  pushContext(usage4, asOf) {
+    this.observedClaudeCoordinate = usage4.max;
     const spent = usage4.categories.filter((category) => !category.deferred && category.tokens > 0 && !CONTEXT_UNSPENT.has(category.name));
     const reserved = usage4.categories.find((category) => category.name === CONTEXT_RESERVED_NAME);
+    const window = this.realWindow(usage4.max);
+    const slices = spent.map((category) => ({
+      name: category.name,
+      tokens: window ? window.unproject(category.tokens) : category.tokens
+    }));
     this.push({
       kind: "context",
-      total: spent.reduce((sum, category) => sum + category.tokens, 0),
-      max: usage4.max,
-      ...reserved && reserved.tokens > 0 ? { reserved: reserved.tokens } : {},
-      ...usage4.compactAt === null ? {} : { compactAt: usage4.compactAt },
-      slices: spent.map((category) => ({ name: category.name, tokens: category.tokens })),
-      ...usage4.memoryFiles.length > 0 ? { memoryFiles: usage4.memoryFiles.map((file2) => ({ name: file2.path, tokens: file2.tokens })) } : {},
+      asOf,
+      total: slices.reduce((sum, slice) => sum + slice.tokens, 0),
+      max: window ? window.max : usage4.max,
+      // 예약분은 되돌리지 않고 **갈아 끼운다**. 자식의 값은 자기 좌표의 여유(max − compactAt)이고
+      // 실제 여유는 정책이 정하는 다른 수다 — 같은 비율로 늘리면 있지도 않은 자리를 예약해 둔다.
+      ...window ? window.max > window.compactAt ? { reserved: window.max - window.compactAt } : {} : reserved && reserved.tokens > 0 ? { reserved: reserved.tokens } : {},
+      ...window ? usage4.compactAt === null ? {} : { compactAt: window.compactAt } : usage4.compactAt === null ? {} : { compactAt: usage4.compactAt },
+      slices,
+      ...usage4.memoryFiles.length > 0 ? {
+        memoryFiles: usage4.memoryFiles.map((file2) => ({
+          name: file2.path,
+          tokens: window ? window.unproject(file2.tokens) : file2.tokens
+        }))
+      } : {},
       ...usage4.mcpTools.length > 0 ? {
         mcpTools: usage4.mcpTools.map((tool) => ({
           name: tool.server ? `${tool.server} \xB7 ${tool.name}` : tool.name,
-          tokens: tool.tokens
+          tokens: window ? window.unproject(tool.tokens) : tool.tokens
         }))
       } : {}
     });
   }
+  /**
+   * 턴이 도는 동안 총량을 흘린다. 미터가 이 턴을 따라 움직이는 유일한 경로다.
+   *
+   * 읽는 것은 `message_delta`의 usage **하나뿐**이며, 그것은 소거로 남은 결과다(실측):
+   * `message_start`와 완성 `assistant`의 usage는 언제나 0으로 오고, `result.usage`는 그 턴의 모든
+   * 모델 호출을 **합산한** 값이어서 창 점유가 아니다 — 도구를 다섯 번 돈 턴에서 61,630이었고 같은
+   * 순간의 실제 점유는 15,785였다. 그것을 총량으로 쓰면 미터가 네 배로 뛴다.
+   *
+   * 서브에이전트의 usage도 제외한다. 그 창은 부모의 창이 아니다.
+   */
+  trackLiveContext(message) {
+    if (message.type !== "stream_event") return;
+    if (typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0) return;
+    const event = message.event;
+    if (!isRecord14(event) || event.type !== "message_delta") return;
+    const total = readClaudeOccupiedInputTokens(event.usage);
+    if (total === null) return;
+    const claudeCoordinate = this.claudeCoordinate();
+    const window = this.realWindow(claudeCoordinate);
+    const live = window ? window.unproject(total) : total;
+    if (this.liveContextTotal === live) return;
+    this.liveContextTotal = live;
+    this.pushEphemeral({
+      kind: "context-live",
+      total: live,
+      max: window ? window.max : claudeCoordinate
+    });
+  }
+  /**
+   * 자식이 이 세션을 재는 좌표.
+   *
+   * 스냅숏이 한 번이라도 왔으면 자식이 직접 말한 값이 권위다. 그 전에는 유도한다 — 좌표를 정하는
+   * 것은 모델 id의 `[1m]` 마커이고, 그 마커를 붙이는 규칙이 곧 카탈로그 창이 1M에 닿는지 여부다.
+   * 유도가 필요한 이유는 라이브 총량이 첫 스냅숏(왕복 30초)을 기다릴 수 없기 때문이다.
+   */
+  claudeCoordinate() {
+    if (this.observedClaudeCoordinate !== null) return this.observedClaudeCoordinate;
+    const window = this.seed.contextWindow;
+    const oneMillion = typeof window === "number" && Number.isFinite(window) && window > 0 ? window >= CLAUDE_COMPAT_CONTEXT_WINDOW : hasClaudeOneMillionMarker(this.seed.model);
+    return oneMillion ? CLAUDE_COMPAT_CONTEXT_WINDOW : CLAUDE_DEFAULT_CONTEXT_WINDOW;
+  }
+  /**
+   * 자식이 보고한 좌표를 이 모델의 실제 창으로 되돌리는 자.
+   *
+   * `null`은 되돌릴 것이 없다는 뜻이며 세 경우가 여기로 온다: 시드에 카탈로그 창이 없는 세션
+   * (네이티브 Claude 모델·카탈로그 밖 id), 그리고 자식이 자기 두 좌표가 아닌 값을 말한 세션 —
+   * 후자는 역함수가 스스로 항등으로 접는다. 어느 경우든 오늘의 숫자가 그대로 나간다.
+   */
+  realWindow(claudeCoordinate) {
+    const max = this.seed.contextWindow;
+    if (typeof max !== "number" || !Number.isFinite(max) || max <= 0) return null;
+    if (claudeCoordinate !== CLAUDE_DEFAULT_CONTEXT_WINDOW && claudeCoordinate !== CLAUDE_COMPAT_CONTEXT_WINDOW) {
+      return null;
+    }
+    const ceiling = this.seed.compactCeiling ?? null;
+    return {
+      max,
+      compactAt: compactThresholdTokens(max, ceiling),
+      unproject: (tokens) => unprojectClaudeContextInputTokens(tokens, max, claudeCoordinate, ceiling)
+    };
+  }
   push(event) {
     const entry = { seq: ++this.seq, event };
     if (event.kind === "job-progress") {
@@ -48996,6 +49516,8 @@ 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);
         }
@@ -49033,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);
   }
   /**
    * 턴 하나를 연다. 화면의 스피너와 활동축이 같은 순간에 켜지는 자리다.
@@ -49072,11 +49632,15 @@ 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;
     this.awaitingTurn = null;
     awaiting?.();
     this.releaseTurnCloseWaiters();
+    const session = this.session;
+    if (session) this.requestContextSnapshot(session, "end");
   }
   /** 자리가 비었음을 줄 서 있던 디스패치들에게 알린다. 결말 하나가 전부를 깨운다. */
   releaseTurnCloseWaiters() {
@@ -49114,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();
@@ -49150,7 +49716,7 @@ var AgentChatSession = class {
       const settled = new Promise((resolve3) => {
         this.awaitingTurn = resolve3;
       });
-      this.snapshotContextAtTurnStart(session);
+      this.requestContextSnapshot(session, "start");
       session.send(text2);
       this.turnReachedChild = true;
       await settled;
@@ -49289,6 +49855,21 @@ var AgentChatRegistry = class {
     await Promise.all([...operationIds].map((operationId) => this.dispose(operationId)));
   }
 };
+function isRecord14(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readClaudeOccupiedInputTokens(usage4) {
+  if (!isRecord14(usage4)) return null;
+  let total = 0;
+  let found = false;
+  for (const field of ["input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]) {
+    const tokens = usage4[field];
+    if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens < 0) continue;
+    total += tokens;
+    found = true;
+  }
+  return found ? total : null;
+}
 
 // ../fleet-plugins/terminal/server/agent-api/chat-ws.ts
 var MAX_CHAT_ANSWER_MESSAGE_CHARS = 2e3;
@@ -49401,6 +49982,15 @@ var ANALYSIS_ERROR_CODES = {
 var ANALYST_GATEWAY_CLI_ID = "claude-gateway";
 var ANALYST_DEFAULT_MODEL = "sonnet";
 var ANALYST_DEFAULT_EFFORT = "low";
+var ANALYST_EFFORT_LEVELS = ["low", "medium", "high"];
+function clampAnalystEffortLevels(levels) {
+  return ANALYST_EFFORT_LEVELS.filter((level) => levels.includes(level));
+}
+function clampAnalystDefaultEffort(levels, fallback) {
+  if (fallback && levels.includes(fallback)) return fallback;
+  if (levels.includes(ANALYST_DEFAULT_EFFORT)) return ANALYST_DEFAULT_EFFORT;
+  return levels[0];
+}
 var NATIVE_CLAUDE_LABELS = {
   "fable[1m]": "Claude Fable",
   sonnet: "Claude Sonnet",
@@ -49410,26 +50000,33 @@ function nativeClaudeAnalystModels() {
   return NATIVE_CLAUDE_MODEL_ALIASES.map((modelId) => ({
     modelId,
     name: NATIVE_CLAUDE_LABELS[modelId] ?? modelId,
-    effort: { supported: true, levels: [...NATIVE_CLAUDE_EFFORTS] }
+    effort: { supported: true, levels: [...ANALYST_EFFORT_LEVELS] }
   }));
 }
 function resolveAnalysisGatewayBaseUrl(origin) {
   return `${origin.replace(/\/+$/u, "")}/plugins/terminal/${AI_GATEWAY_ROUTE_SEGMENT}`;
 }
 function buildAnalysisCatalog(nativeModels, gatewayModels, available) {
-  const native = nativeModels.map((model) => ({
-    id: model.modelId,
-    label: model.name,
-    effortLevels: model.effort.supported ? [...model.effort.levels ?? []] : [],
-    ...model.modelId === ANALYST_DEFAULT_MODEL ? { defaultEffort: ANALYST_DEFAULT_EFFORT } : model.effort.supported && model.effort.default ? { defaultEffort: model.effort.default } : {}
-  }));
-  const gateway = gatewayModels.map((model) => ({
-    id: toClaudeGatewayModelId(model),
-    label: model.displayName,
-    // 게이트웨이 모델 스키마에는 기본 강도가 없다. 없는 값을 지어내면 사용자가 고르지 않은
-    // 강도로 돈다.
-    effortLevels: model.effort.supported ? [...model.effort.levels] : []
-  }));
+  const native = nativeModels.map((model) => {
+    const effortLevels = model.effort.supported ? clampAnalystEffortLevels(model.effort.levels ?? []) : [];
+    const defaultEffort = model.modelId === ANALYST_DEFAULT_MODEL ? clampAnalystDefaultEffort(effortLevels, ANALYST_DEFAULT_EFFORT) : model.effort.supported ? clampAnalystDefaultEffort(effortLevels, model.effort.default) : void 0;
+    return {
+      id: model.modelId,
+      label: model.name,
+      effortLevels,
+      ...defaultEffort ? { defaultEffort } : {}
+    };
+  });
+  const gateway = gatewayModels.map((model) => {
+    const effortLevels = model.effort.supported ? clampAnalystEffortLevels(model.effort.levels) : [];
+    return {
+      id: toClaudeGatewayModelId(model),
+      label: model.displayName,
+      // 게이트웨이 모델 스키마에는 기본 강도가 없다. 없는 값을 지어내면 사용자가 고르지 않은
+      // 강도로 돈다. 클램프 후 단이 비면 강도 없는 모델과 같다.
+      effortLevels
+    };
+  });
   const models = [...native, ...gateway];
   return {
     clis: [{
@@ -49446,7 +50043,7 @@ function analysisError(code, message) {
   return { error: { code, message } };
 }
 function isAnalysisSelection(catalog, value) {
-  if (!isRecord14(value) || !hasExactKeys(value, ["cliId", "model", "effort", "language"]) || typeof value.cliId !== "string" || typeof value.model !== "string" || value.effort !== void 0 && typeof value.effort !== "string" || value.language !== void 0 && value.language !== "en" && value.language !== "ko") return false;
+  if (!isRecord15(value) || !hasExactKeys(value, ["cliId", "model", "effort", "language"]) || typeof value.cliId !== "string" || typeof value.model !== "string" || value.effort !== void 0 && typeof value.effort !== "string" || value.language !== void 0 && value.language !== "en" && value.language !== "ko") return false;
   const cli = catalog.clis.find((candidate) => candidate.cliId === value.cliId);
   if (!cli?.available) return false;
   const model = cli.models.find((candidate) => candidate.id === value.model);
@@ -49455,9 +50052,9 @@ function isAnalysisSelection(catalog, value) {
   return typeof value.effort === "string" && value.effort.length > 0 && model.effortLevels.includes(value.effort);
 }
 function isMessageBody(value) {
-  return isRecord14(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
+  return isRecord15(value) && hasExactKeys(value, ["text"]) && typeof value.text === "string" && value.text.trim().length > 0;
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, keys) {
@@ -50024,6 +50621,8 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     }
     const launchOptions = readLaunchOptions(body, cliId, res);
     if (launchOptions === false) return true;
+    const geometry = readOptionalGeometry(body?.geometry, res);
+    if (geometry === false) return true;
     if (body?.prompt !== void 0 && typeof body.prompt !== "string") {
       ctx.host.http.writeJson(res, 400, { error: "invalid_prompt" });
       return true;
@@ -50064,7 +50663,8 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         ...launchOptions,
         ...composedPrompt ? { prompt: composedPrompt } : {},
         ...attachmentIds.length > 0 ? { attachmentIds } : {},
-        ...chatBorn ? { chatBorn: true } : {}
+        ...chatBorn ? { chatBorn: true } : {},
+        ...geometry ? { geometry } : {}
       });
     } catch (error51) {
       if (attachmentIds.length > 0) launchAttachments.unreserve(attachmentIds);
@@ -50080,6 +50680,24 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     }
     return value;
   }
+  function readOptionalGeometry(value, res) {
+    if (value === void 0) return void 0;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      ctx.host.http.writeJson(res, 400, { error: "invalid_geometry" });
+      return false;
+    }
+    const candidate = value;
+    const x = candidate.x;
+    const y = candidate.y;
+    const width = candidate.width;
+    const height = candidate.height;
+    const zIndex = candidate.zIndex;
+    if (typeof x !== "number" || !Number.isFinite(x) || typeof y !== "number" || !Number.isFinite(y) || typeof width !== "number" || !Number.isFinite(width) || typeof height !== "number" || !Number.isFinite(height) || typeof zIndex !== "number" || !Number.isFinite(zIndex)) {
+      ctx.host.http.writeJson(res, 400, { error: "invalid_geometry" });
+      return false;
+    }
+    return { x, y, width, height, zIndex };
+  }
   function readLaunchOptions(body, cliId, res) {
     if (body?.model !== void 0 && typeof body.model !== "string" || body?.effort !== void 0 && typeof body.effort !== "string") {
       ctx.host.http.writeJson(res, 400, { error: "invalid_launch_option" });
@@ -50204,6 +50822,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         // "transcript 부재는 상실이 아니라 아직 첫 턴 전"이라는 뜻을 durable하게 남긴다.
         ...launchOptions.chatBorn ? { [CHAT_MODE_PAYLOAD_KEY]: true, [CHAT_BORN_PAYLOAD_KEY]: true } : {}
       },
+      ...launchOptions.geometry ? { geometry: launchOptions.geometry } : {},
       createdAt: session.createdAt
     });
     if (launchOptions.chatBorn) {
@@ -50684,6 +51303,9 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       });
     } catch {
     }
+    const gatewayModel = findGatewayModel(model);
+    const gatewayContextWindow = typeof gatewayModel?.contextWindow === "number" && Number.isFinite(gatewayModel.contextWindow) && gatewayModel.contextWindow > 0 ? gatewayModel.contextWindow : void 0;
+    const gatewayCompactCeiling = gatewayContextWindow === void 0 ? void 0 : deps.readAiGatewaySettings?.().compactCeiling ?? null;
     const chatSkillOverrides = buildDisabledSkillOverrides(GATEWAY_DISABLED_CLAUDE_SKILLS);
     const systemPromptMode = deps.globalOptionsService.load().claudeGatewaySystemPromptMode ?? "append";
     const systemPrompt = systemPromptMode === "off" ? void 0 : { mode: systemPromptMode, text: createSystemPromptBuilder().build() };
@@ -50693,6 +51315,11 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       seed: {
         baseUrl: gatewayBaseUrl,
         model,
+        // 자식은 창이 500k인 모델도 자기 200k 좌표로 재고, 그 좌표를 물어보는 모든 표면에 그대로
+        // 말한다. 실제 창과 투영에 쓰인 압축 정책을 함께 실어야 세션이 그것을 되돌릴 수 있다.
+        // 네이티브 Claude 모델은 카탈로그에 없으므로 두 값 없이 지나가고 오늘의 숫자를 유지한다.
+        ...gatewayContextWindow === void 0 ? {} : { contextWindow: gatewayContextWindow },
+        ...gatewayCompactCeiling === void 0 ? {} : { compactCeiling: gatewayCompactCeiling },
         ...launchEffort ? { effort: launchEffort.effort } : {},
         cwd,
         claudeConfigDir,
@@ -50742,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);
         }
       }
     };