@triflux/core 10.43.0 → 10.45.0

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

@@ -23,6 +23,8 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
+
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
   EXECUTING: "EXECUTING",
@@ -39,21 +41,29 @@ export const MODES = Object.freeze({
 });
 
 const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
+const DEFAULT_CLAUDE_MODEL = "fable";
 
-// Escalation chain (2026-05-27 정책):
-//   1. codex gpt-5.6-sol — 기존 최상위 Codex escalation 단계
-//   2. claude opus-4-8 — 최종 수단
+// Escalation chain (2026-09-22 정책):
+//   1. codex gpt-6-astra max: 최난도 단일 작업용 Codex escalation 단계
+//   2. claude fable alias: Claude CLI가 최신 Fable tier로 해석하는 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    model: "gpt-5.6-sol",
-    profile: "gpt56_sol_xhigh",
+    model: "gpt-6-astra",
+    profile: "gpt6_astra_max",
   }),
-  Object.freeze({ cli: "claude", model: "opus-4-8" }),
+  Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
 
 const STUCK_THRESHOLD = 3;
 
+function normalizeEscalationProfile(profile) {
+  const normalized = normalizeCodexProfileName(profile);
+  return normalized === "ultra" || normalized === "gpt6_astra_ultra"
+    ? "gpt6_astra_max"
+    : normalized;
+}
+
 export function createRetryStateMachine(options = {}) {
   const mode = options.mode || MODES.BOUNDED;
   const cliChain = resolveEscalationChain(options);
@@ -234,15 +244,25 @@ function resolveEscalationChain(options) {
   }
 
   const projectRoot = options.projectRoot || process.cwd();
-  return (
-    loadEscalationChainOverride(projectRoot) ||
-    normalizeEscalationChain(
-      DEFAULT_ESCALATION_CHAIN,
-      "DEFAULT_ESCALATION_CHAIN",
-    )
+  const projectOverride = loadEscalationChainOverride(projectRoot);
+  if (projectOverride) return projectOverride;
+
+  return normalizeEscalationChain(
+    resolveDefaultEscalationChain(options.env || process.env),
+    "DEFAULT_ESCALATION_CHAIN",
   );
 }
 
+function resolveDefaultEscalationChain(env) {
+  const configuredModel = env?.TFX_ESCALATION_CLAUDE_MODEL?.trim();
+  if (!configuredModel) return DEFAULT_ESCALATION_CHAIN;
+
+  return [
+    DEFAULT_ESCALATION_CHAIN[0],
+    { cli: "claude", model: configuredModel },
+  ];
+}
+
 export function loadEscalationChainOverride(projectRoot = process.cwd()) {
   const configPath = join(projectRoot, ESCALATION_CHAIN_CONFIG_PATH);
   if (!existsSync(configPath)) return null;
@@ -295,7 +315,9 @@ function normalizeEscalationChainEntry(entry, index, source) {
     model: entry.model,
   };
   if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
-    normalized.profile = entry.profile;
+    const profile = entry.profile.trim();
+    normalized.profile =
+      entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
   }
   return normalized;
 }
@@ -328,6 +350,12 @@ export function loadSnapshot(snapshotFile) {
       `unsupported snapshot version: ${parsed.version} (expected 1)`,
     );
   }
+  if (Array.isArray(parsed.cliChain) && parsed.cliChain.length > 0) {
+    return {
+      ...parsed,
+      cliChain: normalizeEscalationChain(parsed.cliChain, "snapshot.cliChain"),
+    };
+  }
   return parsed;
 }
 

package/hub/team/synapse-http.mjs

@@ -1,6 +1,9 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeRoleKey } from "../role-contract.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
 // Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
@@ -21,6 +24,144 @@ function normalizeToken(raw) {
   return token || null;
 }
 
