triflux 10.62.0 → 10.64.0

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

@@ -33,6 +33,8 @@ macOS의 iTerm2에서 로컬 tmux 세션을 `start`하면 리드가 있는 창
 
 새 세션 이름은 `<월>.<일> <주제>`로 짓는다. `start --name`을 생략하면 자동으로 만들고 `nameGenerated: true`를 보고한다. `--resume` 또는 `--resume-last`는 `--name`을 명시한 경우에만 이름을 적용한다. 승계 세션에는 기존 이름 뒤에 ` 2`, 이후 ` 3`을 붙인다. 이름 적용을 요청한 경우 결과의 `nameApplied: false`는 미적용을 뜻한다. agy의 `namePending: true`는 첫 일반 ask에서 적용할 이름이 보류됐다는 뜻이다. 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 "<이름>"`으로 이름을 바꾼다.
 
+Codex 폴더 신뢰 화면이나 Claude 프로젝트 MCP 승인 화면이 뜨면 `start`는 화면에 답하지 않고 `ready: false`, `blockedBy`(`codex-trust-folder` 또는 `claude-mcp-approval`), 할 일을 적은 `warning`을 반환한다. 세션은 남아 있으므로 tmux 세션에 붙어 직접 고른 뒤 지시를 보낸다.
+
 ## agy 세션
 
 ```bash
@@ -57,11 +59,13 @@ agy `ask`의 기본 `--if-busy queue`는 바쁜 턴에도 바로 전송한다. a
 
 | 동작 | 적용 조건과 실행 |
 | --- | --- |
-| compact | 같은 목표와 담당이 이어지고 파일과 git에서 상태를 복구할 수 있을 때. Claude는 `tfx-live compact` 또는 `/compact <보존 지침>`, Codex는 `/compact` 뒤 리드가 파일 경로와 검증 명령을 다시 전달한다. agy는 수동 compact가 없어 handoff한다. |
+| compact | 같은 목표와 담당이 이어지고 파일과 git에서 상태를 복구할 수 있을 때. Claude와 Codex는 `tfx-live compact --then "다음 지시" --no-wait`로 압축 제출을 확인하고 다음 지시를 미리 넣는다. 압축 뒤에 필요한 파일 경로와 검증 명령도 `--then`에 싣는다. agy는 수동 compact가 없어 handoff한다. |
 | clear | 무관한 작업으로 전환하거나 같은 문제를 두 번 넘게 고쳐도 실패할 때, 스펙에서 구현으로 또는 작성자에서 리뷰어로 바뀔 때. 미완료 상태를 정리한 뒤 Claude는 `/rename`과 `/clear`, Codex는 작업 종료 뒤 `/new <이름>`, agy는 `/clear`를 쓴다. |
 | handoff | 담당·CLI·모델·소유자가 바뀌거나 긴 작업이 창을 넘길 때. 인계 파일에 목표, 완료 조건, 체크아웃과 변경 상태, 확정 결정, 증거 경로, PASS/FAIL/SKIP, 미완료 작업과 프로세스, 다음 행동과 소유자, `predecessorSessionId`를 적는다. 승계 세션이 경로를 확인하면 이전 세션을 닫는다. |
 | close | 결과와 인계를 확인한 즉시 닫는다. Claude 백그라운드는 `claude stop <id>`, tmux는 `tfx-live stop --session`, Claude 팀원은 shutdown, Codex 서브에이전트는 `close_agent`, agy 서브에이전트는 `/agents` 패널의 K를 쓴다. |
 
+Claude TUI는 바쁠 때 들어온 입력을 대기열에 넣고 현재 턴(압축 포함)이 끝나면 순서대로 처리한다. transcript에는 `queue-operation`의 `enqueue`와 `dequeue`로 남는다. Codex app-server 큐도 바쁜 턴 뒤에 순서대로 처리한다. 리드는 compact를 보내고 `--then`으로 다음 지시를 넣는 것을 기본 절차로 쓴다.
+
 두 번째 compact 전에는 handoff가 맞는지 점검한다. compact 횟수는 고정하지 않는다.
 
 리드 역할 절차(역할별 모델, 지시서, 교차 리뷰, 릴리스 조율)는 `tfx-lead` 스킬을 따른다.
@@ -103,30 +107,37 @@ Claude와 Codex는 네이티브 goal을 우선 쓰고, goal-driven은 agy처럼
 
 ### 컨텍스트 판단
 
-분모는 공식 모델 창이고 실행 한도가 더 작으면 그 한도 아래에서 운영한다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
+Claude의 분모는 공식 모델 창과 실행 한도 중 작은 값이다. Codex의 분모는 rollout이 보고한 실행 창이고, 없을 때만 공식 창이다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
 
 | CLI | 준비와 경고 | compact | 신규 배정 중지·handoff | 전송 거부 |
 | --- | ---: | ---: | ---: | ---: |
 | Claude Code 1M 모델 | 60% | 75% | 85% | 90% |
-| Codex | 15% | 18% | 20% | 22% |
+| Codex rollout 실행 창 | 60% | - | - | 85% |
+| Codex 실행 창 없음(1.05M 분모) | 15% | 18% | 20% | 22% |
 | agy | 12% | 없음 | 15% | 18% |
 
-Claude는 85% 도달 시 바로 handoff를 지시한다. agy 행은 운영 지침이며 agy도 `tfx-live` 전송 대상이지만 컨텍스트 비율은 자동으로 읽지 못해 `null`로 보고하고 가드를 건너뛴다. `model_context_window`와 `model_auto_compact_token_limit`은 올리지 않는다.
+Claude는 85% 도달 시 바로 handoff를 지시한다. Codex 실행 창 행의 compact와 handoff 비율은 아직 정하지 않았다. agy 행은 운영 지침이며 agy도 `tfx-live` 전송 대상이지만 컨텍스트 비율은 자동으로 읽지 못해 `null`로 보고하고 가드를 건너뛴다. `model_context_window`와 `model_auto_compact_token_limit`은 올리지 않는다.
 
-결과에는 `estimatedContextTokens`, `contextLimitTokens`, `contextLimitSource`, `contextPct`가 포함된다. Claude 실행 한도는 `executionContextLimitTokens`로 별도 보고하며 `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`이면 200,000이다. 판정에는 공식 창과 실행 한도 중 작은 값을 쓴다. 한도를 모르면 비율은 `null`로 두고 경고만 한다. 사용량이 없는 `probe`는 `context: null`이다. 컨텍스트를 확인하려면 직접 `tfx-live probe`를 실행한다. `interrupt`, 자동 `ask`의 daemon probe, `stop --short`는 transcript를 읽지 않는다.
+결과에는 `estimatedContextTokens`, `contextLimitTokens`, `contextLimitSource`, `contextPct`가 포함된다. Claude 실행 한도는 `executionContextLimitTokens`로 별도 보고하며 `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`이면 200,000이다. Codex는 rollout `token_count`의 `model_context_window`를 `executionContextLimitTokens`로 보고한다. 이 값이 있으면 모델 표에 없는 모델이라도 그 창으로 판정하고, 없으면 1,050,000 표 값을 분모로 쓴다. 한도를 모르면 비율은 `null`로 두고 경고만 한다. 사용량이 없는 `probe`는 `context: null`이다. 컨텍스트를 확인하려면 직접 `tfx-live probe`를 실행한다. `interrupt`, 자동 `ask`의 daemon probe, `stop --short`는 transcript를 읽지 않는다.
 
