triflux 10.52.0 → 10.53.0

package/CLAUDE.md

@@ -81,22 +81,6 @@ Windows 전용 경로는 플랫폼과 `WT_SESSION` 조건을 확인한다.
 프로필은 `$CODEX_HOME/<이름>.config.toml` 파일이다(인라인 `[profiles.*]` 아님).
 </codex-config>
 
-<account-broker>
-## AccountBroker (계정 브로커)
-
-headless 워커는 AccountBroker를 사용한다.
-
-| 항목 | 설명 |
-|------|------|
-| 계정별 회로 차단기 | 장애 격리: 한 계정 오류가 다른 계정에 전파되지 않음 |
-| 사용 중 플래그 | 동일 계정 이중 임대 방지 |
-| `reloadBroker()` | accounts.json을 다시 불러온다. 활성 임대 소유권은 다시 불러온 뒤에도 보존한다. 허브가 없어 HTTP 엔드포인트는 없고 모듈 함수로만 부를 수 있다. |
-| 어댑터의 임대 없음 정책 | headless 어댑터는 브로커가 비활성·비어 있음이면 기본 CLI 인증 경로로 실행하고, 브로커가 활성인데 임대가 없으면 `circuit_open`으로 실패한다. |
-| 공개 스냅숏 정책 | 밖에 보여 줄 때는 `publicSnapshot()`만 쓴다. `env`, `authFile`, `profile`, `host`, 파일 경로, 가공하지 않은 실패 시각은 공개하지 않는다. |
-| 진단 이벤트 | `securityViolation`, `authSyncError`는 이벤트로만 내보낸다. 구독하는 쪽이 없으면 기록되지 않는다. |
-| EventEmitter 이벤트 | `lease`, `release`, `cooldown`, `tierFallback`, `circuitOpen`, `circuitClose`, `noAvailableAccounts`: HUD 연동용 |
-</account-broker>
-
 <remote>
 ## 원격 실행
 

package/README.ko.md

@@ -73,8 +73,9 @@ claude plugin install triflux@triflux
 | --- | --- |
 | `/tfx-auto` | 구현, 수정, 리뷰, 병렬 작업의 진입점. 동작은 아래 플래그로 정한다. |
 | `/tfx-live` | Claude↔Codex 라이브 세션. `start`/`ask`/`wait`/`stop`, `peer` 중계, `list-sessions`. |
+| `/tfx-lead` | 여러 Claude, Codex 세션을 지휘하는 리드 역할. 역할별 모델, 지시서, 교차 리뷰, 머지·릴리스 조율. |
 | `/tfx-remote` | SSH 원격 Claude Code 세션 시작, 조회, 재부착, 메시지 전송, 준비 상태 확인, 모니터링, 종료. |
-| `/tfx-setup` | 대화형 설정. 파일 동기화, HUD, Codex 프로필, MCP, 훅 우선순위. |
+| `/tfx-setup` | 설정. 파일 동기화, HUD, Codex와 Antigravity 프로필, MCP. mods는 `tfx setup --mods`로 설치. |
 | `/tfx-doctor` | 진단과 복구. |
 | `/tfx-ship` | triflux 릴리즈 절차(메인테이너용). |
 | `/tfx-wt` | Windows Terminal 탭·패인 조작. `tfx setup`은 Windows에만 설치한다. |

package/README.md

@@ -75,8 +75,9 @@ Skills you invoke directly:
 | --- | --- |
 | `/tfx-auto` | Front door for implementing, fixing, reviewing, and parallel work. Behavior is set by flags (below). |
 | `/tfx-live` | Live Claude↔Codex sessions: `start`/`ask`/`wait`/`stop`, `peer` relay, `list-sessions`. |
-| `/tfx-remote` | SSH 원격 Claude Code 세션 시작, 조회, 재부착, 메시지 전송, 준비 상태 확인, 모니터링, 종료. |
-| `/tfx-setup` | Interactive setup: file sync, HUD, Codex profiles, MCP, hook priority. |
+| `/tfx-lead` | Lead role for running several Claude/Codex sessions: roles and models, briefs, cross review, merge and release coordination. |
+| `/tfx-remote` | Remote Claude Code sessions over SSH: start, list, reattach, send, readiness probe, monitor, stop. |
+| `/tfx-setup` | Setup: file sync, HUD, Codex and Antigravity profiles, MCP. `tfx setup --mods` installs mods. |
 | `/tfx-doctor` | Diagnose and repair. |
 | `/tfx-ship` | triflux release flow (maintainers). |
 | `/tfx-wt` | Windows Terminal tabs and panes. `tfx setup` installs it on Windows only. |

package/adapters/codex/skills/tfx-live/SKILL.md

@@ -3,7 +3,7 @@ name: tfx-live
 description: >
   Claude·Codex 세션을 실시간으로 생성·질의·대기·압축·종료하거나,
   tmux/daemon UDS 연결과 peer 중계를 운영할 때 사용한다.
