triflux 10.44.0 → 10.46.0

package/bin/tfx-live.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
-import { realpathSync } from "node:fs";
+import { mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join as pathJoin, resolve as pathResolve } from "node:path";
@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { runHygiene } from "../cto/hygiene.mjs";
 import { notifyCtoHygieneOnce } from "../cto/hygiene-notify.mjs";
+import { resolveHardCeilingMs } from "../hub/lib/worker-lifecycle.mjs";
 import { createNotifier } from "../hub/team/notify.mjs";
 import {
   escapePwshSingleQuoted as escapeRemotePwshSingleQuoted,
@@ -23,6 +24,9 @@ const DEFAULT_POLL_INTERVAL_MS = 1500;
 const DEFAULT_READY_TIMEOUT_MS = 30_000;
 const DEFAULT_ANSWER_TIMEOUT_MS = 60_000;
 const FALLBACK_QUIET_POLLS = 3;
+const PROMPT_SUBMIT_MAX_ATTEMPTS = 3;
+const PROMPT_SUBMIT_RETRY_DELAY_MS = 100;
+const PROMPT_COMPOSER_NEEDLE_LENGTH = 30;
 // Capture the complete pane history so a long TUI response does not lose its
 // leading lines. runTmux's MAX_BUFFER remains the memory/output ceiling.
 const CAPTURE_START = "-";
@@ -35,7 +39,8 @@ const BRIDGE_TIMEOUT_BUFFER_MS = 15_000;
 // spill the JSON to a temp file and pass --payload-file instead.
 const PAYLOAD_FILE_THRESHOLD = 96 * 1024;
 const VALID_TRANSPORTS = ["tmux", "uds", "auto"];
-const BOOLEAN_FLAGS = new Set(["json"]);
+const BOOLEAN_FLAGS = new Set(["json", "attach-a", "attach-b"]);
+const PEER_HOP_DONE_MARKER = "<<<TFX_PEER_HOP_DONE>>>";
 // uds-fallback diagnostics land here, written async so a failed daemon attach
 // never blocks the tmux fallback path (see writeUdsBugReport / doAskAuto).
 const BUG_REPORT_DIR =
@@ -45,17 +50,20 @@ const BUG_REPORT_DIR =
 function usage() {
   return [
     "Usage:",
-    "  tfx-live start --session NAME [--cli codex|claude] [--cwd DIR] [--remote HOST] [--resume ID] [--resume-last 1] [--ready-timeout 30] [--poll-interval 1500]",
-    "  tfx-live ask --session NAME --prompt TEXT [--cli codex|claude] [--timeout 60] [--remote HOST] [--settle 1500] [--poll-interval 1500]",
+    "  tfx-live start --session NAME [--cli codex|claude] [--model ID] [--effort TIER] [--cwd DIR] [--remote HOST] [--resume ID] [--resume-last 1] [--ready-timeout 30] [--poll-interval 1500]",
+    "  tfx-live ask --session NAME[:WINDOW.PANE] --prompt TEXT [--cli codex|claude] [--if-busy wait|fail|interrupt] [--busy-timeout 60] [--timeout 60] [--remote HOST] [--settle 1500] [--poll-interval 1500]",
+    "  tfx-live ask --cli codex --transport uds --thread ID|auto --prompt TEXT [--codex-socket PATH|default] [--cwd DIR] [--if-busy wait|fail|steer] [--busy-timeout 60] [--timeout 60] [--max-turn SECONDS]",
     "  tfx-live ask --transport uds|auto (--short SHORT | --session-id ID) --prompt TEXT [--config-dir DIR] [--bridge ABS] [--session NAME (auto fallback)] [--timeout 60]",
     "    transport: auto is the default for Claude when --short/--session-id is present; otherwise tmux. bridge path: --bridge > $TFX_BRIDGE > $TFX_REPO_ROOT/hub/bridge.mjs > bundled Triflux hub/bridge.mjs.",
     "  tfx-live interrupt --session NAME [--cli codex|claude] [--transport tmux|uds|auto] [--short SHORT | --session-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 5]",
     "  tfx-live stop --session NAME [--cli codex|claude] [--remote HOST]",
     "  tfx-live probe [--short SHORT] [--session-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 10]",
+    "  tfx-live list-sessions --cli codex [--transport tmux|uds] [--codex-socket PATH|default] [--cwd DIR] [--remote HOST (tmux)]",
     "  tfx-live converse --session NAME --prompts-file PATH [--cli codex|claude] [--remote HOST] [--cwd DIR] [--timeout 60] [--settle 1500]",
     "  tfx-live goal-driven --session NAME --goal TEXT [--cli codex|claude] [--remote HOST] [--cwd DIR] [--timeout 60] [--settle 1500] [--max-rounds 8] [--done-token DONE]",
-    "  tfx-live peer [--cli-a codex] [--cli-b claude] [--session-a peerA] [--session-b peerB] [--transport-a tmux|uds|auto] [--transport-b tmux|uds|auto] [--short-a SHORT] [--short-b SHORT] [--session-id-a ID] [--session-id-b ID] [--bridge ABS] [--remote HOST] [--cwd DIR] [--rounds 4] [--mode counting|freeform] [--seed TEXT] [--timeout 60]",
-    "  tfx-live orchestrate --task TEXT [--mode peer|codex-led|claude-led] [--codex-transport exec|app-server-uds] [--cwd DIR] [--timeout 120]",
+    "  tfx-live peer [--cli-a codex] [--cli-b claude] [--model-a ID] [--model-b ID] [--effort-a TIER] [--effort-b TIER] [--session-a NAME[:WINDOW.PANE]] [--session-b NAME[:WINDOW.PANE]] [--attach-a] [--attach-b] [--transport-a tmux|uds|auto] [--transport-b tmux|uds|auto] [--short-a SHORT] [--short-b SHORT] [--session-id-a ID] [--session-id-b ID] [--thread-a ID|auto] [--thread-b ID|auto] [--codex-socket-a PATH|default] [--codex-socket-b PATH|default] [--bridge ABS] [--remote HOST] [--cwd DIR] [--if-busy wait|fail] [--if-busy-a POLICY] [--if-busy-b POLICY] [--busy-timeout 60] [--max-turn SECONDS] [--rounds 4] [--mode counting|freeform] [--seed TEXT] [--timeout 60]",
+    "  tfx-live orchestrate --task TEXT [--mode peer|codex-led|claude-led] [--codex-transport exec|app-server-uds] [--codex-socket PATH|default] [--cwd DIR] [--timeout 120]",
+    "    Codex TUI may use a shared app-server daemon. UDS ask resumes the thread to receive answer events; sending to an active thread with --if-busy steer merges input into that turn.",
     "    Runs the Claude(UDS)+Codex orchestration engine. --codex-transport app-server-uds drives a real `codex app-server` over WebSocket-over-UDS (experimental); default exec keeps the codex stdio one-shot path.",
     "  tfx-live cto-hygiene-notify --root DIR --state-file PATH [--json]",
     "    One-shot CTO hygiene dry-run notification: sends only when actionable hygiene state changes; no polling or apply/steward lock.",
@@ -197,7 +205,7 @@ function buildRemoteLiveArgv(verb, opts) {
     "tfx-live",
     verb,
     "--cli",
-    "claude",
+    opts.cli ?? "claude",
     "--transport",
     opts.transport ?? "uds",
   ];
@@ -205,6 +213,13 @@ function buildRemoteLiveArgv(verb, opts) {
   if (opts.sessionId) args.push("--session-id", opts.sessionId);
   if (opts.session) args.push("--session", opts.session);
   if (opts.configDir) args.push("--config-dir", opts.configDir);
+  if (opts.threadId) args.push("--thread", opts.threadId);
+  if (opts.codexSocket) args.push("--codex-socket", opts.codexSocket);
+  if (opts.cwd) args.push("--cwd", opts.cwd);
+  if (opts.ifBusy) args.push("--if-busy", opts.ifBusy);
+  if (opts.busyTimeoutMs)
+    args.push("--busy-timeout", String(opts.busyTimeoutMs / 1000));
+  if (opts.maxTurnMs) args.push("--max-turn", String(opts.maxTurnMs / 1000));
   if (verb === "ask") args.push("--prompt", opts.prompt ?? "");
   args.push("--timeout", timeoutSeconds(opts.timeoutMs));
   if (verb === "ask" && opts.settleMs) {
@@ -311,8 +326,21 @@ async function callRemoteLive(verb, opts, deps = {}) {
   const execRemote = deps.sshExec ?? execFileAsync;
   const env = await probeRemoteEnv(host);
   const plan = buildRemoteLiveCommand(host, verb, opts, env);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_ANSWER_TIMEOUT_MS;
+  const codexUds =
+    verb === "ask" &&
+    opts.cli === "codex" &&
+    (opts.transport ?? "uds") === "uds";
+  const maxTurnMs = codexUds
+    ? (opts.maxTurnMs ?? Math.min(resolveHardCeilingMs(), 15 * 60_000))
+    : 0;
   const execOptions = {
-    timeout: (opts.timeoutMs ?? DEFAULT_ANSWER_TIMEOUT_MS) + 30_000,
+    timeout:
+      (verb === "ask" ? (opts.busyTimeoutMs ?? timeoutMs) : 0) +
+      // Codex checks its hard ceiling on a timeoutMs tick.
+      maxTurnMs +
+      timeoutMs +
+      30_000,
     maxBuffer: MAX_BUFFER,
   };
 
@@ -353,6 +381,292 @@ async function runTmux(remote, tmuxArgs, options = {}) {
   }
 }
 
+function normalizeCwd(value) {
+  if (!value) return null;
+  const resolved = pathResolve(value);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function splitTmuxTarget(value) {
+  const target = String(value ?? "");
+  const session = target.split(":", 1)[0];
+  if (!session)
+    throw new Error("tmux target requires a session name before ':'");
+  return { session, target };
+}
+
+function tmuxBufferName(target) {
+  return `tfx-live-prompt-${target.replace(/[^A-Za-z0-9_-]/g, "_")}-${Date.now()}`;
+}
+
+function resolveCodexDaemonSocket(value = "default") {
+  const socketPath =
+    value === "default"
+      ? pathJoin(
+          process.env.CODEX_HOME ?? pathJoin(homedir(), ".codex"),
+          "app-server-control",
+          "app-server-control.sock",
+        )
+      : pathResolve(value);
+  try {
+    if (statSync(socketPath).isSocket()) return socketPath;
+  } catch {
+    /* handled below */
+  }
+  throw new Error(
+    `Codex daemon socket unavailable: ${socketPath}. Start it with codex app-server daemon start`,
+  );
+}
+
+function isCodexTmuxPane(currentCommand, startCommand) {
+  const current = String(currentCommand ?? "").trim();
+  const currentBase = current.split("/").at(-1);
+  if (currentBase === "codex") {
+    return true;
+  }
+
+  const started = String(startCommand ?? "").trim();
+  const directStart = started
+    .replace(/^exec\s+/, "")
+    .replace(/^['"]|['"]$/g, "");
+  if (/^(?:\S*\/)?codex(?:\s|$)/.test(directStart)) {
+    return true;
+  }
+
+  return (
+    /\bomx_codex_pid\b/.test(started) &&
+    /(?:^|[\s'""])(?:[^'" \t]+\/)?codex(?:[\s'"]|$)/.test(started)
+  );
+}
+
+function isCodexProcessCommand(command) {
+  const argv = (command.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((arg) =>
+    arg.replace(/^["']|["']$/g, ""),
+  );
+  const isCodexPath = (arg) => /^(?:.*\/)?codex(?:\.js)?$/.test(arg ?? "");
+  const executable = argv.shift();
+  if (isCodexPath(executable)) return true;
+  if (!/^(?:.*\/)?node(?:js)?$/.test(executable ?? "")) return false;
+  const valueOptions = new Set([
+    "-r",
+    "--require",
+    "--import",
+    "--loader",
+    "--experimental-loader",
+    "--icu-data-dir",
+  ]);
+  const booleanOptions = new Set([
+    "--no-warnings",
+    "--enable-source-maps",
+    "--preserve-symlinks",
+    "--preserve-symlinks-main",
+  ]);
+  while (argv.length) {
+    const arg = argv.shift();
+    if (arg === "--") return isCodexPath(argv[0]);
+    if (/^(?:-[ep]|--eval(?:=|$)|--print(?:=|$))/.test(arg)) return false;
+    if (!arg.startsWith("-")) return isCodexPath(arg);
+    if (valueOptions.has(arg.split("=", 1)[0])) {
+      if (!arg.includes("=")) argv.shift();
+    } else if (!booleanOptions.has(arg)) {
+      // Unknown Node options may consume the next token as a value.
+      return false;
+    }
+  }
+  return false;
+}
+
+async function inspectCodexTmuxPane(pane, deps = {}) {
+  if (isCodexTmuxPane(pane.currentCommand, pane.startCommand))
+    return { isCodex: true };
+  if (!pane.panePid && !pane.paneTty) return { isCodex: false };
+  const args = ["-ax", "-o", "pid=,ppid=,tty=,args="];
+  const command = pane.remote ? "ssh" : "ps";
+  const commandArgs = pane.remote
+    ? [
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "ConnectTimeout=10",
+        pane.remote,
+        shellQuote(["ps", ...args]),
+      ]
+    : args;
+  let stdout;
+  try {
+    ({ stdout } = await (deps.psExec ?? execFileAsync)(command, commandArgs, {
+      timeout: 15_000,
+      maxBuffer: MAX_BUFFER,
+    }));
+  } catch (error) {
+    return {
+      isCodex: false,
+      preflightWarning: `Codex pane process inspection unavailable: ${error.message}`,
+    };
+  }
+  const processes = String(stdout)
+    .split(/\r?\n/)
+    .flatMap((line) => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/);
+      return match
+        ? [{ pid: match[1], ppid: match[2], tty: match[3], command: match[4] }]
+        : [];
+    });
+  const descendants = new Set([String(pane.panePid)]);
+  let added;
+  do {
+    added = false;
+    for (const process of processes) {
+      if (descendants.has(process.ppid) && !descendants.has(process.pid)) {
+        descendants.add(process.pid);
+        added = true;
+      }
+    }
+  } while (added);
+  const tty = String(pane.paneTty ?? "").replace(/^\/dev\//, "");
+  return {
+    isCodex: processes.some(
+      (process) =>
+        (descendants.has(process.pid) ||
+          (tty && tty !== "?" && tty !== "??" && process.tty === tty)) &&
+        isCodexProcessCommand(process.command),
+    ),
+  };
+}
+
+function parseCodexTmuxSessions(stdout, cwd = null, codexTargets = null) {
+  const cwdFilter = normalizeCwd(cwd);
+  const sessions = new Map();
+
+  for (const line of String(stdout).split(/\r?\n/)) {
+    if (!line) continue;
+    const [
+      session,
+      createdRaw,
+      attachedRaw,
+      windowIndex,
+      paneIndex,
+      paneCwd,
+      currentCommand,
+      startCommand,
+    ] = line.split("\t");
+    if (
+      !session ||
+      !(codexTargets
+        ? codexTargets.has(`${session}:${windowIndex}.${paneIndex}`)
+        : isCodexTmuxPane(currentCommand, startCommand))
+    ) {
+      continue;
+    }
+
+    const normalizedPaneCwd = normalizeCwd(paneCwd);
+    if (cwdFilter && normalizedPaneCwd !== cwdFilter) {
+      continue;
+    }
+
+    const startedAtEpoch = Number.parseInt(createdRaw, 10);
+    const startedAt = Number.isSafeInteger(startedAtEpoch)
+      ? new Date(startedAtEpoch * 1000).toISOString()
+      : null;
+    const existing = sessions.get(session);
+    const pane = {
+      target: `${session}:${windowIndex}.${paneIndex}`,
+      cwd: normalizedPaneCwd,
+      command: currentCommand,
+    };
+    if (existing) {
+      if (!existing.cwd && normalizedPaneCwd) {
+        existing.cwd = normalizedPaneCwd;
+      }
+      existing.panes.push(pane);
+      continue;
+    }
+
+    sessions.set(session, {
+      session,
+      startedAt,
+      startedAtEpoch: Number.isSafeInteger(startedAtEpoch)
+        ? startedAtEpoch
+        : null,
+      cwd: normalizedPaneCwd,
+      attached: Number.parseInt(attachedRaw, 10) > 0,
+      target: pane.target,
+      panes: [pane],
+    });
+  }
+
+  return [...sessions.values()].sort((left, right) =>
+    left.session.localeCompare(right.session),
+  );
+}
+
+async function discoverCodexTmuxSessions(
+  { cwd = null, remote = null } = {},
+  deps = {},
+) {
+  const format = [
+    "#{session_name}",
+    "#{session_created}",
+    "#{session_attached}",
+    "#{window_index}",
+    "#{pane_index}",
+    "#{pane_current_path}",
+    "#{pane_current_command}",
+    "#{pane_start_command}",
+    "#{pane_tty}",
+    "#{pane_pid}",
+  ].join("\t");
+
+  try {
+    const { stdout } = await (deps.runTmux ?? runTmux)(remote, [
+      "list-panes",
+      "-a",
+      "-F",
+      format,
+    ]);
+    const codexTargets = new Set();
+    for (const line of String(stdout).split(/\r?\n/)) {
+      if (!line) continue;
+      const [
+        session,
+        ,
+        ,
+        window,
+        pane,
+        ,
+        currentCommand,
+        startCommand,
+        paneTty,
+        panePid,
+      ] = line.split("\t");
+      const result = await inspectCodexTmuxPane(
+        { currentCommand, startCommand, paneTty, panePid, remote },
+        deps,
+      );
+      if (result.isCodex) codexTargets.add(`${session}:${window}.${pane}`);
+    }
+    return {
+      ok: true,
+      cli: "codex",
+      cwd: normalizeCwd(cwd),
+      sessions: parseCodexTmuxSessions(stdout, cwd, codexTargets),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      cli: "codex",
+      cwd: normalizeCwd(cwd),
+      reason: "tmux-unavailable",
+      error: error.message,
+      sessions: [],
+    };
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -383,6 +697,30 @@ function isBusyByEsc(text) {
   return String(text).includes("esc to interrupt");
 }
 
+function isCodexLoadingCapture(text) {
+  const headers = [
+    ...stripAnsi(text).matchAll(/^\s*(?:│\s*)?model:\s*([^\n]*)/gim),
+  ];
+  return /^loading\b/i.test(headers.at(-1)?.[1] ?? "");
+}
+
+function isCodexTimeLine(line) {
+  return (
+    /^\s*\d{1,2}:\d{2}(?:\s?[AP]M)?\s*$/.test(line) ||
+    /^\s*(?:오전|오후)\s?\d{1,2}:\d{2}\s*$/.test(line)
+  );
+}
+
+function trimResponseLines(adapter, lines) {
+  while (
+    lines.length &&
+    (!lines.at(-1).trim() ||
+      (adapter.cli === "codex" && isCodexTimeLine(lines.at(-1))))
+  )
+    lines.pop();
+  return lines.join("\n").trim();
+}
+
 function hasCodexComposerPrompt(text) {
   return /^\s*[›❯▶▸>]\s*/m.test(text);
 }
@@ -418,7 +756,11 @@ function isClaudeResponseLine(line) {
 }
 
 function isCodexReadyCapture(text) {
-  return !isBusyByEsc(text) && hasCodexComposerPrompt(text);
+  return (
+    !isBusyByEsc(text) &&
+    !isCodexLoadingCapture(text) &&
+    hasCodexComposerPrompt(text)
+  );
 }
 
 function hasClaudeLoginGuard(text) {
@@ -461,23 +803,9 @@ function isWarningLine(line) {
   return /^\s*(?:\u26A0|\(warning\))/i.test(line);
 }
 
-function hasAssistantResponseLine(adapter, text) {
-  return String(text)
-    .split("\n")
-    .some((line) => adapter.isResponseLine(line));
-}
-
 function promptLineIndex(lines, prompt) {
-  if (!prompt) {
-    return -1;
-  }
-
   for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const line = lines[index];
-    if (
-      (hasCodexComposerPrompt(line) || hasClaudeComposerPrompt(line)) &&
-      line.includes(prompt)
-    ) {
+    if (composerLineMatchesPrompt(lines[index], prompt)) {
       return index;
     }
   }
@@ -489,6 +817,31 @@ function isComposerPromptLine(line) {
   return hasCodexComposerPrompt(line) || hasClaudeComposerPrompt(line);
 }
 
+function promptComposerNeedle(prompt) {
+  const firstContentLine = String(prompt)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+  return (firstContentLine ?? "").slice(0, PROMPT_COMPOSER_NEEDLE_LENGTH);
+}
+
+function composerLineMatchesPrompt(line, prompt) {
+  const needle = promptComposerNeedle(prompt);
+  return (
+    Boolean(needle) &&
+    isComposerPromptLine(line) &&
+    String(line).includes(needle)
+  );
+}
+
+function composerShowsPrompt(text, prompt) {
+  const activeComposerLine = String(text)
+    .split("\n")
+    .filter(isComposerPromptLine)
+    .at(-1);
+  return composerLineMatchesPrompt(activeComposerLine, prompt);
+}
+
 function nextComposerPromptIndex(lines, startIndex) {
   for (
     let index = Math.max(0, startIndex + 1);
@@ -515,16 +868,6 @@ function responseLineIndexForPrompt(adapter, lines, promptIndex) {
   return -1;
 }
 
-function hasAssistantResponseAfterPrompt(adapter, text, prompt) {
-  const lines = String(text).split("\n");
-  const promptIndex = promptLineIndex(lines, prompt);
-  if (promptIndex === -1) {
-    return hasAssistantResponseLine(adapter, text);
-  }
-
-  return responseLineIndexForPrompt(adapter, lines, promptIndex) !== -1;
-}
-
 function extractAssistantResponse(adapter, text, prompt = null) {
   const lines = String(text)
     .split("\n")
@@ -560,7 +903,58 @@ function extractAssistantResponse(adapter, text, prompt = null) {
     }
   }
 
-  return response.join("\n").trim();
+  return trimResponseLines(adapter, response);
+}
+
+function extractResponseSinceMarker({ beforeRaw, raw, doneMarker, adapter }) {
+  if (!doneMarker) {
+    return "";
+  }
+
+  const beforeLines = String(beforeRaw)
+    .split("\n")
+    .map((line) => line.replace(/\s+$/g, ""));
+  const rawLines = String(raw)
+    .split("\n")
+    .map((line) => line.replace(/\s+$/g, ""));
+  let sharedPrefixLength = 0;
+  while (
+    sharedPrefixLength < beforeLines.length &&
+    sharedPrefixLength < rawLines.length &&
+    beforeLines[sharedPrefixLength] === rawLines[sharedPrefixLength]
+  ) {
+    sharedPrefixLength += 1;
+  }
+
+  const newLines =
+    sharedPrefixLength > 0 ? rawLines.slice(sharedPrefixLength) : rawLines;
+  const markerIndex = newLines.findIndex((line) => line.trim() === doneMarker);
+  if (markerIndex === -1) {
+    return "";
+  }
+
+  const candidateLines = newLines.slice(0, markerIndex);
+  const responseStart = candidateLines.findIndex((line) =>
+    adapter.isResponseLine(line),
+  );
+  const responseLines =
+    responseStart === -1 ? candidateLines : candidateLines.slice(responseStart);
+
+  return trimResponseLines(
+    adapter,
+    responseLines
+      .filter(
+        (line) =>
+          !adapter.isChromeLine(line) &&
+          !isWarningLine(line) &&
+          !adapter.isStatusLine(line) &&
+          !hasCodexComposerPrompt(line) &&
+          !hasClaudeComposerPrompt(line),
+      )
+      .map((line) =>
+        adapter.isResponseLine(line) ? adapter.stripResponseMarker(line) : line,
+      ),
+  );
 }
 
 function normalizeClaudeTaskText(text) {
@@ -685,19 +1079,35 @@ function hasClaudeCompletedTaskListResponse(text, options = {}) {
   return extractClaudeCompletedTaskListResponse(text, options).length > 0;
 }
 
-function hasTmuxAssistantResponseAfterPrompt(
+function hasTmuxAssistantResponseAfterCurrentPrompt(
   adapter,
   text,
   prompt,
   beforeText,
 ) {
+  if (adapter.cli === "claude") {
+    return hasClaudeCompletedTaskListResponse(text, {
+      beforeText,
+      prompt,
+    });
+  }
+
+  const lines = String(text).split("\n");
+  const promptIndex = promptLineIndex(lines, prompt);
+  if (promptIndex === -1) {
+    return false;
+  }
+
+  const beforePromptCount = String(beforeText)
+    .split("\n")
+    .filter((line) => composerLineMatchesPrompt(line, prompt)).length;
+  const currentPromptCount = lines.filter((line) =>
+    composerLineMatchesPrompt(line, prompt),
+  ).length;
+
   return (
-    hasAssistantResponseAfterPrompt(adapter, text, prompt) ||
-    (adapter.cli === "claude" &&
-      hasClaudeCompletedTaskListResponse(text, {
-        beforeText,
-        prompt,
-      }))
+    currentPromptCount > beforePromptCount &&
+    responseLineIndexForPrompt(adapter, lines, promptIndex) !== -1
   );
 }
 
@@ -912,9 +1322,21 @@ const ADAPTERS = {
   codex: {
     cli: "codex",
     launchArgv: ["codex"],
-    launchKeys: ["codex", "Enter"],
-    resumeById: (id) => shellQuote(["codex", "resume", id]),
-    resumeLast: () => shellQuote(["codex", "resume", "--last"]),
+    launchKeys: ["codex --dangerously-bypass-approvals-and-sandbox", "Enter"],
+    resumeById: (id) =>
+      shellQuote([
+        "codex",
+        "resume",
+        id,
+        "--dangerously-bypass-approvals-and-sandbox",
+      ]),
+    resumeLast: () =>
+      shellQuote([
+        "codex",
+        "resume",
+        "--last",
+        "--dangerously-bypass-approvals-and-sandbox",
+      ]),
     composerGlyph: "›",
     isReady: isCodexReadyCapture,
     contextPct: parseCodexContextPct,
@@ -996,6 +1418,39 @@ const ADAPTERS = {
   },
 };
 
+function buildLaunchKeys(adapter, { model, effort } = {}) {
+  const hasModel = model !== undefined;
+  const hasEffort = effort !== undefined;
+  if (!hasModel && !hasEffort) {
+    return adapter.launchKeys;
+  }
+
+  const overrideArgs = [];
+  if (adapter.cli === "codex") {
+    if (hasModel) {
+      overrideArgs.push("-c", `model=${JSON.stringify(String(model))}`);
+    }
+    if (hasEffort) {
+      overrideArgs.push(
+        "-c",
+        `model_reasoning_effort=${JSON.stringify(String(effort))}`,
+      );
+    }
+  } else if (adapter.cli === "claude") {
+    if (hasModel) {
+      overrideArgs.push("--model", model);
+    }
+    if (hasEffort) {
+      overrideArgs.push("--effort", effort);
+    }
+  } else {
+    throw new Error(`Unsupported adapter: ${adapter.cli}`);
+  }
+
+  const [command, ...remainingKeys] = adapter.launchKeys;
+  return [`${command} ${shellQuote(overrideArgs)}`, ...remainingKeys];
+}
+
 async function dismissStartupScreens(adapter, remote, session) {
   let raw = "";
   let dismissed = false;
@@ -1184,7 +1639,11 @@ async function probeDaemon(bridgePath, ref, timeoutMs) {
 async function hasTmuxSession(adapter, opts) {
   if (!opts.session) return false;
   try {
-    await runTmux(opts.remote, ["has-session", "-t", opts.session]);
+    await runTmux(opts.remote, [
+      "has-session",
+      "-t",
+      splitTmuxTarget(opts.session).session,
+    ]);
     return true;
   } catch {
     return false;
@@ -1258,14 +1717,18 @@ async function doStart(adapter, opts) {
     cwd,
     resume,
     resumeLast,
+    model,
+    effort,
     readyTimeoutMs,
     pollIntervalMs,
   } = opts;
+  if (session.includes(":"))
+    throw new Error("start --session accepts only a session name without ':'");
   const launchKeys = resume
     ? [adapter.resumeById(resume), "Enter"]
     : resumeLast
       ? [adapter.resumeLast(), "Enter"]
-      : adapter.launchKeys;
+      : buildLaunchKeys(adapter, { model, effort });
   const resumed = Boolean(resume || resumeLast);
   const resumeTarget = resume ?? (resumeLast ? "last" : null);
 
@@ -1276,6 +1739,16 @@ async function doStart(adapter, opts) {
     session,
     ...(cwd ? ["-c", cwd] : []),
   ]);
+  // Default tmux history-limit (2000) is far too small for long tool-heavy
+  // CLI sessions (file reads, test runs) — the actual response can scroll
+  // out of scrollback before capturePane() runs, producing an empty extract.
+  await runTmux(remote, [
+    "set-option",
+    "-t",
+    session,
+    "history-limit",
+    "100000",
+  ]);
   await runTmux(remote, ["send-keys", "-t", session, ...launchKeys]);
   await dismissStartupScreens(adapter, remote, session);
 
@@ -1297,14 +1770,89 @@ async function doStart(adapter, opts) {
   });
 }
 
+async function waitForTmuxIdle(adapter, opts) {
+  const { session, remote, pollIntervalMs, busyTimeoutMs, ifBusy } = opts;
+  if (!["wait", "fail", "interrupt"].includes(ifBusy)) {
+    throw new Error("--if-busy must be wait, fail, or interrupt for tmux");
+  }
+  const startedAt = Date.now();
+  let interrupted = false;
+  while (true) {
+    const visible = await captureVisible(remote, session);
+    const elapsedMs = Date.now() - startedAt;
+    const busy =
+      isBusyByEsc(visible) ||
+      (adapter.cli === "codex" && isCodexLoadingCapture(visible));
+    if (!busy) return elapsedMs;
+    if (ifBusy === "fail") throw new Error("target busy (--if-busy fail)");
+    if (elapsedMs >= busyTimeoutMs) {
+      throw new Error(
+        `target busy after ${Math.ceil(busyTimeoutMs / 1000)}s (--if-busy ${ifBusy})`,
+      );
+    }
+    if (ifBusy === "interrupt" && !interrupted) {
+      await runTmux(remote, ["send-keys", "-t", session, "Escape"]);
+      interrupted = true;
+    }
+    await sleep(
+      Math.min(pollIntervalMs, Math.max(1, busyTimeoutMs - elapsedMs)),
+    );
+  }
+}
+
 async function doAskViaTmux(adapter, opts) {
-  const { session, prompt, remote, timeoutMs, settleMs, pollIntervalMs } = opts;
+  const {
+    session,
+    prompt,
+    remote,
+    timeoutMs,
+    settleMs,
+    pollIntervalMs,
+    doneMarker,
+    ifBusy = "wait",
+    busyTimeoutMs = timeoutMs,
+  } = opts;
+  const busyWaitedMs = await waitForTmuxIdle(adapter, {
+    session,
+    remote,
+    pollIntervalMs,
+    busyTimeoutMs,
+    ifBusy,
+  });
   const beforeRaw = await capturePane(remote, session);
   const contextPctBefore = adapter.contextPct(beforeRaw);
 
-  await runTmux(remote, ["send-keys", "-t", session, "--", prompt]);
+  const bufferName = tmuxBufferName(session);
+  await runTmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
+  await runTmux(remote, [
+    "paste-buffer",
+    "-b",
+    bufferName,
+    "-d",
+    "-t",
+    session,
+  ]);
   await sleep(settleMs);
-  await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+
+  let promptSubmitted = !doneMarker;
+  if (doneMarker) {
+    for (let attempt = 1; attempt <= PROMPT_SUBMIT_MAX_ATTEMPTS; attempt += 1) {
+      await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+      await sleep(PROMPT_SUBMIT_RETRY_DELAY_MS);
+      const submissionVisible = await captureVisible(remote, session);
+      if (!composerShowsPrompt(submissionVisible, prompt)) {
+        promptSubmitted = true;
+        break;
+      }
+    }
+    if (!promptSubmitted) {
+      throw new Error(
+        `Prompt did not submit after ${PROMPT_SUBMIT_MAX_ATTEMPTS} attempts`,
+      );
+    }
+  } else {
+    await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+  }
 
   const startedAt = Date.now();
   let raw = "";
@@ -1316,18 +1864,36 @@ async function doAskViaTmux(adapter, opts) {
   let done = false;
 
   while (Date.now() - startedAt < timeoutMs) {
-    visible = await captureVisible(remote, session);
+    visible = doneMarker
+      ? await capturePane(remote, session)
+      : await captureVisible(remote, session);
     contextPctAfter = adapter.contextPct(visible);
 
     quietPolls = visible === previousVisible ? quietPolls + 1 : 0;
     previousVisible = visible;
 
-    const ready = adapter.isReady(visible);
-    const doneSignal =
+    const markerDone =
+      promptSubmitted &&
+      Boolean(
+        extractResponseSinceMarker({
+          beforeRaw,
+          raw: visible,
+          doneMarker,
+          adapter,
+        }),
+      );
+    const fallbackDone =
+      !doneMarker &&
       !adapter.isBusy(visible) &&
-      ready &&
-      hasTmuxAssistantResponseAfterPrompt(adapter, visible, prompt, beforeRaw);
-    if (doneSignal && quietPolls >= FALLBACK_QUIET_POLLS) {
+      adapter.isReady(visible) &&
+      quietPolls >= FALLBACK_QUIET_POLLS &&
+      hasTmuxAssistantResponseAfterCurrentPrompt(
+        adapter,
+        await capturePane(remote, session),
+        prompt,
+        beforeRaw,
+      );
+    if (markerDone || fallbackDone) {
       done = true;
       break;
     }
@@ -1336,7 +1902,20 @@ async function doAskViaTmux(adapter, opts) {
   }
 
   raw = await capturePane(remote, session);
-  response = extractAssistantResponse(adapter, raw, prompt);
+  const markerResponse = promptSubmitted
+    ? extractResponseSinceMarker({
+        beforeRaw,
+        raw,
+        doneMarker,
+        adapter,
+      })
+    : "";
+  if (markerResponse) {
+    response = markerResponse;
+    done = true;
+  } else {
+    response = extractAssistantResponse(adapter, raw, prompt);
+  }
   if (!response && adapter.cli === "claude") {
     response = extractClaudeCompletedTaskListResponse(raw, {
       beforeText: beforeRaw,
@@ -1353,6 +1932,8 @@ async function doAskViaTmux(adapter, opts) {
     session,
     remote: remote ?? null,
     transport: "tmux",
+    ifBusy,
+    busyWaitedMs,
     response,
     contextPctBefore,
     contextPctAfter,
@@ -1368,6 +1949,24 @@ async function doAsk(adapter, opts) {
     return doAskViaTmux(adapter, opts);
   }
 
+  if (adapter.cli === "codex" && transport === "uds") {
+    if (opts.remote) return doAskViaRemoteLive(adapter, opts);
+    const { askCodexAppServerThread } = await import(
+      "../hub/team/uds-orchestrator.mjs"
+    );
+    return askCodexAppServerThread({
+      socketPath: opts.socketPath,
+      threadId: opts.threadId,
+      cwd: opts.cwd,
+      prompt: opts.prompt,
+      timeoutMs: opts.timeoutMs,
+      maxTurnMs: opts.maxTurnMs,
+      ifBusy: opts.ifBusy,
+      busyTimeoutMs: opts.busyTimeoutMs,
+      pollIntervalMs: opts.pollIntervalMs,
+    });
+  }
+
   // uds/auto attach a live background Claude daemon, not a tmux TUI.
   if (adapter.cli !== "claude") {
     throw new Error(
@@ -1397,7 +1996,11 @@ async function doAsk(adapter, opts) {
 }
 
 async function doAskViaRemoteLive(adapter, opts, deps = {}) {
-  const result = await callRemoteLive("ask", opts, deps);
+  const result = await callRemoteLive(
+    "ask",
+    { ...opts, cli: adapter.cli },
+    deps,
+  );
   return {
     ...result,
     cli: result.cli ?? adapter.cli,
@@ -1465,7 +2068,11 @@ function daemonProbeTargetAttachable(probe, opts) {
 async function ensureTmuxSession(adapter, opts) {
   if (!opts.session) return false;
   try {
-    await runTmux(opts.remote, ["has-session", "-t", opts.session]);
+    await runTmux(opts.remote, [
+      "has-session",
+      "-t",
+      splitTmuxTarget(opts.session).session,
+    ]);
     return false;
   } catch {
     await doStart(adapter, {
@@ -1644,6 +2251,10 @@ async function doAskAuto(adapter, opts) {
 
 async function doStop(adapter, opts) {
   const { session, remote } = opts;
+  if (/[:.]|^[%@]\d+$/.test(session))
+    throw new Error(
+      "stop --session accepts only a session name; pass the session name without a pane target",
+    );
   await runTmux(remote, ["kill-session", "-t", session]);
   return {
     cli: adapter.cli,
@@ -1761,12 +2372,17 @@ async function doInterrupt(adapter, opts) {
 }
 
 function startOpts(flags) {
+  const session = requireFlag(flags, "session");
+  if (session.includes(":"))
+    throw new Error("start --session accepts only a session name without ':'");
   return {
-    session: requireFlag(flags, "session"),
+    session,
     remote: flags.remote,
     cwd: flags.cwd,
     resume: flags.resume,
     resumeLast: Object.hasOwn(flags, "resume-last"),
+    model: flags.model,
+    effort: flags.effort,
     readyTimeoutMs: secondsFlag(
       flags,
       "ready-timeout",
@@ -1804,7 +2420,10 @@ function askOpts(flags, adapter) {
   const short = flags.short;
   const sessionId = flags["session-id"];
   const transport = transportFlag(flags, adapter, short, sessionId);
-  if (transport !== "tmux" && !short && !sessionId) {
+  const codexUds = adapter.cli === "codex" && transport === "uds";
+  if (adapter.cli === "codex" && transport === "auto")
+    throw new Error("--transport auto is only supported with --cli claude");
+  if (transport !== "tmux" && !codexUds && !short && !sessionId) {
     throw new Error(
       `--transport ${transport} requires --short or --session-id`,
     );
@@ -1813,15 +2432,37 @@ function askOpts(flags, adapter) {
     // tmux needs a tmux session name; uds needs a daemon ref (short/sessionId);
     // auto can take both (daemon ref to probe, tmux session for fallback).
     session:
-      transport === "tmux" ? requireFlag(flags, "session") : flags.session,
+      transport === "tmux"
+        ? splitTmuxTarget(requireFlag(flags, "session")).target
+        : flags.session,
     short,
     sessionId,
     configDir: flags["config-dir"],
     transport,
+    threadId: codexUds ? requireFlag(flags, "thread") : null,
+    codexSocket: codexUds ? (flags["codex-socket"] ?? "default") : null,
+    socketPath:
+      codexUds && !flags.remote
+        ? resolveCodexDaemonSocket(flags["codex-socket"] ?? "default")
+        : null,
+    cwd: flags.cwd,
+    ifBusy: flags["if-busy"] ?? "wait",
+    busyTimeoutMs: secondsFlag(
+      flags,
+      "busy-timeout",
+      secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
+    ),
     bridgePath: resolveBridgePath(flags),
     prompt: requireFlag(flags, "prompt"),
     remote: flags.remote,
     timeoutMs: secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
+    maxTurnMs: codexUds
+      ? secondsFlag(
+          flags,
+          "max-turn",
+          Math.min(resolveHardCeilingMs(), 15 * 60_000),
+        )
+      : undefined,
     settleMs: msFlag(flags, "settle", DEFAULT_SETTLE_MS),
     pollIntervalMs: msFlag(flags, "poll-interval", DEFAULT_POLL_INTERVAL_MS),
   };
@@ -1838,9 +2479,15 @@ function interruptOpts(flags, adapter) {
   const short = flags.short;
   const sessionId = flags["session-id"];
   const transport = transportFlag(flags, adapter, short, sessionId);
+  if (adapter.cli === "codex" && transport === "uds")
+    throw new Error(
+      "active turnId unavailable; cannot interrupt Codex UDS thread",
+    );
   return {
     session:
-      transport === "tmux" ? requireFlag(flags, "session") : flags.session,
+      transport === "tmux"
+        ? splitTmuxTarget(requireFlag(flags, "session")).target
+        : flags.session,
     short,
     sessionId,
     configDir: flags["config-dir"],
@@ -1887,11 +2534,43 @@ async function probe(flags) {
   );
 }
 
-function startOptsForSession(flags, session) {
+async function listSessions(flags) {
+  const adapter = selectAdapter(flags);
+  if (adapter.cli !== "codex") {
+    throw new Error("list-sessions currently supports only --cli codex");
+  }
+  if (flags.transport === "uds") {
+    const { listCodexAppServerThreads } = await import(
+      "../hub/team/uds-orchestrator.mjs"
+    );
+    printJson(
+      await listCodexAppServerThreads({
+        socketPath: resolveCodexDaemonSocket(
+          flags["codex-socket"] ?? "default",
+        ),
+        cwd: flags.cwd,
+      }),
+    );
+    return;
+  }
+  if (flags.transport && flags.transport !== "tmux")
+    throw new Error("list-sessions --transport must be tmux or uds");
+  printJson(
+    await discoverCodexTmuxSessions({ cwd: flags.cwd, remote: flags.remote }),
+  );
+}
+
+function startOptsForSession(flags, session, side) {
   return {
     session,
     remote: flags.remote,
     cwd: flags.cwd,
+    ...(side
+      ? {
+          model: flags[`model-${side}`],
+          effort: flags[`effort-${side}`],
+        }
+      : {}),
     readyTimeoutMs: secondsFlag(
       flags,
       "ready-timeout",
@@ -1909,6 +2588,12 @@ function askOptsForSession(flags, session, prompt) {
     timeoutMs: secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
     settleMs: msFlag(flags, "settle", DEFAULT_SETTLE_MS),
     pollIntervalMs: msFlag(flags, "poll-interval", DEFAULT_POLL_INTERVAL_MS),
+    ifBusy: flags["if-busy"] ?? "wait",
+    busyTimeoutMs: secondsFlag(
+      flags,
+      "busy-timeout",
+      secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
+    ),
   };
 }
 
@@ -1929,9 +2614,12 @@ async function readPromptsFile(path) {
 
 async function stopAfterLifecycle(stopSpecs, primaryError = null) {
   let stopError = null;
-  for (const { adapter, opts } of stopSpecs) {
+  for (const spec of stopSpecs) {
     try {
-      await doStop(adapter, opts);
+      if (!spec.stopped) {
+        const result = await doStop(spec.adapter, spec.opts);
+        spec.stopped = result.stopped === true;
+      }
     } catch (error) {
       stopError ??= error;
     }
@@ -2054,17 +2742,279 @@ function peerMode(flags) {
 }
 
 function peerPrompt(mode, hopIndex, previous) {
+  let prompt;
   if (mode === "counting") {
     if (hopIndex === 0) {
-      return "Reply with only the integer 1.";
+      prompt = "Reply with only the integer 1.";
+    } else {
+      prompt = `The current integer is ${previous}. Add 1 to it and reply with ONLY the resulting integer, nothing else.`;
+    }
+  } else if (hopIndex === 0) {
+    prompt = previous;
+  } else {
+    prompt = `The other party said: ${previous}\nReply briefly in 1-2 sentences and ask one short follow-up question.`;
+  }
+
+  return [
+    prompt,
+    `After you have completely finished your response, print a new line containing only this token: \`${PEER_HOP_DONE_MARKER}\`. Do not put any other characters on that line.`,
+  ].join("\n");
+}
+
+function buildPeerClosurePrompt(previous) {
+  return [
+    "This is the final closure turn. Based on the discussion so far, declare whether a final agreement was reached.",
+    "First reply with exactly one JSON object and no markdown fences:",
+    '{"agreement_status":"complete|partial","unresolved_questions":[],"needs_more_rounds":false,"summary":"short final agreement"}',
+    "Use agreement_status=complete only when no unresolved question remains and no more rounds are needed.",
+    `The other party's latest response was: ${previous ?? "(none)"}`,
+    `After the JSON is complete, print a new line containing only this token: \`${PEER_HOP_DONE_MARKER}\`. Do not put any other characters on that line.`,
+  ].join("\n");
+}
+
+function isCompleteDeclaration(value) {
+  return ["complete", "completed", "agreed", "합의완료", "완료"].includes(
+    String(value ?? "")
+      .trim()
+      .toLowerCase(),
+  );
+}
+
+function unstructuredPeerClosure() {
+  return {
+    structured: false,
+    declaredComplete: false,
+    unresolvedQuestions: [],
+    needsMoreRounds: null,
+  };
+}
+
+function parsePeerClosure(response) {
+  const text = String(response ?? "").trim();
+  const fenced = text.match(/```(?:json)?\s*({[\s\S]*})\s*```/i)?.[1];
+  const firstBrace = text.indexOf("{");
+  const lastBrace = text.lastIndexOf("}");
+  const objectText =
+    fenced ??
+    (firstBrace >= 0 && lastBrace > firstBrace
+      ? text.slice(firstBrace, lastBrace + 1)
+      : null);
+
+  if (objectText) {
+    try {
+      // Terminal word-wrap can inject a raw newline + indent mid-token in
+      // compact JSON (e.g. "f\n  alse" for "false") since there's often no
+      // space nearby to wrap at. Try the raw text first, then retry with
+      // wrap artifacts collapsed before giving up as unstructured.
+      let parsed;
+      try {
+        parsed = JSON.parse(objectText);
+      } catch {
+        parsed = JSON.parse(objectText.replace(/\n[ \t]*/g, ""));
+      }
+      const unresolvedQuestions = parsed.unresolved_questions;
+      const needsMoreRounds = parsed.needs_more_rounds;
+      const structured =
+        Object.hasOwn(parsed, "agreement_status") &&
+        Array.isArray(unresolvedQuestions) &&
+        typeof needsMoreRounds === "boolean";
+      if (structured) {
+        return {
+          structured: true,
+          declaredComplete: isCompleteDeclaration(parsed.agreement_status),
+          unresolvedQuestions: unresolvedQuestions.map(String),
+          needsMoreRounds,
+        };
+      }
+      return unstructuredPeerClosure();
+    } catch {
+      return unstructuredPeerClosure();
     }
-    return `The current integer is ${previous}. Add 1 to it and reply with ONLY the resulting integer, nothing else.`;
   }
 
-  if (hopIndex === 0) {
-    return previous;
+  const status = text.match(
+    /(?:agreement_status|agreement status|합의상태|합의 상태)\s*[:=]\s*["']?([^\n,"'}]+)/i,
+  )?.[1];
+  const unresolved = text.match(
+    /(?:unresolved_questions|unresolved questions|미해결 쟁점)\s*[:=]\s*([^\n]+)/i,
+  )?.[1];
+  const needsMore = text.match(
+    /(?:needs_more_rounds|needs more rounds|추가 라운드 필요)\s*[:=]\s*(true|false)/i,
+  )?.[1];
+  const structured =
+    status !== undefined && unresolved !== undefined && needsMore !== undefined;
+  const unresolvedQuestions = /^(?:\[\s*\]|none|없음)$/i.test(
+    String(unresolved ?? "").trim(),
+  )
+    ? []
+    : String(unresolved ?? "")
+        .replace(/^\[|\]$/g, "")
+        .split(/[,;|]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+
+  return {
+    structured,
+    declaredComplete: isCompleteDeclaration(status),
+    unresolvedQuestions,
+    needsMoreRounds:
+      needsMore === undefined ? null : needsMore.toLowerCase() === "true",
+  };
+}
+
+function derivePeerStatus({ hopsCompleted, closure, exitReason = null }) {
+  if (hopsCompleted < 1) return "failed";
+  if (exitReason) return "partial";
+  if (
+    closure?.structured === true &&
+    closure.declaredComplete === true &&
+    closure.needsMoreRounds === false &&
+    closure.unresolvedQuestions.length === 0
+  ) {
+    return "complete";
   }
-  return `The other party said: ${previous}\nReply briefly in 1-2 sentences and ask one short follow-up question.`;
+  return "partial";
+}
+
+function classifyPeerExitReason(error) {
+  const fingerprint = [error?.name, error?.code, error?.message]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return /timeout|timed out|etimedout|aborterror/.test(fingerprint)
+    ? "timeout"
+    : "transport_error";
+}
+
+function peerSignalExit(signal) {
+  return signal === "SIGTERM"
+    ? { exitReason: "terminated", exitCode: 143 }
+    : { exitReason: "user_interrupt", exitCode: 130 };
+}
+
+function createPeerSignalController({
+  output,
+  persistTranscript,
+  persistStatus,
+  stopSessions,
+  printOutput = printJson,
+  exitProcess = (code) => process.exit(code),
+  timeoutMs = 3000,
+  now = Date.now,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  let signalCount = 0;
+  let settled = false;
+
+  const recordArtifactError = (kind, error) => {
+    output.artifact_errors ??= [];
+    output.artifact_errors.push(`${kind}: ${error.message}`);
+  };
+
+  return {
+    async handle(signal) {
+      if (settled) return;
+      signalCount += 1;
+      const { exitReason, exitCode } = peerSignalExit(signal);
+      if (signalCount > 1) {
+        settled = true;
+        exitProcess(exitCode);
+        return;
+      }
+
+      const startedAt = now();
+      output.status = "aborted";
+      output.exit_reason = exitReason;
+      output.hops_completed = output.hops.length;
+
+      try {
+        persistTranscript(output);
+      } catch (error) {
+        recordArtifactError("transcript", error);
+      }
+      try {
+        persistStatus(output);
+      } catch (error) {
+        recordArtifactError("status", error);
+      }
+
+      const remainingMs = Math.max(0, timeoutMs - (now() - startedAt));
+      let timer;
+      const graceExpired = new Promise((resolve) => {
+        timer = setTimer(() => resolve("timeout"), remainingMs);
+      });
+      await Promise.race([
+        Promise.resolve()
+          .then(stopSessions)
+          .then(
+            () => "stopped",
+            () => "stop_error",
+          ),
+        graceExpired,
+      ]);
+      clearTimer(timer);
+
+      if (settled) return;
+      settled = true;
+      printOutput(output);
+      exitProcess(exitCode);
+    },
+    dispose() {
+      settled = true;
+    },
+  };
+}
+
+function peerArtifactPaths(sessionA, sessionB) {
+  const preferredDir =
+    process.env.TFX_LIVE_ARTIFACT_DIR ??
+    pathJoin(homedir(), ".claude", "cache", "triflux", "tfx-live", "peer-runs");
+  const fallbackDir = pathJoin(tmpdir(), "triflux-live");
+  let artifactDir = preferredDir;
+  try {
+    mkdirSync(artifactDir, { recursive: true });
+  } catch {
+    artifactDir = fallbackDir;
+    mkdirSync(artifactDir, { recursive: true });
+  }
+  const safe = (value) =>
+    String(value)
+      .replace(/[^A-Za-z0-9._-]+/g, "-")
+      .slice(0, 48);
+  const runId = `peer-${safe(sessionA)}-${safe(sessionB)}-${Date.now()}-${process.pid}`;
+  return {
+    transcriptPath: pathJoin(artifactDir, `${runId}.transcript.json`),
+    statusPath: pathJoin(artifactDir, `${runId}.status.json`),
+  };
+}
+
+function persistPeerTranscript(paths, output) {
+  writeFileSync(
+    paths.transcriptPath,
+    `${JSON.stringify(
+      {
+        mode: output.mode,
+        rounds: output.rounds,
+        cliA: output.cliA,
+        cliB: output.cliB,
+        hops_completed: output.hops.length,
+        hops: output.hops,
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}
+
+function persistPeerStatus(paths, output) {
+  const { hops: _hops, ...status } = output;
+  writeFileSync(
+    paths.statusPath,
+    `${JSON.stringify(status, null, 2)}\n`,
+    "utf8",
+  );
 }
 
 function sideFlag(flags, side, name, fallback = undefined) {
@@ -2089,7 +3039,11 @@ function peerSideTransport(flags, side, adapter) {
       `--transport-${side} must be one of: ${VALID_TRANSPORTS.join(", ")}`,
     );
   }
-  if (transport !== "tmux" && adapter.cli !== "claude") {
+  if (
+    transport !== "tmux" &&
+    adapter.cli !== "claude" &&
+    !(adapter.cli === "codex" && transport === "uds")
+  ) {
     throw new Error(
       `--transport-${side} ${transport} is only supported when --cli-${side} is claude`,
     );
@@ -2097,11 +3051,34 @@ function peerSideTransport(flags, side, adapter) {
   return transport;
 }
 
+function peerSideBusyPolicy(flags, side, adapter, transport) {
+  const allowed =
+    adapter.cli === "codex" && transport === "uds"
+      ? ["wait", "fail", "steer"]
+      : ["wait", "fail", "interrupt"];
+  for (const name of ["if-busy", `if-busy-${side}`]) {
+    if (flags[name] !== undefined && !allowed.includes(flags[name]))
+      throw new Error(
+        `--${name} must be ${allowed.join("|")} for side ${side} (${adapter.cli} ${transport})`,
+      );
+  }
+  return sideFlag(flags, side, "if-busy", "wait");
+}
+
 function peerSideBaseOpts(flags, side, adapter, session) {
   const transport = peerSideTransport(flags, side, adapter);
+  const ifBusy = peerSideBusyPolicy(flags, side, adapter, transport);
   const short = sideFlag(flags, side, "short");
   const sessionId = sideFlag(flags, side, "session-id");
-  if (transport !== "tmux" && !short && !sessionId) {
+  const threadId = sideFlag(flags, side, "thread");
+  if (transport === "uds" && adapter.cli === "codex" && !threadId)
+    throw new Error(`--transport-${side} uds requires --thread-${side}`);
+  if (
+    transport !== "tmux" &&
+    adapter.cli === "claude" &&
+    !short &&
+    !sessionId
+  ) {
     throw new Error(
       `--transport-${side} ${transport} requires --short-${side} or --session-id-${side}`,
     );
@@ -2110,13 +3087,38 @@ function peerSideBaseOpts(flags, side, adapter, session) {
     session,
     short,
     sessionId,
+    threadId,
+    codexSocket:
+      adapter.cli === "codex" && transport === "uds"
+        ? sideFlag(flags, side, "codex-socket", "default")
+        : null,
+    socketPath:
+      adapter.cli === "codex" && transport === "uds" && !flags.remote
+        ? resolveCodexDaemonSocket(
+            sideFlag(flags, side, "codex-socket", "default"),
+          )
+        : null,
     transport,
     bridgePath: sideFlag(flags, side, "bridge", resolveBridgePath(flags)),
     remote: flags.remote,
     cwd: flags.cwd,
     timeoutMs: secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
+    maxTurnMs:
+      adapter.cli === "codex" && transport === "uds"
+        ? secondsFlag(
+            flags,
+            "max-turn",
+            Math.min(resolveHardCeilingMs(), 15 * 60_000),
+          )
+        : undefined,
     settleMs: msFlag(flags, "settle", DEFAULT_SETTLE_MS),
     pollIntervalMs: msFlag(flags, "poll-interval", DEFAULT_POLL_INTERVAL_MS),
+    ifBusy,
+    busyTimeoutMs: secondsFlag(
+      flags,
+      "busy-timeout",
+      secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
+    ),
     readyTimeoutMs: secondsFlag(
       flags,
       "ready-timeout",
@@ -2126,13 +3128,44 @@ function peerSideBaseOpts(flags, side, adapter, session) {
 }
 
 function askOptsFromPeerBase(base, prompt) {
-  return { ...base, prompt };
+  return { ...base, prompt, doneMarker: PEER_HOP_DONE_MARKER };
 }
 
 function shouldPrestartPeerSide(base) {
   return base.transport === "tmux";
 }
 
+async function verifyAttachedPeerSide(adapter, base, deps = {}) {
+  if (base.transport !== "tmux") return;
+  const tmux = deps.runTmux ?? runTmux;
+  const { session, target } = splitTmuxTarget(base.session);
+  try {
+    await tmux(base.remote, ["has-session", "-t", session]);
+  } catch {
+    throw new Error(`attached ${adapter.cli} session not found: ${session}`);
+  }
+  if (adapter.cli === "codex") {
+    const { stdout } = await tmux(base.remote, [
+      "display-message",
+      "-p",
+      "-t",
+      target,
+      "#{pane_current_command}\t#{pane_start_command}\t#{pane_tty}\t#{pane_pid}",
+    ]);
+    const [currentCommand, startCommand, paneTty, panePid] = stdout
+      .trimEnd()
+      .split("\t");
+    const result = await inspectCodexTmuxPane(
+      { currentCommand, startCommand, paneTty, panePid, remote: base.remote },
+      deps,
+    );
+    if (result.preflightWarning) return result;
+    if (!result.isCodex) {
+      throw new Error(`attached target is not a Codex tmux pane: ${target}`);
+    }
+  }
+}
+
 function addStopSpecOnce(stopSpecs, adapter, opts) {
   if (!opts.session) return;
   const exists = stopSpecs.some(
@@ -2152,29 +3185,110 @@ function addStopSpecOnce(stopSpecs, adapter, opts) {
 async function peer(flags) {
   const adapterA = selectAdapterName(flags["cli-a"] ?? "codex", "cli-a");
   const adapterB = selectAdapterName(flags["cli-b"] ?? "claude", "cli-b");
+  peerSideBusyPolicy(
+    flags,
+    "a",
+    adapterA,
+    peerSideTransport(flags, "a", adapterA),
+  );
+  peerSideBusyPolicy(
+    flags,
+    "b",
+    adapterB,
+    peerSideTransport(flags, "b", adapterB),
+  );
   const sessionA = flags["session-a"] ?? "peerA";
   const sessionB = flags["session-b"] ?? "peerB";
   const baseA = peerSideBaseOpts(flags, "a", adapterA, sessionA);
   const baseB = peerSideBaseOpts(flags, "b", adapterB, sessionB);
+  const attachedA =
+    Object.hasOwn(flags, "attach-a") || baseA.transport === "uds";
+  const attachedB =
+    Object.hasOwn(flags, "attach-b") || baseB.transport === "uds";
   const rounds = integerFlag(flags, "rounds", 4);
   const mode = peerMode(flags);
   const hops = [];
   const numbers = [];
   const stopSpecs = [];
+  const artifactPaths = peerArtifactPaths(sessionA, sessionB);
+  const output = {
+    mode,
+    rounds,
+    cliA: adapterA.cli,
+    cliB: adapterB.cli,
+    transportA: baseA.transport,
+    transportB: baseB.transport,
+    attachedA,
+    attachedB,
+    stoppedA: false,
+    stoppedB: false,
+    hops,
+    transcript_path: artifactPaths.transcriptPath,
+    status_path: artifactPaths.statusPath,
+  };
+  if (mode === "counting") {
+    output.numbers = numbers;
+  }
   let previous =
     mode === "freeform"
       ? (flags.seed ??
         "Introduce yourself in one sentence, then ask the other party one short question.")
       : null;
   let primaryError = null;
+  let stopError = null;
+  let closure = null;
+  const stopPeerSessions = async () => {
+    try {
+      await stopAfterLifecycle(stopSpecs);
+    } finally {
+      output.stoppedA =
+        !attachedA &&
+        stopSpecs.some(
+          (spec) => spec.opts.session === sessionA && spec.stopped,
+        );
+      output.stoppedB =
+        !attachedB &&
+        stopSpecs.some(
+          (spec) => spec.opts.session === sessionB && spec.stopped,
+        );
+    }
+  };
+  const signalController = createPeerSignalController({
+    output,
+    persistTranscript: (value) => persistPeerTranscript(artifactPaths, value),
+    persistStatus: (value) => persistPeerStatus(artifactPaths, value),
+    stopSessions: stopPeerSessions,
+  });
+  const onSigint = () => {
+    void signalController.handle("SIGINT");
+  };
+  const onSigterm = () => {
+    void signalController.handle("SIGTERM");
+  };
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
 
   try {
-    if (shouldPrestartPeerSide(baseA)) {
-      await doStart(adapterA, startOptsForSession(flags, sessionA));
+    for (const [side, adapter, base, attached] of [
+      ["a", adapterA, baseA, attachedA],
+      ["b", adapterB, baseB, attachedB],
+    ]) {
+      if (!attached) continue;
+      const result = await verifyAttachedPeerSide(adapter, base);
+      if (result?.preflightWarning) {
+        output.preflightWarning ??= [];
+        output.preflightWarning.push({
+          side,
+          message: result.preflightWarning,
+        });
+      }
+    }
+    if (!attachedA && shouldPrestartPeerSide(baseA)) {
+      await doStart(adapterA, startOptsForSession(flags, sessionA, "a"));
       addStopSpecOnce(stopSpecs, adapterA, baseA);
     }
-    if (shouldPrestartPeerSide(baseB)) {
-      await doStart(adapterB, startOptsForSession(flags, sessionB));
+    if (!attachedB && shouldPrestartPeerSide(baseB)) {
+      await doStart(adapterB, startOptsForSession(flags, sessionB, "b"));
       addStopSpecOnce(stopSpecs, adapterB, baseB);
     }
 
@@ -2186,11 +3300,36 @@ async function peer(flags) {
       const isA = hopIndex % 2 === 0;
       const adapter = isA ? adapterA : adapterB;
       const base = isA ? baseA : baseB;
-      const sent = peerPrompt(mode, hopIndex, previous);
+      const isClosure = hopIndex === rounds * 2 - 1;
+      const sent = isClosure
+        ? buildPeerClosurePrompt(previous)
+        : peerPrompt(mode, hopIndex, previous);
       const result = await doAsk(adapter, askOptsFromPeerBase(base, sent));
-      if (result.tmuxStartedOnDemand) {
+      if (
+        (result.transportSelected ?? result.transport ?? base.transport) ===
+        "uds"
+      ) {
+        result.response = String(result.response ?? "")
+          .split(/\r?\n/)
+          .filter((line) => line.trim() !== PEER_HOP_DONE_MARKER)
+          .join("\n")
+          .trim();
+      }
+      if (result.tmuxStartedOnDemand && !(isA ? attachedA : attachedB)) {
         addStopSpecOnce(stopSpecs, adapter, base);
       }
+      if (
+        result.done !== true ||
+        result.error ||
+        !String(result.response ?? "").trim()
+      ) {
+        throw new Error(
+          (result.timedOut
+            ? `Peer hop timed out at hop ${hopIndex + 1}`
+            : result.error) ??
+            `Empty response from ${adapter.cli} at hop ${hopIndex + 1}`,
+        );
+      }
 
       hops.push({
         hop: hopIndex + 1,
@@ -2205,40 +3344,68 @@ async function peer(flags) {
         aborted: result.aborted === true ? true : undefined,
         reason: result.reason,
       });
+      if (isClosure) {
+        closure = parsePeerClosure(result.response);
+      }
 
       if (mode === "counting") {
         const parsed = parseFirstInteger(result.response);
-        if (parsed === null) {
+        if (parsed === null && !isClosure) {
           throw new Error(
             `Could not parse integer from ${adapter.cli} response at hop ${hopIndex + 1}`,
           );
         }
-        numbers.push(parsed);
-        previous = parsed;
+        if (parsed !== null) {
+          numbers.push(parsed);
+          previous = parsed;
+        } else {
+          previous = result.response;
+        }
       } else {
         previous = result.response;
       }
     }
   } catch (error) {
     primaryError = error;
-  } finally {
-    await stopAfterLifecycle(stopSpecs, primaryError);
   }
 
-  const output = {
-    mode,
-    rounds,
-    cliA: adapterA.cli,
-    cliB: adapterB.cli,
-    transportA: baseA.transport,
-    transportB: baseB.transport,
-    hops,
-  };
-  if (mode === "counting") {
-    output.numbers = numbers;
+  try {
+    await stopPeerSessions();
+  } catch (error) {
+    stopError = error;
+  }
+  signalController.dispose();
+  process.off("SIGINT", onSigint);
+  process.off("SIGTERM", onSigterm);
+
+  const terminalError = primaryError ?? stopError;
+  const exitReason = terminalError
+    ? classifyPeerExitReason(terminalError)
+    : null;
+  output.hops_completed = hops.length;
+  output.closure = closure;
+  output.status = derivePeerStatus({
+    hopsCompleted: hops.length,
+    closure,
+    exitReason,
+  });
+  if (exitReason) {
+    output.exit_reason = exitReason;
+    output.error = terminalError.message;
+  }
+
+  try {
+    persistPeerTranscript(artifactPaths, output);
+  } catch (error) {
+    output.artifact_errors ??= [];
+    output.artifact_errors.push(`transcript: ${error.message}`);
+  }
+  try {
+    persistPeerStatus(artifactPaths, output);
+  } catch (error) {
+    output.artifact_errors ??= [];
+    output.artifact_errors.push(`status: ${error.message}`);
   }
-  output.stoppedA = true;
-  output.stoppedB = true;
   printJson(output);
 }
 
@@ -2251,7 +3418,11 @@ async function orchestrate(flags) {
     throw new Error(`--mode must be one of: ${ORCHESTRATION_MODES.join(", ")}`);
   }
   const task = requireFlag(flags, "task");
-  const codexTransport = flags["codex-transport"] ?? "exec";
+  if (flags["codex-socket"] && flags["codex-transport"] === "exec")
+    throw new Error("--codex-socket conflicts with --codex-transport exec");
+  const codexTransport =
+    flags["codex-transport"] ??
+    (flags["codex-socket"] ? "app-server-uds" : "exec");
   if (!CODEX_ORCH_TRANSPORTS.includes(codexTransport)) {
     throw new Error(
       `--codex-transport must be one of: ${CODEX_ORCH_TRANSPORTS.join(", ")}`,
@@ -2259,6 +3430,9 @@ async function orchestrate(flags) {
   }
   const cwd = flags.cwd ?? process.cwd();
   const timeoutMs = secondsFlag(flags, "timeout", 120_000);
+  const socketPath = flags["codex-socket"]
+    ? resolveCodexDaemonSocket(flags["codex-socket"])
+    : undefined;
 
   // Lazy import keeps the orchestration engine (and its hub/team deps) off the
   // hot path for every other thin-CLI verb; only `orchestrate` pays the cost.
@@ -2276,7 +3450,11 @@ async function orchestrate(flags) {
   const claude = createClaudeUdsEndpoint({ cwd, timeoutMs });
   const codex =
     codexTransport === "app-server-uds"
-      ? createCodexAppServerUdsEndpoint({ cwd, timeoutMs })
+      ? createCodexAppServerUdsEndpoint({
+          cwd,
+          timeoutMs,
+          ...(socketPath ? { socketPath, spawnServer: false } : {}),
+        })
       : createCodexExecEndpoint({ workdir: cwd, timeout: timeoutMs });
 
   const result = await runUdsOrchestration({ mode, task, claude, codex });
@@ -2344,6 +3522,8 @@ async function main() {
     await interrupt(flags);
   } else if (command === "probe") {
     await probe(flags);
+  } else if (command === "list-sessions") {
+    await listSessions(flags);
   } else if (command === "converse") {
     await converse(flags);
   } else if (command === "goal-driven") {
@@ -2361,14 +3541,32 @@ async function main() {
 
 export {
   ADAPTERS,
+  buildLaunchKeys,
+  buildPeerClosurePrompt,
   buildRemoteLiveCommand,
+  buildTmuxCommand,
   callRemoteLive,
+  classifyPeerExitReason,
+  createPeerSignalController,
   ctoHygieneNotify,
+  derivePeerStatus,
+  discoverCodexTmuxSessions,
+  doAskViaTmux,
   extractAssistantResponse,
   extractClaudeCompletedTaskListResponse,
+  extractResponseSinceMarker,
   hasClaudeCompletedTaskListResponse,
+  inspectCodexTmuxPane,
+  isCodexLoadingCapture,
+  parseCodexTmuxSessions,
+  parsePeerClosure,
   parseRemoteLiveJson,
+  peerSideBaseOpts,
   resolveAskTransport,
+  resolveCodexDaemonSocket,
+  splitTmuxTarget,
+  tmuxBufferName,
+  verifyAttachedPeerSide,
 };
 
 function isMainModule() {