-`ask`의 `--warn-context-pct`와 `--max-context-pct`는 경고·거부 비율을 덮어쓰며 0이면 해당 가드를 끈다. 기본값은 표의 경고·전송 거부 열이다. 거부 결과는 `status: "failed"`, `done: false`, `context-limit`와 컨텍스트 필드를 돌려준다. 자세한 근거와 실측은 [컨텍스트 정책 연구](../../docs/research/tfx-live-context-policy-2026-10.md)에 둔다.
+`ask`의 `--warn-context-pct`와 `--max-context-pct`는 경고·거부 비율을 덮어쓰며 0이면 해당 가드를 끈다. 기본값은 표의 경고·전송 거부 열이다. Codex는 `executionContextLimitTokens`가 있으면 실행 창 행을, 없으면 1.05M 분모 행을 쓴다. 거부 결과는 `status: "failed"`, `done: false`, `context-limit`, 컨텍스트 필드와 적용한 거부 비율 `thresholdPct`를 돌려준다. 경고의 `thresholdPct`는 적용한 경고 비율이다. 자세한 근거와 실측은 [컨텍스트 정책 연구](../../docs/research/tfx-live-context-policy-2026-10.md)에 둔다.
 
 ### 수동 compact와 종료
 
 ```bash
-tfx-live compact --cli claude --session cl1 --instructions "변경 파일과 검증 명령을 보존하라" --timeout 120
+tfx-live compact --cli claude --session cl1 --instructions "변경 파일과 검증 명령을 보존하라" --then "인계 파일을 읽고 검증을 이어가라" --no-wait
+tfx-live compact --cli codex --session cx1 --then "src/main.mjs를 확인하고 지정된 단위 테스트를 실행하라" --no-wait
+tfx-live wait --cli codex --session cx1 --request-id <then.requestId> --timeout 120
 tfx-live stop --cli claude --short <8hex>
 tfx-live stop --cli claude --session-id <id>
 tfx-live stop --session cl1
 ```
 
-`compact`는 로컬 Claude tmux `--session`에서 `/compact <instructions>`를 중계 표식 없이 보낸다. 기본 `--if-busy fail`이며 바쁜 세션에는 전송하지 않는다. 새 `compact_boundary`를 확인하면 `compacted: true`, `preTokens`, `postTokens`를 반환한다. 시간 안에 없으면 `compacted: false, timedOut: true`다. UDS compact는 지원하지 않는다.
+`compact --session S [--cli claude|codex] [--instructions TEXT] [--then PROMPT] [--no-wait]`는 로컬 tmux에서 `/compact`를 중계 표식 없이 보낸다. CLI 기본값은 Claude다. `--instructions`는 Claude에서만 받으며 Codex는 인자를 받지 않아 거부한다. 기본 `--if-busy fail`이며 바쁜 세션에는 compact를 전송하지 않는다. UDS compact는 지원하지 않는다.
+
+`--no-wait`는 압축 진행 표시 또는 새 완료 기록으로 제출을 확인한 뒤 반환한다. Codex에서 확인되지 않으면 Enter를 한 번 더 보내고, 그래도 확인되지 않으면 `--then`을 보내지 않고 오류로 끝낸다. `--then`은 일반 텍스트 지시만 받으며 슬래시 명령은 거부한다. 제출 확인 직후 Claude에는 표식을 붙여 tmux로 보내고 화면의 `queued messages` 또는 transcript의 `enqueue`로 확인한다. Claude 압축이 먼저 끝나 지시가 이미 처리에 들어갔으면 `then.queued: false, delivered: true`로 보고한다. Codex에는 기존 queue 경로로만 보내며 tmux로 전환하지 않는다. 결과의 `then.requestId`로 `wait --request-id`에서 압축 뒤 응답을 받는다.
+
+`--no-wait`가 없으면 Claude의 새 `compact_boundary`, Codex rollout의 새 `compacted`까지 기다린다. 결과에 `compact: {submitted: true, done}`과 `then: {requestId, queued, transport}`를 추가하고 기존 `compacted`, `preTokens`, `postTokens`를 유지한다. 토큰 수는 기록에 있는 값만 보고하며 Codex의 압축 후 token_count가 아직 없으면 `postTokens`는 `null`이다. 시간 안에 완료 기록이 없으면 `compacted: false, timedOut: true`다.
 
 `stop --short`와 `stop --session-id`는 `claude stop <id>`를 호출하고 `stopped: true, conversationKept: true`를 반환한다. `claude attach`로 대화를 재개할 수 있다. `/exit`, `←`, Ctrl+Z는 백그라운드 세션의 연결만 끊는다. macOS의 `sysctl -n kern.memorystatus_vm_pressure_level`이 2 이상이면 새 세션을 띄우기 전 정리한다. 원격 배정 전에는 `tfx-remote probe <host>`의 `ready`와 `warnings`를 확인한다.
 

package/bin/tfx-live.mjs