-argument-hint: "<start|ask|wait|compact|stop|rename|interrupt|probe|list-sessions|peer|converse|goal-driven> ..."
+argument-hint: "<start|ask|wait|queue|compact|stop|rename|interrupt|probe|list-sessions|peer|converse|goal-driven> ..."
 ---
 
 # tfx-live
@@ -29,7 +29,7 @@ tfx-live ask --cli codex --session cx1 --prompt "현재 변경사항을 요약
 tfx-live stop --cli codex --session cx1
 ```
 
-새 세션 이름은 `<월>.<일> <주제>`로 짓는다. `start --name`을 생략하면 자동으로 만들고 `nameGenerated: true`를 보고한다. `--resume` 또는 `--resume-last`는 `--name`을 명시한 경우에만 이름을 적용한다. 승계 세션에는 기존 이름 뒤에 ` 2`, 이후 ` 3`을 붙인다. 이름 적용을 요청한 경우 결과의 `nameApplied: false`는 적용 실패를 뜻한다. Codex `start`는 `/rename` 제출을 입력창이 빌 때까지 확인하고, 이름으로 찾은 thread UUID를 `threadId`로 돌려주며 tmux 세션 옵션 `@tfx_codex_thread`에 남긴다. 기존 Codex UDS thread는 `tfx-live rename --cli codex --transport uds --thread ID --name "<이름>"`으로 이름을 바꾼다.
+새 세션 이름은 `<월>.<일> <주제>`로 짓는다. `start --name`을 생략하면 자동으로 만들고 `nameGenerated: true`를 보고한다. `--resume` 또는 `--resume-last`는 `--name`을 명시한 경우에만 이름을 적용한다. 승계 세션에는 기존 이름 뒤에 ` 2`, 이후 ` 3`을 붙인다. 이름 적용을 요청한 경우 결과의 `nameApplied: false`는 적용 실패를 뜻한다. Codex `start`는 `/rename` 제출을 입력창이 빌 때까지 확인하고, 이름으로 찾은 thread UUID를 `threadId`로 돌려주며 tmux 세션 옵션 `@tfx_codex_thread`에 남긴다. 로컬 Codex `--resume-last`는 Codex가 고른 thread를 사후에 찾는다. 띄운 뒤 공유 app-server daemon에 로드된 같은 cwd의 thread 중 rollout에 그 시각 이후의 resume 기록(`thread_settings_applied`)이 생긴 것이 정확히 하나이고 1.5초 뒤에도 같을 때만 `threadId`로 쓴다. 이 확인은 5초 안에 끝난다. TUI가 daemon을 쓰지 않거나 같은 cwd에서 동시에 resume이 일어나면 `null`이다. 기존 Codex UDS thread는 `tfx-live rename --cli codex --transport uds --thread ID --name "<이름>"`으로 이름을 바꾼다.
 
 ## 리드 운영
 
@@ -51,11 +51,19 @@ tfx-live stop --cli codex --session cx1
 1. 기본은 `codex queue --thread <UUID>`다. 입력창을 건드리지 않고, 바쁘면 쌓였다가 앞 턴이 끝난 직후 순서대로 들어간다. 유휴 TUI는 약 20초 주기로 큐를 가져간다.
 2. 첫 줄 머리말은 `[from <보낸 세션 이름>] [tfx-live req=<id>]`다. 이름은 `--from`, `$TFX_LIVE_FROM`, Claude 세션 기록, Codex `session_index` 순으로 찾고 없으면 머리말 없이 표식만 붙인다. Codex TUI는 Claude처럼 접어 보여 주지 않고 사용자 입력으로 그대로 표시한다.
 3. thread는 `--thread UUID`, `start`가 남긴 `@tfx_codex_thread`, Codex 세션 레지스트리, pane 프로세스의 `resume <UUID>` 인자, pane cwd와 같은 rollout 하나 순으로 찾는다. cwd 대응은 그 cwd의 Codex TUI가 하나일 때만 쓰고 exec 워커와 서브에이전트 thread는 뺀다. 이름으로는 보내지 않는다(`codex queue`의 이름 조회가 실패한다).
-4. tmux 직접 입력은 queue를 못 쓸 때만 쓴다: 원격 호스트, thread를 못 찾음(`resume --last`로 띄운 세션, 같은 cwd의 TUI 여럿 포함), `codex queue` 오류(0.160 미만 포함). 결과에 `transport: "tmux"`, `transportRequested: "queue"`, `fallbackReason`이 남는다. 시간 초과처럼 queue가 이미 쌓았을 수도 있는 오류는 `status: "unknown"`으로 끝내고 재전송하지 않는다.
+4. tmux 직접 입력은 queue를 못 쓸 때만 쓴다: 원격 호스트, thread를 못 찾음(`start` 밖에서 `resume --last`로 띄운 세션, `start --resume-last`의 `threadId: null`, 같은 cwd의 TUI 여럿 포함), `codex queue` 오류(0.160 미만 포함). 결과에 `transport: "tmux"`, `transportRequested: "queue"`, `fallbackReason`이 남는다. 시간 초과처럼 queue가 이미 쌓았을 수도 있는 오류는 `status: "unknown"`으로 끝내고 재전송하지 않는다.
 5. 슬래시 명령(`/rename`, `/compact`, `/new`)과 interrupt(Escape)는 tmux 직접 입력 전용이다. queue로 보낸 슬래시 명령은 실행되지 않고 일반 텍스트로 모델에 들어간다. `/명령`으로 시작하는 프롬프트(절대 경로는 제외)와 `--if-busy fail|interrupt`는 tmux로 보내고 `transportReason`을 남긴다. 슬래시 명령에는 표식을 붙이지 않으므로 `wait`로 추적할 수 없다.
 
 결과의 `status`는 `queued`(쌓임), `working`(TUI가 가져가 턴 시작), `completed`, `failed`로 나뉘고 `delivered`, `deliveredAt`, `turnId`가 배달을 구분한다. queue는 바쁜 세션에도 쌓으므로 `--if-busy wait`는 의미가 없다.
 
+```bash
+tfx-live queue --cli codex --session cx1
+tfx-live queue --cli codex --session cx1 --request-id <requestId> --delete all
+tfx-live queue --cli codex --thread <UUID> --delete <queuedMessageId>
+```
+
+`queue`는 TUI가 아직 가져가지 않은 항목을 보고 지운다. Codex app-server의 실험 API `thread/queue/list`·`thread/queue/delete`를 stdio로 호출하며 큐 저장소 파일은 건드리지 않는다. 목록 항목은 `id`(ask 결과의 `queuedMessageId`와 같다), `requestId`, `text`다. 삭제 결과의 `missing`은 이미 TUI가 가져갔거나 없는 항목이다. 유휴 TUI는 쌓인 항목을 곧 가져가므로 지울 수 있는 것은 사실상 바쁜 세션과 닫힌 세션의 항목이다. 가져간 뒤의 처리 여부는 `wait`로 확인한다.
+
 ### 컨텍스트 판단
 
 분모는 공식 모델 창이고 실행 한도가 더 작으면 그 한도 아래에서 운영한다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
@@ -90,6 +98,8 @@ tfx-live stop --session cl1
 ```bash
 tfx-live ask --cli claude --transport uds --short <8hex> --prompt "진행 상황을 보고해줘" --no-wait
 tfx-live wait --cli claude --short <8hex> --request-id <requestId> --timeout 120 --poll-interval 500
