triflux 10.61.2 → 10.63.0

package/bin/triflux.mjs

@@ -67,6 +67,7 @@ import {
   saveRegistry,
   syncRegistryTargets,
 } from "../scripts/lib/mcp-guard-engine.mjs";
+import { resolveModelFamilies } from "../scripts/lib/model-family-resolver.mjs";
 import {
   formatPsmuxInstallGuidance,
   formatPsmuxUpdateGuidance,
@@ -988,11 +989,17 @@ function previewCodexProfiles() {
     ? readFileSync(CODEX_CONFIG_PATH, "utf8")
     : "";
   const profiles = [];
+  const resolved = resolveModelFamilies("codex", {
+    codexHome: CODEX_DIR,
+    allowCommand: false,
+    persist: false,
+  }).profiles;
 
   // Codex 0.134+: 프로필은 별도 파일 ~/.codex/<name>.config.toml 로 관리한다.
   for (const profile of REQUIRED_CODEX_PROFILES) {
     const profilePath = join(CODEX_DIR, `${profile.name}.config.toml`);
-    const desiredContent = `${profile.lines.join("\n")}\n`;
+    const { model, effort } = resolved[profile.name];
+    const desiredContent = `model = "${model}"\nmodel_reasoning_effort = "${effort}"\n`;
     const existingContent = existsSync(profilePath)
       ? readFileSync(profilePath, "utf8")
       : null;
@@ -1483,7 +1490,7 @@ async function cmdSetup(options = {}) {
         "gemini-profiles",
         `Antigravity/Gemini profiles 설정 실패: ${renderErrorMessage(gemini.message)}`,
       );
-    if (gemini.added) report.alreadyInGoalState = false;
+    if (gemini.changed) report.alreadyInGoalState = false;
 
     const settingsPath = join(CLAUDE_DIR, "settings.json");
     const hudPath = join(CLAUDE_DIR, "hud", "hud-qos-status.mjs");

package/hub/team/claude-transcript.mjs

@@ -58,6 +58,28 @@ function beginTurn(state) {
 function acceptEntry(state, entry, marker) {
   if (entry?.isSidechain) return;
   const message = entry?.message;
+  if (
+    entry?.type === "attachment" &&
+    entry.attachment?.type === "goal_status"
+  ) {
+    const goal = entry.attachment;
+    const cleared = goal.met === true && goal.sentinel === true;
+    state.goal = {
+      state: cleared ? "none" : goal.met ? "complete" : "active",
+      objective: cleared ? null : goal.condition,
+      judgedBy: "evaluator",
+      ...(goal.reason !== undefined ? { reason: goal.reason } : {}),
+      ...(goal.tokens !== undefined ? { tokensUsed: goal.tokens } : {}),
+      updatedAt: entry.timestamp ?? null,
+    };
+    if (goal.sentinel === true) {
+      state.goalSentinel = {
+        ...goal,
+        updatedAt: entry.timestamp,
+        count: (state.goalSentinel?.count ?? 0) + 1,
+      };
+    }
+  }
   if (entry?.type === "system" && entry.subtype === "compact_boundary") {
     state.compactCount += 1;
     state.compact = {
@@ -211,6 +233,8 @@ export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
       measuredAt: null,
       compactCount: 0,
       compact: null,
+      goal: { state: "none", objective: null, judgedBy: "evaluator" },
+      goalSentinel: null,
     };
   }
   try {
@@ -248,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,
@@ -255,5 +280,7 @@ export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
     sectionClosed: state.sectionClosed,
     compactCount: state.compactCount,
     compact: state.compact,
+    goal: state.goal,
+    goalSentinel: state.goalSentinel,
   };
 }

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

@@ -23,10 +23,8 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
-import {
-  canonicalCodexProfileModel,
-  normalizeCodexProfileName,
-} from "../../scripts/lib/codex-profile-config.mjs";
+import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
+import { CODEX_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
 
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
@@ -47,13 +45,12 @@ const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
 const DEFAULT_CLAUDE_MODEL = "fable";
 
 // Escalation chain (2026-09-22 정책):
-//   1. codex gpt-6-astra max: 최난도 단일 작업용 Codex escalation 단계
+//   1. codex astra_max: 최난도 단일 작업용 Codex escalation 단계
 //   2. claude fable alias: Claude CLI가 최신 Fable tier로 해석하는 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    model: "gpt-6-astra",
-    profile: "gpt6_astra_max",
+    profile: "astra_max",
   }),
   Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
@@ -62,8 +59,8 @@ const STUCK_THRESHOLD = 3;
 
 function normalizeEscalationProfile(profile) {
   const normalized = normalizeCodexProfileName(profile);
-  return normalized === "ultra" || normalized === "gpt6_astra_ultra"
-    ? "gpt6_astra_max"
+  return normalized === "ultra" || normalized === "astra_ultra"
+    ? "astra_max"
     : normalized;
 }
 
@@ -307,26 +304,21 @@ function normalizeEscalationChainEntry(entry, index, source) {
       `${source}: chain[${index}].cli must be a non-empty string`,
     );
   }
+  const profile = typeof entry.profile === "string" ? entry.profile.trim() : "";
+  const normalizedProfile = normalizeEscalationProfile(profile);
+  if (
+    entry.cli === "codex" &&
+    Object.hasOwn(CODEX_FAMILY_PROFILES, normalizedProfile)
+  ) {
+    return { cli: entry.cli, profile: normalizedProfile };
+  }
   if (typeof entry.model !== "string" || entry.model.trim() === "") {
     throw new Error(
       `${source}: chain[${index}].model must be a non-empty string`,
     );
   }
-
-  const normalized = {
-    cli: entry.cli,
-    model: entry.model,
-  };
-  if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
-    const profile = entry.profile.trim();
-    normalized.profile =
-      entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
-    // A remapped legacy profile must not keep reporting its old model.
-    if (normalized.profile !== profile) {
-      normalized.model =
-        canonicalCodexProfileModel(normalized.profile) ?? normalized.model;
-    }
-  }
+  const normalized = { cli: entry.cli, model: entry.model };
+  if (profile) normalized.profile = profile;
   return normalized;
 }
 

