@dotobokuri/fleet-console 1.62.0 → 1.64.0

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

@@ -20834,12 +20834,12 @@ var benchmarks_default = {
 };
 var models_default = {
   version: 1,
-  updatedAt: "2026-08-15T00:00:00Z",
+  updatedAt: "2026-08-17T00:00:00Z",
   providers: {
     codex: {
       name: "Codex",
       defaultModel: "gpt-5.6-sol",
-      source: "codex app-server model/list (codex-cli 0.147.0, 2026-08-11 \u2014 ultra advertised for sol/sol-wm/terra, luna stops at max) for model/effort/service-tier; contextWindow=272000 is codex debug models context_window/max_context_window (codex-cli 0.146.0, 2026-08-02)",
+      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 512K (524288) and explicit 1M (1000000) variants on the same upstream bases",
       models: [
         {
           modelId: "gpt-5.6-sol",
@@ -20853,8 +20853,7 @@ var models_default = {
               "medium",
               "high",
               "xhigh",
-              "max",
-              "ultra"
+              "max"
             ]
           },
           aliases: [
@@ -20876,8 +20875,7 @@ var models_default = {
               "medium",
               "high",
               "xhigh",
-              "max",
-              "ultra"
+              "max"
             ]
           },
           aliases: [
@@ -20897,8 +20895,7 @@ var models_default = {
               "medium",
               "high",
               "xhigh",
-              "max",
-              "ultra"
+              "max"
             ]
           },
           aliases: [
@@ -20920,8 +20917,7 @@ var models_default = {
               "medium",
               "high",
               "xhigh",
-              "max",
-              "ultra"
+              "max"
             ]
           },
           aliases: [
@@ -20970,6 +20966,264 @@ var models_default = {
             "gpt-5.6-luna-fast"
           ],
           benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-sol-512k",
+          name: "GPT-5.6-Sol-512K",
+          capabilityClass: "flagship",
+          providerModelId: "gpt-5.6-sol",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-sol-512k"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-sol-512k-fast",
+          name: "GPT-5.6-Sol-512K-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-512k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-luna-512k",
+          name: "GPT-5.6-Luna-512K",
+          capabilityClass: "light",
+          providerModelId: "gpt-5.6-luna",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-luna-512k"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-luna-512k-fast",
+          name: "GPT-5.6-Luna-512K-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-512k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-terra-512k",
+          name: "GPT-5.6-Terra-512K",
+          capabilityClass: "standard",
+          providerModelId: "gpt-5.6-terra",
+          contextWindow: 524288,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-terra-512k"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
+        },
+        {
+          modelId: "gpt-5.6-terra-512k-fast",
+          name: "GPT-5.6-Terra-512K-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-512k-fast"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
+        },
+        {
+          modelId: "gpt-5.6-sol-1m",
+          name: "GPT-5.6-Sol-1M",
+          capabilityClass: "flagship",
+          providerModelId: "gpt-5.6-sol",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-sol-1m"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-sol-1m-fast",
+          name: "GPT-5.6-Sol-1M-Fast",
+          capabilityClass: "flagship",
+          providerModelId: "gpt-5.6-sol",
+          serviceTier: "priority",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-sol-1m-fast"
+          ],
+          benchmarkKey: "gpt-5.6-sol"
+        },
+        {
+          modelId: "gpt-5.6-luna-1m",
+          name: "GPT-5.6-Luna-1M",
+          capabilityClass: "light",
+          providerModelId: "gpt-5.6-luna",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-luna-1m"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-luna-1m-fast",
+          name: "GPT-5.6-Luna-1M-Fast",
+          capabilityClass: "light",
+          providerModelId: "gpt-5.6-luna",
+          serviceTier: "priority",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-luna-1m-fast"
+          ],
+          benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          modelId: "gpt-5.6-terra-1m",
+          name: "GPT-5.6-Terra-1M",
+          capabilityClass: "standard",
+          providerModelId: "gpt-5.6-terra",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-terra-1m"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
+        },
+        {
+          modelId: "gpt-5.6-terra-1m-fast",
+          name: "GPT-5.6-Terra-1M-Fast",
+          capabilityClass: "standard",
+          providerModelId: "gpt-5.6-terra",
+          serviceTier: "priority",
+          contextWindow: 1e6,
+          effort: {
+            supported: true,
+            levels: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          },
+          aliases: [
+            "gpt-5.6-terra-1m-fast"
+          ],
+          benchmarkKey: "gpt-5.6-terra"
         }
       ]
     },
