@triflux/core 10.87.0 → 10.88.1

package/hub/team/pane.mjs

@@ -4,6 +4,7 @@ import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { judgeComposerState } from "../lib/jev-addon.mjs";
 import { privateTmpDir } from "../lib/private-tmp.mjs";
 import { psmuxExec } from "./psmux.mjs";
 import { detectMultiplexer, tmuxExec } from "./session.mjs";
@@ -251,6 +252,104 @@ export function submitPromptWithVerification({
   }
 }
 
+/**
+ * 결정론적 컴포저 상태 판정이 모호할 때 Jev로 컴포저 상태를 판별해 Enter 재전송 여부를 결정한다.
+ */
+export async function submitPromptWithJevVerification({
+  cli = "claude",
+  prompt = "",
+  capture,
+  sendEnter,
+  sleep = sleepMs,
+  settleMs = PASTE_SETTLE_MS,
+  retryLimit = SUBMIT_RETRY_LIMIT,
+  jevOptions = {},
+} = {}) {
+  const strictVerification = isAntigravityCli(cli);
+  const promptPrefix = promptComposerNeedle(prompt);
+  const isConfirmedSubmitted = (text) => {
+    if (!promptPrefix) return true;
+    if (!text) return !strictVerification;
+    if (hasBusyMarkerOutsideComposer(text)) return true;
+    const state = composerPromptState(text, promptPrefix);
+    if (state === "absent") return true;
+    if (state === "unknown" && !strictVerification) return true;
+    return false;
+  };
+
+  try {
+    submitPromptWithVerification({
+      cli,
+      prompt,
+      capture,
+      sendEnter,
+      sleep,
+      settleMs,
+      retryLimit,
+    });
+  } catch (err) {
+    const capturedText =
+      typeof capture === "function" ? String(capture() ?? "") : "";
+    const verdict = await judgeComposerState(
+      { capturedText, promptPrefix },
+      jevOptions,
+    );
+    if (verdict?.state === "submitted_running") {
+      return { submitted: true, jevState: verdict.state };
+    }
+    if (
+      verdict?.state === "stuck_in_composer" &&
+      typeof sendEnter === "function"
+    ) {
+      sendEnter();
+      sleep(400);
+      const afterText =
+        typeof capture === "function" ? String(capture() ?? "") : "";
+      if (isConfirmedSubmitted(afterText)) {
+        return { submitted: true, jevState: "submitted_running" };
+      }
+      const postVerdict = await judgeComposerState(
+        { capturedText: afterText, promptPrefix },
+        jevOptions,
+      );
+      if (postVerdict?.state === "submitted_running") {
+        return { submitted: true, jevState: postVerdict.state };
+      }
+    }
+    throw err;
+  }
+  const capturedText =
+    typeof capture === "function" ? String(capture() ?? "") : "";
+  const verdict = await judgeComposerState(
+    { capturedText, promptPrefix },
+    jevOptions,
+  );
+  if (
+    verdict?.state === "stuck_in_composer" &&
+    typeof sendEnter === "function"
+  ) {
+    sendEnter();
+    sleep(400);
+    const afterText =
+      typeof capture === "function" ? String(capture() ?? "") : "";
+    if (isConfirmedSubmitted(afterText)) {
+      return { submitted: true, jevState: "submitted_running" };
+    }
+    const postVerdict = await judgeComposerState(
+      { capturedText: afterText, promptPrefix },
+      jevOptions,
+    );
+    return {
+      submitted: postVerdict?.state === "submitted_running",
+      jevState: postVerdict?.state || verdict.state,
+    };
+  }
+  return {
+    submitted: verdict?.state !== "modal_blocking",
+    jevState: verdict?.state || null,
+  };
+}
+
 function confirmSubmit(target, prompt, cli, sendEnter) {
   submitPromptWithVerification({
     cli,

package/hub/team/retry-state-machine.mjs

@@ -31,6 +31,7 @@ import {
   resolveCodexModelEffort,
 } from "../../scripts/lib/model-effort.mjs";
 import { AGY_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
+import { judgeSameFailureCause } from "../lib/jev-addon.mjs";
 
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
@@ -126,10 +127,14 @@ export function createRetryStateMachine(options = {}) {
     return transition(STATES.DONE);
   }
 
-  function reportVerifyFail(failureReason) {
+  function reportVerifyFail(failureReason, failOptions = {}) {
     const reason = String(failureReason || "unknown");
-    if (reason === state.lastFailureReason) {
+    const isSameCause =
+      reason === state.lastFailureReason ||
+      (Boolean(state.lastFailureReason) && failOptions.sameCause === true);
+    if (isSameCause) {
       state.stuckCounter += 1;
+      state.lastFailureReason = reason;
     } else {
       state.stuckCounter = 1;
       state.lastFailureReason = reason;
@@ -155,6 +160,20 @@ export function createRetryStateMachine(options = {}) {
     return transition(STATES.DIAGNOSING, { reason });
   }
 
+  async function reportVerifyFailAsync(failureReason, jevOptions = {}) {
+    const reason = String(failureReason || "unknown");
+    let sameCause = false;
+    if (state.lastFailureReason && reason !== state.lastFailureReason) {
+      const verdict = await judgeSameFailureCause(
+        state.lastFailureReason,
+        reason,
+        jevOptions,
+      );
+      sameCause = verdict?.sameCause === true;
+    }
+    return reportVerifyFail(reason, { sameCause });
+  }
+
   function escalate() {
     if (state.cliIndex + 1 >= state.cliChain.length) {
       return transition(STATES.BUDGET_EXCEEDED, {
@@ -271,6 +290,7 @@ export function createRetryStateMachine(options = {}) {
     startIteration,
     reportVerifySuccess,
     reportVerifyFail,
+    reportVerifyFailAsync,
     escalate,
     on,
     serialize,

package/hud/hud-qos-status.mjs

@@ -52,8 +52,14 @@ import {
   getProviderRow,
   renderAlignedRows,
 } from "./renderers.mjs";
+import { sessionStatus } from "./session-status.mjs";
 import { selectTier } from "./terminal.mjs";
-import { formatTimeCell, formatTimeCellDH, readStdinJson } from "./utils.mjs";
+import {
+  formatTimeCell,
+  formatTimeCellDH,
+  readStdinJson,
+  stripAnsi,
+} from "./utils.mjs";
 
 async function main() {
   if (process.argv.includes(CLAUDE_REFRESH_FLAG)) {
@@ -74,7 +80,12 @@ async function main() {
   const stdin = await readStdinJson();
   // agy statusLine 은 같은 HUD 를 호출하되 product 로 자신을 밝히고 터미널 폭을 직접 넘긴다.
   const agySession = stdin?.product === "antigravity";
-  if (agySession) {
+  const codexSession = stdin?.product === "codex";
+  const cacheOnly = process.argv.includes("--cache-only");
+  const status = await sessionStatus(stdin);
+  const currentMarker = agySession ? "a" : codexSession ? "x" : "c";
+  const jevMarker = codexSession ? "c" : "x";
+  if (agySession || codexSession) {
     if (stdin.terminal_width > 0)
       process.env.COLUMNS = String(stdin.terminal_width);
   } else {
@@ -94,16 +105,23 @@ async function main() {
   const antigravitySnapshot = antigravityAllowed
     ? readAntigravityQuotaSnapshot()
     : null;
-  if (antigravitySnapshot?.shouldRefresh) scheduleAntigravityQuotaRefresh();
+  if (!cacheOnly && antigravitySnapshot?.shouldRefresh)
+    scheduleAntigravityQuotaRefresh();
   // 설정이 없는 홈에서는 갱신 프로세스를 시작하지 않는다.
   if (
+    !cacheOnly &&
     !stdinClaudeUsage &&
     claudeUsageSnapshot.shouldRefresh &&
     existsSync(join(homedir(), ".claude"))
   ) {
     scheduleClaudeUsageRefresh();
   }
-  if (showCodex && codexSnapshot.shouldRefresh && existsSync(getCodexHome())) {
+  if (
+    !cacheOnly &&
+    showCodex &&
+    codexSnapshot.shouldRefresh &&
+    existsSync(getCodexHome())
+  ) {
     scheduleCodexRateLimitRefresh();
   }
 
@@ -127,6 +145,9 @@ async function main() {
       codexLoggedOut,
       showAntigravity: antigravityAllowed,
       antigravityQuota,
+      sessionStatus: status,
+      currentMarker,
+      jevMarker,
     });
     const header = bandMode ? `${BAND_HEADER}\n` : "";
     process.stdout.write(`${header}\x1b[0m${microLine}\n`);
@@ -136,15 +157,10 @@ async function main() {
   const rows =
     bandState === "claude"
       ? []
-      : getClaudeRows(
-          currentTier,
-          agySession ? null : contextView,
-          claudeUsage,
-          {
-            accountName: getClaudeEmail(),
-            promptCache: stdin?.prompt_cache,
-          },
-        );
+      : getClaudeRows(currentTier, null, claudeUsage, {
+          accountName: getClaudeEmail(),
+          promptCache: stdin?.prompt_cache,
+        });
   let codexRowIndex = -1;
   if (showCodex) {
     codexRowIndex = rows.length;
@@ -169,11 +185,20 @@ async function main() {
         geminiBlue,
         antigravityQuota,
         getAntigravityAccountLabel(),
-        { contextView: agySession ? contextView : null },
       ),
     );
   }
 
+  for (const row of rows) {
+    const marker = stripAnsi(row.prefix);
+    const extra =
+      marker === `${currentMarker}:`
+        ? status.context
+        : marker === `${jevMarker}:`
+          ? status.jev
+          : "";
+    if (extra) row.right = [row.right, extra].filter(Boolean).join(" ");
+  }
   const outputLines = renderAlignedRows(rows);
   if (outputLines[codexRowIndex] != null && codexLoggedOut) {
     outputLines[codexRowIndex] = `${DIM}${outputLines[codexRowIndex]}${RESET}`;
@@ -181,7 +206,11 @@ async function main() {
   // 알림 배너와 TUI 스타일이 HUD 내용에 겹치지 않도록 한다. band 는 자기 자리에 그리니 띄우지 않는다.
   // agy 는 statusLine.padding 이 같은 역할을 한다.
   const leadingBreaks =
-    bandMode || agySession ? "" : contextView.percent >= 85 ? "\n\n" : "\n";
+    bandMode || agySession || codexSession
+      ? ""
+      : contextView.percent >= 85
+        ? "\n\n"
+        : "\n";
   const resetLines = outputLines.map((line) => `\x1b[0m${line}`);
   // band 는 첫 줄 표지로 이 HUD 가 --band 를 아는지 확인한다.
   const header = bandMode ? `${BAND_HEADER}\n` : "";
@@ -190,7 +219,7 @@ async function main() {
 
 main().catch(() => {
   process.stdout.write(
-    `\x1b[0m${bold(claudeOrange("c"))}: ${dim(`5h:--% ${formatTimeCell("")} 1w:--% ${formatTimeCellDH("")} | ctx:--%`)}\n`,
+    `\x1b[0m${bold(claudeOrange("c"))}: ${dim(`5h:--% ${formatTimeCell("")} 1w:--% ${formatTimeCellDH("")} | ctx:--`)}\n`,
   );
 });
 

package/hud/renderers.mjs

@@ -24,7 +24,6 @@ import {
   SEVEN_DAY_MS,
   TIME_CELL_INNER_WIDTH,
 } from "./constants.mjs";
-import { buildContextUsageView } from "./context-monitor.mjs";
 import { cacheGap, claudePromptCache } from "./prompt-cache.mjs";
 import { getTerminalColumns, tierBar, tierDimBar } from "./terminal.mjs";
 import {
@@ -91,7 +90,7 @@ export function getMicroLine(
     showAntigravity = true,
     codexLoggedOut = false,
   } = options;
-  const ctxView = contextView || buildContextUsageView({});
+
   // Claude 5h/1w
   const cF =
     claudeUsage?.fiveHourPercent != null
@@ -144,7 +143,18 @@ export function getMicroLine(
       : agyText;
     segments.push(`${marker}${dim(":")}${agyValue}`);
   }
-  segments.push(`${dim("ctx:")}${contextPercentText(ctxView)}`);
+  if (options.sessionStatus) {
+    for (let index = 0; index < segments.length; index += 1) {
+      const marker = stripAnsi(segments[index]).split(":")[0];
+      const extra =
+        marker === options.currentMarker
+          ? options.sessionStatus.context
+          : marker === options.jevMarker
+            ? options.sessionStatus.jev
+            : "";
+      if (extra) segments[index] += ` ${extra}`;
+    }
+  }
   return truncateAnsi(segments.join(" "), cols);
 }
 

package/hud/session-status.mjs

@@ -0,0 +1,46 @@
+import { buildContextUsageView } from "./context-monitor.mjs";
+import { clampPercent } from "./utils.mjs";
+
+export async function sessionStatus(stdin, env = process.env) {
+  let jev = "";
+  try {
+    const { isJevEnabled } = await import("../hub/lib/jev-addon.mjs");
+    jev = isJevEnabled({ env }) ? "j" : "";
+  } catch {
+    // 설정을 판정하지 못한 것은 런타임 호출 실패의 증거가 아니다.
+  }
+  const window = stdin?.context_window;
+  const view = buildContextUsageView(stdin);
+  const usageValues = Object.entries(window?.current_usage || {})
+    .filter(([key]) =>
+      [
+        "total_tokens",
+        "input_tokens",
+        "cache_creation_input_tokens",
+        "cache_read_input_tokens",
+      ].includes(key),
+    )
+    .map(([, value]) => value);
+  const hasUsage =
+    usageValues.length > 0 &&
+    usageValues.every((value) => Number.isFinite(value) && value >= 0);
+  const hasWindow =
+    Number.isFinite(window?.context_window_size) &&
+    window.context_window_size > 0;
+  const knownZero = hasUsage && usageValues.every((value) => value === 0);
+  let context = "ctx:--";
+  if (hasWindow && hasUsage && (knownZero || view.source === "stdin.tokens")) {
+    const used = knownZero ? 0 : view.usedTokens;
+    context = `ctx:${clampPercent((used / window.context_window_size) * 100)}%`;
+  } else if (
+    !(stdin?.product === "antigravity" && window?.context_window_size === 0)
+  ) {
+    const used = Number.isFinite(window?.used_percentage)
+      ? clampPercent(window.used_percentage)
+      : Number.isFinite(window?.remaining_percentage)
+        ? 100 - clampPercent(window.remaining_percentage)
+        : null;
+    if (used != null) context = `ctx:${used}%`;
+  }
+  return { context, jev };
+}

package/hud/tmux-status.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { readCodexContext } from "../hub/team/session-context.mjs";
+import { stripAnsi } from "./utils.mjs";
+
+const exec = promisify(execFile);
+const quote = (value) => `'${String(value).replace(/'/g, `'"'"'`)}'`;
+
+export async function configureCodexHud(runTmux, target, env = process.env) {
+  // 기존 서버가 다른 홈에서 시작됐어도 신규 세션의 HUD는 실행자의 환경을 따른다.
+  for (const key of [
+    "HOME",
+    "CODEX_HOME",
+    "XDG_CONFIG_HOME",
+    "XDG_STATE_HOME",
+    "PATH",
+    "TFX_JEV",
+    "TFX_JEV_CLI",
+    "JEV_API_KEY",
+    "TYPESAFE_API_KEY",
+    "TFX_DISABLE_CODEX",
+    "TFX_DISABLE_ANTIGRAVITY",
+    "TFX_MACHINE_PROFILE_PATH",
+  ]) {
+    try {
+      await runTmux(null, [
+        "set-environment",
+        "-t",
+        target,
+        ...(env[key] == null ? ["-r", key] : [key, env[key]]),
+      ]);
+    } catch {
+      // execFile의 오류 문자열에 환경변수 값이 포함되지 않게 한다.
+      throw new Error(`Codex HUD environment setup failed: ${key}`);
+    }
+  }
+  const { stdout } = await runTmux(null, [
+    "display-message",
+    "-p",
+    "-t",
+    target,
+    "#{session_id}|#{pane_id}",
+  ]);
+  const [sessionId, paneId] = stdout.trim().split("|");
+  if (!/^\$\d+$/.test(sessionId) || !/^%\d+$/.test(paneId))
+    throw new Error("Codex HUD session/pane identity unavailable");
+  const command = [
+    process.execPath,
+    fileURLToPath(import.meta.url),
+    sessionId,
+    paneId,
+  ]
+    .map(quote)
+    .join(" ")
+    .replace(/#/g, "##");
+  for (const [key, value] of [
+    ["status", "3"],
+    ["status-interval", "5"],
+    ["status-format[0]", `#(${command} #{client_width})`],
+    ...[1, 2].map((n) => [`status-format[${n}]`, `#{@tfx_hud_${n}}`]),
+  ])
+    await runTmux(null, ["set-option", "-t", target, key, value]);
+  for (const key of ["status-format[3]", "@tfx_hud_3"])
+    await runTmux(null, ["set-option", "-u", "-t", target, key]);
+}
+
+export async function updateTmuxHud(session, pane, columns) {
+  // CLI 모듈은 triflux 설치본에 있다. core의 공유 HUD에서는 이 진입점을 실행하지 않는다.
+  const { resolveCodexTmuxThread } = await import(
+    new URL("../bin/tfx-live.mjs", import.meta.url)
+  );
+  const { threadId } = await resolveCodexTmuxThread(pane, {
+    requireRegistryAgreement: true,
+    runTmux: async (_remote, args) => {
+      // tmux 3.8은 format의 탭을 밑줄로 바꾸므로 출력 뒤에 탭으로 복원한다.
+      const safeArgs = args.map((arg) => arg.replace(/\t/g, "|"));
+      const result = await exec("tmux", safeArgs, { timeout: 2000 });
+      return { stdout: result.stdout.replace(/\|/g, "\t") };
+    },
+  });
+  const context = threadId ? await readCodexContext(null, threadId) : null;
+  const limit = context?.executionContextLimitTokens;
+  const used = context?.estimatedContextTokens;
+  const input = {
+    product: "codex",
+    terminal_width: Number(columns) || 120,
+    // 모델별 기본 분모는 쓰지 않고 현재 rollout의 실행 창만 쓴다.
+    ...(Number.isFinite(limit) &&
+    limit > 0 &&
+    Number.isFinite(used) &&
+    used >= 0
+      ? {
+          context_window: {
+            context_window_size: limit,
+            current_usage: { total_tokens: used },
+          },
+        }
+      : {}),
+  };
+  const rendering = exec(
+    process.execPath,
+    [
+      fileURLToPath(new URL("./hud-qos-status.mjs", import.meta.url)),
+      "--cache-only",
+    ],
+    {
+      timeout: 10000,
+      env: { ...process.env, COLUMNS: String(input.terminal_width) },
+    },
+  );
+  rendering.child.stdin.end(JSON.stringify(input));
+  const { stdout } = await rendering;
+  const lines = stripAnsi(stdout).trim().split("\n");
+  for (let n = 0; n < 3; n += 1) {
+    await exec(
+      "tmux",
+      [
+        "set-option",
+        "-t",
+        session,
+        `@tfx_hud_${n}`,
+        (lines[n] || "").replace(/#/g, "##"),
+      ],
+      { timeout: 2000 },
+    );
+  }
+  return lines[0] || "";
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  updateTmuxHud(...process.argv.slice(2))
+    .then((status) => {
+      process.stdout.write(`${status}\n`);
+    })
+    .catch(() => {
+      process.stdout.write("c: ctx:--\n");
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.87.0",
+  "version": "10.88.1",
   "description": "triflux core — CLI routing, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",