@triflux/remote 10.43.0 → 10.45.0

package/hub/team/interactive-tui-transport.mjs

@@ -14,6 +14,7 @@ const STARTUP_PROMPT_MAX_ATTEMPTS = 30;
 const STARTUP_PROMPT_POLL_INTERVAL_MS = 300;
 const PIPE_TEMP_PREFIX = "triflux-tui-pipe-";
 const PIPE_OUTPUT_FILE = "pane.out";
+const CODEX_NO_APPROVAL_FLAG = "--dangerously-bypass-approvals-and-sandbox";
 
 const CONTROL_SEQUENCES = [
   ["\x1b[A", "Up"],
@@ -41,6 +42,13 @@ export async function defaultRunTmux(args, options = {}) {
   });
 }
 
+export function ensureInteractiveCodexPosture(launchCmd) {
+  const command = String(launchCmd || "").trim();
+  if (!/^codex(?:\s|$)/u.test(command)) return command;
+  if (command.includes(CODEX_NO_APPROVAL_FLAG)) return command;
+  return command.replace(/^codex/u, `codex ${CODEX_NO_APPROVAL_FLAG}`);
+}
+
 export function createInteractiveTuiTransport({
   runTmux = defaultRunTmux,
   sessionName,
@@ -113,7 +121,13 @@ export function createInteractiveTuiTransport({
       ...(cwd ? ["-c", cwd] : []),
       ...buildTmuxEnvArgs(env),
     ]);
-    await tmux(["send-keys", "-t", sessionName, String(launchCmd), "Enter"]);
+    await tmux([
+      "send-keys",
+      "-t",
+      sessionName,
+      ensureInteractiveCodexPosture(launchCmd),
+      "Enter",
+    ]);
     await dismissStartupPrompts({ tmux, captureVisible, sessionName });
     started = true;
     await startOutputStream();

package/hub/team/intervention.mjs

@@ -5,11 +5,11 @@ import { statSync } from "node:fs";
 import { readdir, readlink } from "node:fs/promises";
 import { promisify } from "node:util";
 import { isPidAlive } from "@triflux/core/hub/lib/process-utils.mjs";
-import { killProcess } from "@triflux/core/hub/platform.mjs";
 import {
   resolveHardCeilingMs,
   resolveStallInterventionMs as resolveStallThresholdMs,
 } from "@triflux/core/hub/lib/timeout-defaults.mjs";
+import { killProcess } from "@triflux/core/hub/platform.mjs";
 
 export { resolveHardCeilingMs, resolveStallThresholdMs };
 

package/hub/team/launcher-template.mjs

@@ -5,6 +5,11 @@
 // F4 해결: codex exec "prompt" 인라인 (파이프/리다이렉트 아님)
 // F5 해결: 동일 입력 → 동일 args 배열 (런타임 분기 없음)
 
+import {
+  buildDisabledCliError,
+  normalizeCliName,
+  resolveCliPolicy,
+} from "../../scripts/lib/machine-profile.mjs";
 import { buildExecArgs as buildCodexArgs } from "@triflux/core/hub/codex-adapter.mjs";
 
 function shellSingleQuote(value) {
@@ -13,7 +18,7 @@ function shellSingleQuote(value) {
 
 function buildAntigravityArgs(opts = {}) {
   const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
-  const command = `printf %s ${shellSingleQuote(prompt)} | agy --print --dangerously-skip-permissions`;
+  const command = `agy --dangerously-skip-permissions --print ${shellSingleQuote(prompt)}`;
   if (opts.resultFile) {
     return `${command} > ${shellSingleQuote(opts.resultFile)} 2>${shellSingleQuote(`${opts.resultFile}.err`)}`;
   }
@@ -90,6 +95,17 @@ export function buildLauncher(opts) {
   if (!agent) throw new Error("agent is required");
   if (!prompt && prompt !== "") throw new Error("prompt is required");
 
+  // TFX_DISABLE_* SSOT 집행. 이 런처는 tfx-route.sh 를 거치지 않고 codex/agy
+  // 바이너리를 직접 실행하는 경로라서 같은 정책을 여기서 다시 확인한다. 정책
+  // 판독 시임은 opts.cliPolicy(계산된 정책)와 opts.policyEnv(env 객체)뿐이다.
+  // claude 처럼 정책 대상이 아닌 CLI 는 프로파일 파일을 읽지 않는다.
+  if (normalizeCliName(agent)) {
+    const cliPolicy =
+      opts.cliPolicy ?? resolveCliPolicy(opts.policyEnv ?? process.env);
+    const blockedCli = buildDisabledCliError(agent, cliPolicy);
+    if (blockedCli) throw blockedCli;
+  }
+
   const adapter = getAdapter(agent);
 
   const command = adapter.buildArgs({

package/hub/team/notify.mjs

@@ -54,12 +54,17 @@ function normalizeEvent(event, defaults = {}) {
   });
 }
 
-function defaultChannelConfig(name, env) {
+function defaultChannelConfig(name, env, platform = process.platform) {
   switch (name) {
     case "bell":
-      return { enabled: true };
+      return { enabled: envFlag(env?.TRIFLUX_NOTIFY_BELL, true) };
     case "toast":
-      return { enabled: true };
+      return {
+        // macOS `osascript display notification` can surface Script Editor
+        // authorization/UI prompts. Keep it opt-in there; Windows keeps the
+        // historical toast default, and other platforms skip as unsupported.
+        enabled: envFlag(env?.TRIFLUX_NOTIFY_TOAST, platform !== "darwin"),
+      };
     case "webhook": {
       const url = String(env?.TRIFLUX_NOTIFY_WEBHOOK || "");
       return { enabled: Boolean(url), url };
@@ -69,8 +74,13 @@ function defaultChannelConfig(name, env) {
   }
 }
 
-function normalizeChannelConfig(name, value, env) {
-  const base = defaultChannelConfig(name, env);
+function envFlag(value, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  return !["0", "false", "no", "off"].includes(String(value).toLowerCase());
+}
+
+function normalizeChannelConfig(name, value, env, platform) {
+  const base = defaultChannelConfig(name, env, platform);
   const patch =
     typeof value === "boolean"
       ? { enabled: value }
@@ -103,16 +113,21 @@ function normalizeChannelConfig(name, value, env) {
   return freezeRecord(next);
 }
 
-function normalizeChannels(channels, env) {
+function normalizeChannels(channels, env, platform) {
   const source = channels && typeof channels === "object" ? channels : {};
   const normalized = {};
   for (const name of NOTIFY_CHANNELS) {
-    normalized[name] = normalizeChannelConfig(name, source[name], env);
+    normalized[name] = normalizeChannelConfig(
+      name,
+      source[name],
+      env,
+      platform,
+    );
   }
   return Object.freeze(normalized);
 }
 
-function updateChannelConfig(channels, channel, config, env) {
+function updateChannelConfig(channels, channel, config, env, platform) {
   if (!NOTIFY_CHANNELS.includes(channel)) {
     throw new TypeError(`Unknown notify channel: ${channel}`);
   }
@@ -126,6 +141,7 @@ function updateChannelConfig(channels, channel, config, env) {
         ...(typeof config === "boolean" ? { enabled: config } : config || {}),
       },
       env,
+      platform,
     ),
   });
 }
@@ -322,7 +338,7 @@ function createNotifierInstance(channels, deps) {
 
   function setChannel(channel, config) {
     return createNotifierInstance(
-      updateChannelConfig(channels, channel, config, deps.env),
+      updateChannelConfig(channels, channel, config, deps.env, deps.platform),
       deps,
     );
   }
@@ -349,17 +365,21 @@ function createNotifierInstance(channels, deps) {
  */
 export function createNotifier(opts = {}) {
   const env = opts.env || process.env;
+  const platform = opts.platform || process.platform;
   const deps = Object.freeze({
     env,
     stdout: opts.stdout || process.stdout,
     execFile: opts.deps?.execFile || execFile,
     fetch: opts.deps?.fetch || globalThis.fetch?.bind(globalThis),
-    platform: opts.platform || process.platform,
+    platform,
     hostname: opts.hostname || os.hostname(),
     powerShellCandidates: Object.freeze(
       opts.deps?.powerShellCandidates || ["pwsh", "powershell.exe"],
     ),
   });
 
-  return createNotifierInstance(normalizeChannels(opts.channels, env), deps);
+  return createNotifierInstance(
+    normalizeChannels(opts.channels, env, platform),
+    deps,
+  );
 }

package/hub/team/orchestrator.mjs

@@ -126,7 +126,8 @@ export function buildPrompt(subtask, config) {
  * @param {string} opts.hubUrl — Hub URL
  * @param {{target:string, cli:string, task:string}|null} opts.lead
  * @param {string} opts.teammateMode
- * @returns {Promise<void>}
+ * @param {(failure: {target:string, cli:string, role:string, message:string}) => void} [opts.onInjectionFailure]
+ * @returns {Promise<Array<{target:string, cli:string, role:string, message:string}>>}
  */
 export async function orchestrate(sessionName, assignments, opts = {}) {
   const {
@@ -134,7 +135,24 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
     lead = null,
     teammateMode = "tmux",
     injectPrompt = defaultInjectPrompt,
+    onInjectionFailure,
   } = opts;
+  const failures = [];
+
+  function recordInjectionFailure(target, cli, role, error) {
+    const failure = {
+      target,
+      cli: cli || "unknown",
+      role,
+      message: String(error?.message || error || "prompt submission failed"),
+    };
+    failures.push(failure);
+    try {
+      onInjectionFailure?.(failure);
+    } catch {
+      // reporting failure must not stop the remaining pane injections
+    }
+  }
 
   const workers = assignments.map(({ target, cli, subtask }) => ({
     target,
@@ -155,10 +173,14 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
         subtask: w.subtask,
       })),
     });
-    injectPrompt(lead.target, leadPrompt, {
-      useFileRef: true,
-      cli: lead.cli,
-    });
+    try {
+      injectPrompt(lead.target, leadPrompt, {
+        useFileRef: true,
+        cli: lead.cli,
+      });
+    } catch (error) {
+      recordInjectionFailure(lead.target, lead.cli, "lead", error);
+    }
     await new Promise((r) => setTimeout(r, 100));
   }
 
@@ -169,10 +191,15 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       hubUrl,
       sessionName,
     });
-    injectPrompt(worker.target, prompt, {
-      useFileRef: true,
-      cli: worker.cli,
-    });
+    try {
+      injectPrompt(worker.target, prompt, {
+        useFileRef: true,
+        cli: worker.cli,
+      });
+    } catch (error) {
+      recordInjectionFailure(worker.target, worker.cli, "worker", error);
+    }
     await new Promise((r) => setTimeout(r, 100));
   }
+  return failures;
 }

package/hub/team/pane.mjs

@@ -62,7 +62,7 @@ export function buildCliCommand(cli, options = {}) {
       if (trustMode) {
         return buildExecArgs({});
       }
-      return "codex";
+      return "codex --dangerously-bypass-approvals-and-sandbox";
     case "gemini":
       // interactive 모드 — MCP는 ~/.gemini/settings.json에 사전 등록
       return "gemini";
@@ -105,6 +105,149 @@ export function shouldUseFileRef({ multiplexer, useFileRef, cli }) {
   return multiplexer === "psmux" && useFileRef && cli !== "codex";
 }
 
+/** 동기 sleep — injectPrompt는 sync 경로라 setTimeout을 쓸 수 없다 */
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+// paste 직후 Enter가 TUI paste-burst 감지에 개행으로 흡수되는 것을 피하는 정착 지연
+const PASTE_SETTLE_MS = 350;
+// 제출 확인 재시도 상한
+const SUBMIT_RETRY_LIMIT = 3;
+// TUI 준비 대기 상한 — 배너/composer 렌더 완료 전 주입은 키 입력이 통째로 유실될 수 있음
+const COMPOSER_READY_TIMEOUT_MS = 8000;
+
+function capturePaneText(target) {
+  try {
+    if (detectMultiplexer() === "psmux") {
+      return String(
+        psmuxExec(["capture-pane", "-t", target, "-p"], { encoding: "utf8" }) ??
+          "",
+      );
+    }
+    return String(muxExec(`capture-pane -t ${target} -p`) ?? "");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * TUI가 그리기를 마칠 때까지 대기: pane 내용이 비어 있지 않고 연속 두 번의
+ * capture가 동일(정적)해질 때까지 폴링한다. CLI 종류와 무관한 준비 신호이며
+ * 시간 초과 시 그냥 진행한다 (기존 고정-대기 동작으로 degrade).
+ */
+function waitForComposerReady(target) {
+  const deadline = Date.now() + COMPOSER_READY_TIMEOUT_MS;
+  let prev = null;
+  while (Date.now() < deadline) {
+    const text = capturePaneText(target);
+    if (text.trim() && prev !== null && text === prev) return;
+    prev = text;
+    sleepMs(400);
+  }
+}
+
+/**
+ * 주입한 프롬프트가 실제 제출됐는지 확인하고, 안 됐으면 Enter를 재전송한다.
+ *
+ * TUI는 연속 키 입력을 paste burst로 묶으므로 paste 직후의 Enter가 제출 대신
+ * composer 개행으로 흡수될 수 있다. transcript의 과거 prompt가 아니라 마지막
+ * composer line에서 현재 prompt가 사라졌을 때만 제출로 판정한다. Antigravity는
+ * capture 불가 또는 재시도 소진을 성공으로 숨기지 않고 오류로 반환한다.
+ */
+function isAntigravityCli(cli) {
+  return ["agy", "antigravity", "gemini"].includes(
+    String(cli || "").toLowerCase(),
+  );
+}
+
+function promptComposerNeedle(prompt) {
+  const firstContentLine = String(prompt || "")
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean);
+  return (firstContentLine || "").slice(0, 16);
+}
+
+function isComposerPromptLine(line) {
+  return /^\s*(?:[│┃]\s*)?[›❯▶▸>]\s*/u.test(String(line || ""));
+}
+
+function composerPromptState(text, needle) {
+  const composerLines = String(text || "")
+    .split("\n")
+    .filter(isComposerPromptLine);
+  if (composerLines.length === 0) return "unknown";
+  return composerLines.at(-1).includes(needle) ? "present" : "absent";
+}
+
+function hasBusyMarkerOutsideComposer(text) {
+  return String(text || "")
+    .split("\n")
+    .some(
+      (line) =>
+        !isComposerPromptLine(line) &&
+        /esc to (?:interrupt|cancel)/iu.test(line),
+    );
+}
+
+/**
+ * paste된 prompt가 실제 제출될 때까지 Enter를 bounded retry한다.
+ * Antigravity는 capture로 성공을 확인하지 못하면 조용히 idle 상태로 남기지 않고
+ * caller에 명확한 오류를 반환한다.
+ */
+export function submitPromptWithVerification({
+  cli,
+  prompt,
+  capture,
+  sendEnter,
+  sleep = sleepMs,
+  settleMs = PASTE_SETTLE_MS,
+  retryLimit = SUBMIT_RETRY_LIMIT,
+} = {}) {
+  if (typeof capture !== "function" || typeof sendEnter !== "function") {
+    throw new TypeError("capture and sendEnter are required");
+  }
+
+  const strictVerification = isAntigravityCli(cli);
+  const needle = promptComposerNeedle(prompt);
+  sleep(settleMs);
+
+  if (!needle) {
+    sendEnter();
+    return;
+  }
+
+  for (let attempt = 1; attempt <= retryLimit; attempt++) {
+    sendEnter();
+    sleep(400 * attempt);
+    const text = String(capture() ?? "");
+    if (!text) {
+      if (strictVerification) continue;
+      return;
+    }
+    if (hasBusyMarkerOutsideComposer(text)) return;
+    const composerState = composerPromptState(text, needle);
+    if (composerState === "absent") return;
+    if (composerState === "unknown" && !strictVerification) return;
+  }
+
+  if (strictVerification) {
+    throw new Error(
+      `Antigravity prompt submission failed after ${retryLimit} attempts: prompt remains in composer or submission could not be verified`,
+    );
+  }
+}
+
+function confirmSubmit(target, prompt, cli, sendEnter) {
+  submitPromptWithVerification({
+    cli,
+    prompt,
+    capture: () => capturePaneText(target),
+    sendEnter,
+  });
+}
+
 /**
  * pane에 프롬프트 주입
  * @param {string} target — 예: tfx-multi-abc:0.1
@@ -131,16 +274,29 @@ export function injectPrompt(
   if (shouldUseFileRef({ multiplexer, useFileRef, cli })) {
     writeFileSync(tmpFile, prompt, "utf8");
     const filePath = tmpFile.replace(/\\/g, "/");
-    psmuxExec(["select-pane", "-t", target]);
-    psmuxExec(["send-keys", "-t", target, "-l", `@${filePath}`]);
-    psmuxExec(["send-keys", "-t", target, "Enter"]);
-    // TUI가 파일을 읽을 시간을 주고 정리
-    setTimeout(() => {
-      try {
-        unlinkSync(tmpFile);
-      } catch {}
-    }, 10000);
-    return;
+    let cleanupScheduled = false;
+    try {
+      waitForComposerReady(target);
+      psmuxExec(["select-pane", "-t", target]);
+      psmuxExec(["send-keys", "-t", target, "-l", `@${filePath}`]);
+      confirmSubmit(target, `@${filePath}`, cli, () =>
+        psmuxExec(["send-keys", "-t", target, "Enter"]),
+      );
+      // TUI가 파일을 읽을 시간을 주고 정리
+      setTimeout(() => {
+        try {
+          unlinkSync(tmpFile);
+        } catch {}
+      }, 10000);
+      cleanupScheduled = true;
+      return;
+    } finally {
+      if (!cleanupScheduled) {
+        try {
+          unlinkSync(tmpFile);
+        } catch {}
+      }
+    }
   }
 
   try {
@@ -148,17 +304,23 @@ export function injectPrompt(
 
     if (detectMultiplexer() === "psmux") {
       const sessionName = getPsmuxSessionName(target);
+      waitForComposerReady(target);
       psmuxExec(["load-buffer", "-t", sessionName, toMuxPath(tmpFile)]);
       psmuxExec(["select-pane", "-t", target]);
       psmuxExec(["paste-buffer", "-t", target]);
-      psmuxExec(["send-keys", "-t", target, "Enter"]);
+      confirmSubmit(target, prompt, cli, () =>
+        psmuxExec(["send-keys", "-t", target, "Enter"]),
+      );
       return;
     }
 
-    // tmux load-buffer → paste-buffer → Enter
+    // tmux load-buffer → paste-buffer → (정착 지연 + 제출 확인) Enter
+    waitForComposerReady(target);
     muxExec(`load-buffer ${quoteArg(toMuxPath(tmpFile))}`);
     muxExec(`paste-buffer -t ${target}`);
-    muxExec(`send-keys -t ${target} Enter`);
+    confirmSubmit(target, prompt, cli, () =>
+      muxExec(`send-keys -t ${target} Enter`),
+    );
   } finally {
     try {
       unlinkSync(tmpFile);

package/hub/team/psmux.mjs

@@ -676,41 +676,32 @@ export function createPsmuxSession(sessionName, opts = {}) {
     newSessionArgs.push(PWSH_BIN, "-NoLogo", "-NoProfile");
   const leadPane = psmuxExec(newSessionArgs);
 
-  // split-window로 생성되는 pane도 동일 셸 사용 (Windows: PowerShell 강제)
-  if (PWSH_BIN && IS_WINDOWS) {
-    try {
-      psmuxExec([
-        "set-option",
-        "-t",
-        sessionName,
-        "default-command",
-        `${PWSH_BIN} -NoLogo -NoProfile`,
-      ]);
-    } catch {
-      /* 미지원 시 무시 */
+  try {
+    // split-window로 생성되는 pane도 동일 셸 사용 (Windows: PowerShell 강제)
+    if (PWSH_BIN && IS_WINDOWS) {
+      try {
+        psmuxExec([
+          "set-option",
+          "-t",
+          sessionName,
+          "default-command",
+          `${PWSH_BIN} -NoLogo -NoProfile`,
+        ]);
+      } catch {
+        /* 미지원 시 무시 */
+      }
     }
-  }
 
-  if (layout === "2x2" && limitedPaneCount >= 3) {
-    const rightPane = psmuxExec([
-      "split-window",
-      "-h",
-      "-P",
-      "-F",
-      "#{session_name}:#{window_index}.#{pane_index}",
-      "-t",
-      leadPane,
-    ]);
-    psmuxExec([
-      "split-window",
-      "-v",
-      "-P",
-      "-F",
-      "#{session_name}:#{window_index}.#{pane_index}",
-      "-t",
-      rightPane,
-    ]);
-    if (limitedPaneCount >= 4) {
+    if (layout === "2x2" && limitedPaneCount >= 3) {
+      const rightPane = psmuxExec([
+        "split-window",
+        "-h",
+        "-P",
+        "-F",
+        "#{session_name}:#{window_index}.#{pane_index}",
+        "-t",
+        leadPane,
+      ]);
       psmuxExec([
         "split-window",
         "-v",
@@ -718,51 +709,69 @@ export function createPsmuxSession(sessionName, opts = {}) {
         "-F",
         "#{session_name}:#{window_index}.#{pane_index}",
         "-t",
-        leadPane,
+        rightPane,
       ]);
+      if (limitedPaneCount >= 4) {
+        psmuxExec([
+          "split-window",
+          "-v",
+          "-P",
+          "-F",
+          "#{session_name}:#{window_index}.#{pane_index}",
+          "-t",
+          leadPane,
+        ]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "tiled"]);
+    } else if (layout === "1xN") {
+      for (let index = 1; index < limitedPaneCount; index += 1) {
+        psmuxExec(["split-window", "-h", "-t", sessionTarget]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "even-horizontal"]);
+    } else {
+      for (let index = 1; index < limitedPaneCount; index += 1) {
+        psmuxExec(["split-window", "-v", "-t", sessionTarget]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "even-vertical"]);
     }
-    psmuxExec(["select-layout", "-t", sessionTarget, "tiled"]);
-  } else if (layout === "1xN") {
-    for (let index = 1; index < limitedPaneCount; index += 1) {
-      psmuxExec(["split-window", "-h", "-t", sessionTarget]);
-    }
-    psmuxExec(["select-layout", "-t", sessionTarget, "even-horizontal"]);
-  } else {
-    for (let index = 1; index < limitedPaneCount; index += 1) {
-      psmuxExec(["split-window", "-v", "-t", sessionTarget]);
-    }
-    psmuxExec(["select-layout", "-t", sessionTarget, "even-vertical"]);
-  }
 
-  psmuxExec(["select-pane", "-t", leadPane]);
+    psmuxExec(["select-pane", "-t", leadPane]);
 
-  const panes = collectSessionPanes(sessionName).slice(0, limitedPaneCount);
-  panes.forEach((pane, index) => {
+    const panes = collectSessionPanes(sessionName).slice(0, limitedPaneCount);
+    panes.forEach((pane, index) => {
+      try {
+        psmuxExec(["select-pane", "-t", pane, "-T", toPaneTitle(index)]);
+      } catch {
+        // tmux 2.6 미만: select-pane -T 미지원 — pane title 없이 계속 진행
+      }
+    });
+
+    // CP949 등 non-UTF-8 codepage 환경에서 CLI stdout 깨짐 방지:
+    // pane 생성 직후 UTF-8 인코딩을 강제 설정한다.
+    // chcp 65001: 프로세스 코드 페이지를 UTF-8로 전환
+    // OutputEncoding: 네이티브 명령(gemini/codex) stdout 디코딩
+    // $OutputEncoding: PowerShell 파이프라인 기본 인코딩
+    if (IS_WINDOWS) {
+      const encodingInit = [
+        "chcp 65001 > $null",
+        "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
+        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
+        "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+      ].join("; ");
+      panes.forEach((paneId) => {
+        sendLiteralToPane(paneId, encodingInit, true);
+      });
+    }
+
+    return { sessionName, panes };
+  } catch (error) {
     try {
-      psmuxExec(["select-pane", "-t", pane, "-T", toPaneTitle(index)]);
+      killPsmuxSession(sessionName);
     } catch {
-      // tmux 2.6 미만: select-pane -T 미지원 — pane title 없이 계속 진행
+      /* rollback is best-effort; preserve the initialization error */
     }
-  });
-
-  // CP949 등 non-UTF-8 codepage 환경에서 CLI stdout 깨짐 방지:
-  // pane 생성 직후 UTF-8 인코딩을 강제 설정한다.
-  // chcp 65001: 프로세스 코드 페이지를 UTF-8로 전환
-  // OutputEncoding: 네이티브 명령(gemini/codex) stdout 디코딩
-  // $OutputEncoding: PowerShell 파이프라인 기본 인코딩
-  if (IS_WINDOWS) {
-    const encodingInit = [
-      "chcp 65001 > $null",
-      "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
-      "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
-      "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
-    ].join("; ");
-    panes.forEach((paneId) => {
-      sendLiteralToPane(paneId, encodingInit, true);
-    });
+    throw error;
   }
-
-  return { sessionName, panes };
 }
 
 /**