+tfx-live ask --cli claude --session cl1 --prompt "진행 상황을 보고해줘" --no-wait
+tfx-live wait --cli claude --session cl1 --request-id <requestId> --timeout 120
 tfx-live ask --cli codex --session cx1 --prompt "진행 상황을 보고해줘" --no-wait
 tfx-live wait --cli codex --session cx1 --request-id <requestId> --timeout 120
 ```
@@ -98,6 +108,8 @@ tfx-live wait --cli codex --session cx1 --request-id <requestId> --timeout 120
 
 `wait`는 Claude transcript에서 표식을 user 메시지, `queue-operation`의 `enqueue` content, queued command attachment에서 찾는다. 표식이 소비된 턴이 끝난 뒤 마지막 assistant 텍스트를 응답으로 쓴다. 표식 없는 `wait`는 최신 user turn을 본다. `isSidechain`과 합성 API 오류 메시지는 정상 응답에서 제외한다. 요청을 소비한 턴에서 합성 오류가 나타나면 오류 문구와 `status: "failed"`를 반환한다. daemon의 `idle`만으로 완료를 단정하지 않는다. timeout은 `status: "working"`, `timedOut: true`, `done: false`다.
 
+tmux로 띄운 대화형 Claude는 `wait --session <tmux 대상>`을 쓴다. pane에 붙은 Claude 세션 기록(`~/.claude/sessions`)에서 sessionId를 찾아 같은 transcript 규칙으로 판정하고, daemon의 idle 대신 세션 기록의 `status: "idle"`을 쓴다. transcript는 처음 찾은 것을 끝까지 쓰므로 대기 중 `/clear`로 바뀐 세션은 따라가지 않는다. 로컬 전용이다.
+
 Codex `wait`는 `--session` 또는 `--thread UUID`의 rollout에서 표식이 든 user 메시지의 `turn_id`를 찾고, 같은 턴의 `task_complete.last_agent_message`를 응답으로 쓴다. `turn_aborted`는 `status: "failed"`다. 표식이 아직 없으면 `status: "queued"`, `timedOut: true`다. `--timeout 0`은 한 번만 확인한다.
 
 명시한 `--config-dir`은 정확히 일치하는 daemon만 선택한다. `CLAUDE_CONFIG_DIR`도 해당 env 디렉터리로 제한한다. stale endpoint 복구는 같은 source configDir 안에서만 재시도한다. attach 전 예외는 `inputSent: false`이므로 `auto`의 tmux fallback이 가능하다. attach 뒤 전송 여부가 불명확하면 `status: "unknown"`으로 보고하고 재전송하지 않는다.

package/bin/tfx-live.mjs

@@ -8,6 +8,7 @@ import {
   readdir,
   readFile,
   rm,
+  stat,
   writeFile,
 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
@@ -22,14 +23,17 @@ import {
 import { resolveHardCeilingMs } from "../hub/lib/worker-lifecycle.mjs";
 import { exposeLiveSession } from "../hub/team/agents-row.mjs";
 import {
+  claudeWaitVerdict,
   findClaudeTranscript,
   readClaudeTranscript,
 } from "../hub/team/claude-transcript.mjs";
 import {
   codexThreadIdByName,
   countCodexTuiInCwd,
+  deleteCodexQueueItems,
   findCodexThreadByCwd,
   isCodexThreadId,
+  listCodexQueue,
   queueCodexMessage,
   resolveSenderName,
   waitCodexRequest,
@@ -43,6 +47,7 @@ import {
 import {
   CONTEXT_THRESHOLDS,
   contextGuard,
+  findCodexRollout,
   modelContext,
   readCodexContext,
 } from "../hub/team/session-context.mjs";
@@ -94,8 +99,10 @@ function usage(command) {
     "  tfx-live ask --transport uds|auto (--short SHORT | --session-id ID) --prompt TEXT [--config-dir DIR] [--bridge ABS] [--session NAME (auto fallback)] [--timeout 60]",
     "    ask options: --no-wait --no-relay-tag --warn-context-pct N --max-context-pct N (0 disables; Claude 60/90, Codex 15/22).",
     "  tfx-live compact --cli claude --session NAME [--instructions TEXT] [--if-busy fail|wait] [--timeout 60]",
-    "  tfx-live wait --cli claude (--short SHORT | --session-id ID) [--request-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 60] [--poll-interval 1500]",
+    "  tfx-live wait --cli claude (--short SHORT | --session-id ID | --session NAME[:WINDOW.PANE]) [--request-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 60] [--poll-interval 1500]",
     "  tfx-live wait --cli codex (--session NAME[:WINDOW.PANE] | --thread UUID) --request-id ID [--timeout 60] [--poll-interval 1500]",
+    "  tfx-live queue --cli codex (--session NAME[:WINDOW.PANE] | --thread UUID) [--request-id ID] [--delete QUEUED_ID|all]",
+    "    queue lists or deletes items the TUI has not picked up yet (official app-server thread/queue API); missing means already delivered or gone.",
     "  tfx-live rename --cli codex --transport uds --thread ID --name NAME [--codex-socket PATH|default]",
     "    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]",
@@ -2061,6 +2068,76 @@ async function resolveAskTransport(adapter, opts, deps = {}) {
   };
 }
 
+// 공유 app-server daemon 에 로드된 thread 중 cwd 가 같은 것. daemon 이 없거나 늦으면 빈 목록.
+async function loadedCodexThreadIds(cwd, timeoutMs) {
+  try {
+    const { listCodexAppServerThreads } = await import(
+      "../hub/team/uds-orchestrator.mjs"
+    );
+    const threads = await listCodexAppServerThreads({
+      socketPath: resolveCodexDaemonSocket("default"),
+      cwd,
+      timeoutMs,
+    });
+    return threads.map((thread) => thread.threadId);
+  } catch {
+    return [];
+  }
+}
+
+const ROLLOUT_TAIL_BYTES = 256 * 1024;
+
+// thread_settings_applied 는 resume 과 설정 변경 때 쓰인다. 끝부분이 sinceMs 이후를 다 덮지
+// 못하면 "unknown" 이다.
+async function resumedSince(rollout, sinceMs) {
+  const info = await stat(rollout).catch(() => null);
+  if (!info || info.mtimeMs < sinceMs) return "no";
+  const handle = await open(rollout, "r");
+  let text;
+  try {
+    const length = Math.min(info.size, ROLLOUT_TAIL_BYTES);
+    const { buffer } = await handle.read(
+      Buffer.alloc(length),
+      0,
+      length,
+      info.size - length,
+    );
+    text = buffer.toString("utf8");
+  } finally {
+    await handle.close();
+  }
+  let covered = info.size <= ROLLOUT_TAIL_BYTES;
+  for (const line of text.split("\n")) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const at = Date.parse(entry.timestamp);
+    if (at < sinceMs) covered = true;
+    else if (entry.payload?.type === "thread_settings_applied")
+      return "resumed";
+  }
+  return covered ? "no" : "unknown";
+}
+
+// resume --last 는 pane 인자에 UUID 가 남지 않아 Codex 가 실제로 연 thread 를 사후에 찾는다.
+// 띄운 뒤 기록이 생긴 thread 가 정확히 하나이고 나머지 후보가 모두 확인됐을 때만 인정한다.
+async function resumedCodexThread(
+  { cwd, launchedAtMs, timeoutMs },
+  { loadedIds = loadedCodexThreadIds, findRollout = findCodexRollout } = {},
+) {
+  const matches = [];
+  for (const id of await loadedIds(cwd, timeoutMs)) {
+    const rollout = isCodexThreadId(id) && (await findRollout(id));
+    const state = rollout ? await resumedSince(rollout, launchedAtMs) : "no";
+    if (state === "unknown") return null;
+    if (state === "resumed") matches.push(id);
+  }
+  return matches.length === 1 ? matches[0] : null;
+}
+
 async function doStart(adapter, opts) {
   const {
     session,
@@ -2093,6 +2170,8 @@ async function doStart(adapter, opts) {
   if (resumed && name && adapter.cli === "claude")
     launchKeys[0] += ` ${shellQuote(["-n", name])}`;
   const resumeTarget = resume ?? (resumeLast ? "last" : null);
+  const trackResumeLast = resumeLast && adapter.cli === "codex" && !remote;
+  const launchedAtMs = Date.now();
 
   // 분리 세션 기본 80x24 에서는 긴 입력이 화면 높이를 넘으므로 넓게 만든다. 붙으면 클라이언트 크기를 따른다.
   await runTmux(remote, [
@@ -2129,6 +2208,23 @@ async function doStart(adapter, opts) {
   let nameApplied = Boolean(name) && adapter.cli === "claude" && ready;
   let threadId =
     adapter.cli === "codex" && isCodexThreadId(resume) ? resume : null;
+  // 우리 TUI 의 resume 기록이 늦게 반영되면 남의 기록만 보일 수 있어, 1.5초 뒤에도 같은 후보가
+  // 유일할 때만 확정한다. 5초 안에 확인하지 못하면 null 로 둔다.
+  const threadDeadline = Date.now() + 5000;
+  let candidate = null;
+  while (trackResumeLast && ready && !threadId) {
+    const timeoutMs = threadDeadline - Date.now();
+    if (timeoutMs <= 0) break;
+    const found = await resumedCodexThread({
+      cwd: cwd ?? process.cwd(),
+      launchedAtMs,
+      timeoutMs,
+    });
+    if (found && found === candidate) threadId = found;
+    candidate = found;
+    if (!threadId)
+      await sleep(Math.min(found ? 1500 : 500, threadDeadline - Date.now()));
+  }
   if (name && adapter.cli === "codex" && ready) {
     try {
       const command = `/rename ${name}`;
@@ -3272,19 +3368,24 @@ async function ask(flags) {
   printJson(await doAsk(adapter, askOpts(flags, adapter)));
 }
 
+async function codexThreadFromFlags(flags) {
+  if (flags.thread) {
+    if (!isCodexThreadId(flags.thread))
+      throw new Error("--thread must be a Codex session UUID");
+    return { threadId: flags.thread, threadSource: "flag" };
+  }
+  const thread = await resolveCodexTmuxThread(
+    splitTmuxTarget(requireFlag(flags, "session")).target,
+  );
+  if (!thread.threadId)
+    throw new Error(`Codex thread unavailable: ${thread.reason}`);
+  return thread;
+}
+
 async function waitCodex(flags) {
   if (flags.remote) throw new Error("Codex wait supports local sessions only");
   const requestId = requireFlag(flags, "request-id");
-  let thread = { threadId: flags.thread, threadSource: "flag" };
-  if (flags.thread && !isCodexThreadId(flags.thread))
-    throw new Error("--thread must be a Codex session UUID");
-  if (!flags.thread) {
-    thread = await resolveCodexTmuxThread(
-      splitTmuxTarget(requireFlag(flags, "session")).target,
-    );
-    if (!thread.threadId)
-      throw new Error(`Codex thread unavailable: ${thread.reason}`);
-  }
+  const thread = await codexThreadFromFlags(flags);
   printJson({
     ...(await waitCodexRequest({
       threadId: thread.threadId,
@@ -3296,12 +3397,74 @@ async function waitCodex(flags) {
   });
 }
 
+// tmux 대화형 Claude 는 daemon 이 없어 pane 의 세션 레코드 status 와 transcript 로 판정한다.
+async function waitClaudeTmux(flags) {
+  if (flags.remote)
+    throw new Error("Claude tmux wait supports local sessions only");
+  const session = splitTmuxTarget(flags.session).target;
+  const requestId = flags["request-id"] ?? null;
+  const timeoutMs = secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS);
+  const pollIntervalMs = msFlag(
+    flags,
+    "poll-interval",
+    DEFAULT_POLL_INTERVAL_MS,
+  );
+  const deadline = Date.now() + timeoutMs;
+  let transcriptPath = null;
+  for (;;) {
+    const target = await claudeTmuxTarget(session);
+    if (!target)
+      throw new Error(`no live Claude session in tmux target ${session}`);
+    // 처음 찾은 transcript 를 고정해 /clear 로 바뀐 세션을 따라가지 않는다.
+    transcriptPath ??= await claudeTmuxTranscript(
+      session,
+      flags["config-dir"],
+      target,
+    );
+    const transcript = await readClaudeTranscript(transcriptPath, {
+      requestId,
+    });
+    const result = {
+      ok: true,
+      status: transcript?.userSeen ? "working" : "submitted",
+      done: false,
+      timedOut: false,
+      response: transcript?.response || "",
+      ...(transcript?.context ?? modelContext("claude", null)),
+      requestId,
+      target,
+    };
+    const verdict = claudeWaitVerdict(transcript, target.status === "idle");
+    if (verdict) return { ...result, ...verdict };
+    if (Date.now() >= deadline) return { ...result, timedOut: true };
+    await sleep(Math.min(pollIntervalMs, deadline - Date.now()));
+  }
+}
+
+// 배달 전 항목은 공식 app-server 큐 API 로만 보고 지운다. 큐 저장소 파일은 건드리지 않는다.
+async function queue(flags) {
+  if ((flags.cli ?? "codex") !== "codex" || flags.remote)
+    throw new Error("queue supports local --cli codex only");
+  const { threadId, threadSource } = await codexThreadFromFlags(flags);
+  const requestId = flags["request-id"];
+  const items = (await listCodexQueue(threadId)).filter(
+    (item) => !requestId || item.requestId === requestId,
+  );
+  const result = { ok: true, cli: "codex", threadId, threadSource };
+  if (!flags.delete) return printJson({ ...result, items });
+  const ids =
+    flags.delete === "all" ? items.map((item) => item.id) : [flags.delete];
+  printJson({ ...result, ...(await deleteCodexQueueItems(threadId, ids)) });
+}
+
 async function wait(flags) {
   if (flags.cli === "codex") return waitCodex(flags);
   if ((flags.cli ?? "claude") !== "claude")
     throw new Error("wait supports --cli claude or codex");
+  if (flags.session && !flags.short && !flags["session-id"])
+    return printJson(await waitClaudeTmux(flags));
   if (!flags.short && !flags["session-id"])
-    throw new Error("wait requires --short or --session-id");
+    throw new Error("wait requires --short, --session-id or --session");
   if (flags.remote || (flags.transport && flags.transport !== "uds"))
     throw new Error("wait supports local Claude UDS only");
   const timeoutMs = secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS);
@@ -3354,7 +3517,7 @@ async function stop(flags) {
   printJson(await doStop(adapter, stopOpts(flags)));
 }
 
-async function claudeTmuxTranscript(session, configDir) {
+async function claudeTmuxTarget(session) {
   const { stdout: paneId } = await runTmux(null, [
     "display-message",
     "-p",
@@ -3363,9 +3526,13 @@ async function claudeTmuxTranscript(session, configDir) {
     "#{pane_id}",
   ]);
   const discovery = await discoverClaudeTmuxSessions();
-  const target = discovery.sessions.find(
-    (entry) => entry.paneId === paneId.trim(),
+  return (
+    discovery.sessions.find((entry) => entry.paneId === paneId.trim()) ?? null
   );
+}
+
+async function claudeTmuxTranscript(session, configDir, target) {
+  target ??= await claudeTmuxTarget(session);
   return findClaudeTranscript({
     configDir:
       configDir ||
@@ -4389,6 +4556,8 @@ async function main() {
     await ask(flags);
   } else if (command === "wait") {
     await wait(flags);
+  } else if (command === "queue") {
+    await queue(flags);
   } else if (command === "compact") {
     await compact(flags);
   } else if (command === "rename") {
@@ -4437,6 +4606,7 @@ export {
   peerSideBaseOpts,
   resolveAskTransport,
   resolveCodexDaemonSocket,
+  resumedCodexThread,
   splitTmuxTarget,
   stopOpts,
   tmuxBufferName,

package/bin/triflux.mjs

@@ -154,8 +154,7 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
       {
         name: "--diagnose",
         type: "boolean",
-        description:
-          "진단 번들(zip) 생성: spawn-trace + hook timing + system info",
+        description: "진단 번들(zip) 생성: spawn-trace + system info",
       },
       {
         name: "--purge-logs",
@@ -1318,7 +1317,7 @@ function cmdSetup(options = {}) {
     summary.push({ item: "Codex profiles", status: "⚠️", detail: reason });
   } else if (codexProfileResult.changed > 0) {
     ok(
-      `Codex profiles: ${codexProfileResult.changed}개 반영됨 (~/.codex/config.toml)`,
+      `Codex profiles: ${codexProfileResult.changed}개 반영됨 (~/.codex/<프로필>.config.toml)`,
     );
     summary.push({
       item: "Codex profiles",
@@ -1671,7 +1670,8 @@ async function cmdDoctor(options = {}) {
             name: "mcp-inventory",
             status: "failed",
           });
-          warn("MCP 인벤토리 재생성 실패 — 다음 세션에서 자동 재시도");
+          warn("MCP 인벤토리 재생성 실패");
+          info(`수동: node ${mcpCheck}`);
         }
       }
       const hudScript = join(CLAUDE_DIR, "hud", "hud-qos-status.mjs");
@@ -2126,7 +2126,7 @@ async function cmdDoctor(options = {}) {
           );
           if (psmuxSupport.missingOptionalCommands.includes("detach-client")) {
             info(
-              "  detach-client: WT 1.24 ConPTY close-race 회피용. WT 기반 병렬 실행(swarm dashboard, tfx-multi wt 모드) 에서 pane freeze/ConPTY hang 위험 증가.",
+              "  detach-client: WT 1.24 ConPTY close-race 회피용. WT 탭에서 psmux 세션을 닫을 때 pane freeze/ConPTY hang 위험 증가.",
             );
             info(
               "  해결: psmux v3.4+ 로 업그레이드. 현재 psmux 업그레이드 명령:",
@@ -2389,17 +2389,12 @@ async function cmdDoctor(options = {}) {
           status: "ok",
           path: mcpCache,
           codex_servers: inv.codex?.servers?.length || 0,
-          gemini_servers: inv.gemini?.servers?.length || 0,
         });
         ok(`캐시 존재 (${inv.timestamp})`);
         if (inv.codex?.servers?.length) {
           const names = inv.codex.servers.map((s) => s.name).join(", ");
           info(`Codex: ${inv.codex.servers.length}개 서버 (${names})`);
         }
-        if (inv.gemini?.servers?.length) {
-          const names = inv.gemini.servers.map((s) => s.name).join(", ");
-          info(`Gemini: ${inv.gemini.servers.length}개 서버 (${names})`);
-        }
       } catch {
         addDoctorCheck(report, {
           name: "mcp-inventory",
@@ -2416,7 +2411,7 @@ async function cmdDoctor(options = {}) {
         path: mcpCache,
         fix: `node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`,
       });
-      warn("캐시 없음 — 다음 세션 시작 시 자동 생성");
+      warn("캐시 없음: tfx update 또는 tfx doctor --reset 이 생성");
       info(`수동: node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`);
     }
 
@@ -3704,16 +3699,22 @@ function cmdHelp() {
     ${DIM}  --fix${RESET}        ${GRAY}진단 + 자동 수정${RESET}
     ${DIM}  --reset${RESET}      ${GRAY}캐시 전체 초기화${RESET}
     ${DIM}  --json${RESET}       ${GRAY}구조화된 진단 결과 JSON 출력${RESET}
+    ${DIM}  --help${RESET}       ${GRAY}--audit, --diagnose 등 전체 옵션${RESET}
     ${WHITE_BRIGHT}tfx mcp${RESET}        ${GRAY}MCP registry 관리 (list/sync/add/remove)${RESET}
     ${WHITE_BRIGHT}tfx update${RESET}     ${GRAY}최신 안정 버전으로 업데이트${RESET}
     ${DIM}  --dev / dev${RESET}   ${GRAY}dev 태그로 업데이트${RESET}
     ${WHITE_BRIGHT}tfx list${RESET}       ${GRAY}설치된 스킬 목록${RESET}
-    ${WHITE_BRIGHT}tfx multi${RESET}       ${GRAY}멀티-CLI 팀 모드 (tmux)${RESET}
+    ${WHITE_BRIGHT}tfx multi${RESET}      ${GRAY}멀티-CLI 팀 모드 (tmux)${RESET}
+    ${WHITE_BRIGHT}tfx cto${RESET}        ${GRAY}저장소 스냅숏 수집과 조회 (collect/status/hygiene)${RESET}
     ${WHITE_BRIGHT}tfx version${RESET}    ${GRAY}버전 표시${RESET}
+    ${WHITE_BRIGHT}tfx-live${RESET}       ${GRAY}Claude·Codex 라이브 세션 (tfx-live --help)${RESET}
 
   ${BOLD}Skills${RESET} ${GRAY}(Claude Code 슬래시 커맨드)${RESET}
 
     ${AMBER}/tfx-auto${RESET}       ${GRAY}자동 분류 + 병렬 실행 (--cli codex|antigravity|claude, --parallel N)${RESET}
+    ${AMBER}/tfx-live${RESET}       ${GRAY}Claude·Codex 라이브 세션 생성, 질의, 대기, 종료${RESET}
+    ${AMBER}/tfx-lead${RESET}       ${GRAY}여러 세션을 지휘하는 리드 역할${RESET}
+    ${AMBER}/tfx-remote${RESET}     ${GRAY}SSH 원격 Claude Code 세션${RESET}
     ${AMBER}/tfx-setup${RESET}      ${GRAY}HUD 설정 + 진단${RESET}
     ${YELLOW}/tfx-doctor${RESET}     ${GRAY}진단 + 수리 + 캐시 초기화${RESET}
 
@@ -3799,9 +3800,7 @@ async function main() {
             console.log(
               `\n  ${GREEN_BRIGHT}✓${RESET} 진단 번들 생성: ${result.zipPath}`,
             );
-            console.log(
-              `  spawn 이벤트: ${result.traceCount}건, 훅 타이밍: ${result.hookTimingCount}건\n`,
-            );
+            console.log(`  spawn 이벤트: ${result.traceCount}건\n`);
           } else {
             console.log(`\n  ${RED}✗${RESET} 진단 실패: ${result.error}\n`);
           }

package/config/mcp-registry.json

@@ -10,7 +10,7 @@
     "transport": "Server transport accepts \"http\" for direct Streamable HTTP MCP endpoints, or \"stdio\" for directly launched MCP servers.",
     "headers": "Optional headers are allowed only for HTTP-compatible transports. Each header value must be a descriptor: {\"value\":\"literal\"} for non-secret static values, {\"env\":\"ENV_VAR_NAME\"} for secrets resolved at sync/runtime, or {\"env\":\"ENV_VAR_NAME\",\"prefix\":\"Bearer \"} for common authorization formats.",
     "secret_safety": "Resolved secret values must not be written back to this registry file. Missing env vars warn during sync and do not emit empty secret headers.",
-    "sync_denylist": "Array of client:server strings skipped by proactive registry sync, for example gemini:context7."
+    "sync_denylist": "Array of client:server strings skipped by proactive registry sync, for example codex:context7."
   },
   "servers": {
     "context7": {
@@ -18,7 +18,7 @@
       "transport": "http",
       "url": "https://mcp.context7.com/mcp",
       "safe": true,
-      "targets": ["claude", "gemini", "codex", "antigravity"],
+      "targets": ["claude", "codex", "antigravity"],
       "description": "Upstash Context7 — 라이브러리 문서/코드 컨텍스트 (HTTP MCP, API key 불필요)"
     },
     "exa": {
@@ -29,7 +29,7 @@
         "Authorization": { "env": "EXA_API_KEY", "prefix": "Bearer " }
       },
       "safe": true,
-      "targets": ["claude", "gemini", "codex", "antigravity"],
+      "targets": ["claude", "codex", "antigravity"],
       "description": "Exa neural/semantic web search — 학술/기술 깊이. Key 발급: https://exa.ai/dashboard → secrets.env의 EXA_API_KEY"
     },
     "brave-search": {
@@ -41,7 +41,7 @@
         "BRAVE_API_KEY": { "env": "BRAVE_API_KEY" }
       },
       "safe": true,
-      "targets": ["claude", "gemini", "codex", "antigravity"],
+      "targets": ["claude", "codex", "antigravity"],
       "description": "Brave Search MCP — 직접 stdio 연결. secrets.env 의 BRAVE_API_KEY 참조."
     },
     "tavily": {
@@ -52,7 +52,7 @@
         "Authorization": { "env": "TAVILY_API_KEY", "prefix": "Bearer " }
       },
       "safe": true,
-      "targets": ["claude", "gemini", "codex", "antigravity"],
+      "targets": ["claude", "codex", "antigravity"],
       "description": "Tavily research — 비용/운영/DX/일반 웹. Key 발급: https://app.tavily.com/home → secrets.env의 TAVILY_API_KEY"
     }
   },
@@ -60,7 +60,6 @@
     "unknown_server_action": "warn",
     "sync_denylist": [],
     "watched_paths": [
-      "~/.gemini/settings.json",
       "~/.codex/config.toml",
       "~/.claude.json",
       "~/.claude/settings.json",

package/hub/bridge.mjs

@@ -465,9 +465,8 @@ async function cmdDaemonWait(args) {
     if (!payload.short && !payload.sessionId)
       throw new Error("short or sessionId is required");
     const { probeClaudeDaemonCandidates } = await loadDaemonControl();
-    const { findClaudeTranscript, readClaudeTranscript } = await import(
-      "./team/claude-transcript.mjs"
-    );
+    const { claudeWaitVerdict, findClaudeTranscript, readClaudeTranscript } =
+      await import("./team/claude-transcript.mjs");
     const timeoutMs = numericOption(payload.timeoutMs, 30_000);
     const pollIntervalMs = Math.max(
       10,
@@ -535,28 +534,8 @@ async function cmdDaemonWait(args) {
         target: probe.target,
         ...daemonProbeMetadata(probe),
       };
-      if (transcript?.error) {
-        return emitJson({
-          ...last,
-          ok: false,
-          status: "failed",
-          error: transcript.error,
-        });
-      }
-      if (
-        (idle || transcript?.sectionClosed) &&
-        transcript?.userSeen &&
-        transcript.turnEnded
-      ) {
-        if (!transcript.response.trim())
-          return emitJson({
-            ...last,
-            ok: false,
-            status: "failed",
-            error: "turn ended without assistant text",
-          });
-        return emitJson({ ...last, status: "completed", done: true });
-      }
+      const verdict = claudeWaitVerdict(transcript, idle);
+      if (verdict) return emitJson({ ...last, ...verdict });
       if (Date.now() >= deadline) break;
       await new Promise((resolve) =>
         setTimeout(resolve, Math.min(pollIntervalMs, deadline - Date.now())),