+function opaqueId(prefix, value) {
+  return `${prefix}_${createHash("sha256")
+    .update(String(value || ""))
+    .digest("base64url")
+    .slice(0, 22)}`;
+}
+
+function normalizedProjectId(value) {
+  try {
+    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
+  } catch {
+    return "";
+  }
+}
+
+function resolveProjectId(cwd, meta, opts = {}) {
+  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
+  if (explicit) return normalizedProjectId(explicit);
+  if (typeof opts.resolveProjectId === "function") {
+    return normalizedProjectId(opts.resolveProjectId(cwd));
+  }
+  let current = cwd;
+  while (current) {
+    const manifest = join(current, ".triflux", "project.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed?.schema_version !== "tfx.project.v1") return "";
+        return normalizedProjectId(parsed.project_id);
+      } catch {
+        return "";
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function inferSessionCli(meta, opts = {}) {
+  const explicit = String(meta?.cli || meta?.actor_cli || "")
+    .trim()
+    .toLowerCase();
+  if (explicit === "codex" || explicit === "claude") return explicit;
+  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
+  if (entrypoint.includes("codex-session-hook")) return "codex";
+  if (entrypoint.includes("agy-session-hook")) return "other";
+  return "claude";
+}
+
+function resolveTmuxSession(meta, opts = {}) {
+  const explicit =
+    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
+  if (explicit) return String(explicit).trim();
+  if (!process.env.TMUX) return "";
+  try {
+    const run =
+      opts.tmuxSessionName ||
+      (() =>
+        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        }));
+    return String(run() || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+export function buildSynapseRegistrationMeta(meta, opts = {}) {
+  if (!meta || meta.sessionKind !== "interactive") return meta;
+  const sessionId = String(meta.sessionId || "").trim();
+  if (!sessionId) return meta;
+  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
+  const cli = inferSessionCli(meta, opts);
+  const hostId = String(
+    meta.host_id ||
+      process.env.TFX_HOST_ID ||
+      opaqueId("hst", opts.hostname?.() || hostname()),
+  ).trim();
+  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
+  const transportLocators = [];
+  if (cli === "claude") {
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
+      kind: "claude-uds",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: 100,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_id: sessionId,
+        bridge_id: String(
+          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
+        ),
+      },
+    });
+  }
+  const tmuxSession = resolveTmuxSession(meta, opts);
+  if (tmuxSession) {
+    const muxServerSource =
+      meta.mux_server_id ||
+      process.env.TFX_MUX_SERVER_ID ||
+      String(process.env.TMUX || "default").split(",", 1)[0];
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
+      kind: "tmux",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: cli === "codex" ? 100 : 50,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_name: tmuxSession,
+        mux_server_id: opaqueId("mux", muxServerSource),
+      },
+    });
+  }
+  const directAgentId = `session:${sessionId}`;
+  return {
+    ...meta,
+    agent_id:
+      meta.agent_id ||
+      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
+        ? directAgentId
+        : opaqueId("session", sessionId)),
+    cli,
+    project_id: resolveProjectId(cwd, meta, opts) || undefined,
+    session_id: meta.session_id || sessionId,
+    host_id: hostId,
+    transport_locators_json:
+      meta.transport_locators_json ?? JSON.stringify(transportLocators),
+  };
+}
+
 // Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
 // Missing token → null (backward-compatible with token-less hubs).
 function readHubToken() {
@@ -139,7 +280,11 @@ export function drainPendingSynapse(timeoutMs = 1000) {
 }
 
 export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse("/synapse/register", meta, opts);
+  return fireAndForgetSynapse(
+    "/synapse/register",
+    buildSynapseRegistrationMeta(meta, opts),
+    opts,
+  );
 }
 
 export function heartbeatSynapseSession(

package/hud/cli-policy.mjs

@@ -0,0 +1,69 @@
+// HUD CLI 표시 정책 판정 (순수 함수)
+//
+// machine profile 의 TFX_DISABLE_CODEX / TFX_DISABLE_ANTIGRAVITY 를 읽어서 HUD 가
+// 어떤 프로바이더 행을 그릴지 정한다. 판독 자체는 scripts/lib/machine-profile.mjs
+// 가 단일 정본이고, 이 모듈은 그 결과를 HUD 표시 결정으로 접기만 한다.
+//
+// 상대 경로 import 를 고정하는 이유: setup 이 hud/** 를 ~/.claude/hud/ 로,
+// scripts/lib/* 를 ~/.claude/scripts/lib/ 로 각각 동기화한다. 그래서 설치본에서도
+// ../scripts/lib/ 가 repo 와 같은 파일을 가리킨다. packages/core 와
+// packages/triflux 미러도 같은 상대 레이아웃이다.
+//
+// fail-open 원칙: HUD 는 statusline 이라 어떤 예외에서도 죽으면 안 된다. 정책
+// 판독이 실패하면 전부 표시하는 쪽으로 돌아간다.
+
+import { resolveCliPolicy } from "../scripts/lib/machine-profile.mjs";
+
+/**
+ * HUD 가 codex / antigravity 행을 그릴 수 있는지 판정한다.
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {{
+ *   policy?: ReturnType<typeof resolveCliPolicy>|null,
+ *   resolve?: (env: NodeJS.ProcessEnv, opts: object) => ReturnType<typeof resolveCliPolicy>,
+ *   profile?: object,
+ *   platform?: string,
+ *   home?: string,
+ * }} [opts] policy 는 이미 계산한 정책 주입, resolve 는 테스트용 판독 시임이다.
+ * @returns {{ showCodex: boolean, antigravityAllowed: boolean, policy: object|null }}
+ */
+export function resolveHudCliVisibility(env = process.env, opts = {}) {
+  try {
+    const resolver =
+      typeof opts.resolve === "function" ? opts.resolve : resolveCliPolicy;
+    const policy = opts.policy ?? resolver(env, opts);
+    return {
+      showCodex: policy?.codexDisabled !== true,
+      antigravityAllowed: policy?.antigravityDisabled !== true,
+      policy: policy ?? null,
+    };
+  } catch {
+    return { showCodex: true, antigravityAllowed: true, policy: null };
+  }
+}
+
+/**
+ * antigravity / gemini 슬롯 행을 그릴지 판정한다.
+ *
+ * antigravity 가 허용이면 기존 동작 그대로 항상 그린다. 정책으로 꺼졌을 때만
+ * gemini 폴백 정보가 하나라도 있는지 보고, 전부 비어 있으면 행을 생략한다.
+ *
+ * @param {{
+ *   antigravityAllowed?: boolean,
+ *   antigravityReady?: boolean,
+ *   geminiEmail?: unknown,
+ *   geminiBucket?: unknown,
+ *   geminiSession?: unknown,
+ * }} [args]
+ * @returns {boolean}
+ */
+export function shouldRenderGeminiFallbackRow({
+  antigravityAllowed = true,
+  antigravityReady = false,
+  geminiEmail = null,
+  geminiBucket = null,
+  geminiSession = null,
+} = {}) {
+  if (antigravityAllowed || antigravityReady) return true;
+  return Boolean(geminiEmail || geminiBucket || geminiSession);
+}

package/hud/constants.mjs

@@ -71,7 +71,7 @@ export const CONTEXT_MONITOR_LOG_DIR = join(
   "logs",
 );
 
-// 원격 프로브 캐시 (tfx-remote-spawn)
+// 원격 프로브 캐시 (tfx-remote)
 export const REMOTE_ENV_CACHE_DIR = join(
   homedir(),
   ".claude",
@@ -89,12 +89,19 @@ export const CLAUDE_CREDENTIALS_PATH = join(
 );
 export const CLAUDE_CREDENTIALS_FILENAME = ".credentials.json";
 export const CLAUDE_CODE_USER_AGENT_FALLBACK = "claude-code/2.x";
+// Claude Code 2.1.x 평문 폴백 파일 위치: CLAUDE_SECURESTORAGE_CONFIG_DIR 가 정의돼 있으면 그 디렉터리
+// (빈 문자열은 기본 ~/.claude), 아니면 CLAUDE_CONFIG_DIR. 기본 경로는 항상 마지막 후보로 둔다.
 export function getClaudeCredentialPaths(env = process.env) {
   const paths = [];
-  if (env.CLAUDE_CONFIG_DIR) {
+  const secureDir = env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  if (secureDir !== undefined) {
+    if (secureDir) {
+      paths.push(join(secureDir.normalize("NFC"), CLAUDE_CREDENTIALS_FILENAME));
+    }
+  } else if (env.CLAUDE_CONFIG_DIR) {
     paths.push(join(env.CLAUDE_CONFIG_DIR, CLAUDE_CREDENTIALS_FILENAME));
   }
-  paths.push(CLAUDE_CREDENTIALS_PATH);
+  if (paths[0] !== CLAUDE_CREDENTIALS_PATH) paths.push(CLAUDE_CREDENTIALS_PATH);
   return paths;
 }
 export function getClaudeCodeUserAgent(env = process.env) {
@@ -198,7 +205,16 @@ export const ANTIGRAVITY_SETTINGS_PATH = join(
 // /usage 실측 (2026-05-22): Gemini 4개 모델이 동일 reset window 공유 (family-pool).
 // Claude/GPT-OSS family는 Gemini와 별도 quota 윈도우.
 export const ANTIGRAVITY_MODEL_ABBREV = {
-  // Gemini family — 통합 quota
+  // Gemini family — 통합 quota. 3.6+ Flash 는 세대 숫자 + 등급으로 구분한다.
+  "Gemini 3.8 Flash (High)": "8h",
+  "Gemini 3.8 Flash (Medium)": "8m",
+  "Gemini 3.8 Flash (Low)": "8l",
+  "Gemini 3.7 Flash (High)": "7h",
+  "Gemini 3.7 Flash (Medium)": "7m",
+  "Gemini 3.7 Flash (Low)": "7l",
+  "Gemini 3.6 Flash (High)": "6h",
+  "Gemini 3.6 Flash (Medium)": "6m",
+  "Gemini 3.6 Flash (Low)": "6l",
   "Gemini 3.5 Flash (High)": "Fh",
   "Gemini 3.5 Flash (Medium)": "Fm",
   "Gemini 3.5 Flash (Low)": "Fl",
@@ -242,12 +258,6 @@ export const GEMINI_RPM_TRACKER_PATH = join(
   "cache",
   "gemini-rpm-tracker.json",
 );
-export const SV_ACCUMULATOR_PATH = join(
-  homedir(),
-  ".claude",
-  "cache",
-  "sv-accumulator.json",
-);
 // 이전 .omc/ 경로 fallback (기존 환경 호환)
 export const LEGACY_GEMINI_QUOTA_CACHE = join(
   homedir(),
@@ -273,12 +283,6 @@ export const LEGACY_GEMINI_RPM_TRACKER = join(
   "state",
   "gemini_rpm_tracker.json",
 );
-export const LEGACY_SV_ACCUMULATOR = join(
-  homedir(),
-  ".omc",
-  "state",
-  "sv-accumulator.json",
-);
 
 export const GEMINI_RPM_WINDOW_MS = 60 * 1000; // 60초 슬라이딩 윈도우
 export const GEMINI_QUOTA_STALE_MS = 5 * 60 * 1000; // 5분
@@ -289,7 +293,6 @@ export const ACCOUNT_LABEL_WIDTH = 10;
 export const PROVIDER_PREFIX_WIDTH = 2;
 export const PERCENT_CELL_WIDTH = 3;
 export const TIME_CELL_INNER_WIDTH = 6;
-export const SV_CELL_WIDTH = 5;
 
 export const CLAUDE_REFRESH_FLAG = "--refresh-claude-usage";
 export const CODEX_REFRESH_FLAG = "--refresh-codex-rate-limits";

package/hud/context-monitor.mjs

@@ -15,13 +15,12 @@ const MAX_CAPTURE_BYTES = 256 * 1024;
 const MAX_TOP_KEYS = 20;
 
 // stdin 이 context_window_size 를 제공하지 않을 때 모델 ID 로 한도를 추정한다.
-// Anthropic 공식 문서(2026-04 기준): Opus 4.8 / Opus 4.7 / Opus 4.6 / Sonnet 4.6 = 1M,
-// Sonnet 4.5 / Haiku 4.5 = 200K. 그 외 모델은 [1m] suffix 로 opt-in 가능.
+// Anthropic 공식 문서(2026-09-22 기준): Opus 4.6 이상, Sonnet 4.6/5,
+// Fable 5/5.1 = 1M. Sonnet 4.5 / Haiku 4.5 = 200K이며 [1m]도 유지한다.
 const MODEL_HINT_1M_PREFIXES = [
-  "claude-opus-4-8",
-  "claude-opus-4-7",
-  "claude-opus-4-6",
   "claude-sonnet-4-6",
+  "claude-sonnet-5",
+  "claude-fable-5",
 ];
 
 function normalizeModelId(modelId) {
@@ -29,24 +28,34 @@ function normalizeModelId(modelId) {
   return String(modelId).toLowerCase();
 }
 
-function resolveModelLimit(modelId) {
-  const id = normalizeModelId(modelId);
-  if (!id) return DEFAULT_CONTEXT_LIMIT;
-  if (id.includes("[1m]")) return MILLION_CONTEXT_LIMIT;
-  for (const prefix of MODEL_HINT_1M_PREFIXES) {
-    if (id.startsWith(prefix)) return MILLION_CONTEXT_LIMIT;
-  }
-  return DEFAULT_CONTEXT_LIMIT;
+function isMillionContextOpusModel(modelId) {
+  const match = /^claude-opus-(\d+)(?:-(\d+))?(?:$|[-[\s])/u.exec(modelId);
+  if (!match) return false;
+
+  const major = Number(match[1]);
+  const minor = Number(match[2] || 0);
+  return major > 4 || (major === 4 && minor >= 6);
 }
 
-export function shouldSuppressInfoOnlyContextStatus(modelId) {
+function isMillionContextModel(modelId) {
   const id = normalizeModelId(modelId);
   if (!id) return false;
-  return (
-    id.startsWith("claude-opus-4-8") ||
-    id.startsWith("claude-opus-4-7") ||
-    id.includes("[1m]")
-  );
+  if (id.includes("[1m]")) return true;
+  if (isMillionContextOpusModel(id)) return true;
+  return MODEL_HINT_1M_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+
+function resolveModelLimit(modelId) {
+  return isMillionContextModel(modelId)
+    ? MILLION_CONTEXT_LIMIT
+    : DEFAULT_CONTEXT_LIMIT;
+}
+
+export function shouldSuppressInfoOnlyContextStatus(modelId, contextLimit = 0) {
+  const explicitLimit = Number(contextLimit);
+  return explicitLimit > 0
+    ? explicitLimit >= MILLION_CONTEXT_LIMIT
+    : isMillionContextModel(modelId);
 }
 
 const WARNING_LEVELS = Object.freeze({
@@ -282,6 +291,7 @@ export function deriveContextLimit(stdin) {
 }
 
 export function buildContextUsageView(stdin, snapshot = null) {
+  const modelId = stdin?.model?.id ?? stdin?.model;
   const stdinUsage = getStdinContextUsage(stdin);
   if (!stdinUsage) {
     return {
@@ -296,14 +306,14 @@ export function buildContextUsageView(stdin, snapshot = null) {
     };
   }
 
-  const modelId = stdin?.model?.id ?? stdin?.model;
   const limitTokens = Math.max(1, stdinUsage.limitTokens);
   const usedTokens = stdinUsage.usedTokens;
   const percent = clampPercent((usedTokens / limitTokens) * 100);
 
   const warning = classifyContextThreshold(percent);
   const showInfoOnlyStatus = !(
-    warning.level === "info" && shouldSuppressInfoOnlyContextStatus(modelId)
+    warning.level === "info" &&
+    shouldSuppressInfoOnlyContextStatus(modelId, stdinUsage.limitTokens)
   );
   return {
     usedTokens,