@triflux/core 10.67.1 → 10.69.0

package/hub/team/agent-map.json

@@ -14,7 +14,7 @@
   "quality-reviewer": "codex",
   "scientist": "codex",
   "scientist-deep": "codex",
-  "document-specialist": "codex",
+  "document-specialist": "antigravity",
   "spark": "codex",
   "designer": "antigravity",
   "writer": "antigravity",

package/package.json

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

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

@@ -408,13 +408,13 @@ async function runCli() {
         const module = await import(pathToFileURL(geminiProfilesModule).href);
         resolver = (agent) => {
           try {
-            return module.resolveGeminiProfileForPurpose(agent) || "flash";
+            return module.resolveGeminiProfileForPurpose(agent) || "argon";
           } catch {
-            return "flash";
+            return "argon";
           }
         };
       } catch {
-        resolver = () => "flash";
+        resolver = () => "argon";
       }
     }
     process.stdout.write(

package/scripts/lib/gemini-profiles.mjs

@@ -1,16 +1,16 @@
 import { copyFileSync, existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import {
-  FLASH_FAMILY_PROFILES,
+  AGY_FAMILY_PROFILES,
   modelFamilyPaths,
   resolveModelFamilies,
   writeModelFile,
 } from "./model-family-resolver.mjs";
 
 const DEFAULT_GEMINI_PROFILES = {
-  model: FLASH_FAMILY_PROFILES.flash.model,
+  model: AGY_FAMILY_PROFILES.argon.model,
   profiles: Object.fromEntries(
-    Object.entries(FLASH_FAMILY_PROFILES).map(([name, { model }]) => [
+    Object.entries(AGY_FAMILY_PROFILES).map(([name, { model }]) => [
       name,
       { model },
     ]),
@@ -19,46 +19,47 @@ const DEFAULT_GEMINI_PROFILES = {
 
 export function normalizeGeminiProfileName(name) {
   const raw = String(name ?? "").trim();
-  return raw.replace(/^flash\d*(?=_(?:low|high)$|$)/, "flash");
+  // Flash 가족은 뺐다. 옛 Flash 이름은 effort 와 상관없이 더 빠른 Argon Low 로 보낸다.
+  return raw.replace(/^flash\d*(?:_(?:low|high))?$/, "argon_low");
 }
 
 // ── 용도별 effort (SSOT) ──
-// Flash 가족 안에서 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름
+// Argon 가족 안에서 역할에 따라 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: "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",
+  designer: "argon_high",
+  reviewer: "argon_high",
+  "code-reviewer": "argon_high",
+  "security-reviewer": "argon_high",
+  "quality-reviewer": "argon_high",
+  critic: "argon_high",
+  architect: "argon_high",
+  verifier: "argon_high",
+  analyst: "argon_high",
+  debugger: "argon_high",
+  planner: "argon_high",
+  scientist: "argon_high",
+  "test-engineer": "argon_high",
+  writer: "argon",
+  executor: "argon",
+  worker: "argon",
+  "document-specialist": "argon",
+  researcher: "argon",
+  antigravity: "argon",
+  agy: "argon",
+  gemini: "argon",
+  summarizer: "argon_low",
+  classifier: "argon_low",
+  triage: "argon_low",
+  translator: "argon_low",
+  formatter: "argon_low",
+  explore: "argon_low",
 });
-const GEMINI_DEFAULT_PURPOSE_PROFILE = "flash";
+const GEMINI_DEFAULT_PURPOSE_PROFILE = "argon";
 
 function resolveGeminiProfileForPurpose(name) {
   const key = String(name ?? "")
@@ -96,7 +97,8 @@ function resolveGeminiModel(profileOrModel, opts = {}) {
     cfg?.modelProfiles,
     cfg?.models,
   ]) {
-    const entry = bucket?.[name] || bucket?.[raw];
+    // 옛 Flash 이름은 정규화한 이름으로만 찾는다. 원래 이름으로 찾으면 남은 Flash 항목이 돌아온다.
+    const entry = bucket?.[name];
     const value = modelValue(entry);
     if (typeof value === "string" && value.trim()) return value.trim();
   }
@@ -152,8 +154,11 @@ function ensureGeminiProfiles(opts = {}) {
       if (!cfg.profiles[name]) added++;
       cfg.profiles[name] = { model };
     }
-    if (!cfg.model || /^Gemini \d+(?:\.\d+)* Flash \(/.test(cfg.model))
-      cfg.model = profiles.flash.model;
+    if (
+      !cfg.model ||
+      /^Gemini \d+(?:\.\d+)* (?:Flash|Argon) \(/.test(cfg.model)
+    )
+      cfg.model = profiles.argon.model;
     const changed = writeModelFile(
       profilesPath,
       `${JSON.stringify(cfg, null, 2)}\n`,

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

@@ -19,26 +19,26 @@ export const CODEX_FAMILY_PROFILES = Object.freeze({
   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",
+export const AGY_FAMILY_PROFILES = Object.freeze({
+  argon_low: {
+    family: "argon",
     effort: "low",
-    model: "Gemini 3.8 Flash (Low)",
+    model: "Gemini 4 Argon (Low)",
   },
-  flash: {
-    family: "flash",
+  argon: {
+    family: "argon",
     effort: "medium",
-    model: "Gemini 3.8 Flash (Medium)",
+    model: "Gemini 4 Argon (Medium)",
   },
-  flash_high: {
-    family: "flash",
+  argon_high: {
+    family: "argon",
     effort: "high",
-    model: "Gemini 3.8 Flash (High)",
+    model: "Gemini 4 Argon (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)$/;
+const AGY_SLUG = /^gemini-(\d+(?:\.\d+)*)-(argon)-(low|medium|high)$/;
 
 function compareVersions(a, b) {
   const left = a.split(".").map(Number);
@@ -75,22 +75,25 @@ export function parseAgyModels(output) {
     .split(/\r?\n/)
     .flatMap((line) => {
       const [slug, model] = line.trim().split("\t");
-      return FLASH_SLUG.test(slug) && model?.trim()
+      return AGY_SLUG.test(slug) && model?.trim()
         ? [{ slug, model: model.trim() }]
         : [];
     });
 }
 
-export function selectFlashModel(models, effort) {
+export function selectAgyModel(models, family, effort) {
   return (
     (models || [])
-      .filter(
-        (item) =>
-          FLASH_SLUG.exec(item?.slug)?.[2] === effort &&
-          typeof item.model === "string",
-      )
+      .filter((item) => {
+        const match = AGY_SLUG.exec(item?.slug);
+        return (
+          match?.[2] === family &&
+          match?.[3] === effort &&
+          typeof item.model === "string"
+        );
+      })
       .sort((a, b) =>
-        compareVersions(FLASH_SLUG.exec(b.slug)[1], FLASH_SLUG.exec(a.slug)[1]),
+        compareVersions(AGY_SLUG.exec(b.slug)[1], AGY_SLUG.exec(a.slug)[1]),
       )[0] || null
   );
 }
@@ -174,7 +177,7 @@ export function readCodexModelCatalog(opts = {}) {
 export function resolveModelFamilies(provider, opts = {}) {
   const paths = modelFamilyPaths(opts);
   const definitions =
-    provider === "codex" ? CODEX_FAMILY_PROFILES : FLASH_FAMILY_PROFILES;
+    provider === "codex" ? CODEX_FAMILY_PROFILES : AGY_FAMILY_PROFILES;
   const recordPath = join(paths.stateDir, `${provider}-model-resolution.json`);
   const previous = readJson(recordPath) || {};
   const now = (opts.now || Date.now)();
@@ -276,7 +279,7 @@ export function resolveModelFamilies(provider, opts = {}) {
             definition.family,
             definition.effort,
           )
-        : selectFlashModel(catalog?.models, definition.effort);
+        : selectAgyModel(catalog?.models, definition.family, definition.effort);
     profiles[name] =
       candidate &&
       (!last?.fetched_at ||
@@ -294,6 +297,10 @@ export function resolveModelFamilies(provider, opts = {}) {
           };
     selectedProfiles[name] = { ...profiles[name] };
     const pin = pins[definition.family];
+    const agyPin =
+      provider === "agy" && typeof pin === "string"
+        ? AGY_SLUG.exec(`${pin}-${definition.effort}`)
+        : null;
     if (
       typeof pin === "string" &&
       provider === "codex" &&
@@ -305,19 +312,17 @@ export function resolveModelFamilies(provider, opts = {}) {
         source: paths.pinsPath,
         fetched_at: null,
       };
-    } else if (
-      typeof pin === "string" &&
-      provider === "agy" &&
-      /^gemini-\d+(?:\.\d+)*-flash$/.test(pin)
-    ) {
+    } else if (agyPin?.[2] === definition.family) {
       const slug = `${pin}-${definition.effort}`;
-      const version = pin.slice(7, -6);
+      const version = agyPin[1];
+      const family =
+        definition.family[0].toUpperCase() + definition.family.slice(1);
       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})`,
+          `Gemini ${version} ${family} (${effort})`,
         effort: definition.effort,
         source: paths.pinsPath,
         fetched_at: null,