@dotobokuri/fleet-console 1.63.0 → 1.65.0

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

@@ -20839,7 +20839,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; Fleet catalog effort ladders are capped at max because harness launch capabilities are not model rungs; contextWindow=272000 is codex debug models context_window/max_context_window (codex-cli 0.146.0, observed 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 1M (1000000) variants on the same upstream bases",
       models: [
         {
           modelId: "gpt-5.6-sol",
@@ -20966,6 +20966,135 @@ var models_default = {
             "gpt-5.6-luna-fast"
           ],
           benchmarkKey: "gpt-5.6-luna"
+        },
+        {
+          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"
         }
       ]
     },
@@ -45652,6 +45781,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";
@@ -45773,6 +45905,111 @@ function runVendorQuery(input) {
     }
   };
 }
+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,
@@ -45807,80 +46044,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();
           }
-        },
-        getContextUsage: () => run.getContextUsage()
-      };
-      active = tracked;
-      return tracked;
+        };
+        if (active !== reservation) {
+          session.close();
+          throw new Error("This Claude gateway SDK instance has been disposed.");
+        }
+        active = tracked;
+        return tracked;
+      } catch (error51) {
+        if (active === reservation) active = null;
+        throw error51;
+      }
     },
     async dispose() {
       if (disposed) return;
@@ -45962,6 +46254,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) {
@@ -45979,6 +46279,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, {
@@ -47469,6 +47777,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;
@@ -47518,6 +47834,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 [];
@@ -48067,6 +48386,10 @@ var AgentChatSession = class {
   latestSessionId;
   /** 이미 Operation에 심은 세션 id. 같은 좌표를 매 턴 다시 심지 않기 위한 축이다. */
   reportedSessionId = null;
+  /** 날고 있는 좌표 심기. 리더가 메시지마다 이 자리를 지나므로 겹치지 않게 붙든다. */
+  syncFlight = null;
+  /** 그 비행 중에 들어온 요청이 있었다. 착지 후 좌표가 아직 남아 있으면 한 번 더 간다. */
+  syncDirty = false;
   journal = [];
   seq = 0;
   listeners = /* @__PURE__ */ new Set();
@@ -48074,11 +48397,52 @@ var AgentChatSession = class {
   pendingTurns = 0;
   disposed = false;
   /**
-   * 지금 도는 턴의 런. `runTurn`의 지역 변수로 두면 밖에서 닿을 수 없어 중지가 불가능하다 —
-   * 이 필드가 곧 중지 레버이며, 턴이 끝나면 반드시 null로 돌아간다(스스로 close된 런을 들고
-   * 있으면 다음 중지가 이미 죽은 런을 닫고 성공했다고 답한다).
+   * 이 세션이 붙들고 있는 자식. 턴마다 세우고 접는 것이 아니라 **Operation이 열려 있는 동안**
+   * 살아 있으며, 그 수명이 곧 백그라운드 작업의 수명이다 — 턴 단위 실행은 vendor가 single-turn으로
+   * 보고 자식의 입력을 닫아, Claude Code의 wind-down이 백그라운드 셸을 유예 뒤 kill한다.
+   */
+  session = null;
+  sessionFlight = null;
+  /** 세션 스트림을 소진하는 리더. dispose가 착지를 기다리는 자리다. */
+  readerDone = null;
+  /**
+   * 지금 화면에 열려 있는 턴이 있는가.
+   *
+   * 스트림이 턴마다 끝나지 않으므로 이 축이 필요하다. 여는 자리는 둘 — 사용자가 보낸 디스패치와,
+   * 백그라운드 작업이 끝나 자식이 모델을 다시 깨운 뒤 흐르기 시작한 내용이다. 닫는 자리는 `result`
+   * 하나이고, 중지도 여기를 닫는다.
    */
-  activeRun = null;
+  turnOpen = false;
+  /** 열린 턴의 완주를 기다리는 디스패치. 턴이 닫히면 풀린다. */
+  awaitingTurn = null;
+  /**
+   * 열린 턴이 닫히기를 기다리는 디스패치들.
+   *
+   * 자식이 백그라운드 완료로 스스로 깨어나 연 턴은 아무도 기다리지 않는다. 그 창에 사용자
+   * 메시지가 들어오면 자기 턴을 세우지 못한 채 남의 결말에 실려 나가므로, 여기서 줄을 세운다.
+   */
+  turnCloseWaiters = /* @__PURE__ */ new Set();
+  /**
+   * 중지한 턴이 아직 자기 `result`를 내지 않았다.
+   *
+   * 자식은 중단을 받아도 그 턴의 결말을 **반드시** 낸다(실측: `interrupt()` 뒤 2ms에
+   * `error_during_execution`). 그것은 이미 닫은 턴의 것이므로 새 턴의 결말로 읽으면 안 되고,
+   * 그 사이에 들어온 디스패치는 그 한 건이 지나갈 때까지 기다린다.
+   */
+  settlingStoppedTurn = false;
+  /**
+   * 지금 열린 턴의 프롬프트가 자식에 실제로 닿았는가.
+   *
+   * 닿지 않은 턴에는 자식이 낼 결말도 없다 — 세션을 여는 동안(자식 spawn·플러그인·MCP 발급은
+   * 몇 초가 걸린다) 사용자가 중지하면 그 턴은 자식이 존재조차 모른 채 닫힌다. 그때 결말을
+   * 기다리기 시작하면 오지 않을 것을 기다리며 세션이 영구히 막힌다.
+   */
+  turnReachedChild = false;
+  /**
+   * 지금 살아 있다고 알려진 잡. 세션이 끊기면 이 잡들은 자식과 함께 사라지므로, 원장에 "도는 중"
+   * 으로 남겨 두지 않고 거둬진 것으로 닫는다 — 화면이 없는 작업을 기다리게 두지 않기 위해서다.
+   */
+  liveJobs = /* @__PURE__ */ new Set();
   /**
    * 중지 세대. 중지는 도는 턴 하나가 아니라 **그 시점의 큐 전체**를 끊어야 한다 — 큐에 밀려
    * 있던 턴이 중지 직후 태연히 시작하면, 사용자가 멈춘 것은 화면에서 멈추지 않는다. 각 턴은
@@ -48180,31 +48544,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;
@@ -48283,10 +48665,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();
@@ -48436,10 +48824,10 @@ var AgentChatSession = class {
    * 응답을 기다리지 않는 이유는 스트림 때문이다: 여기서 await하면 첫 메시지 소비가 그만큼 늦다.
    * 늦게 도착한 답도 같은 턴의 시작 시점 값이므로, 그때 실어도 뜻이 달라지지 않는다.
    */
-  snapshotContextAtTurnStart(run) {
+  snapshotContextAtTurnStart(session) {
     const generation = ++this.contextGeneration;
     try {
-      void run.getContextUsage().then((usage4) => {
+      void session.getContextUsage().then((usage4) => {
         if (usage4 && generation === this.contextGeneration) this.pushContext(usage4);
       }, () => void 0);
     } catch {
@@ -48512,6 +48900,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),
@@ -48548,88 +48937,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;
-      this.snapshotContextAtTurnStart(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);
     }
   }
   /**
@@ -48639,6 +49169,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;
@@ -49580,6 +50129,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;
@@ -50041,6 +50591,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);
@@ -50096,7 +50672,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 {
@@ -50117,7 +50693,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
       seed: {
         baseUrl: gatewayBaseUrl,
         model,
-        ...effort ? { effort } : {},
+        ...launchEffort ? { effort: launchEffort.effort } : {},
         cwd,
         claudeConfigDir,
         origin: sessionOrigin,
@@ -50144,6 +50720,7 @@ async function createAgentApi(ctx, terminalRuntime, deps) {
         // 터미널이 `--settings`로 강제하는 것과 같은 값이다. 없으면 같은 프롬프트가 표면에
         // 따라 다른 내장 스킬을 깨운다.
         ...chatSkillOverrides ? { skillOverrides: chatSkillOverrides } : {},
+        ...launchEffort?.ultracode ? { ultracode: true } : {},
         // 터미널 런치와 같은 자리에 같은 옵션으로 렌더한다 — 두 표면이 한 플러그인을 공유한다.
         resolveFleetPluginRoots: () => renderFleetPluginRootsForChat({
           cwd,
@@ -50471,11 +51048,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;