@@ -53,7 +53,6 @@ import {
   validateHost as validateRemoteHost,
 } from "../hub/team/remote-session.mjs";
 import {
-  CONTEXT_THRESHOLDS,
   contextGuard,
   findCodexRollout,
   modelContext,
@@ -107,8 +106,8 @@ function usage(command) {
     "    Codex ask defaults to the app-server queue (thread/queue/add, `codex queue --message` only when add is unavailable; delivered when the TUI picks it up); tmux paste is the reported fallback and the path for slash commands.",
     "  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]",
-    "    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]",
+    "    ask options: --no-wait --no-relay-tag --warn-context-pct N --max-context-pct N (0 disables; Claude 60/90, Codex 60/85 of rollout window or 15/22 of 1.05M).",
+    "  tfx-live compact --session NAME [--cli claude|codex] [--instructions TEXT] [--then PROMPT] [--no-wait] [--if-busy fail|wait] [--timeout 60]",
     "  tfx-live goal set --session NAME [--cli claude|codex] --condition TEXT [--budget N]",
     "  tfx-live goal status --session NAME [--cli claude|codex]",
     "  tfx-live goal clear --session NAME [--cli claude|codex]",
@@ -220,8 +219,10 @@ function integerFlag(flags, name, defaultValue) {
   return value;
 }
 
-function contextPctFlag(flags, name, defaultValue) {
-  const value = flags[name] === undefined ? defaultValue : Number(flags[name]);
+// 기본값은 contextGuard 가 읽은 실행 창에 맞춰 고른다.
+function contextPctFlag(flags, name) {
+  if (flags[name] === undefined) return undefined;
+  const value = Number(flags[name]);
   if (!Number.isFinite(value) || value < 0 || value > 100)
     throw new Error(`--${name} must be between 0 and 100`);
   return value;
@@ -230,16 +231,8 @@ function contextPctFlag(flags, name, defaultValue) {
 function contextOpts(flags, cli) {
   if (cli === "agy") return {};
   return {
-    warnContextPct: contextPctFlag(
-      flags,
-      "warn-context-pct",
-      CONTEXT_THRESHOLDS[cli].warnContextPct,
-    ),
-    maxContextPct: contextPctFlag(
-      flags,
-      "max-context-pct",
-      CONTEXT_THRESHOLDS[cli].maxContextPct,
-    ),
+    warnContextPct: contextPctFlag(flags, "warn-context-pct"),
+    maxContextPct: contextPctFlag(flags, "max-context-pct"),
   };
 }
 
@@ -1770,6 +1763,49 @@ function isClaudeExternalImportsPrompt(text) {
   );
 }
 
+// 승인 화면에서는 마지막 선택 글리프 줄이 메뉴 항목이다. 문구를 인용한 대화라면
+// 그 아래 입력창이 마지막 글리프 줄이 되므로 걸러진다. 위쪽 문구는 테두리와
+// 줄바꿈이 끊어도 맞도록 공백 하나로 접는다.
+function splitAtLastSelector(text, glyph) {
+  const lines = stripAnsi(text)
+    .split("\n")
+    .map((line) => line.replace(/^[\s│┃]+/, ""));
+  const index = lines.findLastIndex((line) => line.startsWith(glyph));
+  if (index < 0) return null;
+  const isRule = (line = "") => /^─{3,}/.test(line);
+  return {
+    above: lines.slice(0, index).join(" ").replace(/\s+/g, " "),
+    selected: lines[index],
+    // Claude 입력창은 위아래 가로줄 상자다. 여러 줄 입력이면 아래 가로줄이 몇 줄 뒤에 온다.
+    inComposerBox:
+      isRule(lines[index - 1]) && lines.slice(index + 1).some(isRule),
+  };
+}
+
+function isCodexTrustFolderPrompt(text) {
+  const menu = splitAtLastSelector(text, "›");
+  return (
+    Boolean(menu) &&
+    /trust this folder\?/i.test(menu.above) &&
+    /^›\s*(?:\d+\.\s*)?(?:trust and continue|open restricted)/i.test(
+      menu.selected,
+    )
+  );
+}
+
+// 다중 선택 항목은 한 글자 체크박스로 그린다. 바이너리 상수: [ ] [×] [✔] [√] ☐ ☒, 라디오 ( ) (*) ◯ ◉.
+function isClaudeMcpApprovalPrompt(text) {
+  const menu = splitAtLastSelector(text, "❯");
+  return (
+    Boolean(menu) &&
+    !menu.inComposerBox &&
+    /new MCP servers? found in this project/i.test(menu.above) &&
+    /^❯\s*(?:\d+\.\s*)?(?:use this|continue without using this MCP server|enable selected|\[.\]|\(.\)|[☐☒◯◉])/iu.test(
+      menu.selected,
+    )
+  );
+}
+
 function isClaudeTourPrompt(text) {
   // Claude's post-update welcome/tour screen ("Take the tour" / "Skip for now").
   // Claude has no codex-style "Update available / Skip until next version" menu
@@ -2024,6 +2060,15 @@ const ADAPTERS = {
         dismiss: dismissCodexDaemonSettingsPrompt,
       },
     ],
+    // 사람의 보안 판단이 필요한 화면이라 고르지 않고 start 를 ready:false 로 끝낸다.
+    blockingScreens: [
+      {
+        name: "codex-trust-folder",
+        isPresent: isCodexTrustFolderPrompt,
+        warning:
+          "Codex is asking whether to trust this folder; attach to the tmux session and answer it yourself",
+      },
+    ],
   },
   claude: {
     cli: "claude",
@@ -2081,6 +2126,14 @@ const ADAPTERS = {
         dismiss: dismissClaudeTourPrompt,
       },
     ],
+    blockingScreens: [
+      {
+        name: "claude-mcp-approval",
+        isPresent: isClaudeMcpApprovalPrompt,
+        warning:
+          "Claude is asking to approve project MCP servers; attach to the tmux session and answer it yourself",
+      },
+    ],
   },
   agy: {
     cli: "agy",
@@ -2204,6 +2257,17 @@ async function waitForReady(
 
   while (Date.now() - startedAt < timeoutMs) {
     raw = await captureVisible(remote, session);
+    const blocking = adapter.blockingScreens?.find((screen) =>
+      screen.isPresent(raw),
+    );
+    if (blocking) {
+      return {
+        ready: false,
+        raw,
+        blockedBy: blocking.name,
+        warning: blocking.warning,
+      };
+    }
     if (isStartupScreen(adapter, raw)) {
       await dismissStartupScreens(adapter, remote, session);
       await sleep(pollIntervalMs);
@@ -2706,7 +2770,7 @@ async function doStart(adapter, opts) {
   await runTmux(remote, ["send-keys", "-t", session, ...launchKeys]);
   await dismissStartupScreens(adapter, remote, session);
 
-  const { ready, raw } = await waitForReady(
+  const { ready, raw, blockedBy, warning } = await waitForReady(
     adapter,
     remote,
     session,
@@ -2886,6 +2950,7 @@ end tell`;
     resumed,
     resumeTarget,
     ready,
+    ...(blockedBy ? { blockedBy, warning } : {}),
     name,
     nameGenerated: !resumed && opts.name === undefined,
     nameApplied,
@@ -2941,7 +3006,10 @@ async function renameAgyConversation(session, name, timeoutMs, pollIntervalMs) {
   return false;
 }
 
-async function waitForTmuxIdle(adapter, opts) {
+async function waitForTmuxIdle(adapter, opts, deps = {}) {
+  const capture = deps.captureVisible ?? captureVisible;
+  const tmux = deps.runTmux ?? runTmux;
+  const pause = deps.sleep ?? sleep;
   const { session, remote, pollIntervalMs, busyTimeoutMs, ifBusy } = opts;
   if (
     ![
@@ -2958,7 +3026,7 @@ async function waitForTmuxIdle(adapter, opts) {
   const startedAt = Date.now();
   let interrupted = false;
   while (true) {
-    const visible = await captureVisible(remote, session);
+    const visible = await capture(remote, session);
     const elapsedMs = Date.now() - startedAt;
     const busy =
       adapter.isBusy(visible) ||
@@ -2971,16 +3039,20 @@ async function waitForTmuxIdle(adapter, opts) {
       );
     }
     if (ifBusy === "interrupt" && !interrupted) {
-      await runTmux(remote, ["send-keys", "-t", session, "Escape"]);
+      await tmux(remote, ["send-keys", "-t", session, "Escape"]);
       interrupted = true;
     }
-    await sleep(
+    await pause(
       Math.min(pollIntervalMs, Math.max(1, busyTimeoutMs - elapsedMs)),
     );
   }
 }
 
-async function doAskViaTmux(adapter, opts) {
+async function doAskViaTmux(adapter, opts, deps = {}) {
+  const tmux = deps.runTmux ?? runTmux;
+  const capture = deps.captureVisible ?? captureVisible;
+  const captureHistory = deps.capturePane ?? capturePane;
+  const pause = deps.sleep ?? sleep;
   const {
     session,
     prompt,
@@ -2993,17 +3065,22 @@ async function doAskViaTmux(adapter, opts) {
     busyTimeoutMs = timeoutMs,
   } = opts;
   const slashCommand = adapter.cli === "agy" && isSlashCommand(prompt);
-  const busyWaitedMs = await waitForTmuxIdle(adapter, {
-    session,
-    remote,
-    pollIntervalMs,
-    busyTimeoutMs,
-    ifBusy: slashCommand ? "queue" : ifBusy,
-  });
+  const busyWaitedMs = opts.skipBusyCheck
+    ? 0
+    : await waitForTmuxIdle(
+        adapter,
+        {
+          session,
+          remote,
+          pollIntervalMs,
+          busyTimeoutMs,
+          ifBusy: slashCommand ? "queue" : ifBusy,
+        },
+        deps,
+      );
   const queued =
-    adapter.cli === "agy" &&
-    adapter.isBusy(await captureVisible(remote, session));
-  const beforeRaw = await capturePane(remote, session);
+    adapter.cli === "agy" && adapter.isBusy(await capture(remote, session));
+  const beforeRaw = await captureHistory(remote, session);
   const contextPctBefore = adapter.contextPct(beforeRaw);
   const context =
     adapter.cli === "agy"
@@ -3026,8 +3103,8 @@ async function doAskViaTmux(adapter, opts) {
     };
 
   const bufferName = tmuxBufferName(session);
-  await runTmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
-  await runTmux(remote, [
+  await tmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
+  await tmux(remote, [
     "paste-buffer",
     "-b",
     bufferName,
@@ -3036,31 +3113,42 @@ async function doAskViaTmux(adapter, opts) {
     "-t",
     session,
   ]);
-  await sleep(settleMs);
+  await pause(settleMs);
 
-  let promptSubmitted = adapter.cli === "agy" ? false : !doneMarker;
+  let promptSubmitted =
+    adapter.cli === "agy" || opts.confirmSubmission ? false : !doneMarker;
   if (doneMarker || opts.noWait || adapter.cli === "agy") {
-    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, adapter.cli)) {
+    for (
+      let attempt = 1;
+      attempt <= (opts.submitAttempts ?? PROMPT_SUBMIT_MAX_ATTEMPTS);
+      attempt += 1
+    ) {
+      await tmux(remote, ["send-keys", "-t", session, "Enter"]);
+      await pause(PROMPT_SUBMIT_RETRY_DELAY_MS);
+      const submissionVisible = await capture(remote, session);
+      if (
+        opts.confirmSubmission
+          ? await opts.confirmSubmission(submissionVisible)
+          : !composerShowsPrompt(submissionVisible, prompt, adapter.cli)
+      ) {
         promptSubmitted = true;
         break;
       }
     }
     if (!promptSubmitted) {
       throw new Error(
-        `Prompt did not submit after ${PROMPT_SUBMIT_MAX_ATTEMPTS} attempts`,
+        opts.confirmSubmission
+          ? "compact submission could not be confirmed (it may still have started, or /compact may remain in the composer); --then was not sent"
+          : `Prompt did not submit after ${PROMPT_SUBMIT_MAX_ATTEMPTS} attempts`,
       );
     }
   } else {
-    await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+    await tmux(remote, ["send-keys", "-t", session, "Enter"]);
   }
 
   let nameApplied;
   if (adapter.cli === "agy" && !slashCommand) {
-    const { stdout } = await runTmux(null, [
+    const { stdout } = await tmux(null, [
       "show-options",
       "-qv",
       "-t",
@@ -3093,7 +3181,7 @@ async function doAskViaTmux(adapter, opts) {
               pollIntervalMs,
             );
             if (nameApplied)
-              await runTmux(null, [
+              await tmux(null, [
                 "set-option",
                 "-u",
                 "-t",
@@ -3102,7 +3190,7 @@ async function doAskViaTmux(adapter, opts) {
               ]);
             break;
           }
-          await sleep(Math.min(pollIntervalMs, 200));
+          await pause(Math.min(pollIntervalMs, 200));
         }
       } catch {
         nameApplied = false;
@@ -3160,8 +3248,8 @@ async function doAskViaTmux(adapter, opts) {
 
   while (Date.now() - startedAt < timeoutMs) {
     visible = doneMarker
-      ? await capturePane(remote, session)
-      : await captureVisible(remote, session);
+      ? await captureHistory(remote, session)
+      : await capture(remote, session);
     contextPctAfter = adapter.contextPct(visible);
 
     quietPolls = visible === previousVisible ? quietPolls + 1 : 0;
@@ -3184,7 +3272,7 @@ async function doAskViaTmux(adapter, opts) {
       quietPolls >= FALLBACK_QUIET_POLLS &&
       hasTmuxAssistantResponseAfterCurrentPrompt(
         adapter,
-        await capturePane(remote, session),
+        await captureHistory(remote, session),
         prompt,
         beforeRaw,
       );
@@ -3193,10 +3281,10 @@ async function doAskViaTmux(adapter, opts) {
       break;
     }
 
-    await sleep(pollIntervalMs);
+    await pause(pollIntervalMs);
   }
 
-  raw = await capturePane(remote, session);
+  raw = await captureHistory(remote, session);
   const markerResponse = promptSubmitted
     ? extractResponseSinceMarker({
         beforeRaw,
@@ -3412,11 +3500,15 @@ async function resolveCodexTmuxThread(session, deps = {}) {
 
 async function doAskViaQueue(adapter, opts, deps = {}) {
   // queue 를 못 쓰면 tmux 붙여넣기로 보내고 그 이유를 결과에 남긴다.
-  const fallback = async (reason) => ({
-    ...(await doAskViaTmux(adapter, { ...opts, transport: "tmux" })),
-    transportRequested: "queue",
-    fallbackReason: reason,
-  });
+  const fallback = async (reason) => {
+    if (opts.queueOnly)
+      throw new Error(`compact --then requires Codex queue: ${reason}`);
+    return {
+      ...(await doAskViaTmux(adapter, { ...opts, transport: "tmux" })),
+      transportRequested: "queue",
+      fallbackReason: reason,
+    };
+  };
   if (opts.remote) return fallback("remote-host");
   const thread = opts.threadId
     ? { threadId: opts.threadId, threadSource: "flag" }
@@ -4374,70 +4466,208 @@ async function tmuxContext(adapter, opts) {
   }
 }
 
-async function compact(flags) {
-  if (flags.cli === "agy")
+async function doCompact(flags, deps = {}) {
+  const cli = flags.cli ?? "claude";
+  if (cli === "agy")
     throw new Error("agy has no compact; use /clear or a handoff");
   if (
-    (flags.cli ?? "claude") !== "claude" ||
+    !["claude", "codex"].includes(cli) ||
     flags.remote ||
     flags.short ||
     flags["session-id"] ||
     (flags.transport && flags.transport !== "tmux")
   )
     throw new Error(
-      "compact supports local --cli claude --session NAME only; UDS slash execution is unverified",
+      "compact supports local --cli claude|codex --session NAME only",
     );
+  if (cli === "codex" && flags.instructions)
+    throw new Error(
+      "Codex /compact does not accept --instructions; use --then for follow-up instructions",
+    );
+  const thenPrompt = flags.then?.trim();
+  if (flags.then !== undefined && !thenPrompt)
+    throw new Error("--then must not be blank");
+  if (isSlashCommand(thenPrompt))
+    throw new Error("--then accepts text instructions, not slash commands");
   const ifBusy = flags["if-busy"] ?? "fail";
   if (!["fail", "wait"].includes(ifBusy))
     throw new Error("compact --if-busy must be fail or wait");
+  const adapter = ADAPTERS[cli];
   const opts = askOpts(
     {
       ...flags,
-      cli: "claude",
+      cli,
       transport: "tmux",
       "if-busy": ifBusy,
       "no-wait": true,
       prompt: `/compact${flags.instructions ? ` ${flags.instructions}` : ""}`,
     },
-    ADAPTERS.claude,
-  );
-  if (ifBusy === "wait") await waitForTmuxIdle(ADAPTERS.claude, opts);
-  const transcriptPath = await claudeTmuxTranscript(
-    opts.session,
-    opts.configDir,
+    adapter,
   );
-  const before = await readClaudeTranscript(transcriptPath);
-  if (!before)
+  const pause = deps.sleep ?? sleep;
+  const capture = deps.captureVisible ?? captureVisible;
+  await waitForTmuxIdle(adapter, opts, deps);
+  let transcriptPath;
+  let threadId;
+  if (cli === "claude") {
+    transcriptPath = await (deps.claudeTmuxTranscript ?? claudeTmuxTranscript)(
+      opts.session,
+      opts.configDir,
+    );
+  } else {
+    const thread = await (
+      deps.resolveCodexTmuxThread ?? resolveCodexTmuxThread
+    )(opts.session, deps);
+    threadId = thread.threadId;
+    transcriptPath = await (deps.findCodexRollout ?? findCodexRollout)(
+      threadId,
+    );
+  }
+  const readSnapshot = () =>
+    cli === "claude"
+      ? readClaudeTranscript(transcriptPath)
+      : readCodexContext(transcriptPath, threadId);
+  const before = transcriptPath && (await readSnapshot());
+  if (!before || !Number.isInteger(before.compactCount))
     throw new Error(
-      "compact requires a discoverable Claude transcript for this tmux pane",
+      `compact requires a discoverable ${cli === "claude" ? "Claude transcript" : "Codex rollout"} for this tmux pane`,
     );
-  await doAskViaTmux(ADAPTERS.claude, {
-    ...opts,
-    ifBusy: "fail",
-    skipContextGuard: true,
-  });
+  let snapshot = before;
+  const done = () => snapshot?.compactCount > before.compactCount;
   const deadline = Date.now() + opts.timeoutMs;
-  do {
-    const snapshot = await readClaudeTranscript(transcriptPath);
-    if (snapshot?.compactCount > before.compactCount) {
-      printJson({
-        cli: "claude",
-        session: opts.session,
-        compacted: true,
-        ...snapshot.compact,
-      });
-      return;
-    }
-    await sleep(
-      Math.min(opts.pollIntervalMs, Math.max(0, deadline - Date.now())),
+  const confirmSubmission = async (visible) => {
+    const submissionDeadline = Math.min(
+      deadline,
+      Date.now() + (cli === "codex" ? 1000 : 5000),
     );
-  } while (Date.now() < deadline);
-  printJson({
-    cli: "claude",
+    do {
+      snapshot = await readSnapshot();
+      if (
+        done() ||
+        (cli === "claude"
+          ? /Compacting conversation/i.test(stripAnsi(visible))
+          : /Compacting context/i.test(stripAnsi(visible)))
+      )
+        return true;
+      await pause(
+        Math.min(
+          opts.pollIntervalMs,
+          Math.max(0, submissionDeadline - Date.now()),
+        ),
+      );
+      visible = await capture(null, opts.session);
+    } while (Date.now() < submissionDeadline);
+    return false;
+  };
+  await doAskViaTmux(
+    adapter,
+    {
+      ...opts,
+      skipBusyCheck: true,
+      skipContextGuard: true,
+      submitAttempts: cli === "codex" ? 2 : 1,
+      confirmSubmission,
+    },
+    deps,
+  );
+  const result = {
+    cli,
     session: opts.session,
-    compacted: false,
-    timedOut: true,
-  });
+    compact: { submitted: true, done: done() },
+    compacted: done(),
+  };
+  if (thenPrompt) {
+    const requestId = randomBytes(6).toString("hex");
+    const thenOpts = {
+      ...opts,
+      prompt: `[tfx-live req=${requestId}]\n${thenPrompt}`,
+      requestId,
+      threadId,
+      noWait: true,
+      settleMs: 0,
+      transport: cli === "codex" ? "queue" : "tmux",
+      skipBusyCheck: true,
+      skipContextGuard: true,
+      queueOnly: true,
+    };
+    try {
+      if (cli === "codex") {
+        const queued = await doAskViaQueue(adapter, thenOpts, deps);
+        // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+        result.then = {
+          ...queued,
+          requestId,
+          queued: queued.inputSent === true,
+        };
+        if (!result.then.queued) {
+          result.ok = false;
+          result.error =
+            queued.status === "unknown"
+              ? `${queued.error}; --then may already be queued, use wait --request-id and do not resend`
+              : queued.error;
+        }
+      } else {
+        await doAskViaTmux(adapter, thenOpts, deps);
+        const queueDeadline = Date.now() + Math.min(opts.timeoutMs, 5000);
+        let confirmedBy;
+        do {
+          const transcript = await readClaudeTranscript(transcriptPath, {
+            requestId,
+          });
+          if (transcript?.enqueued) confirmedBy = "enqueue";
+          else if (transcript?.userSeen) confirmedBy = "user";
+          else if (
+            /queued messages/i.test(
+              stripAnsi(await capture(null, opts.session)),
+            )
+          )
+            confirmedBy = "tui";
+          if (confirmedBy) break;
+          await pause(
+            Math.min(
+              opts.pollIntervalMs,
+              Math.max(0, queueDeadline - Date.now()),
+            ),
+          );
+        } while (Date.now() < queueDeadline);
+        // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+        result.then = {
+          requestId,
+          queued: Boolean(confirmedBy) && confirmedBy !== "user",
+          transport: "tmux",
+          ...(confirmedBy === "user" ? { delivered: true } : {}),
+          ...(confirmedBy ? { confirmedBy } : {}),
+        };
+        if (!confirmedBy) {
+          result.ok = false;
+          result.error =
+            "Claude --then was sent but enqueue could not be confirmed; use wait --request-id, do not resend";
+        }
+      }
+    } catch (error) {
+      // compact 는 이미 제출됐으므로 그 정보를 지우지 않고 then 실패만 결과에 담는다.
+      // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+      result.then = { requestId, queued: false, error: error.message };
+      result.ok = false;
+      result.error = `compact was submitted but --then failed: ${error.message}`;
+    }
+  }
+  if (!Object.hasOwn(flags, "no-wait")) {
+    do {
+      snapshot = await readSnapshot();
+      if (done()) break;
+      await pause(
+        Math.min(opts.pollIntervalMs, Math.max(0, deadline - Date.now())),
+      );
+    } while (Date.now() < deadline);
+    if (!done()) result.timedOut = true;
+  }
+  result.compacted = result.compact.done = done();
+  if (done()) {
+    Object.assign(result, snapshot.compact);
+    Object.assign(result.compact, snapshot.compact);
+  }
+  return result;
 }
 
 function codexGoalStatus(goal) {
@@ -5695,7 +5925,9 @@ async function main() {
   } else if (command === "queue") {
     await queue(flags);
   } else if (command === "compact") {
-    await compact(flags);
+    const result = await doCompact(flags);
+    printJson(result);
+    if (result.ok === false) process.exitCode = 1;
   } else if (command === "goal") {
     printJson(await goal(action, flags));
   } else if (command === "rename") {
@@ -5737,6 +5969,7 @@ export {
   discoverClaudeTmuxSessions,
   discoverCodexTmuxSessions,
   doAskViaTmux,
+  doCompact,
   extractAssistantResponse,
   extractClaudeCompletedTaskListResponse,
   extractResponseSinceMarker,

package/hub/team/claude-transcript.mjs

@@ -272,6 +272,7 @@ export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
             model: state.model,
             measuredAt: state.measuredAt,
           },
+    enqueued: state.queuedContent !== null,
     userSeen: state.userSeen,
     response: state.response,
     error: state.error,

package/hub/team/session-context.mjs

@@ -23,14 +23,21 @@ const MODEL_CONTEXT = [
   },
 ];
 
-export const CONTEXT_THRESHOLDS = {
+const CONTEXT_THRESHOLDS = {
   claude: { warnContextPct: 60, maxContextPct: 90 },
-  codex: { warnContextPct: 15, maxContextPct: 22 },
+  codex: { warnContextPct: 60, maxContextPct: 85 },
 };
+// rollout 실행 창을 못 읽으면 1.05M 표 값이 분모라 실제 창보다 비율이 작게 나온다.
+const CODEX_MODEL_WINDOW_THRESHOLDS = { warnContextPct: 15, maxContextPct: 22 };
 
 const rolloutCache = new Map();
 
-export function modelContext(cli, model, estimatedContextTokens = null) {
+export function modelContext(
+  cli,
+  model,
+  estimatedContextTokens = null,
+  rolloutContextWindow = null,
+) {
   const entry = MODEL_CONTEXT.find(
     (item) => item.cli === cli && item.model.test(model || ""),
   );
@@ -38,18 +45,20 @@ export function modelContext(cli, model, estimatedContextTokens = null) {
   const executionContextLimitTokens =
     cli === "claude" && process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT === "1"
       ? 200_000
-      : null;
-  const effectiveLimit = Math.min(
-    contextLimitTokens ?? Infinity,
-    executionContextLimitTokens ?? Infinity,
-  );
+      : rolloutContextWindow;
+  // Codex 는 rollout 이 보고한 창이 실제 실행 한도라 표 값과 무관하게 그 창을 쓴다.
+  const effectiveLimit =
+    cli === "codex"
+      ? (executionContextLimitTokens ?? contextLimitTokens)
+      : contextLimitTokens &&
+        Math.min(contextLimitTokens, executionContextLimitTokens ?? Infinity);
   return {
     estimatedContextTokens,
     contextLimitTokens,
     contextLimitSource: entry?.source ?? null,
     ...(executionContextLimitTokens ? { executionContextLimitTokens } : {}),
     contextPct:
-      contextLimitTokens && Number.isFinite(estimatedContextTokens)
+      effectiveLimit && Number.isFinite(estimatedContextTokens)
         ? (estimatedContextTokens / effectiveLimit) * 100
         : null,
   };
@@ -60,7 +69,10 @@ export function contextGuard(
   context,
   { warnContextPct, maxContextPct } = {},
 ) {
-  const defaults = CONTEXT_THRESHOLDS[cli];
+  const defaults =
+    cli === "codex" && !context?.executionContextLimitTokens
+      ? CODEX_MODEL_WINDOW_THRESHOLDS
+      : CONTEXT_THRESHOLDS[cli];
   const warn = warnContextPct ?? defaults?.warnContextPct ?? 0;
   const max = maxContextPct ?? defaults?.maxContextPct ?? 0;
   const fields = {
@@ -90,6 +102,7 @@ export function contextGuard(
       inputSent: false,
       hint: "세션을 승계한 뒤 새 세션에 요청하라.",
       ...fields,
+      thresholdPct: max,
     };
   }
   return warn > 0 && fields.contextPct >= warn
@@ -137,12 +150,19 @@ function acceptCodexLine(state, line) {
   } catch {
     return false;
   }
+  if (entry?.type === "compacted") {
+    state.compactCount += 1;
+    state.compact = { preTokens: state.tokens, postTokens: null };
+  }
   if (entry?.type === "turn_context")
     state.model = entry.payload?.model || state.model;
   if (entry?.type === "event_msg" && entry.payload?.type === "token_count") {
     const info = entry.payload.info;
-    if (Number.isFinite(info?.last_token_usage?.total_tokens))
+    if (Number.isFinite(info?.last_token_usage?.total_tokens)) {
       state.tokens = info.last_token_usage.total_tokens;
+      if (state.compact && state.compact.postTokens === null)
+        state.compact.postTokens = state.tokens;
+    }
     if (Number.isFinite(info?.model_context_window))
       state.executionContextLimitTokens = info.model_context_window;
   }
@@ -172,6 +192,8 @@ export async function readCodexContext(rolloutPath, threadId) {
       decoder: new StringDecoder("utf8"),
       model: null,
       tokens: null,
+      compactCount: 0,
+      compact: null,
       executionContextLimitTokens: null,
     };
   }
@@ -197,8 +219,15 @@ export async function readCodexContext(rolloutPath, threadId) {
   state.mtimeMs = stat.mtimeMs;
   rolloutCache.set(rolloutPath, state);
   return {
-    ...modelContext("codex", state.model, state.tokens),
+    ...modelContext(
+      "codex",
+      state.model,
+      state.tokens,
+      state.executionContextLimitTokens,
+    ),
     model: state.model,
+    compactCount: state.compactCount,
+    compact: state.compact,
     executionContextLimitTokens: state.executionContextLimitTokens,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.62.0",
+  "version": "10.64.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/scripts/pack.mjs

@@ -120,42 +120,54 @@ function buildFileSet(baseDir) {
 }
 
 /**
- * remote 패키지 내 .mjs 파일에서 core 모듈을 참조하는 상대 import를
- * @triflux/core 패키지 경로로 리라이팅한다.
+ * remote 패키지 내 .mjs 파일 하나에서 core 모듈을 참조하는 상대 import를
+ * @triflux/core 패키지 경로로 리라이팅한다. release:check-mirror 도 이 함수로 기대본을 만든다.
  */
+export function rewriteRemoteSource(
+  content,
+  filePath,
+  remotePkgDir,
+  corePkgDir,
+  coreFiles = buildFileSet(corePkgDir),
+) {
+  let rewrites = 0;
+  const rewriteRelativeSpecifier = (match, pre, importPath, post) => {
+    const resolved = normalize(join(dirname(filePath), importPath));
+    // import 대상이 remote 패키지 내에 있으면 그대로 유지
+    if (existsSync(resolved)) return match;
+    // core 패키지에 동일 상대경로로 존재하는지 확인
+    const relToRemote = relative(remotePkgDir, resolved).replace(/\\/g, "/");
+    const coreEquiv = normalize(join(corePkgDir, relToRemote));
+    if (coreFiles.has(coreEquiv)) {
+      rewrites++;
+      return `${pre}@triflux/core/${relToRemote}${post}`;
+    }
+    return match;
+  };
+
+  const rewritten = content
+    .replace(/(from\s+['"])(\.[^'"]+)(['"])/g, rewriteRelativeSpecifier)
+    .replace(
+      /(import\(\s*['"])(\.[^'"]+)(['"]\s*\))/g,
+      rewriteRelativeSpecifier,
+    );
+  return { content: rewritten, rewrites };
+}
+
 function rewriteRemoteImports(remotePkgDir, corePkgDir) {
   const coreFiles = buildFileSet(corePkgDir);
   let totalRewrites = 0;
 
   for (const filePath of walkMjs(remotePkgDir)) {
-    let content = readFileSync(filePath, "utf8");
-    let changed = false;
-
-    const rewriteRelativeSpecifier = (match, pre, importPath, post) => {
-      const resolved = normalize(join(dirname(filePath), importPath));
-      // import 대상이 remote 패키지 내에 있으면 그대로 유지
-      if (existsSync(resolved)) return match;
-      // core 패키지에 동일 상대경로로 존재하는지 확인
-      const relToRemote = relative(remotePkgDir, resolved).replace(/\\/g, "/");
-      const coreEquiv = normalize(join(corePkgDir, relToRemote));
-      if (coreFiles.has(coreEquiv)) {
-        changed = true;
-        totalRewrites++;
-        return `${pre}@triflux/core/${relToRemote}${post}`;
-      }
-      return match;
-    };
-
-    content = content.replace(
-      /(from\s+['"])(\.[^'"]+)(['"])/g,
-      rewriteRelativeSpecifier,
+    const { content, rewrites } = rewriteRemoteSource(
+      readFileSync(filePath, "utf8"),
+      filePath,
+      remotePkgDir,
+      corePkgDir,
+      coreFiles,
     );
-    content = content.replace(
-      /(import\(\s*['"])(\.[^'"]+)(['"]\s*\))/g,
-      rewriteRelativeSpecifier,
-    );
-
-    if (changed) writeFileSync(filePath, content);
+    if (rewrites > 0) writeFileSync(filePath, content);
+    totalRewrites += rewrites;
   }
 
   return totalRewrites;

package/scripts/release/check-packages-mirror.mjs

@@ -19,7 +19,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CORE_ENTRIES } from "../pack.mjs";
+import { CORE_ENTRIES, rewriteRemoteSource } from "../pack.mjs";
 
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_REPO_ROOT = join(SCRIPT_DIR, "..", "..");
@@ -77,6 +77,7 @@ function walkRelFiles(root, skipRels = new Set()) {
 // the two drift classes that shipped silently in v10.33.0: a broken remote
 // import (relative specifier to a core-only module) and a stale non-JS asset
 // (the tray UI), neither of which the triflux/core byte-mirror check can see.
+// .mjs 본문도 pack:remote 리라이트를 거친 root 와 비교한다. 해석만 보면 옛 구현이 남아도 OK 였다.
 const REMOTE_NON_MIRROR = new Set([
   "package.json",
   "package-lock.json",
@@ -99,16 +100,12 @@ function extractImportSpecifiers(content) {
   return specs;
 }
 
-function restoreRemoteCoreHubImports(content) {
-  return content
-    .replace(
-      /(from\s+["'])@triflux\/core\/hub\/([^"']+)(["'])/g,
-      "$1../../hub/$2$3",
-    )
-    .replace(
-      /(import\(\s*["'])@triflux\/core\/hub\/([^"']+)(["']\s*\))/g,
-      "$1../../hub/$2$3",
-    );
+function firstDiffLine(expected, actual) {
+  const a = expected.split("\n");
+  const b = actual.split("\n");
+  let i = 0;
+  while (a[i] === b[i]) i++;
+  return `line ${i + 1}: root ${JSON.stringify(a[i] ?? "<EOF>")} / remote ${JSON.stringify(b[i] ?? "<EOF>")}`;
 }
 
 function checkRemoteMirror(repoRoot) {
@@ -140,15 +137,21 @@ function checkRemoteMirror(repoRoot) {
           });
         }
       }
-      if (rel.startsWith("scripts/lib/")) {
-        const rootPath = join(repoRoot, rel);
-        if (
-          existsSync(rootPath) &&
-          !readFileSync(rootPath).equals(
-            Buffer.from(restoreRemoteCoreHubImports(content)),
-          )
-        ) {
-          issues.push({ path: displayPath, kind: "remote-content-diff" });
+      const rootPath = join(repoRoot, rel);
+      if (existsSync(rootPath)) {
+        // pack:remote 와 같은 리라이트를 root 원본에 적용한 기대본과 비교한다.
+        const { content: expected } = rewriteRemoteSource(
+          readFileSync(rootPath, "utf8"),
+          remotePath,
+          remoteRoot,
+          coreRoot,
+        );
+        if (content !== expected) {
+          issues.push({
+            path: displayPath,
+            kind: "remote-content-diff",
+            detail: firstDiffLine(expected, content),
+          });
         }
       }
     } else {
@@ -329,13 +332,14 @@ function main() {
       }
     } else {
       console.log(
-        "Mirror OK — packages/triflux + packages/core (byte) and packages/remote (imports + assets) match root",
+        "Mirror OK — packages/triflux + packages/core (byte) and packages/remote (import-normalized content) match root",
       );
     }
   } else {
     console.log(`Mirror mismatch (${result.issues.length} issues):`);
     for (const i of result.issues) {
       console.log(`  ${i.kind.padEnd(18)} ${i.path}`);
+      if (i.detail) console.log(`    ${i.detail}`);
     }
     if (result.fixed.length > 0) {
       console.log(`Fixed during run (${result.fixed.length}):`);

package/skills/tfx-live/SKILL.md

@@ -29,6 +29,8 @@ macOS의 iTerm2에서 로컬 tmux 세션을 `start`하면 리드가 있는 창
 
 새 세션 이름은 `<월>.<일> <주제>`로 짓는다. `start --name`을 생략하면 자동으로 만들고 `nameGenerated: true`를 보고한다. `--resume` 또는 `--resume-last`는 `--name`을 명시한 경우에만 이름을 적용한다. 승계 세션에는 기존 이름 뒤에 ` 2`, 이후 ` 3`을 붙인다. 이름 적용을 요청한 경우 결과의 `nameApplied: false`는 미적용을 뜻한다. agy의 `namePending: true`는 첫 일반 ask에서 적용할 이름이 보류됐다는 뜻이다. 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 "<이름>"`으로 이름을 바꾼다.
 
+Codex 폴더 신뢰 화면이나 Claude 프로젝트 MCP 승인 화면이 뜨면 `start`는 화면에 답하지 않고 `ready: false`, `blockedBy`(`codex-trust-folder` 또는 `claude-mcp-approval`), 할 일을 적은 `warning`을 반환한다. 세션은 남아 있으므로 tmux 세션에 붙어 직접 고른 뒤 지시를 보낸다.
+
 ## agy 세션
 
 ```bash
@@ -53,11 +55,13 @@ agy `ask`의 기본 `--if-busy queue`는 바쁜 턴에도 바로 전송한다. a
 
 | 동작 | 적용 조건과 실행 |
 | --- | --- |
-| compact | 같은 목표와 담당이 이어지고 파일과 git에서 상태를 복구할 수 있을 때. Claude는 `tfx-live compact` 또는 `/compact <보존 지침>`, Codex는 `/compact` 뒤 리드가 파일 경로와 검증 명령을 다시 전달한다. agy는 수동 compact가 없어 handoff한다. |
+| compact | 같은 목표와 담당이 이어지고 파일과 git에서 상태를 복구할 수 있을 때. Claude와 Codex는 `tfx-live compact --then "다음 지시" --no-wait`로 압축 제출을 확인하고 다음 지시를 미리 넣는다. 압축 뒤에 필요한 파일 경로와 검증 명령도 `--then`에 싣는다. agy는 수동 compact가 없어 handoff한다. |
 | clear | 무관한 작업으로 전환하거나 같은 문제를 두 번 넘게 고쳐도 실패할 때, 스펙에서 구현으로 또는 작성자에서 리뷰어로 바뀔 때. 미완료 상태를 정리한 뒤 Claude는 `/rename`과 `/clear`, Codex는 작업 종료 뒤 `/new <이름>`, agy는 `/clear`를 쓴다. |
 | handoff | 담당·CLI·모델·소유자가 바뀌거나 긴 작업이 창을 넘길 때. 인계 파일에 목표, 완료 조건, 체크아웃과 변경 상태, 확정 결정, 증거 경로, PASS/FAIL/SKIP, 미완료 작업과 프로세스, 다음 행동과 소유자, `predecessorSessionId`를 적는다. 승계 세션이 경로를 확인하면 이전 세션을 닫는다. |
 | close | 결과와 인계를 확인한 즉시 닫는다. Claude 백그라운드는 `claude stop <id>`, tmux는 `tfx-live stop --session`, Claude 팀원은 shutdown, Codex 서브에이전트는 `close_agent`, agy 서브에이전트는 `/agents` 패널의 K를 쓴다. |
 
+Claude TUI는 바쁠 때 들어온 입력을 대기열에 넣고 현재 턴(압축 포함)이 끝나면 순서대로 처리한다. transcript에는 `queue-operation`의 `enqueue`와 `dequeue`로 남는다. Codex app-server 큐도 바쁜 턴 뒤에 순서대로 처리한다. 리드는 compact를 보내고 `--then`으로 다음 지시를 넣는 것을 기본 절차로 쓴다.
+
 두 번째 compact 전에는 handoff가 맞는지 점검한다. compact 횟수는 고정하지 않는다.
 
 리드 역할 절차(역할별 모델, 지시서, 교차 리뷰, 릴리스 조율)는 `tfx-lead` 스킬을 따른다.
@@ -99,30 +103,37 @@ Claude와 Codex는 네이티브 goal을 우선 쓰고, goal-driven은 agy처럼
 
 ### 컨텍스트 판단
 
-분모는 공식 모델 창이고 실행 한도가 더 작으면 그 한도 아래에서 운영한다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
+Claude의 분모는 공식 모델 창과 실행 한도 중 작은 값이다. Codex의 분모는 rollout이 보고한 실행 창이고, 없을 때만 공식 창이다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
 
 | CLI | 준비와 경고 | compact | 신규 배정 중지·handoff | 전송 거부 |
 | --- | ---: | ---: | ---: | ---: |
 | Claude Code 1M 모델 | 60% | 75% | 85% | 90% |
-| Codex | 15% | 18% | 20% | 22% |
+| Codex rollout 실행 창 | 60% | - | - | 85% |
+| Codex 실행 창 없음(1.05M 분모) | 15% | 18% | 20% | 22% |
 | agy | 12% | 없음 | 15% | 18% |
 
-Claude는 85% 도달 시 바로 handoff를 지시한다. agy 행은 운영 지침이며 agy도 `tfx-live` 전송 대상이지만 컨텍스트 비율은 자동으로 읽지 못해 `null`로 보고하고 가드를 건너뛴다. `model_context_window`와 `model_auto_compact_token_limit`은 올리지 않는다.
+Claude는 85% 도달 시 바로 handoff를 지시한다. Codex 실행 창 행의 compact와 handoff 비율은 아직 정하지 않았다. agy 행은 운영 지침이며 agy도 `tfx-live` 전송 대상이지만 컨텍스트 비율은 자동으로 읽지 못해 `null`로 보고하고 가드를 건너뛴다. `model_context_window`와 `model_auto_compact_token_limit`은 올리지 않는다.
 
-결과에는 `estimatedContextTokens`, `contextLimitTokens`, `contextLimitSource`, `contextPct`가 포함된다. Claude 실행 한도는 `executionContextLimitTokens`로 별도 보고하며 `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`이면 200,000이다. 판정에는 공식 창과 실행 한도 중 작은 값을 쓴다. 한도를 모르면 비율은 `null`로 두고 경고만 한다. 사용량이 없는 `probe`는 `context: null`이다. 컨텍스트를 확인하려면 직접 `tfx-live probe`를 실행한다. `interrupt`, 자동 `ask`의 daemon probe, `stop --short`는 transcript를 읽지 않는다.
+결과에는 `estimatedContextTokens`, `contextLimitTokens`, `contextLimitSource`, `contextPct`가 포함된다. Claude 실행 한도는 `executionContextLimitTokens`로 별도 보고하며 `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`이면 200,000이다. Codex는 rollout `token_count`의 `model_context_window`를 `executionContextLimitTokens`로 보고한다. 이 값이 있으면 모델 표에 없는 모델이라도 그 창으로 판정하고, 없으면 1,050,000 표 값을 분모로 쓴다. 한도를 모르면 비율은 `null`로 두고 경고만 한다. 사용량이 없는 `probe`는 `context: null`이다. 컨텍스트를 확인하려면 직접 `tfx-live probe`를 실행한다. `interrupt`, 자동 `ask`의 daemon probe, `stop --short`는 transcript를 읽지 않는다.
 
-`ask`의 `--warn-context-pct`와 `--max-context-pct`는 경고·거부 비율을 덮어쓰며 0이면 해당 가드를 끈다. 기본값은 표의 경고·전송 거부 열이다. 거부 결과는 `status: "failed"`, `done: false`, `context-limit`와 컨텍스트 필드를 돌려준다. 자세한 근거와 실측은 [컨텍스트 정책 연구](../../docs/research/tfx-live-context-policy-2026-10.md)에 둔다.
+`ask`의 `--warn-context-pct`와 `--max-context-pct`는 경고·거부 비율을 덮어쓰며 0이면 해당 가드를 끈다. 기본값은 표의 경고·전송 거부 열이다. Codex는 `executionContextLimitTokens`가 있으면 실행 창 행을, 없으면 1.05M 분모 행을 쓴다. 거부 결과는 `status: "failed"`, `done: false`, `context-limit`, 컨텍스트 필드와 적용한 거부 비율 `thresholdPct`를 돌려준다. 경고의 `thresholdPct`는 적용한 경고 비율이다. 자세한 근거와 실측은 [컨텍스트 정책 연구](../../docs/research/tfx-live-context-policy-2026-10.md)에 둔다.
 
 ### 수동 compact와 종료
 
 ```bash
-tfx-live compact --cli claude --session cl1 --instructions "변경 파일과 검증 명령을 보존하라" --timeout 120
+tfx-live compact --cli claude --session cl1 --instructions "변경 파일과 검증 명령을 보존하라" --then "인계 파일을 읽고 검증을 이어가라" --no-wait
+tfx-live compact --cli codex --session cx1 --then "src/main.mjs를 확인하고 지정된 단위 테스트를 실행하라" --no-wait
+tfx-live wait --cli codex --session cx1 --request-id <then.requestId> --timeout 120
 tfx-live stop --cli claude --short <8hex>
 tfx-live stop --cli claude --session-id <id>
 tfx-live stop --session cl1
 ```
 
-`compact`는 로컬 Claude tmux `--session`에서 `/compact <instructions>`를 중계 표식 없이 보낸다. 기본 `--if-busy fail`이며 바쁜 세션에는 전송하지 않는다. 새 `compact_boundary`를 확인하면 `compacted: true`, `preTokens`, `postTokens`를 반환한다. 시간 안에 없으면 `compacted: false, timedOut: true`다. UDS compact는 지원하지 않는다.
+`compact --session S [--cli claude|codex] [--instructions TEXT] [--then PROMPT] [--no-wait]`는 로컬 tmux에서 `/compact`를 중계 표식 없이 보낸다. CLI 기본값은 Claude다. `--instructions`는 Claude에서만 받으며 Codex는 인자를 받지 않아 거부한다. 기본 `--if-busy fail`이며 바쁜 세션에는 compact를 전송하지 않는다. UDS compact는 지원하지 않는다.
+
+`--no-wait`는 압축 진행 표시 또는 새 완료 기록으로 제출을 확인한 뒤 반환한다. Codex에서 확인되지 않으면 Enter를 한 번 더 보내고, 그래도 확인되지 않으면 `--then`을 보내지 않고 오류로 끝낸다. `--then`은 일반 텍스트 지시만 받으며 슬래시 명령은 거부한다. 제출 확인 직후 Claude에는 표식을 붙여 tmux로 보내고 화면의 `queued messages` 또는 transcript의 `enqueue`로 확인한다. Claude 압축이 먼저 끝나 지시가 이미 처리에 들어갔으면 `then.queued: false, delivered: true`로 보고한다. Codex에는 기존 queue 경로로만 보내며 tmux로 전환하지 않는다. 결과의 `then.requestId`로 `wait --request-id`에서 압축 뒤 응답을 받는다.
+
+`--no-wait`가 없으면 Claude의 새 `compact_boundary`, Codex rollout의 새 `compacted`까지 기다린다. 결과에 `compact: {submitted: true, done}`과 `then: {requestId, queued, transport}`를 추가하고 기존 `compacted`, `preTokens`, `postTokens`를 유지한다. 토큰 수는 기록에 있는 값만 보고하며 Codex의 압축 후 token_count가 아직 없으면 `postTokens`는 `null`이다. 시간 안에 완료 기록이 없으면 `compacted: false, timedOut: true`다.
 
 `stop --short`와 `stop --session-id`는 `claude stop <id>`를 호출하고 `stopped: true, conversationKept: true`를 반환한다. `claude attach`로 대화를 재개할 수 있다. `/exit`, `←`, Ctrl+Z는 백그라운드 세션의 연결만 끊는다. macOS의 `sysctl -n kern.memorystatus_vm_pressure_level`이 2 이상이면 새 세션을 띄우기 전 정리한다. 원격 배정 전에는 `tfx-remote probe <host>`의 `ready`와 `warnings`를 확인한다.