@@ -21453,8 +21707,7 @@ var GATEWAY_REASONING_EFFORTS = [
   "medium",
   "high",
   "xhigh",
-  "max",
-  "ultra"
+  "max"
 ];
 var GatewayEffortUpstreamModelIdsSchema = external_exports.partialRecord(
   external_exports.enum(GATEWAY_REASONING_EFFORTS),
@@ -21881,8 +22134,7 @@ var ANTHROPIC_EFFORT_RUNGS = /* @__PURE__ */ new Set([
   "medium",
   "high",
   "xhigh",
-  "max",
-  "ultra"
+  "max"
 ]);
 function freezeGatewayModelEffort(effort) {
   if (!effort?.supported) return UNSUPPORTED_GATEWAY_MODEL_EFFORT;
@@ -31491,11 +31743,10 @@ var GENERAL_PURPOSE_AGENT_PROMPT = [
 ].join("\n");
 var FLEET_PLUGIN_NAME = "fleet";
 function exposedEffortLadder(modelId, ladder, exposure) {
-  const deliverable = ladder.filter((rung) => rung !== "ultra");
   const chosen = exposure?.[modelId];
-  if (chosen === void 0 || chosen.length === 0) return deliverable;
-  const narrowed = deliverable.filter((rung) => chosen.includes(rung));
-  return narrowed.length > 0 ? narrowed : deliverable;
+  if (chosen === void 0 || chosen.length === 0) return ladder;
+  const narrowed = ladder.filter((rung) => chosen.includes(rung));
+  return narrowed.length > 0 ? narrowed : ladder;
 }
 function buildGatewayCustomAgents(exposed, exposure) {
   const agents = {};
@@ -44313,6 +44564,9 @@ function shouldSyncDirectoryForTest(platform) {
 function readSocketRole(value) {
   return value === "viewer" ? "viewer" : void 0;
 }
+function readTicketChannel(value) {
+  return value === "chat" ? "chat" : void 0;
+}
 var DEFAULT_TICKET_TTL_MS = 1e4;
 function createPluginTerminalTicketRegistry(deps = {}) {
   const ttlMs = deps.ttlMs ?? DEFAULT_TICKET_TTL_MS;
@@ -45000,7 +45254,23 @@ function createPluginTerminalUpgradeHandler(deps) {
       return true;
     }
     const context = deps.tickets.consume(url2.searchParams.get("ticket"));
-    if (!context || !deps.sessions.canAttach(context.sessionId)) {
+    if (!context) {
+      socket.destroy();
+      return true;
+    }
+    if (context.channel === "chat") {
+      const attachChat = deps.attachChat;
+      if (!attachChat) {
+        socket.destroy();
+        return true;
+      }
+      const server2 = getWebSocketServer();
+      server2.handleUpgrade(req, socket, head, (ws) => {
+        attachChat(ws, context);
+      });
+      return true;
+    }
+    if (!deps.sessions.canAttach(context.sessionId)) {
       socket.destroy();
       return true;
     }
@@ -45039,6 +45309,7 @@ function readUpgradeUrl(req) {
 var SHELL_OPERATION_TYPE = "shell";
 function createTerminalRuntime(ctx) {
   const tickets = createPluginTerminalTicketRegistry();
+  let chatAttach = null;
   const terminalExitListeners = /* @__PURE__ */ new Set();
   const terminalTitleListeners = /* @__PURE__ */ new Map();
   const terminalLaunchResolvers = /* @__PURE__ */ new Map();
@@ -45061,7 +45332,14 @@ function createTerminalRuntime(ctx) {
   const upgrade = createPluginTerminalUpgradeHandler({
     tickets,
     sessions,
-    isAuthorized: ctx.host.security.isTerminalAuthorized
+    isAuthorized: ctx.host.security.isTerminalAuthorized,
+    attachChat: (socket, context) => {
+      if (!chatAttach) {
+        socket.close(1013, "chat_unavailable");
+        return;
+      }
+      chatAttach(socket, context);
+    }
   });
   return {
     handleUpgrade: upgrade.handleUpgrade,
@@ -45097,7 +45375,14 @@ function createTerminalRuntime(ctx) {
         if (terminalLaunchResolvers.get(operationType) === resolver) terminalLaunchResolvers.delete(operationType);
       };
     },
+    bindChatAttach: (attach) => {
+      chatAttach = attach;
+      return () => {
+        if (chatAttach === attach) chatAttach = null;
+      };
+    },
     stop: async () => {
+      chatAttach = null;
       upgrade.close();
       await sessions.stop();
       terminalExitListeners.clear();
@@ -45345,6 +45630,7 @@ var EFFORT_LABELS = {
   ultra: "ULTRACODE"
 };
 var APEX_EFFORTS = ["max", "ultra"];
+var ULTRACODE_LAUNCH_EFFORT = "ultra";
 var NATIVE_MODEL_LABELS = {
   // Claude Code's 1M coordinates stay under their plain menu labels.
   "fable[1m]": "Fable",
@@ -45401,27 +45687,27 @@ function buildClaudeGatewayLaunchVariants(selection) {
   }
   return groups;
 }
-var EFFORT_AXIS = [...NATIVE_CLAUDE_EFFORTS, "ultra"];
+var EFFORT_AXIS = [...NATIVE_CLAUDE_EFFORTS, ULTRACODE_LAUNCH_EFFORT];
 function providerGroupId(provider) {
   return `gateway:${provider}`;
 }
 function toGatewayRow(model, selection) {
-  const efforts = (selection.effortExposure[model.id] ?? exposableEffortLadder(model)).filter((effort) => EFFORT_AXIS.includes(effort));
-  const gatedEfforts = APEX_EFFORTS.filter((effort) => efforts.includes(effort));
-  const effortAxis = EFFORT_AXIS.filter((effort) => !APEX_EFFORTS.includes(effort) || efforts.includes(effort));
+  const ordinary = selection.effortExposure[model.id] ?? exposableEffortLadder(model);
+  const hasMax = ordinary.includes("max");
+  const effortAxis = ordinary.length === 0 ? [ULTRACODE_LAUNCH_EFFORT] : [...NATIVE_CLAUDE_EFFORTS.filter((effort) => effort !== "max" || hasMax), ULTRACODE_LAUNCH_EFFORT];
+  const gatedEfforts = hasMax ? ["max", ULTRACODE_LAUNCH_EFFORT] : [ULTRACODE_LAUNCH_EFFORT];
+  const chips = [...ordinary, ULTRACODE_LAUNCH_EFFORT];
   return {
     id: model.id,
     label: bareModelName(model),
     launch: { model: model.id },
-    ...efforts.length > 0 ? {
-      effortAxis,
-      ...gatedEfforts.length > 0 ? { gatedEfforts } : {},
-      chips: efforts.map((effort) => ({
-        id: effort,
-        label: EFFORT_LABELS[effort] ?? effort.toUpperCase(),
-        launch: { model: model.id, effort }
-      }))
-    } : {}
+    effortAxis,
+    gatedEfforts,
+    chips: chips.map((effort) => ({
+      id: effort,
+      label: EFFORT_LABELS[effort] ?? effort.toUpperCase(),
+      launch: { model: model.id, effort }
+    }))
   };
 }
 function resolveDisabledReason(cli) {
@@ -45624,6 +45910,9 @@ var CLAUDE_GATEWAY_TURN_KEYS = Object.freeze([
   "abortController",
   "stderr"
 ]);
+var CLAUDE_GATEWAY_SESSION_KEYS = Object.freeze(
+  CLAUDE_GATEWAY_TURN_KEYS.filter((key) => key !== "prompt")
+);
 
 // ../../packages/core-agent/src/claude/launch-env.ts
 var CLAUDE_GATEWAY_MODEL_CACHE_RELPATH = "cache/gateway-models.json";
@@ -45684,6 +45973,32 @@ async function createIsolatedClaudeConfigDir(tempRoot = tmpdir()) {
     }
   };
 }
+function readVendorContextUsage(response) {
+  if (typeof response !== "object" || response === null) return null;
+  const usage4 = response;
+  if (typeof usage4.totalTokens !== "number" || typeof usage4.maxTokens !== "number") return null;
+  const rows = Array.isArray(usage4.categories) ? usage4.categories : [];
+  const memory = Array.isArray(usage4.memoryFiles) ? usage4.memoryFiles : [];
+  const mcp = Array.isArray(usage4.mcpTools) ? usage4.mcpTools : [];
+  return {
+    total: usage4.totalTokens,
+    max: usage4.maxTokens,
+    model: typeof usage4.model === "string" ? usage4.model : "",
+    compactAt: usage4.isAutoCompactEnabled === true && typeof usage4.autoCompactThreshold === "number" ? usage4.autoCompactThreshold : null,
+    categories: rows.flatMap((row) => {
+      const entry = row;
+      return typeof entry?.name === "string" && typeof entry.tokens === "number" ? [{ name: entry.name, tokens: entry.tokens, deferred: entry.isDeferred === true }] : [];
+    }),
+    memoryFiles: memory.flatMap((row) => {
+      const entry = row;
+      return typeof entry?.path === "string" && typeof entry.tokens === "number" ? [{ path: entry.path, tokens: entry.tokens }] : [];
+    }),
+    mcpTools: mcp.flatMap((row) => {
+      const entry = row;
+      return typeof entry?.name === "string" && typeof entry.tokens === "number" ? [{ name: entry.name, server: typeof entry.serverName === "string" ? entry.serverName : "", tokens: entry.tokens }] : [];
+    })
+  };
+}
 function runVendorQuery(input) {
   const run = query({
     prompt: input.prompt,
@@ -45691,6 +46006,14 @@ function runVendorQuery(input) {
   });
   let closed = false;
   return {
+    async getContextUsage() {
+      if (closed || typeof run.getContextUsage !== "function") return null;
+      try {
+        return readVendorContextUsage(await run.getContextUsage());
+      } catch {
+        return null;
+      }
+    },
     [Symbol.asyncIterator]() {
       const iterator = run[Symbol.asyncIterator]();
       return {
@@ -45711,7 +46034,112 @@ function runVendorQuery(input) {
     }
   };
 }
-function defineVendorTool(name, description, inputSchema, handler, extras) {
+var VendorInputQueue = class {
+  pending = [];
+  waiting = null;
+  closed = false;
+  push(message) {
+    if (this.closed) return;
+    const waiting = this.waiting;
+    if (waiting) {
+      this.waiting = null;
+      waiting({ done: false, value: message });
+      return;
+    }
+    this.pending.push(message);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    const waiting = this.waiting;
+    if (waiting) {
+      this.waiting = null;
+      waiting({ done: true, value: void 0 });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.pending.length > 0) return { done: false, value: this.pending.shift() };
+        if (this.closed) return { done: true, value: void 0 };
+        return await new Promise((resolve3) => {
+          this.waiting = resolve3;
+        });
+      }
+    };
+  }
+};
+function vendorUserMessage(text2) {
+  return {
+    type: "user",
+    session_id: "",
+    message: { role: "user", content: [{ type: "text", text: text2 }] },
+    parent_tool_use_id: null
+  };
+}
+function runVendorSession(input) {
+  const queue = new VendorInputQueue();
+  const run = query({
+    prompt: queue,
+    options: input.options
+  });
+  let closed = false;
+  return {
+    send(text2) {
+      if (closed) return;
+      queue.push(vendorUserMessage(text2));
+    },
+    async interrupt() {
+      if (closed || typeof run.interrupt !== "function") return;
+      await run.interrupt();
+    },
+    async stopTask(taskId) {
+      if (closed) return;
+      if (typeof run.stopTask !== "function") {
+        throw new TypeError("This Claude Agent SDK build has no stopTask control request.");
+      }
+      await run.stopTask(taskId);
+    },
+    async backgroundTasks(toolUseId) {
+      if (closed) return false;
+      if (typeof run.backgroundTasks !== "function") {
+        throw new TypeError("This Claude Agent SDK build has no background_tasks control request.");
+      }
+      return await run.backgroundTasks(toolUseId);
+    },
+    async getContextUsage() {
+      if (closed || typeof run.getContextUsage !== "function") return null;
+      try {
+        return readVendorContextUsage(await run.getContextUsage());
+      } catch {
+        return null;
+      }
+    },
+    [Symbol.asyncIterator]() {
+      const iterator = run[Symbol.asyncIterator]();
+      return {
+        async next() {
+          const result = await iterator.next();
+          return result.done === true ? { done: true, value: void 0 } : { done: false, value: result.value };
+        }
+      };
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      queue.close();
+      try {
+        if (typeof run.close === "function") run.close();
+        else {
+          const closing = run.return?.(void 0);
+          if (closing !== void 0) void closing.catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+  };
+}
+function defineVendorTool(name, description, inputSchema, handler, extras) {
   const definition = tool(
     name,
     description,
@@ -45745,79 +46173,135 @@ async function createClaudeGatewaySdk(options) {
   const configDir = options.home?.kind === "shared" ? createSharedClaudeConfigHome(options.home.configDir) : await createIsolatedClaudeConfigDir(options.tempRoot);
   let disposed = false;
   let active = null;
+  const reserveSlot = (kind) => {
+    if (disposed) throw new Error("This Claude gateway SDK instance has been disposed.");
+    if (active) {
+      throw new Error(kind === "turn" ? "A turn is already running on this instance. Await it, or create another instance." : "A turn or session is already running on this instance. Close it, or create another instance.");
+    }
+    const reservation = { close: () => void 0 };
+    active = reservation;
+    return reservation;
+  };
+  const prepareLaunch = async () => {
+    await configDir.writeModelCache({ baseUrl, models: catalogModels, fetchedAt: Date.now() });
+    return claudeGatewayLaunchEnv(inherited, {
+      baseUrl,
+      configDir: configDir.path,
+      homeKind: options.home?.kind === "shared" ? "shared" : "isolated"
+    });
+  };
+  const vendorRunOptions = (request, model, env) => ({
+    env,
+    model,
+    ...request.systemPrompt === void 0 ? {} : { systemPrompt: vendorSystemPrompt(request.systemPrompt) },
+    // 패키지가 스스로 지어내는 지시는 없다 — 여기 실리는 것은 전부 호출자가 고른 것이고,
+    // 고르지 않으면 아무것도 붙지 않는다. 두 기본값이 그 규율을 구조로 만든다:
+    // `settingSources: []`가 사용자·프로젝트 설정과 CLAUDE.md를 끄고, `strictMcpConfig`가
+    // 그와 별개인 ambient .mcp.json·플러그인 MCP를 막는다.
+    settingSources: options.settingSources ? [...options.settingSources] : [],
+    strictMcpConfig: options.allowAmbientMcpServers !== true,
+    // 플러그인의 MCP 선언은 읽지 않는다 — 좌표는 호출자가 이미 소유한다.
+    ...options.plugins && options.plugins.length > 0 ? { plugins: options.plugins.map((plugin) => ({ type: "local", path: plugin.path, skipMcpDiscovery: true })) } : {},
+    // `--settings`와 같은 자리다. flag 소스로 병합되므로 사용자·프로젝트 설정을 대체하지 않는다.
+    // skillOverrides와 ultracode만 연다 — settings 전체를 열면 호출자가 쓰지 않은 지시가 들어온다.
+    ...vendorFlagSettings(options),
+    ...request.effort === void 0 ? {} : { effort: request.effort },
+    ...request.cwd === void 0 ? {} : { cwd: request.cwd },
+    ...request.resume === void 0 ? {} : { resume: request.resume },
+    ...request.maxTurns === void 0 ? {} : { maxTurns: request.maxTurns },
+    ...request.maxBudgetUsd === void 0 ? {} : { maxBudgetUsd: request.maxBudgetUsd },
+    ...request.tools === void 0 ? {} : { tools: [...request.tools] },
+    ...request.allowedTools === void 0 ? {} : { allowedTools: [...request.allowedTools] },
+    ...request.disallowedTools === void 0 ? {} : { disallowedTools: [...request.disallowedTools] },
+    ...request.permissionMode === void 0 ? {} : { permissionMode: request.permissionMode },
+    ...request.canUseTool === void 0 ? {} : { canUseTool: vendorCanUseTool(request.canUseTool) },
+    ...request.mcpServers === void 0 && request.servedMcpServers === void 0 ? {} : { mcpServers: { ...request.mcpServers, ...vendorServedMcpServers(request.servedMcpServers) } },
+    ...request.includePartialMessages === void 0 ? {} : { includePartialMessages: request.includePartialMessages },
+    ...request.abortController === void 0 ? {} : { abortController: request.abortController },
+    ...request.stderr === void 0 ? {} : { stderr: request.stderr }
+  });
   const sdk = {
     configDir: configDir.path,
     models: Object.freeze(accepted.map((entry) => entry.id)),
     async startTurn(turn) {
-      if (disposed) throw new Error("This Claude gateway SDK instance has been disposed.");
-      if (active) throw new Error("A turn is already running on this instance. Await it, or create another instance.");
-      assertKnownTurnKeys(turn);
-      if (typeof turn.prompt !== "string" || turn.prompt.length === 0) {
-        throw new TypeError("turn.prompt must be a non-empty string.");
-      }
-      const model = resolveTurnModel(turn.model, accepted);
-      await configDir.writeModelCache({ baseUrl, models: catalogModels, fetchedAt: Date.now() });
-      const env = claudeGatewayLaunchEnv(inherited, {
-        baseUrl,
-        configDir: configDir.path,
-        homeKind: options.home?.kind === "shared" ? "shared" : "isolated"
-      });
-      const run = runVendorQuery({
-        prompt: turn.prompt,
-        options: {
-          env,
-          model,
-          ...turn.systemPrompt === void 0 ? {} : { systemPrompt: vendorSystemPrompt(turn.systemPrompt) },
-          // 패키지가 스스로 지어내는 지시는 없다 — 여기 실리는 것은 전부 호출자가 고른 것이고,
-          // 고르지 않으면 아무것도 붙지 않는다. 두 기본값이 그 규율을 구조로 만든다:
-          // `settingSources: []`가 사용자·프로젝트 설정과 CLAUDE.md를 끄고, `strictMcpConfig`가
-          // 그와 별개인 ambient .mcp.json·플러그인 MCP를 막는다.
-          settingSources: options.settingSources ? [...options.settingSources] : [],
-          strictMcpConfig: options.allowAmbientMcpServers !== true,
-          // 플러그인의 MCP 선언은 읽지 않는다 — 좌표는 호출자가 이미 소유한다.
-          ...options.plugins && options.plugins.length > 0 ? { plugins: options.plugins.map((plugin) => ({ type: "local", path: plugin.path, skipMcpDiscovery: true })) } : {},
-          // `--settings`와 같은 자리다. flag 소스로 병합되므로 사용자·프로젝트 설정을 대체하지 않는다.
-          ...options.skillOverrides && Object.keys(options.skillOverrides).length > 0 ? { settings: { skillOverrides: { ...options.skillOverrides } } } : {},
-          ...turn.effort === void 0 ? {} : { effort: turn.effort },
-          ...turn.cwd === void 0 ? {} : { cwd: turn.cwd },
-          ...turn.resume === void 0 ? {} : { resume: turn.resume },
-          ...turn.maxTurns === void 0 ? {} : { maxTurns: turn.maxTurns },
-          ...turn.maxBudgetUsd === void 0 ? {} : { maxBudgetUsd: turn.maxBudgetUsd },
-          ...turn.tools === void 0 ? {} : { tools: [...turn.tools] },
-          ...turn.allowedTools === void 0 ? {} : { allowedTools: [...turn.allowedTools] },
-          ...turn.disallowedTools === void 0 ? {} : { disallowedTools: [...turn.disallowedTools] },
-          ...turn.permissionMode === void 0 ? {} : { permissionMode: turn.permissionMode },
-          ...turn.canUseTool === void 0 ? {} : { canUseTool: vendorCanUseTool(turn.canUseTool) },
-          ...turn.mcpServers === void 0 && turn.servedMcpServers === void 0 ? {} : { mcpServers: { ...turn.mcpServers, ...vendorServedMcpServers(turn.servedMcpServers) } },
-          ...turn.includePartialMessages === void 0 ? {} : { includePartialMessages: turn.includePartialMessages },
-          ...turn.abortController === void 0 ? {} : { abortController: turn.abortController },
-          ...turn.stderr === void 0 ? {} : { stderr: turn.stderr }
+      const reservation = reserveSlot("turn");
+      try {
+        assertKnownTurnKeys(turn);
+        if (typeof turn.prompt !== "string" || turn.prompt.length === 0) {
+          throw new TypeError("turn.prompt must be a non-empty string.");
+        }
+        const model = resolveTurnModel(turn.model, accepted);
+        const env = await prepareLaunch();
+        const run = runVendorQuery({
+          prompt: turn.prompt,
+          options: vendorRunOptions(turn, model, env)
+        });
+        const release = () => {
+          if (active === tracked) active = null;
+        };
+        const tracked = {
+          [Symbol.asyncIterator]() {
+            const iterator = run[Symbol.asyncIterator]();
+            return {
+              async next() {
+                const result = await iterator.next();
+                if (result.done === true) release();
+                return result;
+              }
+            };
+          },
+          close() {
+            try {
+              run.close();
+            } finally {
+              release();
+            }
+          },
+          getContextUsage: () => run.getContextUsage()
+        };
+        if (active !== reservation) {
+          run.close();
+          throw new Error("This Claude gateway SDK instance has been disposed.");
         }
-      });
-      const release = () => {
-        if (active === tracked) active = null;
-      };
-      const tracked = {
-        [Symbol.asyncIterator]() {
-          const iterator = run[Symbol.asyncIterator]();
-          return {
-            async next() {
-              const result = await iterator.next();
-              if (result.done === true) release();
-              return result;
+        active = tracked;
+        return tracked;
+      } catch (error51) {
+        if (active === reservation) active = null;
+        throw error51;
+      }
+    },
+    async openSession(request) {
+      const reservation = reserveSlot("session");
+      try {
+        assertKnownSessionKeys(request);
+        const model = resolveTurnModel(request.model, accepted);
+        const env = await prepareLaunch();
+        const session = runVendorSession({ options: vendorRunOptions(request, model, env) });
+        const tracked = {
+          send: (text2) => session.send(text2),
+          interrupt: () => session.interrupt(),
+          stopTask: (taskId) => session.stopTask(taskId),
+          backgroundTasks: (toolUseId) => session.backgroundTasks(toolUseId),
+          getContextUsage: () => session.getContextUsage(),
+          [Symbol.asyncIterator]: () => session[Symbol.asyncIterator](),
+          close() {
+            try {
+              session.close();
+            } finally {
+              if (active === tracked) active = null;
             }
-          };
-        },
-        close() {
-          try {
-            run.close();
-          } finally {
-            release();
           }
+        };
+        if (active !== reservation) {
+          session.close();
+          throw new Error("This Claude gateway SDK instance has been disposed.");
         }
-      };
-      active = tracked;
-      return tracked;
+        active = tracked;
+        return tracked;
+      } catch (error51) {
+        if (active === reservation) active = null;
+        throw error51;
+      }
     },
     async dispose() {
       if (disposed) return;
@@ -45899,6 +46383,14 @@ function vendorCanUseTool(canUseTool) {
     }
   };
 }
+function vendorFlagSettings(options) {
+  const settings2 = {};
+  if (options.skillOverrides && Object.keys(options.skillOverrides).length > 0) {
+    settings2.skillOverrides = { ...options.skillOverrides };
+  }
+  if (options.ultracode === true) settings2.ultracode = true;
+  return Object.keys(settings2).length > 0 ? { settings: settings2 } : {};
+}
 function vendorSystemPrompt(systemPrompt) {
   const text2 = systemPrompt?.text;
   if (typeof text2 !== "string" || text2.length === 0) {
@@ -45916,6 +46408,14 @@ function assertKnownTurnKeys(turn) {
     );
   }
 }
+function assertKnownSessionKeys(request) {
+  const unknown2 = Object.keys(request).filter((key) => !CLAUDE_GATEWAY_SESSION_KEYS.includes(key));
+  if (unknown2.length > 0) {
+    throw new TypeError(
+      `Unsupported session option(s): ${unknown2.join(", ")}. Only an instruction the caller authored may reach the child, through systemPrompt; every other instruction channel is closed, so those options do not exist. A session receives its prompts through send(), never as an option.`
+    );
+  }
+}
 function vendorServedMcpServers(servers) {
   if (!servers?.length) return {};
   return Object.fromEntries(servers.map((server) => [server.name, {
@@ -46401,7 +46901,8 @@ var GatewayLaunchOptionError = class extends Error {
   }
 };
 function isGatewayLaunchEffortAllowed(selection, model, effort) {
-  if (![...NATIVE_CLAUDE_EFFORTS, "ultra"].includes(effort)) return false;
+  if (effort === "ultra") return true;
+  if (!GATEWAY_REASONING_EFFORTS.includes(effort)) return false;
   const efforts = selection.effortExposure[model.id] ?? exposableEffortLadder(model);
   return efforts.includes(effort);
 }
@@ -47405,6 +47906,14 @@ function readAnalysisProviderSession(value) {
     ...typeof candidate.source === "string" ? { source: candidate.source } : {}
   };
 }
+
+// ../fleet-plugins/terminal/server/agent-api/chat-launch-effort.ts
+var WIRE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+function resolveChatLaunchEffort(value) {
+  if (value.length === 0) return void 0;
+  if (value === "ultra") return { effort: "xhigh", ultracode: true };
+  return WIRE_EFFORTS.includes(value) ? { effort: value } : void 0;
+}
 var MAX_TOOL_DETAIL_CHARS = 160;
 var MAX_TOOL_RESULT_CHARS = 120;
 var MAX_TEXT_CHARS = 6e4;
@@ -47454,6 +47963,9 @@ function eventsFromTranscriptLine(line, options) {
   return [];
 }
 function chatEventsFromSdkMessage(message, options = {}) {
+  if (typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0) {
+    return [];
+  }
   if (message.type === "stream_event") {
     const inner = message.event;
     if (!inner || typeof inner !== "object") return [];
@@ -47951,6 +48463,8 @@ function capText(text2) {
 // ../fleet-plugins/terminal/server/agent-api/chat-session.ts
 var JOURNAL_CAP = 2e3;
 var TOOL_NAME_CAP = 500;
+var CONTEXT_RESERVED_NAME = "Autocompact buffer";
+var CONTEXT_UNSPENT = /* @__PURE__ */ new Set([CONTEXT_RESERVED_NAME, "Free space"]);
 var JOB_KIND_CAP = 200;
 var JOB_TAIL_READ_BYTES = 256 * 1024;
 var JOB_TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
@@ -48001,6 +48515,10 @@ var AgentChatSession = class {
   latestSessionId;
   /** 이미 Operation에 심은 세션 id. 같은 좌표를 매 턴 다시 심지 않기 위한 축이다. */
   reportedSessionId = null;
+  /** 날고 있는 좌표 심기. 리더가 메시지마다 이 자리를 지나므로 겹치지 않게 붙든다. */
+  syncFlight = null;
+  /** 그 비행 중에 들어온 요청이 있었다. 착지 후 좌표가 아직 남아 있으면 한 번 더 간다. */
+  syncDirty = false;
   journal = [];
   seq = 0;
   listeners = /* @__PURE__ */ new Set();
@@ -48008,11 +48526,52 @@ var AgentChatSession = class {
   pendingTurns = 0;
   disposed = false;
   /**
-   * 지금 도는 턴의 런. `runTurn`의 지역 변수로 두면 밖에서 닿을 수 없어 중지가 불가능하다 —
-   * 이 필드가 곧 중지 레버이며, 턴이 끝나면 반드시 null로 돌아간다(스스로 close된 런을 들고
-   * 있으면 다음 중지가 이미 죽은 런을 닫고 성공했다고 답한다).
+   * 이 세션이 붙들고 있는 자식. 턴마다 세우고 접는 것이 아니라 **Operation이 열려 있는 동안**
+   * 살아 있으며, 그 수명이 곧 백그라운드 작업의 수명이다 — 턴 단위 실행은 vendor가 single-turn으로
+   * 보고 자식의 입력을 닫아, Claude Code의 wind-down이 백그라운드 셸을 유예 뒤 kill한다.
    */
-  activeRun = null;
+  session = null;
+  sessionFlight = null;
+  /** 세션 스트림을 소진하는 리더. dispose가 착지를 기다리는 자리다. */
+  readerDone = null;
+  /**
+   * 지금 화면에 열려 있는 턴이 있는가.
+   *
+   * 스트림이 턴마다 끝나지 않으므로 이 축이 필요하다. 여는 자리는 둘 — 사용자가 보낸 디스패치와,
+   * 백그라운드 작업이 끝나 자식이 모델을 다시 깨운 뒤 흐르기 시작한 내용이다. 닫는 자리는 `result`
+   * 하나이고, 중지도 여기를 닫는다.
+   */
+  turnOpen = false;
+  /** 열린 턴의 완주를 기다리는 디스패치. 턴이 닫히면 풀린다. */
+  awaitingTurn = null;
+  /**
+   * 열린 턴이 닫히기를 기다리는 디스패치들.
+   *
+   * 자식이 백그라운드 완료로 스스로 깨어나 연 턴은 아무도 기다리지 않는다. 그 창에 사용자
+   * 메시지가 들어오면 자기 턴을 세우지 못한 채 남의 결말에 실려 나가므로, 여기서 줄을 세운다.
+   */
+  turnCloseWaiters = /* @__PURE__ */ new Set();
+  /**
+   * 중지한 턴이 아직 자기 `result`를 내지 않았다.
+   *
+   * 자식은 중단을 받아도 그 턴의 결말을 **반드시** 낸다(실측: `interrupt()` 뒤 2ms에
+   * `error_during_execution`). 그것은 이미 닫은 턴의 것이므로 새 턴의 결말로 읽으면 안 되고,
+   * 그 사이에 들어온 디스패치는 그 한 건이 지나갈 때까지 기다린다.
+   */
+  settlingStoppedTurn = false;
+  /**
+   * 지금 열린 턴의 프롬프트가 자식에 실제로 닿았는가.
+   *
+   * 닿지 않은 턴에는 자식이 낼 결말도 없다 — 세션을 여는 동안(자식 spawn·플러그인·MCP 발급은
+   * 몇 초가 걸린다) 사용자가 중지하면 그 턴은 자식이 존재조차 모른 채 닫힌다. 그때 결말을
+   * 기다리기 시작하면 오지 않을 것을 기다리며 세션이 영구히 막힌다.
+   */
+  turnReachedChild = false;
+  /**
+   * 지금 살아 있다고 알려진 잡. 세션이 끊기면 이 잡들은 자식과 함께 사라지므로, 원장에 "도는 중"
+   * 으로 남겨 두지 않고 거둬진 것으로 닫는다 — 화면이 없는 작업을 기다리게 두지 않기 위해서다.
+   */
+  liveJobs = /* @__PURE__ */ new Set();
   /**
    * 중지 세대. 중지는 도는 턴 하나가 아니라 **그 시점의 큐 전체**를 끊어야 한다 — 큐에 밀려
    * 있던 턴이 중지 직후 태연히 시작하면, 사용자가 멈춘 것은 화면에서 멈추지 않는다. 각 턴은
@@ -48041,6 +48600,11 @@ var AgentChatSession = class {
    * dispose(). 어느 경로로도 비워지지 않으면 SDK는 무기한 멈춘다(권한 요청에 park deadline이 없다).
    */
   pendingAsks = /* @__PURE__ */ new Map();
+  /**
+   * 문맥 스냅숏의 세대. 턴마다 하나씩 오르며, 늦게 도착한 응답이 자기 턴의 것인지 가른다 —
+   * 답은 턴이 끝난 뒤에 오므로(실측), 그 사이 새 턴이 시작했다면 그 값은 남의 턴 자리에 앉는다.
+   */
+  contextGeneration = 0;
   constructor(operationId, seed, createSdk) {
     this.operationId = operationId;
     this.seed = seed;
@@ -48109,31 +48673,49 @@ var AgentChatSession = class {
     if (this.disposed) return;
     const epoch = this.stopEpoch;
     this.pendingTurns += 1;
-    this.turnFlight = this.turnFlight.then(() => epoch === this.stopEpoch ? this.runTurn(text2) : void 0).catch(() => void 0).finally(() => {
+    this.turnFlight = this.turnFlight.then(() => epoch === this.stopEpoch ? this.dispatch(text2) : void 0).catch(() => void 0).finally(() => {
       this.pendingTurns -= 1;
     });
   }
   /**
    * 도는 턴을 사용자가 끊는다.
    *
-   * 이 자리가 여는 문은 **턴 하나**다. 잡 하나만 멈추는 길은 `TaskStop`뿐인데 그것은 모델이
-   * 부르는 도구이고 호스트에게는 그 제어 경로가 없다(SDK 0.3.212 실측). 그래서 여기서 잡을
-   * 멈추는 척하지 않는다 — 턴을 끊어도 이미 태어난 백그라운드 작업은 계속 살고, 원장의 잡
-   * 표면이 그것을 그대로 말한다.
+   * 이 자리가 여는 문은 **턴 하나**다. 자식은 죽지 않으며, 이미 태어난 백그라운드 작업도 계속
+   * 산다 — 그것을 멈추는 문은 `stopJob`이 따로 연다. 턴만 끊는 것이 CLI의 Esc와 같은 자리다.
    *
    * 돌려주는 값은 "끊을 것이 있었는가"다. 없는데 true를 돌려주면 화면이 멈춤을 그리고 아무 일도
    * 일어나지 않는다.
    */
   stopTurn() {
     if (this.disposed) return false;
-    if (this.pendingTurns === 0) return false;
+    if (this.pendingTurns === 0 && !this.turnOpen) return false;
     this.stopEpoch += 1;
-    const run = this.activeRun;
-    this.activeRun = null;
     this.abandonAsks("The turn was stopped before the question was answered.");
-    run?.close();
+    void this.session?.interrupt().catch(() => void 0);
+    if (this.turnOpen && this.turnReachedChild) this.settlingStoppedTurn = true;
+    this.closeTurn({ stopped: true });
     return true;
   }
+  /**
+   * 백그라운드 작업 하나를 사용자가 멈춘다.
+   *
+   * 좌표는 SDK가 발급한 `task_id`이며, 우리가 그 잡을 실제로 본 적이 있어야 한다(`jobKinds`가
+   * 그 문이다) — 브라우저가 지어낸 id는 자식에 닿지 않는다. 결말은 자식이 내는 `stopped` 알림이
+   * 말하므로, 여기서 원장을 미리 고쳐 쓰지 않는다.
+   */
+  async stopJob(jobId) {
+    if (this.disposed) return false;
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(jobId)) return false;
+    if (!this.jobKinds.has(jobId)) return false;
+    const session = this.session;
+    if (!session) return false;
+    try {
+      await session.stopTask(jobId);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   /** 지금 답을 기다리는 도구 호출이 있는가. 라우트가 대기 유무를 묻는 자리. */
   get awaiting() {
     return this.pendingAsks.size > 0;
@@ -48212,10 +48794,16 @@ var AgentChatSession = class {
     if (this.disposed) return;
     this.disposed = true;
     this.abandonAsks("The chat session closed before the question was answered.");
+    const session = this.session;
+    this.session = null;
+    session?.close();
     const sdk = this.sdk;
     this.sdk = null;
     if (sdk) await sdk.dispose().catch(() => void 0);
+    if (this.readerDone) await this.readerDone.catch(() => void 0);
+    this.releaseTurnCloseWaiters();
     await this.turnFlight.catch(() => void 0);
+    if (this.syncFlight) await this.syncFlight.catch(() => void 0);
     if (this.fleetMcpFlight) await this.fleetMcpFlight.catch(() => void 0);
     this.seed.releaseFleetMcpServers?.();
     this.listeners.clear();
@@ -48352,6 +48940,58 @@ var AgentChatSession = class {
       this.seed.reportAwaiting(true);
     });
   }
+  /**
+   * 턴이 시작하는 순간 자식에게 문맥 내역을 묻고, 답이 오면 그대로 저널에 싣는다.
+   *
+   * **이 한 번이 유일한 기회다**(실측). 자식은 턴이 시작되면 control 채널을 닫아, +0ms의 요청만
+   * 답을 받고 그 뒤의 요청은 턴이 10초를 돌든 전부 "Query closed before response received"로
+   * 끝난다. 주기적으로 물어 최신값을 좇는 설계는 이 자식에서 성립하지 않는다.
+   *
+   * 그래서 값은 **이 턴이 시작될 때까지의** 문맥이다 — 방금 끝난 턴이 더한 몫은 다음 턴이
+   * 시작될 때 비로소 드러난다. 화면은 그 지연을 감추지 않는다.
+   *
+   * 응답을 기다리지 않는 이유는 스트림 때문이다: 여기서 await하면 첫 메시지 소비가 그만큼 늦다.
+   * 늦게 도착한 답도 같은 턴의 시작 시점 값이므로, 그때 실어도 뜻이 달라지지 않는다.
+   */
+  snapshotContextAtTurnStart(session) {
+    const generation = ++this.contextGeneration;
+    try {
+      void session.getContextUsage().then((usage4) => {
+        if (usage4 && generation === this.contextGeneration) this.pushContext(usage4);
+      }, () => void 0);
+    } catch {
+    }
+  }
+  /**
+   * 턴 시작 시점의 문맥을 저널에 심는다.
+   *
+   * 총량을 vendor의 `total`이 아니라 **카테고리 합으로 다시 세는** 이유는 실측이다: 게이트웨이
+   * 세션에서 그 값(24,948)은 카테고리 합(129,670)과 크게 어긋났다 — 전자는 게이트웨이가 실제로
+   * 읽은 토큰이고 후자는 CLI가 센 로컬 배분이다. 화면은 내역과 총량을 나란히 세우므로 둘이
+   * 다른 셈을 쓰면 사용자가 보는 자리에서 모순이 드러난다. 내역이 곧 총량이어야 한다.
+   *
+   * 예약분(자동 압축 여유)과 남은 자리는 **쓴 것이 아니다**. 같은 목록에 두면 합이 언제나 창
+   * 전체가 되어 미터가 항상 100%를 가리킨다.
+   */
+  pushContext(usage4) {
+    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);
+    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 })) } : {},
+      ...usage4.mcpTools.length > 0 ? {
+        mcpTools: usage4.mcpTools.map((tool) => ({
+          name: tool.server ? `${tool.server} \xB7 ${tool.name}` : tool.name,
+          tokens: tool.tokens
+        }))
+      } : {}
+    });
+  }
   push(event) {
     const entry = { seq: ++this.seq, event };
     if (event.kind === "job-progress") {
@@ -48389,6 +49029,7 @@ var AgentChatSession = class {
           settingSources: ["user", "project", "local"],
           allowAmbientMcpServers: true,
           ...this.seed.skillOverrides ? { skillOverrides: this.seed.skillOverrides } : {},
+          ...this.seed.ultracode ? { ultracode: true } : {},
           // 플러그인이 실은 훅은 세션 식별자로 자기 축을 찾는다. 이 자식에게는 그 식별자가
           // 없어야 한다 — 상속된 값이 남으면 남의 세션 축에 보고한다.
           env: chatChildEnv(process.env),
@@ -48425,87 +49066,229 @@ var AgentChatSession = class {
     }
     return this.fleetMcpFlight;
   }
-  async runTurn(text2) {
+  /**
+   * 자식 하나를 열고, 그 스트림을 끝까지 소진하는 리더를 세운다. 세션당 한 번이다.
+   *
+   * 턴이 아니라 세션이 실행 정책을 소유한다 — 모델·강도·doctrine·도구 좌표·cwd는 자식이 사는
+   * 동안 바뀌지 않고, 바뀌어야 한다면 그것은 이 세션을 접고 새로 여는 사건이다.
+   */
+  async ensureSession() {
+    if (this.session) return this.session;
+    if (!this.sessionFlight) {
+      this.sessionFlight = (async () => {
+        const sdk = await this.ensureSdk();
+        const fleetMcpServers = await this.ensureFleetMcpServers().catch(() => {
+          this.push({ kind: "error", code: "chat_fleet_tools_unavailable" });
+          return [];
+        });
+        const session = await sdk.openSession({
+          model: this.seed.model,
+          ...this.seed.effort ? { effort: this.seed.effort } : {},
+          ...this.seed.systemPrompt ? { systemPrompt: this.seed.systemPrompt } : {},
+          ...fleetMcpServers.length > 0 ? { servedMcpServers: fleetMcpServers } : {},
+          cwd: this.seed.cwd,
+          // 이어붙일 좌표는 세션을 열 때 한 번 선다. 채팅으로 태어난 세션에는 그것이 없고,
+          // SDK가 돌려주는 session_id가 그 자리를 채운다 — 자식이 사는 동안은 그 세션이 계속
+          // 자라므로 매 턴 다시 이어붙일 일이 없다.
+          ...this.latestSessionId ? { resume: this.latestSessionId } : {},
+          permissionMode: "bypassPermissions",
+          // 이 콜백은 권한 게이트가 아니다. 모드는 그대로 bypass이고 평범한 도구는 여기서 그냥
+          // 통과한다 — 콜백을 주는 이유는 그래야 자식이 대화형 도구를 갖기 때문이다(실측: 29→32).
+          canUseTool: (name, input, context) => this.askUser(name, input, context),
+          // 스트리밍 감각의 근거 — 글자 단위 text_delta를 받으려면 부분 메시지가 필요하다.
+          includePartialMessages: true
+        });
+        if (this.disposed) {
+          session.close();
+          throw new Error("chat session disposed");
+        }
+        this.session = session;
+        this.readerDone = this.readSession(session);
+        return session;
+      })().finally(() => {
+        this.sessionFlight = null;
+      });
+    }
+    return this.sessionFlight;
+  }
+  /**
+   * 세션 스트림을 끝까지 읽는다. 이 루프가 사는 동안 자식은 "사용자가 아직 있다"고 보므로,
+   * 백그라운드 작업이 턴을 넘어 살고 그 결말 알림도 받을 자리가 있다.
+   *
+   * 여기서 끝나는 것은 턴이 아니라 세션이다 — 자식이 죽거나 우리가 접었을 때만 빠져나온다.
+   */
+  async readSession(session) {
+    try {
+      for await (const message of session) {
+        if (typeof message.session_id === "string" && message.session_id.length > 0) {
+          this.latestSessionId = message.session_id;
+          if (this.latestSessionId !== this.reportedSessionId) this.syncProviderSessionOnce();
+        }
+        this.rememberJobOutput(message);
+        for (const event of chatEventsFromSdkMessage(message, { cwd: this.seed.cwd, toolNames: this.toolNames })) {
+          this.ingest(event);
+        }
+      }
+    } catch {
+      if (!this.disposed) this.push({ kind: "error", code: "chat_session_lost" });
+    } finally {
+      this.retireSession(session);
+    }
+  }
+  /**
+   * 리더가 만든 이벤트 하나를 원장에 반영한다. 턴 경계도 여기서 결정된다.
+   *
+   * 스트림이 턴마다 끝나지 않으므로 경계는 내용이 말한다: `result`가 열린 턴을 닫고, 닫힌 뒤에
+   * 다시 흐르기 시작한 내용이 새 턴을 연다. 후자가 백그라운드 작업이 끝나 자식이 모델을 다시
+   * 깨운 자리이며, 그것을 앞 턴에 이어 붙이면 사용자가 읽은 답이 갈아치워진다.
+   */
+  ingest(event) {
+    if (event.kind === "turn-end") {
+      const settling = this.settlingStoppedTurn;
+      this.settlingStoppedTurn = false;
+      if (this.turnOpen) {
+        this.closeTurn({ ok: event.ok, ...event.durationMs === void 0 ? {} : { durationMs: event.durationMs }, ...event.answer === void 0 ? {} : { answer: event.answer } });
+      } else if (settling) {
+        this.releaseTurnCloseWaiters();
+      }
+      return;
+    }
+    if (!this.turnOpen && opensChatTurn(event)) this.openTurn({ dispatched: false });
+    this.rememberTool(event);
+    this.trackJob(event);
+    if ((event.kind === "tool" || event.kind === "tool-start") && AGENT_CHAT_ASK_TOOLS.has(event.name)) return;
+    if (event.kind === "text-delta" || event.kind === "tool-start") this.pushEphemeral(event);
+    else this.push(event);
+  }
+  /** 살아 있는 잡의 집합을 이벤트대로 따라간다. `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") {
+      this.liveJobs.clear();
+      for (const id of event.ids) this.liveJobs.add(id);
+    }
+  }
+  /**
+   * 턴 하나를 연다. 화면의 스피너와 활동축이 같은 순간에 켜지는 자리다.
+   *
+   * 이미 열려 있으면 다시 열지 않는다. 자식은 자기 큐를 갖고 있어 도는 중에도 메시지를 받는데
+   * (백그라운드가 끝나 모델이 다시 깨어난 턴이 그 상태다), 그때 두 번째 `turn-start`를 세우면
+   * 원장에 닫히지 않는 턴이 겹쳐 남는다 — 결말은 하나뿐이기 때문이다.
+   */
+  openTurn(options) {
+    if (this.turnOpen) return;
+    this.turnOpen = true;
+    this.turnReachedChild = !options.dispatched;
+    this.push({ kind: "turn-start", at: Date.now() });
+    if (!options.dispatched) this.seed.reportActivity(true);
+  }
+  /**
+   * 열린 턴을 닫는다. 부르는 자리는 셋 — 자식의 `result`, 사용자의 중지, 세션의 소멸.
+   *
+   * 대기 중인 디스패치를 여기서 푼다. 그것이 풀려야 큐에 있던 다음 메시지가 시작하고, 풀리지
+   * 않으면 세션은 조용히 멈춘 채 사용자의 다음 문장을 영영 받지 않는다.
+   */
+  closeTurn(end) {
+    if (!this.turnOpen) return;
+    this.turnOpen = false;
+    this.turnReachedChild = false;
+    this.push({
+      kind: "turn-end",
+      ok: end.ok ?? end.stopped !== true,
+      ...end.stopped === true ? { stopped: true } : {},
+      ...end.durationMs === void 0 ? {} : { durationMs: end.durationMs },
+      ...end.answer === void 0 ? {} : { answer: end.answer }
+    });
+    this.abandonAsks("The turn ended before the question was answered.");
+    this.seed.reportActivity(false);
+    const awaiting = this.awaitingTurn;
+    this.awaitingTurn = null;
+    awaiting?.();
+    this.releaseTurnCloseWaiters();
+  }
+  /** 자리가 비었음을 줄 서 있던 디스패치들에게 알린다. 결말 하나가 전부를 깨운다. */
+  releaseTurnCloseWaiters() {
+    if (this.turnCloseWaiters.size === 0) return;
+    const waiters = [...this.turnCloseWaiters];
+    this.turnCloseWaiters.clear();
+    for (const wake of waiters) wake();
+  }
+  /**
+   * 열린 턴이 닫힐 때까지 기다린다.
+   *
+   * 억제가 아니라 대기여야 하는 이유: 열린 턴에 그냥 올라타면 그 턴의 `result`가 이 디스패치를
+   * 풀어 버린다. 사용자의 프롬프트는 아직 자식 안에서 도는데 원장은 끝났다고 말하고, 큐의 다음
+   * 메시지가 그 위에서 조기에 시작한다.
+   */
+  async awaitTurnClose() {
+    if (!this.turnOpen && !this.settlingStoppedTurn) return;
+    await new Promise((resolve3) => {
+      this.turnCloseWaiters.add(resolve3);
+    });
+  }
+  /**
+   * 자식이 사라졌다. 열린 턴과 살아 있던 잡을 정직하게 닫고, 다음 디스패치가 새 자식을 세우도록
+   * 자리를 비운다.
+   *
+   * 잡을 `stopped`로 닫는 이유: 그 작업들은 자식과 함께 사라졌다. 원장에 "도는 중"으로 남겨 두면
+   * 화면은 오지 않을 결말을 기다리고, 그 조용한 거짓말이 이 원장이 고치려던 바로 그것이다.
+   */
+  retireSession(session) {
+    if (this.session === session) this.session = null;
+    this.readerDone = null;
+    try {
+      session.close();
+    } catch {
+    }
+    for (const id of [...this.liveJobs]) this.push({ kind: "job-end", id, status: "stopped" });
+    this.liveJobs.clear();
+    this.settlingStoppedTurn = false;
+    this.closeTurn({ ok: false });
+    this.releaseTurnCloseWaiters();
+  }
+  /**
+   * 사용자의 메시지 하나를 자식에게 보내고 그 턴이 닫힐 때까지 기다린다.
+   *
+   * 기다리는 이유는 자식의 사정이 아니라 화면의 사정이다 — 자식은 자기 큐를 갖고 있어 턴 중에
+   * 받아도 잃지 않지만, 원장은 턴 하나씩 그리므로 앞 턴이 닫힌 뒤 다음 디스패치를 세운다.
+   */
+  async dispatch(text2) {
     if (this.disposed) return;
     const epoch = this.stopEpoch;
     const stopped = () => epoch !== this.stopEpoch;
+    await this.awaitTurnClose();
+    if (this.disposed || stopped()) return;
     this.push({ kind: "dispatch", text: text2, at: Date.now() });
-    this.push({ kind: "turn-start", at: Date.now() });
     if (!this.seed.reportActivity(true)) {
       this.push({ kind: "error", code: "chat_activity_unavailable" });
       this.push({ kind: "turn-end", ok: false });
       return;
     }
-    let turnClosed = false;
+    this.openTurn({ dispatched: true });
     try {
-      const sdk = await this.ensureSdk();
-      const fleetMcpServers = await this.ensureFleetMcpServers().catch(() => {
-        this.push({ kind: "error", code: "chat_fleet_tools_unavailable" });
-        return [];
-      });
-      const run = await sdk.startTurn({
-        prompt: text2,
-        model: this.seed.model,
-        ...this.seed.effort ? { effort: this.seed.effort } : {},
-        ...this.seed.systemPrompt ? { systemPrompt: this.seed.systemPrompt } : {},
-        ...fleetMcpServers.length > 0 ? { servedMcpServers: fleetMcpServers } : {},
-        cwd: this.seed.cwd,
-        // 채팅으로 태어난 세션의 첫 턴에는 이어붙일 좌표가 없다 — resume 없이 시작하고,
-        // SDK가 돌려주는 session_id가 그 자리를 채운다(그다음 턴부터는 resume이 선다).
-        ...this.latestSessionId ? { resume: this.latestSessionId } : {},
-        permissionMode: "bypassPermissions",
-        // 이 콜백은 권한 게이트가 아니다. 모드는 그대로 bypass이고 평범한 도구는 여기서 그냥
-        // 통과한다 — 콜백을 주는 이유는 그래야 자식이 대화형 도구를 갖기 때문이다(실측: 29→32).
-        canUseTool: (name, input, context) => this.askUser(name, input, context),
-        // 스트리밍 감각의 근거 — 글자 단위 text_delta를 받으려면 부분 메시지가 필요하다.
-        includePartialMessages: true
-      });
+      const session = await this.ensureSession();
       if (stopped()) {
-        run.close();
-        this.push({ kind: "turn-end", ok: false, stopped: true });
+        this.closeTurn({ stopped: true });
         return;
       }
-      this.activeRun = run;
-      try {
-        for await (const message of run) {
-          if (typeof message.session_id === "string" && message.session_id.length > 0) {
-            this.latestSessionId = message.session_id;
-          }
-          this.rememberJobOutput(message);
-          for (const event of chatEventsFromSdkMessage(message, { cwd: this.seed.cwd, toolNames: this.toolNames })) {
-            if (event.kind === "turn-end") {
-              turnClosed = true;
-            } else if (turnClosed && opensChatTurn(event)) {
-              this.push({ kind: "turn-start", at: Date.now() });
-              turnClosed = false;
-            }
-            this.rememberTool(event);
-            if ((event.kind === "tool" || event.kind === "tool-start") && AGENT_CHAT_ASK_TOOLS.has(event.name)) continue;
-            if (event.kind === "text-delta" || event.kind === "tool-start") this.pushEphemeral(event);
-            else this.push(event);
-          }
-        }
-      } finally {
-        this.activeRun = null;
-        run.close();
-      }
-      if (!turnClosed) {
-        if (stopped()) this.push({ kind: "turn-end", ok: false, stopped: true });
-        else this.push({ kind: "turn-end", ok: true });
+      if (this.session !== session) {
+        this.closeTurn({ ok: false });
+        return;
       }
-      await this.syncProviderSession();
+      const settled = new Promise((resolve3) => {
+        this.awaitingTurn = resolve3;
+      });
+      this.snapshotContextAtTurnStart(session);
+      session.send(text2);
+      this.turnReachedChild = true;
+      await settled;
     } catch {
-      this.activeRun = null;
-      if (stopped()) {
-        if (!turnClosed) this.push({ kind: "turn-end", ok: false, stopped: true });
-        await this.syncProviderSession().catch(() => void 0);
-      } else {
+      if (stopped()) this.closeTurn({ stopped: true });
+      else {
         this.push({ kind: "error", code: "chat_turn_failed" });
-        if (!turnClosed) this.push({ kind: "turn-end", ok: false });
+        this.closeTurn({ ok: false });
       }
-    } finally {
-      this.abandonAsks("The turn ended before the question was answered.");
-      this.seed.reportActivity(false);
     }
   }
   /**
@@ -48515,6 +49298,25 @@ var AgentChatSession = class {
    * 좌표를 확정하는 것뿐이며, 세션 id가 바뀌지 않는 한 다시 할 일도 없다(resume이 새 id를 낳는
    * 경우에만 다시 확정한다).
    */
+  /**
+   * 좌표 심기를 한 번에 하나만 날린다.
+   *
+   * 리더는 메시지마다 이 자리를 지난다. 첫 시도가 파일을 못 찾아 실패하는 것은 정상이므로
+   * (자식이 아직 트랜스크립트를 만들지 않았다) 다음 메시지가 다시 시도해야 하는데, 가드가 없으면
+   * 그 사이 도착한 메시지들이 같은 좌표를 겹쳐 심어 Operation write-back이 여러 번 인다.
+   */
+  syncProviderSessionOnce() {
+    if (this.syncFlight) {
+      this.syncDirty = true;
+      return;
+    }
+    this.syncDirty = false;
+    this.syncFlight = this.syncProviderSession().catch(() => void 0).finally(() => {
+      this.syncFlight = null;
+      if (this.disposed || !this.syncDirty) return;
+      if (this.latestSessionId !== this.reportedSessionId) this.syncProviderSessionOnce();
+    });
+  }
   async syncProviderSession() {
     const sessionId = this.latestSessionId;
     if (!sessionId || sessionId === this.reportedSessionId) return;
@@ -48617,6 +49419,105 @@ var AgentChatRegistry = class {
   }
 };
 
+// ../fleet-plugins/terminal/server/agent-api/chat-ws.ts
+var MAX_CHAT_ANSWER_MESSAGE_CHARS = 2e3;
+var CHAT_UNAVAILABLE_CLOSE_CODE = 1013;
+function attachAgentChatSocket(socket, start) {
+  let closed = false;
+  let unsubscribe = null;
+  let session = null;
+  socket.once("close", () => {
+    closed = true;
+    unsubscribe?.();
+    unsubscribe = null;
+    session = null;
+  });
+  socket.on("message", (data, isBinary) => {
+    if (closed || isBinary || !session) return;
+    const command = readChatSocketCommand(decodeSocketText(data));
+    if (!command) {
+      sendJson(socket, { type: "nack", error: "invalid_command", ...commandId(data) ? { id: commandId(data) } : {} });
+      return;
+    }
+    if (command.type === "stop") {
+      if (!session.stopTurn()) {
+        sendJson(socket, { type: "nack", id: command.id, error: "chat_idle" });
+        return;
+      }
+      sendJson(socket, { type: "ok", id: command.id });
+      return;
+    }
+    const result = session.answer(command.askId, {
+      ...command.answers ? { answers: command.answers } : {},
+      ...command.approve === true ? { approve: true } : {},
+      ...command.message !== void 0 ? { message: command.message.slice(0, MAX_CHAT_ANSWER_MESSAGE_CHARS) } : {}
+    });
+    if (!result.ok) {
+      sendJson(socket, { type: "nack", id: command.id, error: result.error });
+      return;
+    }
+    sendJson(socket, { type: "ok", id: command.id });
+  });
+  void start().then((ready) => {
+    if (closed) return;
+    if ("error" in ready) {
+      sendJson(socket, { seq: 0, event: { kind: "error", code: ready.error } });
+      socket.close(CHAT_UNAVAILABLE_CLOSE_CODE, ready.error);
+      return;
+    }
+    session = ready;
+    unsubscribe = ready.subscribe((entry) => {
+      if (!closed) sendJson(socket, entry);
+    });
+  }).catch(() => {
+    if (closed) return;
+    sendJson(socket, { seq: 0, event: { kind: "error", code: "chat_unavailable" } });
+    socket.close(CHAT_UNAVAILABLE_CLOSE_CODE, "chat_unavailable");
+  });
+}
+function sendJson(socket, value) {
+  if (socket.readyState !== 1) return;
+  socket.send(Buffer.from(JSON.stringify(value), "utf8"), { binary: false });
+}
+function decodeSocketText(data) {
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+  return Buffer.from(data).toString("utf8");
+}
+function commandId(data) {
+  try {
+    const parsed = JSON.parse(decodeSocketText(data));
+    if (parsed && typeof parsed === "object" && typeof parsed.id === "string") {
+      return parsed.id;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readChatSocketCommand(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const value = parsed;
+  if (typeof value.id !== "string" || value.id.length === 0) return null;
+  if (value.type === "stop") return { type: "stop", id: value.id };
+  if (value.type !== "answer" || typeof value.askId !== "string" || value.askId.length === 0) return null;
+  const answers = Array.isArray(value.answers) ? value.answers.filter((entry) => typeof entry === "string") : void 0;
+  if (Array.isArray(value.answers) && answers?.length !== value.answers.length) return null;
+  return {
+    type: "answer",
+    id: value.id,
+    askId: value.askId,
+    ...answers ? { answers } : {},
+    ...value.approve === true ? { approve: true } : {},
+    ...typeof value.message === "string" ? { message: value.message } : {}
+  };
+}
+
 // ../fleet-plugins/terminal/server/agent-api/analysis-types.ts
 var ANALYSIS_ERROR_CODES = {
   captureMissing: "analysis_capture_missing",
@@ -48909,7 +49810,7 @@ var TERMINAL_PLUGIN_ID = "terminal";
 var CHAT_MODE_PAYLOAD_KEY = "chatMode";
 var CHAT_BORN_PAYLOAD_KEY = "chatBorn";
 var CHAT_SUPPORTED_CLI_ID = "claude-gateway";
-var MAX_CHAT_ANSWER_MESSAGE_CHARS = 2e3;
+var MAX_CHAT_ANSWER_MESSAGE_CHARS2 = 2e3;
 function resolveClaudeConfigDir() {
   const configured = process4.env.CLAUDE_CONFIG_DIR;
   return configured && configured.length > 0 ? configured : path19__default.join(os3__default.homedir(), ".claude");
@@ -48934,7 +49835,7 @@ async function registerAgentRoutes(ctx, terminalRuntime, deps) {
     { method: "POST", path: "/sessions/:sessionId/message", summary: "Deliver a prompt to an Agent session.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
     { method: "POST", path: "/sessions/:sessionId/chat", summary: "Switch an Agent session to chat mode.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
     { method: "DELETE", path: "/sessions/:sessionId/chat", summary: "Leave chat mode for an Agent session.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
-    { method: "GET", path: "/sessions/:sessionId/chat-stream", summary: "Stream Agent chat events.", category: "Terminal Plugin", gate: "origin-write", transport: "sse" },
+    { method: "GET", path: "/sessions/:sessionId/chat-stream", summary: "Removed \u2014 Chat Mode observation uses the ticketed WebSocket.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
     { method: "POST", path: "/sessions/:sessionId/chat-answer", summary: "Answer a pending Agent chat question.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
     { method: "POST", path: "/sessions/:sessionId/chat-stop", summary: "Stop the in-flight Agent chat turn.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
     { method: "GET", path: "/sessions/:sessionId/chat-job", summary: "Read one Agent chat background job's detail.", category: "Terminal Plugin", gate: "origin-write", transport: "http" },
@@ -49001,6 +49902,27 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
   const oscActivityTrackers = /* @__PURE__ */ new Map();
   const testChatSdkFactory = globalThis.__fleetAgentChatSdkFactory;
   const chatRegistry = testChatSdkFactory ? new AgentChatRegistry(testChatSdkFactory) : new AgentChatRegistry();
+  const unbindChatAttach = terminalRuntime.bindChatAttach((socket, context) => {
+    const sessionId = context.sessionId;
+    attachAgentChatSocket(socket, async () => {
+      const node = ctx.host.operations.get(sessionId);
+      if (!node || node.pluginId !== ctx.pluginId || node.type !== AGENT_OPERATION_TYPE) {
+        return { error: "session_not_found" };
+      }
+      if (node.payload[CHAT_MODE_PAYLOAD_KEY] !== true) return { error: "chat_not_active" };
+      const seed = await resolveChatSeed(node);
+      if (!seed.ok) return { error: seed.error };
+      if (ctx.host.operations.get(sessionId)?.payload[CHAT_MODE_PAYLOAD_KEY] !== true) {
+        return { error: "chat_not_active" };
+      }
+      try {
+        return await chatRegistry.ensure(sessionId, () => seed.seed);
+      } catch {
+        return { error: "chat_unavailable" };
+      }
+    });
+  });
+  ctx.host.lifecycle.registerCleanup(unbindChatAttach);
   const launchResolver = createAgentTerminalLaunchResolver({
     agentRuntime: runtime,
     ...deps.aiGateway ? { aiGateway: deps.aiGateway } : {},
@@ -49136,6 +50058,23 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         ctx.host.http.writeJson(res, 404, { error: "terminal_session_not_found" });
         return true;
       }
+      const channel = readTicketChannel(body?.channel);
+      if (channel === "chat") {
+        if (operation.payload[CHAT_MODE_PAYLOAD_KEY] !== true) {
+          ctx.host.http.writeJson(res, 409, { error: "chat_not_active" });
+          return true;
+        }
+        ctx.host.http.writeJson(res, 200, terminalRuntime.issueTicket({
+          cwd: readPayloadString(operation.payload, "cwd") ?? ctx.host.paths.resolveTheaterPath(operation.theaterId) ?? "",
+          sessionId: operation.id,
+          operationId: operation.id,
+          operationType: operation.type,
+          pluginId: operation.pluginId,
+          theaterId: operation.theaterId,
+          channel: "chat"
+        }));
+        return true;
+      }
       if (observability.getTerminalSessionInfo(operation.id)?.status === "dormant") {
         ctx.host.http.writeJson(res, 409, { error: "operation_dormant" });
         return true;
@@ -49319,6 +50258,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     if (action === "chat-answer") return handleChatAnswer(req, res, sessionId);
     if (action === "chat-stop") return handleChatStop(req, res, sessionId);
     if (action === "chat-job") return handleChatJob(req, res, sessionId);
+    if (action === "chat-job-stop") return handleChatJobStop(req, res, sessionId);
     if (!ctx.host.security.isTerminalAuthorized(req)) {
       ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
       return true;
@@ -49750,7 +50690,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     const result = chat.answer(askId, {
       ...answers ? { answers } : {},
       ...body?.approve === true ? { approve: true } : {},
-      ...typeof body?.message === "string" ? { message: body.message.slice(0, MAX_CHAT_ANSWER_MESSAGE_CHARS) } : {}
+      ...typeof body?.message === "string" ? { message: body.message.slice(0, MAX_CHAT_ANSWER_MESSAGE_CHARS2) } : {}
     });
     if (!result.ok) {
       const status = result.error === "ask_not_found" ? 404 : result.error === "plan_truncated" ? 409 : 400;
@@ -49780,6 +50720,32 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     ctx.host.http.writeJson(res, 200, { ok: true });
     return true;
   }
+  async function handleChatJobStop(req, res, sessionId) {
+    if (req.method !== "POST") return methodNotAllowed2(res);
+    if (!ctx.host.security.validateHost(req) || !ctx.host.security.isTerminalAuthorized(req)) return unauthorized(res);
+    const node = ctx.host.operations.get(sessionId);
+    if (!node || node.pluginId !== ctx.pluginId || node.type !== AGENT_OPERATION_TYPE) {
+      ctx.host.http.writeJson(res, 404, { error: "session_not_found" });
+      return true;
+    }
+    const chat = chatRegistry.get(sessionId);
+    if (!chat) {
+      ctx.host.http.writeJson(res, 409, { error: "chat_not_active" });
+      return true;
+    }
+    const body = await ctx.host.http.readJsonBody(req);
+    const jobId = typeof body?.jobId === "string" ? body.jobId : "";
+    if (jobId.length === 0) {
+      ctx.host.http.writeJson(res, 400, { error: "invalid_job_id" });
+      return true;
+    }
+    if (!await chat.stopJob(jobId)) {
+      ctx.host.http.writeJson(res, 409, { error: "job_stop_unavailable" });
+      return true;
+    }
+    ctx.host.http.writeJson(res, 200, { ok: true });
+    return true;
+  }
   async function handleChatJob(req, res, sessionId) {
     if (req.method !== "GET") return methodNotAllowed2(res);
     if (!ctx.host.security.validateHost(req) || !ctx.host.security.isTerminalAuthorized(req)) return unauthorized(res);
@@ -49818,56 +50784,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       ctx.host.http.writeJson(res, 409, { error: "chat_not_active" });
       return true;
     }
-    let closed = false;
-    let unsubscribe = null;
-    const write = (data) => {
-      if (!closed && !res.writableEnded && !res.destroyed) res.write(data);
-    };
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-store",
-      Connection: "keep-alive",
-      "Cross-Origin-Opener-Policy": "same-origin",
-      "Cross-Origin-Resource-Policy": "same-origin",
-      "Referrer-Policy": "no-referrer",
-      "X-Content-Type-Options": "nosniff"
-    });
-    write(": open\n\n");
-    const keepalive = setInterval(() => write(": keepalive\n\n"), 3e4);
-    req.on("close", () => {
-      closed = true;
-      clearInterval(keepalive);
-      unsubscribe?.();
-    });
-    void (async () => {
-      const seed = await resolveChatSeed(node);
-      if (!seed.ok) {
-        write(`data: ${JSON.stringify({ seq: 0, event: { kind: "error", code: seed.error } })}
-
-`);
-        res.end();
-        return;
-      }
-      if (ctx.host.operations.get(sessionId)?.payload[CHAT_MODE_PAYLOAD_KEY] !== true) {
-        write(`data: ${JSON.stringify({ seq: 0, event: { kind: "error", code: "chat_not_active" } })}
-
-`);
-        res.end();
-        return;
-      }
-      try {
-        const chat = await chatRegistry.ensure(sessionId, () => seed.seed);
-        if (closed) return;
-        unsubscribe = chat.subscribe((entry) => write(`data: ${JSON.stringify(entry)}
-
-`));
-      } catch {
-        write(`data: ${JSON.stringify({ seq: 0, event: { kind: "error", code: "chat_unavailable" } })}
-
-`);
-        res.end();
-      }
-    })();
+    ctx.host.http.writeJson(res, 410, { error: "chat_stream_moved" });
     return true;
   }
   async function resolveChatSeed(node) {
@@ -49884,7 +50801,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     const cwd = readPayloadString(node.payload, "cwd") || ctx.host.paths.resolveTheaterPath(node.theaterId);
     if (!cwd) return { ok: false, status: 404, error: "theater_not_found" };
     const model = readPayloadString(node.payload, "launchModel") || "opus[1m]";
-    const effort = chatEffortFromLaunchEffort(readPayloadString(node.payload, "launchEffort"));
+    const launchEffort = resolveChatLaunchEffort(readPayloadString(node.payload, "launchEffort"));
     const claudeConfigDir = resolveClaudeConfigDir();
     const gatewayBaseUrl = resolveAnalysisGatewayBaseUrl(origin);
     try {
@@ -49905,7 +50822,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       seed: {
         baseUrl: gatewayBaseUrl,
         model,
-        ...effort ? { effort } : {},
+        ...launchEffort ? { effort: launchEffort.effort } : {},
         cwd,
         claudeConfigDir,
         origin: sessionOrigin,
@@ -49932,6 +50849,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         // 터미널이 `--settings`로 강제하는 것과 같은 값이다. 없으면 같은 프롬프트가 표면에
         // 따라 다른 내장 스킬을 깨운다.
         ...chatSkillOverrides ? { skillOverrides: chatSkillOverrides } : {},
+        ...launchEffort?.ultracode ? { ultracode: true } : {},
         // 터미널 런치와 같은 자리에 같은 옵션으로 렌더한다 — 두 표면이 한 플러그인을 공유한다.
         resolveFleetPluginRoots: () => renderFleetPluginRootsForChat({
           cwd,
@@ -50259,11 +51177,6 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
     return true;
   }
 }
-function chatEffortFromLaunchEffort(value) {
-  if (value.length === 0) return void 0;
-  if (value === "ultra") return "max";
-  return ["low", "medium", "high", "xhigh", "max"].includes(value) ? value : void 0;
-}
 function isOperationDeletedEventPayload(value) {
   if (!value || typeof value !== "object") return false;
   const event = value;