@triflux/remote 10.61.1 → 10.62.0

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

@@ -4,12 +4,13 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
-// https://platform.claude.com/docs/en/build-with-claude/context-windows 2026-10-08
+// https://platform.claude.com/docs/en/build-with-claude/context-windows 2026-10-12
 // https://developers.openai.com/api/docs/models 2026-10-08
 const MODEL_CONTEXT = [
   {
     cli: "claude",
-    model: /^(?:claude-)?(?:fable-5[.-]1|opus-5[.-]5|sonnet-5[.-]5)(?:$|[-[])/i,
+    model:
+      /^(?: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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.61.1",
+  "version": "10.62.0",
   "description": "triflux remote — team mode, psmux, MCP workers.",
   "type": "module",
   "main": "hub/index.mjs",

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}"`);

package/scripts/lib/gemini-profiles.mjs

@@ -1,72 +1,64 @@
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+  FLASH_FAMILY_PROFILES,
+  modelFamilyPaths,
+  resolveModelFamilies,
+  writeModelFile,
+} from "./model-family-resolver.mjs";
 
-// 모델명 SSOT. 값은 `agy models` 가 출력하는 display name 형식이다
-// (`--model` 인자가 이 문자열을 받는다). 옛 `gemini-*-preview` ID 형식이 아님.
-// 카탈로그 확인: agy 1.1.27 `agy models` (2026-09-07). 운영 정책은 3.8 Flash 한 세대만
-// 쓰고 effort(Low/Medium/High)로 차등한다. Pro 와 이전 세대 Flash 는 기본 프로필에서 뺐다.
 const DEFAULT_GEMINI_PROFILES = {
-  model: "Gemini 3.8 Flash (Medium)",
-  profiles: {
-    flash38_low: {
-      model: "Gemini 3.8 Flash (Low)",
-      hint: "3.8 Flash (Low) — 경량·저비용",
-    },
-    flash38: {
-      model: "Gemini 3.8 Flash (Medium)",
-      hint: "3.8 Flash (Medium) — 기본, 비용·속도 균형",
-    },
-    flash38_high: {
-      model: "Gemini 3.8 Flash (High)",
-      hint: "3.8 Flash (High) — 코드/추론 강화",
-    },
-  },
+  model: FLASH_FAMILY_PROFILES.flash.model,
+  profiles: Object.fromEntries(
+    Object.entries(FLASH_FAMILY_PROFILES).map(([name, { model }]) => [
+      name,
+      { model },
+    ]),
+  ),
 };
 
+export function normalizeGeminiProfileName(name) {
+  const raw = String(name ?? "").trim();
+  return raw.replace(/^flash\d*(?=_(?:low|high)$|$)/, "flash");
+}
+
 // ── 용도별 effort (SSOT) ──
-// 한 세대(3.8 Flash)만 쓰고 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름
+// Flash 가족 안에서 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름
 // (agent-map.json 의 에이전트, tfx multi --assign 의 role). bash(tfx-route.sh)와
 // 실행 모드(execution-mode)가 이 표를 읽는다.
 //   High   : 판단이 결과를 좌우하는 역할 (검토, 설계, 디버깅, 분석)
 //   Medium : 생성/작성/실행 (기본값)
 //   Low    : 분류, 요약, 추출, 번역처럼 짧고 기계적인 작업
 const GEMINI_PROFILE_BY_PURPOSE = Object.freeze({
-  designer: "flash38_high",
-  reviewer: "flash38_high",
-  "code-reviewer": "flash38_high",
-  "security-reviewer": "flash38_high",
-  "quality-reviewer": "flash38_high",
-  critic: "flash38_high",
-  architect: "flash38_high",
-  verifier: "flash38_high",
-  analyst: "flash38_high",
-  debugger: "flash38_high",
-  planner: "flash38_high",
-  scientist: "flash38_high",
-  "test-engineer": "flash38_high",
-  writer: "flash38",
-  executor: "flash38",
-  worker: "flash38",
-  "document-specialist": "flash38",
-  researcher: "flash38",
-  antigravity: "flash38",
-  agy: "flash38",
-  gemini: "flash38",
-  summarizer: "flash38_low",
-  classifier: "flash38_low",
-  triage: "flash38_low",
-  translator: "flash38_low",
-  formatter: "flash38_low",
-  explore: "flash38_low",
+  designer: "flash_high",
+  reviewer: "flash_high",
+  "code-reviewer": "flash_high",
+  "security-reviewer": "flash_high",
+  "quality-reviewer": "flash_high",
+  critic: "flash_high",
+  architect: "flash_high",
+  verifier: "flash_high",
+  analyst: "flash_high",
+  debugger: "flash_high",
+  planner: "flash_high",
+  scientist: "flash_high",
+  "test-engineer": "flash_high",
+  writer: "flash",
+  executor: "flash",
+  worker: "flash",
+  "document-specialist": "flash",
+  researcher: "flash",
+  antigravity: "flash",
+  agy: "flash",
+  gemini: "flash",
+  summarizer: "flash_low",
+  classifier: "flash_low",
+  triage: "flash_low",
+  translator: "flash_low",
+  formatter: "flash_low",
+  explore: "flash_low",
 });
-const GEMINI_DEFAULT_PURPOSE_PROFILE = "flash38";
+const GEMINI_DEFAULT_PURPOSE_PROFILE = "flash";
 
 function resolveGeminiProfileForPurpose(name) {
   const key = String(name ?? "")
@@ -84,70 +76,66 @@ function resolveGeminiModel(profileOrModel, opts = {}) {
   const profilesPath =
     opts.profilesPath ||
     process.env.GEMINI_PROFILES_PATH ||
-    join(homedir(), ".gemini", "triflux-profiles.json");
+    join(modelFamilyPaths(opts).home, ".gemini", "triflux-profiles.json");
   let cfg = null;
   try {
     cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
   } catch {
     cfg = null;
   }
-  const entry = cfg?.profiles?.[raw];
-  const fromFile = typeof entry === "string" ? entry : entry?.model;
-  if (typeof fromFile === "string" && fromFile.trim()) return fromFile.trim();
-  const fromDefault = DEFAULT_GEMINI_PROFILES.profiles[raw];
-  if (fromDefault) return fromDefault.model;
-  if (typeof cfg?.model === "string" && cfg.model.trim())
-    return cfg.model.trim();
-  return DEFAULT_GEMINI_PROFILES.model;
+  const name = normalizeGeminiProfileName(raw);
+  const modelValue = (entry) =>
+    typeof entry === "string"
+      ? entry
+      : typeof entry?.model === "string"
+        ? entry.model
+        : entry?.model?.name || entry?.name;
+  for (const bucket of [
+    cfg?.profiles,
+    cfg?.model?.profiles,
+    cfg?.modelProfiles,
+    cfg?.models,
+  ]) {
+    const entry = bucket?.[name] || bucket?.[raw];
+    const value = modelValue(entry);
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  if (name !== "default" && DEFAULT_GEMINI_PROFILES.profiles[name])
+    return DEFAULT_GEMINI_PROFILES.profiles[name].model;
+  const fallback =
+    cfg?.defaultModel ||
+    cfg?.default_profile ||
+    cfg?.defaultProfile ||
+    (typeof cfg?.model === "string" ? cfg.model : cfg?.model?.default);
+  if (typeof fallback === "string" && fallback.trim()) return fallback.trim();
+  const defaultProfile = normalizeGeminiProfileName(
+    (opts.env || process.env).TFX_GEMINI_DEFAULT_PROFILE,
+  );
+  return (
+    modelValue(cfg?.profiles?.[defaultProfile]) ||
+    DEFAULT_GEMINI_PROFILES.profiles[defaultProfile]?.model ||
+    DEFAULT_GEMINI_PROFILES.model
+  );
 }
 
-const DEFAULT_PROFILE_COUNT = Object.keys(
-  DEFAULT_GEMINI_PROFILES.profiles,
-).length;
-
-function ensureGeminiProfiles({
-  geminiDir = join(homedir(), ".gemini"),
-  profilesPath = join(geminiDir, "triflux-profiles.json"),
-} = {}) {
+function ensureGeminiProfiles(opts = {}) {
+  const geminiDir =
+    opts.geminiDir || join(modelFamilyPaths(opts).home, ".gemini");
+  const profilesPath =
+    opts.profilesPath ||
+    process.env.GEMINI_PROFILES_PATH ||
+    join(geminiDir, "triflux-profiles.json");
   try {
-    if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
-
-    if (!existsSync(profilesPath)) {
-      writeFileSync(
-        profilesPath,
-        JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n",
-        { encoding: "utf8", mode: 0o600 },
-      );
-      return {
-        ok: true,
-        created: true,
-        added: DEFAULT_PROFILE_COUNT,
-        count: DEFAULT_PROFILE_COUNT,
-        message: null,
-      };
-    }
-
     let cfg;
-    try {
-      cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
-    } catch {
+    let created = !existsSync(profilesPath);
+    if (!created) {
       try {
-        copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`);
-      } catch {}
-      writeFileSync(
-        profilesPath,
-        JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n",
-        { encoding: "utf8", mode: 0o600 },
-      );
-      return {
-        ok: true,
-        created: true,
-        added: DEFAULT_PROFILE_COUNT,
-        count: DEFAULT_PROFILE_COUNT,
-        message: null,
-      };
+        cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
+      } catch {
+        copyFileSync(profilesPath, `${profilesPath}.bak.${Date.now()}`);
+        created = true;
+      }
     }
-
     if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) cfg = {};
     if (
       !cfg.profiles ||
@@ -155,28 +143,25 @@ function ensureGeminiProfiles({
       Array.isArray(cfg.profiles)
     )
       cfg.profiles = {};
-
+    const { profiles } = resolveModelFamilies("agy", {
+      ...opts,
+      home: opts.home || dirname(geminiDir),
+    });
     let added = 0;
-    for (const [name, value] of Object.entries(
-      DEFAULT_GEMINI_PROFILES.profiles,
-    )) {
-      if (!cfg.profiles[name]) {
-        cfg.profiles[name] = value;
-        added++;
-      }
+    for (const [name, { model }] of Object.entries(profiles)) {
+      if (!cfg.profiles[name]) added++;
+      cfg.profiles[name] = { model };
     }
-    if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
-
-    if (added > 0) {
-      writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-    }
-
+    if (!cfg.model || /^Gemini \d+(?:\.\d+)* Flash \(/.test(cfg.model))
+      cfg.model = profiles.flash.model;
+    const changed = writeModelFile(
+      profilesPath,
+      `${JSON.stringify(cfg, null, 2)}\n`,
+    );
     return {
       ok: true,
-      created: false,
+      created,
+      changed,
       added,
       count: Object.keys(cfg.profiles).length,
       message: null,
@@ -185,6 +170,7 @@ function ensureGeminiProfiles({
     return {
       ok: false,
       created: false,
+      changed: false,
       added: 0,
       count: 0,
       message: error.message,

package/scripts/lib/model-family-resolver.mjs

@@ -0,0 +1,335 @@
+import { execFileSync } from "node:child_process";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveTrifluxHome } from "./machine-profile.mjs";
+
+export const CODEX_FAMILY_PROFILES = Object.freeze({
+  sol_high: { family: "sol", effort: "high", model: "gpt-6.1-sol" },
+  sol_med: { family: "sol", effort: "medium", model: "gpt-6.1-sol" },
+  astra_xhigh: { family: "astra", effort: "xhigh", model: "gpt-6-astra" },
+  astra_max: { family: "astra", effort: "max", model: "gpt-6-astra" },
+  astra_ultra: { family: "astra", effort: "ultra", model: "gpt-6-astra" },
+  luna_high: { family: "luna", effort: "high", model: "gpt-6-luna" },
+  luna_low: { family: "luna", effort: "low", model: "gpt-6-luna" },
+});
+export const FLASH_FAMILY_PROFILES = Object.freeze({
+  flash_low: {
+    family: "flash",
+    effort: "low",
+    model: "Gemini 3.8 Flash (Low)",
+  },
+  flash: {
+    family: "flash",
+    effort: "medium",
+    model: "Gemini 3.8 Flash (Medium)",
+  },
+  flash_high: {
+    family: "flash",
+    effort: "high",
+    model: "Gemini 3.8 Flash (High)",
+  },
+});
+const DAY_MS = 86_400_000;
+const CODEX_SLUG = /^gpt-(\d+(?:\.\d+)*)-(sol|astra|luna)$/;
+const FLASH_SLUG = /^gemini-(\d+(?:\.\d+)*)-flash-(low|medium|high)$/;
+
+function compareVersions(a, b) {
+  const left = a.split(".").map(Number);
+  const right = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const difference = (left[i] || 0) - (right[i] || 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+export function selectCodexModel(models, family, effort) {
+  return (
+    (models || [])
+      .filter((item) => {
+        const match = CODEX_SLUG.exec(item?.slug);
+        return (
+          match?.[2] === family &&
+          item.visibility === "list" &&
+          Array.isArray(item.supported_reasoning_levels) &&
+          item.supported_reasoning_levels.some(
+            (level) => (level?.effort ?? level) === effort,
+          )
+        );
+      })
+      .sort((a, b) =>
+        compareVersions(CODEX_SLUG.exec(b.slug)[1], CODEX_SLUG.exec(a.slug)[1]),
+      )[0] || null
+  );
+}
+
+export function parseAgyModels(output) {
+  return String(output)
+    .split(/\r?\n/)
+    .flatMap((line) => {
+      const [slug, model] = line.trim().split("\t");
+      return FLASH_SLUG.test(slug) && model?.trim()
+        ? [{ slug, model: model.trim() }]
+        : [];
+    });
+}
+
+export function selectFlashModel(models, effort) {
+  return (
+    (models || [])
+      .filter(
+        (item) =>
+          FLASH_SLUG.exec(item?.slug)?.[2] === effort &&
+          typeof item.model === "string",
+      )
+      .sort((a, b) =>
+        compareVersions(FLASH_SLUG.exec(b.slug)[1], FLASH_SLUG.exec(a.slug)[1]),
+      )[0] || null
+  );
+}
+
+export function modelFamilyPaths(opts = {}) {
+  const env = opts.env || process.env;
+  const platform = opts.platform || process.platform;
+  const home = opts.home || resolveTrifluxHome({ env, platform });
+  const stateDir =
+    opts.stateDir ||
+    join(
+      platform === "win32"
+        ? env.APPDATA || join(home, "AppData", "Roaming")
+        : env.XDG_CONFIG_HOME || join(home, ".config"),
+      "triflux",
+    );
+  return {
+    home,
+    stateDir,
+    codexHome:
+      opts.codexHome ||
+      env.CODEX_HOME ||
+      env.TFX_CODEX_HOME ||
+      join(home, ".codex"),
+    pinsPath: join(stateDir, "models.json"),
+  };
+}
+
+function readJson(path) {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? value
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function signature(path) {
+  try {
+    const stat = statSync(path);
+    return `${path}:${stat.ino}:${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return `${path}:missing`;
+  }
+}
+
+export function writeModelFile(path, content) {
+  try {
+    if (readFileSync(path, "utf8") === content) return false;
+  } catch {}
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, content, { encoding: "utf8", mode: 0o600 });
+  renameSync(temp, path);
+  return true;
+}
+
+function saveJson(path, value) {
+  try {
+    writeModelFile(path, `${JSON.stringify(value)}\n`);
+  } catch {
+    // 읽기 전용 상태 디렉터리여도 이번 실행의 해석 결과는 쓸 수 있다.
+  }
+}
+
+const codexCatalogs = new Map();
+export function readCodexModelCatalog(opts = {}) {
+  const path = join(modelFamilyPaths(opts).codexHome, "models_cache.json");
+  const key = signature(path);
+  let cached = codexCatalogs.get(path);
+  if (cached?.key !== key) {
+    const value = readJson(path);
+    cached = { key, catalog: Array.isArray(value?.models) ? value : null };
+    codexCatalogs.set(path, cached);
+  }
+  return cached.catalog;
+}
+
+export function resolveModelFamilies(provider, opts = {}) {
+  const paths = modelFamilyPaths(opts);
+  const definitions =
+    provider === "codex" ? CODEX_FAMILY_PROFILES : FLASH_FAMILY_PROFILES;
+  const recordPath = join(paths.stateDir, `${provider}-model-resolution.json`);
+  const previous = readJson(recordPath) || {};
+  const now = (opts.now || Date.now)();
+  const fetchedAt = new Date(now).toISOString();
+  const run =
+    opts.runCommand ||
+    ((command, args) =>
+      execFileSync(command, args, {
+        encoding: "utf8",
+        timeout: 10_000,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...(opts.env || process.env),
+          HOME: paths.home,
+          CODEX_HOME: paths.codexHome,
+        },
+        maxBuffer: 4 * 1024 * 1024,
+      }));
+  let catalog = null;
+  let sourceSignature;
+  let checkedAt = previous.checked_at;
+  if (provider === "codex") {
+    const cachePath = join(paths.codexHome, "models_cache.json");
+    sourceSignature = signature(cachePath);
+    if (sourceSignature !== previous.sourceSignature)
+      catalog = readCodexModelCatalog(opts);
+    if (
+      sourceSignature.endsWith(":missing") &&
+      opts.allowCommand !== false &&
+      (!checkedAt || now - Date.parse(checkedAt) >= DAY_MS)
+    ) {
+      checkedAt = fetchedAt;
+      try {
+        const parsed = JSON.parse(
+          run(opts.command || "codex", ["debug", "models"]),
+        );
+        if (Array.isArray(parsed?.models))
+          catalog = { ...parsed, fetched_at: parsed.fetched_at || fetchedAt };
+      } catch {}
+    }
+  } else {
+    const cachePath = join(paths.stateDir, "agy-models.json");
+    let cached = readJson(cachePath) || {};
+    if (
+      opts.allowCommand !== false &&
+      (!cached.checked_at || now - Date.parse(cached.checked_at) >= DAY_MS)
+    ) {
+      const lock = `${cachePath}.lock`;
+      let acquired = false;
+      try {
+        if (opts.persist !== false) {
+          mkdirSync(paths.stateDir, { recursive: true });
+          // 프로세스가 끊긴 잠금만 회수한다. CLI 조회 제한은 10초다.
+          try {
+            if (now - statSync(lock).mtimeMs > 60_000)
+              rmSync(lock, { recursive: true, force: true });
+          } catch {}
+          mkdirSync(lock);
+          acquired = true;
+          cached = readJson(cachePath) || cached;
+        }
+        if (
+          !cached.checked_at ||
+          now - Date.parse(cached.checked_at) >= DAY_MS
+        ) {
+          cached.checked_at = fetchedAt;
+          try {
+            const models = parseAgyModels(
+              run(opts.command || "agy", ["models"]),
+            );
+            if (models.length)
+              cached = { models, fetched_at: fetchedAt, checked_at: fetchedAt };
+          } catch {}
+          if (opts.persist !== false) saveJson(cachePath, cached);
+        }
+      } catch {
+        // 다른 디스패치가 갱신 중이면 기존 결과로 실행한다.
+      } finally {
+        if (acquired) rmSync(lock, { recursive: true, force: true });
+      }
+    }
+    sourceSignature = signature(cachePath);
+    checkedAt = cached.checked_at;
+    if (Array.isArray(cached.models)) catalog = cached;
+  }
+  const profiles = {};
+  const selectedProfiles = {};
+  const pins = readJson(paths.pinsPath) || {};
+  for (const [name, definition] of Object.entries(definitions)) {
+    const saved = previous.profiles?.[name];
+    const last =
+      typeof saved?.model === "string" && saved.effort === definition.effort
+        ? saved
+        : null;
+    const candidate =
+      provider === "codex"
+        ? selectCodexModel(
+            catalog?.models,
+            definition.family,
+            definition.effort,
+          )
+        : selectFlashModel(catalog?.models, definition.effort);
+    profiles[name] =
+      candidate &&
+      (!last?.fetched_at ||
+        !catalog.fetched_at ||
+        Date.parse(catalog.fetched_at) >= Date.parse(last.fetched_at))
+        ? {
+            model: provider === "codex" ? candidate.slug : candidate.model,
+            effort: definition.effort,
+            fetched_at: catalog.fetched_at || fetchedAt,
+          }
+        : last || {
+            model: definition.model,
+            effort: definition.effort,
+            fetched_at: null,
+          };
+    selectedProfiles[name] = { ...profiles[name] };
+    const pin = pins[definition.family];
+    if (
+      typeof pin === "string" &&
+      provider === "codex" &&
+      CODEX_SLUG.exec(pin)?.[2] === definition.family
+    ) {
+      selectedProfiles[name] = {
+        model: pin,
+        effort: definition.effort,
+        source: paths.pinsPath,
+        fetched_at: null,
+      };
+    } else if (
+      typeof pin === "string" &&
+      provider === "agy" &&
+      /^gemini-\d+(?:\.\d+)*-flash$/.test(pin)
+    ) {
+      const slug = `${pin}-${definition.effort}`;
+      const version = pin.slice(7, -6);
+      const effort =
+        definition.effort[0].toUpperCase() + definition.effort.slice(1);
+      selectedProfiles[name] = {
+        model:
+          catalog?.models?.find((item) => item.slug === slug)?.model ||
+          `Gemini ${version} Flash (${effort})`,
+        effort: definition.effort,
+        source: paths.pinsPath,
+        fetched_at: null,
+      };
+    }
+  }
+  const record = {
+    sourceSignature,
+    checked_at: checkedAt || null,
+    profiles,
+    selectedProfiles,
+  };
+  if (opts.persist !== false) saveJson(recordPath, record);
+  return { profiles: selectedProfiles };
+}