triflux 10.62.0 → 10.63.0

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

@@ -57,11 +57,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` 스킬을 따른다.
@@ -120,13 +122,19 @@ Claude는 85% 도달 시 바로 handoff를 지시한다. agy 행은 운영 지
 ### 수동 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

@@ -108,7 +108,7 @@ function usage(command) {
     "  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]",
+    "  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]",
@@ -2941,7 +2941,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 +2961,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 +2974,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 +3000,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 +3038,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 +3048,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 +3116,7 @@ async function doAskViaTmux(adapter, opts) {
               pollIntervalMs,
             );
             if (nameApplied)
-              await runTmux(null, [
+              await tmux(null, [
                 "set-option",
                 "-u",
                 "-t",
@@ -3102,7 +3125,7 @@ async function doAskViaTmux(adapter, opts) {
               ]);
             break;
           }
-          await sleep(Math.min(pollIntervalMs, 200));
+          await pause(Math.min(pollIntervalMs, 200));
         }
       } catch {
         nameApplied = false;
@@ -3160,8 +3183,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 +3207,7 @@ async function doAskViaTmux(adapter, opts) {
       quietPolls >= FALLBACK_QUIET_POLLS &&
       hasTmuxAssistantResponseAfterCurrentPrompt(
         adapter,
-        await capturePane(remote, session),
+        await captureHistory(remote, session),
         prompt,
         beforeRaw,
       );
@@ -3193,10 +3216,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 +3435,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 +4401,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 +5860,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 +5904,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

@@ -137,12 +137,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 +179,8 @@ export async function readCodexContext(rolloutPath, threadId) {
       decoder: new StringDecoder("utf8"),
       model: null,
       tokens: null,
+      compactCount: 0,
+      compact: null,
       executionContextLimitTokens: null,
     };
   }
@@ -199,6 +208,8 @@ export async function readCodexContext(rolloutPath, threadId) {
   return {
     ...modelContext("codex", state.model, state.tokens),
     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.63.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/skills/tfx-live/SKILL.md

@@ -53,11 +53,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` 스킬을 따른다.
@@ -116,13 +118,19 @@ Claude는 85% 도달 시 바로 handoff를 지시한다. agy 행은 운영 지
 ### 수동 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`를 확인한다.