package/hub/team/session-context.mjs

@@ -10,7 +10,7 @@ const MODEL_CONTEXT = [
   {
     cli: "claude",
     model:
-      /^(?:claude-)?(?:fable-5[.-]1|opus-5[.-]5|sonnet-5[.-]5|haiku-5[.-]5)(?:$|[-[])/i,
+      /^(?:claude-)?(?:fable|opus|sonnet|haiku)-(?:[5-9]|[1-9]\d+)(?:[.-]\d+)*(?:$|[-[])/i,
     tokens: 1_000_000,
     source:
       "https://platform.claude.com/docs/en/build-with-claude/context-windows",
@@ -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.61.2",
+  "version": "10.63.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/scripts/lib/agent-route-policy.mjs

@@ -10,127 +10,127 @@ import { resolveGeminiProfileForPurpose } from "./gemini-profiles.mjs";
 
 const policy = {
   executor: {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   codex: {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "build-fixer": {
-    profile: "gpt6_luna_high",
+    profile: "luna_high",
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   cleanup: {
-    profile: "gpt61_sol_med",
+    profile: "sol_med",
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   deslop: {
-    profile: "gpt61_sol_med",
+    profile: "sol_med",
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   debugger: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "deep-executor": {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "implement",
     subcommand: "exec",
   },
   architect: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   critic: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   planner: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   analyst: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "code-reviewer": {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "quality-reviewer": {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "security-reviewer": {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   scientist: {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "document-specialist": {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "scientist-deep": {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   verifier: {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   "test-engineer": {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1200,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "qa-tester": {
-    profile: "gpt61_sol_high",
+    profile: "sol_high",
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   spark: {
-    profile: "gpt6_luna_low",
+    profile: "luna_low",
     timeoutSec: 180,
     mcpHint: "implement",
     subcommand: "exec",
@@ -138,13 +138,13 @@ const policy = {
   // These entries are only for explicit direct-Codex overrides. agent-map.json
   // remains the provider-selection authority for their normal execution.
   designer: {
-    profile: "gpt6_astra_xhigh",
+    profile: "astra_xhigh",
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   writer: {
-    profile: "gpt6_luna_high",
+    profile: "luna_high",
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
@@ -167,13 +167,13 @@ const DEFAULT_CODEX_AGENT = "executor";
 
 const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
   new Set([
-    "gpt6_luna_low",
-    "gpt6_luna_high",
-    "gpt61_sol_med",
-    "gpt61_sol_high",
-    "gpt6_astra_xhigh",
-    "gpt6_astra_max",
-    "gpt6_astra_ultra",
+    "luna_low",
+    "luna_high",
+    "sol_med",
+    "sol_high",
+    "astra_xhigh",
+    "astra_max",
+    "astra_ultra",
   ]),
 );
 const ULTRA_ELIGIBLE_CODEX_AGENTS = Object.freeze(
@@ -183,8 +183,8 @@ const ULTRA_ELIGIBLE_CODEX_AGENTS = Object.freeze(
 const NESTED_GLOBAL_PROFILE_OVERRIDES = new Set([
   "max",
   "ultra",
-  "gpt6_astra_max",
-  "gpt6_astra_ultra",
+  "astra_max",
+  "astra_ultra",
 ]);
 
 export function resolveCodexAgentPolicy(agent) {
@@ -219,9 +219,9 @@ export function resolveCodexAgentProfile(
 
   const canonical =
     requested === "max"
-      ? "gpt6_astra_max"
+      ? "astra_max"
       : requested === "ultra"
-        ? "gpt6_astra_ultra"
+        ? "astra_ultra"
         : requested;
   if (!CANONICAL_CODEX_PROFILE_OVERRIDES.has(canonical)) {
     if (allowCustom) return requested;
@@ -229,9 +229,9 @@ export function resolveCodexAgentProfile(
       `[agent-route-policy] unsupported profile override: ${requested}`,
     );
   }
-  if (canonical !== "gpt6_astra_ultra") return canonical;
+  if (canonical !== "astra_ultra") return canonical;
   return nested || !ULTRA_ELIGIBLE_CODEX_AGENTS.has(agent)
-    ? "gpt6_astra_max"
+    ? "astra_max"
     : canonical;
 }
 
@@ -270,7 +270,7 @@ export function resolveNestedCodexAgentProfile(
   });
   const { effort } = resolveCodexProfileConfigValues(candidate, { codexHome });
   if (!effort) return fallback;
-  return effort.toLowerCase() === "ultra" ? "gpt6_astra_max" : candidate;
+  return effort.toLowerCase() === "ultra" ? "astra_max" : candidate;
 }
 
 const EXPECTED_DURATION_BY_AGENT = Object.freeze({
@@ -408,13 +408,13 @@ async function runCli() {
         const module = await import(pathToFileURL(geminiProfilesModule).href);
         resolver = (agent) => {
           try {
-            return module.resolveGeminiProfileForPurpose(agent) || "flash38";
+            return module.resolveGeminiProfileForPurpose(agent) || "flash";
           } catch {
-            return "flash38";
+            return "flash";
           }
         };
       } catch {
-        resolver = () => "flash38";
+        resolver = () => "flash";
       }
     }
     process.stdout.write(

package/scripts/lib/codex-profile-config.mjs

@@ -9,6 +9,12 @@ import {
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { writeRotatedBackup } from "./backup-rotation.mjs";
+import {
+  CODEX_FAMILY_PROFILES,
+  modelFamilyPaths,
+  resolveModelFamilies,
+  writeModelFile,
+} from "./model-family-resolver.mjs";
 
 const EFFORT_BY_SUFFIX = {
   ultra: "ultra",
@@ -20,41 +26,38 @@ const EFFORT_BY_SUFFIX = {
   low: "low",
 };
 
-const CANONICAL_PROFILE_VALUES = Object.freeze({
-  gpt6_luna_low: { model: "gpt-6-luna", effort: "low" },
-  gpt6_luna_high: { model: "gpt-6-luna", effort: "high" },
-  gpt61_sol_med: { model: "gpt-6.1-sol", effort: "medium" },
-  gpt61_sol_high: { model: "gpt-6.1-sol", effort: "high" },
-  gpt6_astra_xhigh: { model: "gpt-6-astra", effort: "xhigh" },
-  gpt6_astra_max: { model: "gpt-6-astra", effort: "max" },
-  gpt6_astra_ultra: { model: "gpt-6-astra", effort: "ultra" },
-});
-
-// GPT-5.6 lane names map to the GPT-6 lane with the same effort. GPT-6 has no
-// Terra tier, so Terra lanes move to Sol. GPT-6 Sol lane names map to GPT-6.1
-// Sol with the same effort.
 const LEGACY_CANONICAL_PROFILE_ALIASES = Object.freeze({
-  gpt56_sol_xhigh: "gpt6_astra_xhigh",
-  gpt56_sol_max: "gpt6_astra_max",
-  gpt56_sol_ultra: "gpt6_astra_ultra",
-  gpt56_terra_high: "gpt61_sol_high",
-  gpt56_terra_med: "gpt61_sol_med",
-  gpt56_luna_low: "gpt6_luna_low",
-  gpt6_sol_high: "gpt61_sol_high",
-  gpt6_sol_med: "gpt61_sol_med",
+  gpt56_sol_xhigh: "astra_xhigh",
+  gpt56_sol_max: "astra_max",
+  gpt56_sol_ultra: "astra_ultra",
+  gpt56_terra_high: "sol_high",
+  gpt56_terra_med: "sol_med",
 });
 
 export function normalizeCodexProfileName(profileName) {
   const normalized = String(profileName ?? "").trim();
-  return LEGACY_CANONICAL_PROFILE_ALIASES[normalized] || normalized;
+  const legacy = LEGACY_CANONICAL_PROFILE_ALIASES[normalized];
+  if (legacy) return legacy;
+  const familyName = normalized.replace(/^gpt\d+_(sol|astra|luna)_/, "$1_");
+  return Object.hasOwn(CODEX_FAMILY_PROFILES, familyName)
+    ? familyName
+    : normalized;
 }
 
-/** Model ID of a canonical profile (after legacy normalization), or null. */
-export function canonicalCodexProfileModel(profileName) {
-  return (
-    CANONICAL_PROFILE_VALUES[normalizeCodexProfileName(profileName)]?.model ??
-    null
-  );
+export function ensureManagedCodexProfiles(opts = {}) {
+  const { codexHome } = modelFamilyPaths(opts);
+  const { profiles } = resolveModelFamilies("codex", opts);
+  let changed = 0;
+  for (const [name, { model, effort }] of Object.entries(profiles)) {
+    if (
+      writeModelFile(
+        join(codexHome, `${name}.config.toml`),
+        `model = "${model}"\nmodel_reasoning_effort = "${effort}"\n`,
+      )
+    )
+      changed++;
+  }
+  return { changed, profiles };
 }
 
 function readProfileScalar(raw, key) {
@@ -70,7 +73,7 @@ function readProfileScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt61_sol_high") to the `-c key=value`
+ * Resolve a Codex effort profile name (e.g. "sol_high") to the `-c key=value`
  * config overrides that `codex exec` accepts, so the headless CLI lanes can
  * select a profile WITHOUT `codex exec --profile <name>`. codex 0.134+ rejects
  * `--profile X` whenever config.toml still contains an inline `[profiles.X]`
@@ -118,12 +121,20 @@ export function codexProfileConfigOverrides(profileName, opts = {}) {
     opts,
   );
   if (opts.enforceCanonicalProfile === true) {
-    const canonical = CANONICAL_PROFILE_VALUES[normalizedProfileName];
-    if (canonical) ({ model, effort } = canonical);
+    if (Object.hasOwn(CODEX_FAMILY_PROFILES, normalizedProfileName)) {
+      ({ model, effort } = resolveModelFamilies("codex", {
+        ...opts,
+        allowCommand: false,
+        persist: false,
+      }).profiles[normalizedProfileName]);
+    }
   }
   if (opts.disallowUltra === true && effort?.toLowerCase() === "ultra") {
-    model = "gpt-6-astra";
-    effort = "max";
+    ({ model, effort } = resolveModelFamilies("codex", {
+      ...opts,
+      allowCommand: false,
+      persist: false,
+    }).profiles.astra_max);
   }
   const overrides = [];
   if (model) overrides.push(`model="${model}"`);