@triflux/remote 10.86.0 → 10.87.0

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

@@ -24,7 +24,13 @@ import {
 import { dirname, join } from "node:path";
 
 import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
-import { CODEX_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
+import {
+  EFFORT_ORDER,
+  modelEffortFromProfile,
+  profileFromModelEffort,
+  resolveCodexModelEffort,
+} from "@triflux/core/scripts/lib/model-effort.mjs";
+import { AGY_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
 
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
@@ -50,7 +56,8 @@ const DEFAULT_CLAUDE_MODEL = "fable";
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    profile: "astra_max",
+    family: "astra",
+    effort: "max",
   }),
   Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
@@ -155,6 +162,39 @@ export function createRetryStateMachine(options = {}) {
         chain: state.cliChain,
       });
     }
+    const current = state.cliChain[state.cliIndex];
+    const next = state.cliChain[state.cliIndex + 1];
+    if (
+      current.cli === "codex" &&
+      next.cli === "codex" &&
+      current.family &&
+      next.family
+    ) {
+      try {
+        const base = resolveCodexModelEffort(current, options);
+        const promoted = resolveCodexModelEffort(next, options);
+        if (
+          promoted.effort !== next.effort &&
+          base.model === promoted.model &&
+          base.effort === promoted.effort
+        ) {
+          return transition(STATES.BUDGET_EXCEEDED, {
+            reason: "escalation-not-promoted",
+            escalated: false,
+            model: promoted.model,
+            requestedEffort: next.effort,
+            effort: promoted.effort,
+          });
+        }
+      } catch (error) {
+        if (error.code !== "unsupported-effort") throw error;
+        return transition(STATES.BUDGET_EXCEEDED, {
+          reason: "unsupported-escalation-effort",
+          escalated: false,
+          error: error.message,
+        });
+      }
+    }
     state.cliIndex += 1;
     state.iterations = 0;
     state.stuckCounter = 0;
@@ -306,11 +346,34 @@ function normalizeEscalationChainEntry(entry, index, source) {
   }
   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 };
