@triflux/core 10.44.0 → 10.45.0

package/hub/router.mjs

@@ -376,6 +376,9 @@ export function createRouter(store) {
   const queuesByAgent = new Map();
   const liveMessages = new Map();
   const roleStates = new Map();
+  const hubInstanceId = uuidv7();
+  const storeFingerprint =
+    store.fingerprint || `${store.type || "unknown"}:unknown`;
   const updateRegistrationIdentity = store.db?.prepare
     ? store.db.prepare(`
         UPDATE agents SET
@@ -392,6 +395,70 @@ export function createRouter(store) {
   let latencyIdx = 0;
   const deliveryLatencies = new Array(MAX_LATENCY_SAMPLES).fill(0);
 
+  function hubIdentity() {
+    return {
+      hub_instance_id: hubInstanceId,
+      store_fingerprint: storeFingerprint,
+    };
+  }
+
+  function validateCallerIdentity(input = {}) {
+    if (
+      input.hub_instance_id != null &&
+      input.hub_instance_id !== hubInstanceId
+    ) {
+      return {
+        ok: false,
+        error: {
+          code: "STALE_HUB_INSTANCE",
+          message: "caller is bound to a previous hub instance",
+        },
+        data: hubIdentity(),
+      };
+    }
+    if (
+      input.store_fingerprint != null &&
+      input.store_fingerprint !== storeFingerprint
+    ) {
+      return {
+        ok: false,
+        error: {
+          code: "STORE_FINGERPRINT_MISMATCH",
+          message: "caller store fingerprint does not match this hub",
+        },
+        data: hubIdentity(),
+      };
+    }
+    return null;
+  }
+
+  function isControlPlaneRegistration(args = {}) {
+    const metadata = args.metadata || {};
+    const values = [
+      ...(Array.isArray(args.capabilities) ? args.capabilities : []),
+      ...(Array.isArray(args.topics) ? args.topics : []),
+      metadata.role,
+      ...(Array.isArray(metadata.roles) ? metadata.roles : []),
+    ]
+      .flat()
+      .map((value) => String(value || "").toLowerCase());
+    return (
+      metadata.control_plane === true ||
+      values.some((value) => value === "cto" || value === "role:cto")
+    );
+  }
+
+  function staleOwnerFailure(agentId, result) {
+    return {
+      ok: false,
+      error: {
+        code: "STALE_PRESENCE_OWNER",
+        message: `stale presence owner: ${agentId}`,
+      },
+      data: { ...result, ...hubIdentity() },
+    };
+  }
+
   function ensureAgentQueue(agentId) {
     let queue = queuesByAgent.get(agentId);
     if (!queue) {
@@ -1120,6 +1187,18 @@ export function createRouter(store) {
     deliveryEmitter,
 
     registerAgent(args) {
+      const identityFailure = validateCallerIdentity(args);
+      if (identityFailure) return identityFailure;
+      if (isControlPlaneRegistration(args) && store.type !== "sqlite") {
+        return {
+          ok: false,
+          error: {
+            code: "CONTROL_PLANE_STORE_DEGRADED",
+            message: "control-plane presence requires durable SQLite storage",
+          },
+          data: { ...hubIdentity(), store_type: store.type || "unknown" },
+        };
+      }
       const identity = normalizeRegistrationIdentity(args);
       const result = store.registerAgent(args);
       if (!registerPresenceIsEffective(result)) {
@@ -1139,11 +1218,23 @@ export function createRouter(store) {
           transferBacklog: true,
         });
       }
-      return { ok: true, data: { ...result, hub_pid: process.pid } };
+      return {
+        ok: true,
+        data: { ...result, hub_pid: process.pid, ...hubIdentity() },
+      };
     },
 
-    refreshAgentLease(agentId, ttlMs = 30000) {
-      const result = store.refreshLease(agentId, ttlMs);
+    refreshAgentLease(
+      agentId,
+      ttlMs = 30000,
+      presenceGeneration,
+      callerIdentity = {},
+    ) {
+      const identityFailure = validateCallerIdentity(callerIdentity);
+      if (identityFailure) return identityFailure;
+      const result = store.refreshLease(agentId, ttlMs, presenceGeneration);
+      if (result?.effective?.updated === false)
+        return staleOwnerFailure(agentId, result);
       refreshRoleCandidateForAgent(agentId);
       for (const roleName of ROLE_TOPICS) {
         ensureRoleLeader(roleName, {
@@ -1151,7 +1242,7 @@ export function createRouter(store) {
           transferBacklog: true,
         });
       }
-      return result;
+      return { ok: true, data: result };
     },
 
     subscribeAgent(agentId, topics, { replace = false } = {}) {
@@ -1170,11 +1261,15 @@ export function createRouter(store) {
       return listRuntimeTopics(agentId);
     },
 
-    updateAgentStatus(agentId, status) {
+    updateAgentStatus(agentId, status, presenceGeneration) {
       if (status === "offline") {
         runtimeTopics.delete(agentId);
       }
-      const updated = store.updateAgentStatus(agentId, status);
+      const updated = store.updateAgentStatus(
+        agentId,
+        status,
+        presenceGeneration,
+      );
       refreshRoleCandidateForAgent(agentId);
       for (const roleName of ROLE_TOPICS) {
         ensureRoleLeader(roleName, {
@@ -1185,6 +1280,39 @@ export function createRouter(store) {
       return updated;
     },
 
+    transitionAgentStatus(
+      agentId,
+      status,
+      presenceGeneration,
+      callerIdentity = {},
+    ) {
+      const identityFailure = validateCallerIdentity(callerIdentity);
+      if (identityFailure) return identityFailure;
+      const updated = store.updateAgentStatus(
+        agentId,
+        status,
+        presenceGeneration,
+      );
+      if (!updated) return staleOwnerFailure(agentId, { status });
+      if (status === "offline") runtimeTopics.delete(agentId);
+      refreshRoleCandidateForAgent(agentId);
+      for (const roleName of ROLE_TOPICS) {
+        ensureRoleLeader(roleName, {
+          reason: `status:${status}`,
+          transferBacklog: true,
+        });
+      }
+      return {
+        ok: true,
+        data: {
+          agent_id: agentId,
+          status,
+          presence_generation: presenceGeneration,
+          ...hubIdentity(),
+        },
+      };
+    },
+
     route(msg) {
       const recipients = uniqueStrings(resolveRecipients(msg));
       if (!recipients.length) {
@@ -1369,7 +1497,14 @@ export function createRouter(store) {
       agent_id,
       reason = "manual",
       requested_by = "manual",
+      hub_instance_id,
+      store_fingerprint,
     } = {}) {
+      const identityFailure = validateCallerIdentity({
+        hub_instance_id,
+        store_fingerprint,
+      });
+      if (identityFailure) return identityFailure;
       const roleName = normalizeRoleName(role);
       if (!roleName) {
         return {
@@ -1440,6 +1575,7 @@ export function createRouter(store) {
           leader_epoch: snapshot.leader_epoch,
           ...transfer,
           status: snapshot,
+          ...hubIdentity(),
         },
       };
     },
@@ -1647,18 +1783,15 @@ export function createRouter(store) {
       return scheduleAssignRetry(job, reason, job.error, requested_by);
     },
 
-    sweepExpired() {
-      const now = Date.now();
-      let expired = 0;
-      const deadLettered = [];
+    sweepExpired({ now_ms = Date.now(), source = "manual" } = {}) {
+      const result = store.sweepExpired({ now_ms });
       for (const [messageId, record] of Array.from(liveMessages.entries())) {
-        if (record.message.expires_at_ms > now) continue;
-        store.moveToDeadLetter(messageId, "ttl_expired", null);
-        deadLettered.push(record.message);
+        if (record.message.expires_at_ms > now_ms) continue;
         removeMessage(messageId);
-        expired += 1;
       }
-      for (const message of deadLettered) {
+      for (const transition of result.transitions) {
+        if (!transition.dlq_inserted) continue;
+        const { message } = transition;
         if (
           !["handoff", "request"].includes(message.type) ||
           message.payload?.kind === "assign.job"
@@ -1683,12 +1816,15 @@ export function createRouter(store) {
             original_to: message.to_agent,
             reason: "ttl_expired",
             task: message.payload?.task ?? null,
+            expired_at_ms: message.expires_at_ms,
+            failed_at_ms: transition.failed_at_ms,
+            recovery_source: source,
           },
           trace_id: message.trace_id,
           correlation_id: message.correlation_id,
         });
       }
-      return { messages: expired };
+      return result;
     },
 
     sweepTimedOutAssigns() {
@@ -1709,19 +1845,49 @@ export function createRouter(store) {
       return { timed_out, retried };
     },
 
-    startSweeper() {
+    startSweeper({
+      run_immediately = false,
+      interval_ms = 10000,
+      onSweepError,
+    } = {}) {
       if (sweepTimer) return;
-      sweepTimer = setInterval(() => {
+      const reportSweepError = (source, error, failures) => {
+        if (typeof onSweepError === "function") {
+          onSweepError({ source, error, consecutive_failures: failures });
+        }
+      };
+      let sweepFailures = 0;
+      let assignFailures = 0;
+      const runSweep = () => {
+        try {
+          router.sweepExpired({ source: "periodic" });
+          sweepFailures = 0;
+        } catch (error) {
+          sweepFailures += 1;
+          reportSweepError("periodic", error, sweepFailures);
+        }
         try {
-          router.sweepExpired();
           router.sweepTimedOutAssigns();
-        } catch {}
-      }, 10000);
+          assignFailures = 0;
+        } catch (error) {
+          assignFailures += 1;
+          reportSweepError("assign_timeout", error, assignFailures);
+        }
+      };
+      if (run_immediately) runSweep();
+      sweepTimer = setInterval(() => {
+        runSweep();
+      }, interval_ms);
+      let staleFailures = 0;
       staleTimer = setInterval(() => {
         try {
           store.sweepStaleAgents();
           router.reelectStaleRoles();
-        } catch {}
+          staleFailures = 0;
+        } catch (error) {
+          staleFailures += 1;
+          reportSweepError("stale_agents", error, staleFailures);
+        }
       }, 120000);
       sweepTimer.unref();
       staleTimer.unref();
@@ -1777,8 +1943,19 @@ export function createRouter(store) {
 
     getStatus(
       scope = "hub",
-      { agent_id, trace_id, include_metrics = true } = {},
+      {
+        agent_id,
+        trace_id,
+        include_metrics = true,
+        hub_instance_id,
+        store_fingerprint,
+      } = {},
     ) {
+      const identityFailure = validateCallerIdentity({
+        hub_instance_id,
+        store_fingerprint,
+      });
+      if (identityFailure) return identityFailure;
       const data = {};
 
       if (scope === "hub" || scope === "queue") {
@@ -1787,6 +1964,7 @@ export function createRouter(store) {
           uptime_ms: (process.uptime() * 1000) | 0,
           realtime_transport: "named-pipe",
           audit_store: store.type || "sqlite",
+          ...hubIdentity(),
         };
         data.roles = {
           cto: getRoleSnapshot("cto"),
@@ -1840,7 +2018,7 @@ export function createRouter(store) {
         data.trace = store.getMessagesByTrace(trace_id);
       }
 
-      return { ok: true, data };
+      return { ok: true, data: { ...data, ...hubIdentity() } };
     },
   };
 

package/hub/team/claude-daemon-control.mjs

@@ -321,10 +321,12 @@ export async function probeClaudeDaemonCandidates({
   short,
   sessionId,
   timeoutMs = 6000,
+  tmpRoot = "/tmp",
 } = {}) {
   const candidates = await buildClaudeDaemonDiscoveryCandidates({
     configDir,
     env,
+    tmpRoot,
   });
   const callerProvenance = detectCallerProvenance(env);
   const targetRequested = Boolean(short || sessionId);

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 max — 최난도 단일 작업용 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_max",
+    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;
@@ -297,10 +317,7 @@ function normalizeEscalationChainEntry(entry, index, source) {
   if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
     const profile = entry.profile.trim();
     normalized.profile =
-      entry.cli === "codex" &&
-      (profile === "ultra" || profile === "gpt56_sol_ultra")
-        ? "gpt56_sol_max"
-        : profile;
+      entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
   }
   return normalized;
 }
@@ -333,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/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";