+  const provider = entry.cli === "agy" ? "antigravity" : entry.cli;
+  if (provider === "codex" || provider === "antigravity") {
+    const explicit = entry.family !== undefined || entry.effort !== undefined;
+    let spec = explicit
+      ? typeof entry.family === "string" && typeof entry.effort === "string"
+        ? modelEffortFromProfile(provider, entry.family, entry.effort)
+        : null
+      : modelEffortFromProfile(
+          provider,
+          provider === "codex" ? normalizedProfile : profile,
+        );
+    if (explicit && !spec)
+      throw new Error(`${source}: chain[${index}] has invalid family/effort`);
+    if (spec) {
+      if (provider === "codex" && spec.effort === "ultra")
+        spec = { family: "astra", effort: "max" };
+      const legacy = profileFromModelEffort(provider, spec);
+      const normalized = { cli: entry.cli, ...spec };
+      if (legacy) normalized.profile = legacy;
+      if (provider === "antigravity" && legacy) {
+        normalized.model = entry.model || AGY_FAMILY_PROFILES[legacy]?.model;
+        if (typeof normalized.model !== "string" || !normalized.model.trim())
+          throw new Error(
+            `${source}: chain[${index}].model must be a non-empty string`,
+          );
+      }
+      return normalized;
+    }
   }
   if (typeof entry.model !== "string" || entry.model.trim() === "") {
     throw new Error(
@@ -319,6 +382,11 @@ function normalizeEscalationChainEntry(entry, index, source) {
   }
   const normalized = { cli: entry.cli, model: entry.model };
   if (profile) normalized.profile = profile;
+  if (entry.effort !== undefined) {
+    if (!EFFORT_ORDER.includes(entry.effort))
+      throw new Error(`${source}: chain[${index}] has invalid effort`);
+    normalized.effort = entry.effort;
+  }
   return normalized;
 }
 

package/package.json

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

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

@@ -9,130 +9,134 @@ import {
   resolveCodexProfileConfigValues,
 } from "./codex-profile-config.mjs";
 import { resolveGeminiProfileForPurpose } from "./gemini-profiles.mjs";
+import {
+  modelEffortFromProfile,
+  profileFromModelEffort,
+} from "@triflux/core/scripts/lib/model-effort.mjs";
 
 const policy = {
   executor: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   codex: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "build-fixer": {
-    profile: "luna_high",
+    codex: { family: "luna", effort: "high" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   cleanup: {
-    profile: "sol_med",
+    codex: { family: "sol", effort: "medium" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   deslop: {
-    profile: "sol_med",
+    codex: { family: "sol", effort: "medium" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   debugger: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "deep-executor": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "implement",
     subcommand: "exec",
   },
   architect: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   critic: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   planner: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   analyst: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "code-reviewer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "quality-reviewer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "security-reviewer": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   scientist: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "document-specialist": {
-    profile: "terra_high",
+    codex: { family: "terra", effort: "high" },
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "scientist-deep": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   verifier: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   "test-engineer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "qa-tester": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   spark: {
-    profile: "luna_low",
+    codex: { family: "luna", effort: "low" },
     timeoutSec: 180,
     mcpHint: "implement",
     subcommand: "exec",
@@ -140,13 +144,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: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   writer: {
-    profile: "terra_high",
+    codex: { family: "terra", effort: "high" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
@@ -154,7 +158,11 @@ const policy = {
 };
 
 function freezePolicy(entry) {
-  return Object.freeze({ ...entry });
+  return Object.freeze({
+    ...entry,
+    codex: Object.freeze({ ...entry.codex }),
+    profile: profileFromModelEffort("codex", entry.codex),
+  });
 }
 
 const CODEX_AGENT_POLICY = Object.freeze(
@@ -264,16 +272,16 @@ export function resolveNestedCodexAgentProfile(
       : NESTED_GLOBAL_PROFILE_OVERRIDES.has(globalOverride)
         ? globalOverride
         : "auto";
-  const fallback = resolveCodexAgentProfile(agent);
   const candidate = resolveCodexAgentProfile(agent, {
     profileOverride: effectiveOverride,
     retryProfile,
     nested: true,
     allowCustom: true,
   });
-  const { effort } = resolveCodexProfileConfigValues(candidate, { codexHome });
-  if (!effort) return fallback;
-  return effort.toLowerCase() === "ultra" ? "astra_max" : candidate;
+  const { effort } =
+    modelEffortFromProfile("codex", candidate) ||
+    resolveCodexProfileConfigValues(candidate, { codexHome });
+  return effort?.toLowerCase() === "ultra" ? "astra_max" : candidate;
 }
 
 const EXPECTED_DURATION_BY_AGENT = Object.freeze({
@@ -365,6 +373,7 @@ export function resolveAgentRoute(
       );
     }
   }
+  const { family, effort } = modelEffortFromProfile("codex", resolvedOverride);
   return [
     provider,
     policy.profile,
@@ -378,6 +387,8 @@ export function resolveAgentRoute(
     NATIVE_CODEX_AGENTS.has(agent),
     byAuthor ? reviewAuthor : "",
     usageSwitch,
+    effort,
+    family,
   ];
 }
 

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

@@ -9,6 +9,11 @@ import {
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { writeRotatedBackup } from "./backup-rotation.mjs";
+import {
+  modelEffortFromProfile,
+  normalizeCodexProfileName,
+  resolveCodexModelEffort,
+} from "@triflux/core/scripts/lib/model-effort.mjs";
 import {
   CODEX_FAMILY_PROFILES,
   modelFamilyPaths,
@@ -16,46 +21,42 @@ import {
   writeModelFile,
 } from "./model-family-resolver.mjs";
 
-const EFFORT_BY_SUFFIX = {
-  ultra: "ultra",
-  max: "max",
-  xhigh: "xhigh",
-  high: "high",
-  med: "medium",
-  medium: "medium",
-  low: "low",
-};
-
-const LEGACY_CANONICAL_PROFILE_ALIASES = Object.freeze({
-  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 { normalizeCodexProfileName };
 
-export function normalizeCodexProfileName(profileName) {
-  const normalized = String(profileName ?? "").trim();
-  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;
+export function managedCodexProfileContents(opts = {}) {
+  const { profiles, families } = resolveModelFamilies("codex", opts);
+  const contents = {};
+  for (const [name, { model, effort }] of Object.entries(profiles)) {
+    contents[name] =
+      `model = "${model}"\nmodel_reasoning_effort = "${effort}"\n`;
+  }
+  for (const [family, { model }] of Object.entries(families)) {
+    contents[family] = `model = "${model}"\n`;
+  }
+  return { profiles, contents };
 }
 
 export function ensureManagedCodexProfiles(opts = {}) {
   const { codexHome } = modelFamilyPaths(opts);
-  const { profiles } = resolveModelFamilies("codex", opts);
+  const { profiles, contents } = managedCodexProfileContents(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++;
+  const families = new Set(
+    Object.values(CODEX_FAMILY_PROFILES).map(({ family }) => family),
+  );
+  for (const [name, content] of Object.entries(contents)) {
+    const path = join(codexHome, `${name}.config.toml`);
+    if (families.has(name) && existsSync(path)) {
+      const existing = readFileSync(path, "utf8");
+      if (existing !== content) {
+        const backup = writeRotatedBackup(path, existing, {
+          label: "bak-model-family",
+          suffix: stamp(),
+          mode: privateFileMode(path),
+        });
+        opts.notice?.(`Codex 가족 프로필 백업: ${backup}`);
+      }
+    }
+    if (writeModelFile(path, content)) changed++;
   }
   return { changed, profiles };
 }
@@ -72,45 +73,25 @@ function readProfileScalar(raw, key) {
   return value || null;
 }
 
-/**
- * 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]`
- * table (which codex itself re-injects when it rewrites config.toml), so the
- * `-c` form is immune and needs no config mutation / sanitize race.
- *
- * SSOT = the per-profile file `~/.codex/<name>.config.toml` written by
- * `tfx setup`; falls back to deriving the effort from the `<...>_<effort>`
- * naming convention when the file is absent. Returns the keys that resolve, in
- * `key="value"` TOML-scalar form ready to be shell-quoted by the caller.
- *
- * @param {string} profileName
- * @param {{ codexHome?: string }} [opts]
- * @returns {string[]} e.g. ['model="gpt-6.1-sol"', 'model_reasoning_effort="high"']
- */
+// 관리 이름의 effort는 변환 표가 정한다. custom 파일은 ultra 제한 판정에 사용한다.
 export function resolveCodexProfileConfigValues(profileName, opts = {}) {
   if (typeof profileName !== "string" || !profileName) {
     return { model: null, effort: null };
   }
   const normalizedProfileName = normalizeCodexProfileName(profileName);
+  const managed = modelEffortFromProfile("codex", normalizedProfileName);
   const codexHome =
     opts.codexHome || process.env.CODEX_HOME || join(homedir(), ".codex");
   let model = null;
-  let effort = null;
+  let effort = managed ? resolveCodexModelEffort(managed, opts).effort : null;
   try {
     const raw = readFileSync(
       join(codexHome, `${normalizedProfileName}.config.toml`),
       "utf8",
     );
     model = readProfileScalar(raw, "model");
-    effort = readProfileScalar(raw, "model_reasoning_effort");
-  } catch {
-    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(
-      normalizedProfileName,
-    );
-    if (suffix) effort = EFFORT_BY_SUFFIX[suffix[1]] || null;
-  }
+    if (!managed) effort = readProfileScalar(raw, "model_reasoning_effort");
+  } catch {}
   return { model, effort };
 }
 

package/scripts/lib/gemini-profiles.mjs

@@ -1,5 +1,6 @@
 import { copyFileSync, existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { normalizeGeminiProfileName } from "@triflux/core/scripts/lib/model-effort.mjs";
 import {
   AGY_FAMILY_PROFILES,
   modelFamilyPaths,
@@ -17,11 +18,7 @@ const DEFAULT_GEMINI_PROFILES = {
   ),
 };
 
-export function normalizeGeminiProfileName(name) {
-  const raw = String(name ?? "").trim();
-  // Flash 가족은 뺐다. 옛 Flash 이름은 effort 와 상관없이 더 빠른 Argon Low 로 보낸다.
-  return raw.replace(/^flash\d*(?:_(?:low|high))?$/, "argon_low");
-}
+export { normalizeGeminiProfileName };
 
 // ── 용도별 effort (SSOT) ──
 // Argon 가족 안에서 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름

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

@@ -39,7 +39,8 @@ export const AGY_FAMILY_PROFILES = Object.freeze({
 });
 const DAY_MS = 86_400_000;
 const CODEX_SLUG = /^gpt-(\d+(?:\.\d+)*)-(sol|astra|terra|luna)$/;
-const AGY_SLUG = /^gemini-(\d+(?:\.\d+)*)-(argon)-(low|medium|high)$/;
+const AGY_SLUG =
+  /^gemini-(\d+(?:\.\d+)*)-(argon)-(none|low|medium|high|xhigh|max|ultra)$/;
 
 function compareVersions(a, b) {
   const left = a.split(".").map(Number);
@@ -59,10 +60,11 @@ export function selectCodexModel(models, family, effort) {
         return (
           match?.[2] === family &&
           item.visibility === "list" &&
-          Array.isArray(item.supported_reasoning_levels) &&
-          item.supported_reasoning_levels.some(
-            (level) => (level?.effort ?? level) === effort,
-          )
+          (effort === undefined ||
+            (Array.isArray(item.supported_reasoning_levels) &&
+              item.supported_reasoning_levels.some(
+                (level) => (level?.effort ?? level) === effort,
+              )))
         );
       })
       .sort((a, b) =>
@@ -89,7 +91,7 @@ export function selectAgyModel(models, family, effort) {
         const match = AGY_SLUG.exec(item?.slug);
         return (
           match?.[2] === family &&
-          match?.[3] === effort &&
+          (effort === undefined || match?.[3] === effort) &&
           typeof item.model === "string"
         );
       })
@@ -203,7 +205,7 @@ export function resolveModelFamilies(provider, opts = {}) {
   if (provider === "codex") {
     const cachePath = join(paths.codexHome, "models_cache.json");
     sourceSignature = signature(cachePath);
-    if (sourceSignature !== previous.sourceSignature)
+    if (sourceSignature !== previous.sourceSignature || !previous.families)
       catalog = readCodexModelCatalog(opts);
     if (
       sourceSignature.endsWith(":missing") &&
@@ -266,6 +268,8 @@ export function resolveModelFamilies(provider, opts = {}) {
   }
   const profiles = {};
   const selectedProfiles = {};
+  const families = {};
+  const selectedFamilies = {};
   const pins = readJson(paths.pinsPath) || {};
   for (const [name, definition] of Object.entries(definitions)) {
     const saved = previous.profiles?.[name];
@@ -329,13 +333,74 @@ export function resolveModelFamilies(provider, opts = {}) {
         fetched_at: null,
       };
     }
+    if (provider === "codex" && !Object.hasOwn(families, definition.family)) {
+      const latest = selectCodexModel(catalog?.models, definition.family);
+      const lastFamily =
+        previous.families?.[definition.family] || profiles[name];
+      families[definition.family] =
+        latest &&
+        (!lastFamily.fetched_at ||
+          !catalog.fetched_at ||
+          Date.parse(catalog.fetched_at) >= Date.parse(lastFamily.fetched_at))
+          ? { model: latest.slug, fetched_at: catalog.fetched_at || fetchedAt }
+          : { model: lastFamily.model, fetched_at: lastFamily.fetched_at };
+      selectedFamilies[definition.family] =
+        typeof pin === "string" &&
+        CODEX_SLUG.exec(pin)?.[2] === definition.family
+          ? { model: pin, source: paths.pinsPath, fetched_at: null }
+          : { ...families[definition.family] };
+    }
+  }
+  if (provider === "agy") {
+    const latest = selectAgyModel(catalog?.models, "argon");
+    // 옛 기록에는 가족 ID가 없으므로 마지막 성공 프로필의 표시 이름에서 복원한다.
+    const savedModels = [
+      ...Object.values(AGY_FAMILY_PROFILES),
+      ...Object.values(profiles),
+    ].flatMap((profile) => {
+      const match = /^Gemini (\d+(?:\.\d+)*) Argon \(/i.exec(profile.model);
+      return match
+        ? [{ ...profile, slug: `gemini-${match[1]}-argon-${profile.effort}` }]
+        : [];
+    });
+    const saved = selectAgyModel(savedModels, "argon");
+    const last = previous.families?.argon || {
+      model: saved.slug.replace(/-[^-]+$/, ""),
+      fetched_at: saved.fetched_at,
+    };
+    families.argon =
+      latest &&
+      (!last.fetched_at ||
+        !catalog.fetched_at ||
+        Date.parse(catalog.fetched_at) >= Date.parse(last.fetched_at))
+        ? {
+            model: latest.slug.replace(/-[^-]+$/, ""),
+            fetched_at: catalog.fetched_at || fetchedAt,
+          }
+        : last;
+    const pin = pins.argon;
+    selectedFamilies.argon =
+      typeof pin === "string" && AGY_SLUG.test(`${pin}-low`)
+        ? { model: pin, source: paths.pinsPath, fetched_at: null }
+        : { ...families.argon };
+    const supported = catalog?.models
+      ?.filter((item) =>
+        item.slug.startsWith(`${selectedFamilies.argon.model}-`),
+      )
+      .map((item) => AGY_SLUG.exec(item.slug)?.[3])
+      .filter(Boolean);
+    if (supported?.length) selectedFamilies.argon.supportedEfforts = supported;
   }
   const record = {
     sourceSignature,
     checked_at: checkedAt || null,
     profiles,
     selectedProfiles,
+    families,
   };
   if (opts.persist !== false) saveJson(recordPath, record);
-  return { profiles: selectedProfiles };
+  return {
+    profiles: selectedProfiles,
+    families: selectedFamilies,
+  };
 }