@triflux/core 10.42.0 → 10.44.0

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

@@ -0,0 +1,360 @@
+// Canonical Codex role policy. Concrete model IDs stay in profile config files.
+
+import { resolveCodexProfileConfigValues } from "./codex-profile-config.mjs";
+
+const policy = {
+  executor: {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1080,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  codex: {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1080,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  "build-fixer": {
+    profile: "gpt56_luna_low",
+    timeoutSec: 540,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  cleanup: {
+    profile: "gpt56_terra_med",
+    timeoutSec: 540,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  deslop: {
+    profile: "gpt56_terra_med",
+    timeoutSec: 540,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  debugger: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 900,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  "deep-executor": {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "bg",
+    opusOversight: true,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  architect: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "bg",
+    opusOversight: true,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  critic: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "bg",
+    opusOversight: true,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  planner: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "fg",
+    opusOversight: true,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  analyst: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "fg",
+    opusOversight: true,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  "code-reviewer": {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1800,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "review",
+    subcommand: "review",
+  },
+  "quality-reviewer": {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1800,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "review",
+    subcommand: "review",
+  },
+  "security-reviewer": {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 1800,
+    runMode: "bg",
+    opusOversight: true,
+    mcpHint: "review",
+    subcommand: "review",
+  },
+  scientist: {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1440,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  "document-specialist": {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1440,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  "scientist-deep": {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 3600,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "analyze",
+    subcommand: "exec",
+  },
+  verifier: {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1200,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "review",
+    subcommand: "review",
+  },
+  "test-engineer": {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1200,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  "qa-tester": {
+    profile: "gpt56_terra_high",
+    timeoutSec: 1200,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "review",
+    subcommand: "review",
+  },
+  spark: {
+    profile: "gpt56_luna_low",
+    timeoutSec: 180,
+    runMode: "fg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  // These entries are only for explicit direct-Codex overrides. agent-map.json
+  // remains the provider-selection authority for their normal execution.
+  designer: {
+    profile: "gpt56_sol_xhigh",
+    timeoutSec: 900,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+  writer: {
+    profile: "gpt56_luna_low",
+    timeoutSec: 900,
+    runMode: "bg",
+    opusOversight: false,
+    mcpHint: "implement",
+    subcommand: "exec",
+  },
+};
+
+function freezePolicy(entry) {
+  return Object.freeze({ ...entry });
+}
+
+export const CODEX_AGENT_POLICY = Object.freeze(
+  Object.fromEntries(
+    Object.entries(policy).map(([agent, entry]) => [
+      agent,
+      freezePolicy(entry),
+    ]),
+  ),
+);
+export const DEFAULT_CODEX_AGENT = "executor";
+
+export const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
+  new Set([
+    "gpt56_luna_low",
+    "gpt56_terra_med",
+    "gpt56_terra_high",
+    "gpt56_sol_xhigh",
+    "gpt56_sol_max",
+    "gpt56_sol_ultra",
+  ]),
+);
+export const ULTRA_ELIGIBLE_CODEX_AGENTS = Object.freeze(
+  new Set(["deep-executor", "scientist-deep"]),
+);
+
+const NESTED_GLOBAL_PROFILE_OVERRIDES = new Set([
+  "max",
+  "ultra",
+  "gpt56_sol_max",
+  "gpt56_sol_ultra",
+]);
+
+export function resolveCodexAgentPolicy(agent) {
+  return freezePolicy(
+    CODEX_AGENT_POLICY[agent] ?? CODEX_AGENT_POLICY[DEFAULT_CODEX_AGENT],
+  );
+}
+
+/**
+ * Resolves a requested Codex profile against the canonical role policy.
+ *
+ * `retryProfile` intentionally wins over `profileOverride`: retry snapshots
+ * represent an already-selected escalation step and must not be replaced by a
+ * later process-level `TFX_CODEX_PROFILE`. Ultra is reserved for an eligible
+ * top-level role; every nested/sandboxed or ineligible request is max.
+ */
+export function resolveCodexAgentProfile(
+  agent,
+  {
+    profileOverride = "auto",
+    retryProfile = null,
+    nested = false,
+    allowCustom = false,
+  } = {},
+) {
+  const defaultProfile = resolveCodexAgentPolicy(agent).profile;
+  const retryRequested = String(retryProfile ?? "").trim();
+  const requested = retryRequested || String(profileOverride || "auto").trim();
+  if (!requested || requested === "auto") return defaultProfile;
+
+  const canonical =
+    requested === "max"
+      ? "gpt56_sol_max"
+      : requested === "ultra"
+        ? "gpt56_sol_ultra"
+        : requested;
+  if (!CANONICAL_CODEX_PROFILE_OVERRIDES.has(canonical)) {
+    if (allowCustom) return requested;
+    throw new Error(
+      `[agent-route-policy] unsupported profile override: ${requested}`,
+    );
+  }
+  if (canonical !== "gpt56_sol_ultra") return canonical;
+  return nested || !ULTRA_ELIGIBLE_CODEX_AGENTS.has(agent)
+    ? "gpt56_sol_max"
+    : canonical;
+}
+
+/**
+ * Nested headless, team, worker, and delegator launches always select an
+ * explicit role profile rather than inheriting the global Codex config. A
+ * custom profile that resolves to ultra is also downgraded to max.
+ */
+export function resolveNestedCodexAgentProfile(
+  agent,
+  {
+    profileOverride = "auto",
+    globalProfile = "auto",
+    retryProfile = null,
+    codexHome,
+  } = {},
+) {
+  const explicitProfile = String(profileOverride || "auto").trim();
+  const globalOverride = String(globalProfile || "auto").trim();
+  // Headless lanes must select their role policy explicitly. Only the max and
+  // ultra exception lanes may cross the process environment boundary.
+  const effectiveOverride =
+    explicitProfile !== "auto"
+      ? explicitProfile
+      : 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" ? "gpt56_sol_max" : candidate;
+}
+
+export function describeCodexAgentPolicy() {
+  return {
+    defaultAgent: DEFAULT_CODEX_AGENT,
+    agents: Object.keys(CODEX_AGENT_POLICY),
+  };
+}
+
+function parseCliArgs(argv) {
+  const args = [...argv];
+  let format = "json";
+  let agent = DEFAULT_CODEX_AGENT;
+  while (args.length > 0) {
+    const flag = args.shift();
+    if (flag === "--format") format = args.shift() || "";
+    else if (flag === "--agent") agent = args.shift() || "";
+    else throw new Error(`unknown argument: ${flag}`);
+  }
+  if (!new Set(["json", "tsv"]).has(format)) {
+    throw new Error(`unsupported format: ${format}`);
+  }
+  return { format, agent };
+}
+
+function runCli() {
+  const { format, agent } = parseCliArgs(process.argv.slice(2));
+  const resolved = resolveCodexAgentPolicy(agent);
+  if (format === "tsv") {
+    process.stdout.write(
+      [
+        resolved.profile,
+        resolved.timeoutSec,
+        resolved.runMode,
+        resolved.opusOversight,
+        resolved.mcpHint,
+        resolved.subcommand,
+      ].join("\t"),
+    );
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(resolved)}\n`);
+}
+
+if (import.meta.url === new URL(process.argv[1], "file:").href) {
+  try {
+    runCli();
+  } catch (error) {
+    process.stderr.write(`[agent-route-policy] ${error.message}\n`);
+    process.exitCode = 1;
+  }
+}

package/scripts/lib/cli-agy.mjs

@@ -5,6 +5,7 @@
 //
 // 출처: scripts/tfx-route.sh route_agent() L1052-L1059, run_codex_exec() L2036-L2046.
 //        .claude/rules/tfx-update-logic.md Antigravity CLI 1.0.0 정밀 sanity matrix.
+// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
 
 export const id = "agy";
 export const cliType = "antigravity";

package/scripts/lib/cli-claude.mjs

@@ -5,6 +5,7 @@
 //
 // 출처: scripts/tfx-route.sh route_agent() L1062-L1063 (explore|claude),
 //        L1196-L1203 (TFX_CLI_MODE=gemini fallback), TFX_VERIFIER_OVERRIDE=claude.
+// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
 
 export const id = "claude";
 export const cliType = "claude-native";

package/scripts/lib/cli-codex.mjs

@@ -4,168 +4,23 @@
 // 산출한다. 실제 spawn 은 Phase 1 에서 이관된다 (현재는 tfx-route.sh 가 수행).
 //
 // 진입점: tfx-route.mjs → selectAdapter("codex") → plan({...}).
-// 출처: scripts/tfx-route.sh route_agent() L1001-L1079 case 문 미러.
+// 출처: agent-route-policy.mjs 의 canonical Codex role policy.
+// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
 
 export const id = "codex";
 export const cliType = "codex";
 export const command = "codex";
 
-const AGENT_PROFILES = {
-  executor: {
-    profile: "gpt55_high",
-    timeoutSec: 1080,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  codex: {
-    profile: "gpt55_high",
-    timeoutSec: 1080,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  "build-fixer": {
-    profile: "gpt55_low",
-    timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  cleanup: {
-    profile: "gpt55_med",
-    timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  deslop: {
-    profile: "gpt55_med",
-    timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  debugger: {
-    profile: "gpt55_xhigh",
-    timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  "deep-executor": {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
-    mcpHint: "implement",
-  },
-  architect: {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
-    mcpHint: "analyze",
-  },
-  critic: {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
-    mcpHint: "analyze",
-  },
-  planner: {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "fg",
-    opusOversight: true,
-    mcpHint: "analyze",
-  },
-  analyst: {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "fg",
-    opusOversight: true,
-    mcpHint: "analyze",
-  },
-  "code-reviewer": {
-    profile: "gpt55_high",
-    timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "review",
-    subcommand: "review",
-  },
-  "quality-reviewer": {
-    profile: "gpt55_high",
-    timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "review",
-    subcommand: "review",
-  },
-  "security-reviewer": {
-    profile: "gpt55_xhigh",
-    timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: true,
-    mcpHint: "review",
-    subcommand: "review",
-  },
-  scientist: {
-    profile: "gpt55_high",
-    timeoutSec: 1440,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "analyze",
-  },
-  "document-specialist": {
-    profile: "gpt55_high",
-    timeoutSec: 1440,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "analyze",
-  },
-  "scientist-deep": {
-    profile: "gpt55_xhigh",
-    timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "analyze",
-  },
-  verifier: {
-    profile: "gpt55_high",
-    timeoutSec: 1200,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "review",
-    subcommand: "review",
-  },
-  "test-engineer": {
-    profile: "gpt55_high",
-    timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-  "qa-tester": {
-    profile: "gpt55_high",
-    timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "review",
-    subcommand: "review",
-  },
-  spark: {
-    profile: "gpt55_low",
-    timeoutSec: 180,
-    runMode: "fg",
-    opusOversight: false,
-    mcpHint: "implement",
-  },
-};
+import {
+  CODEX_AGENT_POLICY,
+  resolveCodexAgentPolicy,
+  resolveCodexAgentProfile,
+  resolveNestedCodexAgentProfile,
+} from "./agent-route-policy.mjs";
 
-const DEFAULT_PROFILE = AGENT_PROFILES.executor;
+// Compatibility re-exports for launchers which historically imported these
+// helpers from this adapter. The policy module owns the semantics.
+export { resolveCodexAgentProfile, resolveNestedCodexAgentProfile };
 
 export function plan({
   agent,
@@ -173,18 +28,26 @@ export function plan({
   mcpProfile = "auto",
   timeoutSec,
   contextFile,
+  profileOverride = "auto",
+  retryProfile = null,
+  nested = false,
 } = {}) {
   if (!agent) {
     throw new Error("[cli-codex] agent required");
   }
-  const cfg = AGENT_PROFILES[agent] ?? DEFAULT_PROFILE;
+  const cfg = resolveCodexAgentPolicy(agent);
+  const profile = resolveCodexAgentProfile(agent, {
+    profileOverride,
+    retryProfile,
+    nested,
+  });
   const effectiveTimeoutSec =
     Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : cfg.timeoutSec;
   return {
     command,
     subcommand: cfg.subcommand ?? "exec",
-    profile: cfg.profile,
-    effort: cfg.profile,
+    profile,
+    effort: profile,
     timeoutMs: effectiveTimeoutSec * 1000,
     runMode: cfg.runMode,
     opusOversight: cfg.opusOversight,
@@ -195,5 +58,5 @@ export function plan({
 }
 
 export function describe() {
-  return { id, cliType, command, agents: Object.keys(AGENT_PROFILES) };
+  return { id, cliType, command, agents: Object.keys(CODEX_AGENT_POLICY) };
 }

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

@@ -9,6 +9,8 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 const EFFORT_BY_SUFFIX = {
+  ultra: "ultra",
+  max: "max",
   xhigh: "xhigh",
   high: "high",
   med: "medium",
@@ -16,6 +18,15 @@ const EFFORT_BY_SUFFIX = {
   low: "low",
 };
 
+const CANONICAL_PROFILE_VALUES = Object.freeze({
+  gpt56_luna_low: { model: "gpt-5.6-luna", effort: "low" },
+  gpt56_terra_med: { model: "gpt-5.6-terra", effort: "medium" },
+  gpt56_terra_high: { model: "gpt-5.6-terra", effort: "high" },
+  gpt56_sol_xhigh: { model: "gpt-5.6-sol", effort: "xhigh" },
+  gpt56_sol_max: { model: "gpt-5.6-sol", effort: "max" },
+  gpt56_sol_ultra: { model: "gpt-5.6-sol", effort: "ultra" },
+});
+
 function readProfileScalar(raw, key) {
   const match = String(raw).match(
     new RegExp(
@@ -29,7 +40,7 @@ function readProfileScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt55_high") to the `-c key=value`
+ * Resolve a Codex effort profile name (e.g. "gpt56_terra_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]`
@@ -47,10 +58,12 @@ function readProfileScalar(raw, key) {
  *
  * @param {string} profileName
  * @param {{ codexHome?: string }} [opts]
- * @returns {string[]} e.g. ['model="gpt-5.5"', 'model_reasoning_effort="high"']
+ * @returns {string[]} e.g. ['model="gpt-5.6-terra"', 'model_reasoning_effort="high"']
  */
-export function codexProfileConfigOverrides(profileName, opts = {}) {
-  if (typeof profileName !== "string" || !profileName) return [];
+export function resolveCodexProfileConfigValues(profileName, opts = {}) {
+  if (typeof profileName !== "string" || !profileName) {
+    return { model: null, effort: null };
+  }
   const codexHome =
     opts.codexHome || process.env.CODEX_HOME || join(homedir(), ".codex");
   let model = null;
@@ -63,9 +76,22 @@ export function codexProfileConfigOverrides(profileName, opts = {}) {
     model = readProfileScalar(raw, "model");
     effort = readProfileScalar(raw, "model_reasoning_effort");
   } catch {
-    const suffix = /_(xhigh|high|med|medium|low)$/.exec(profileName);
+    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(profileName);
     if (suffix) effort = EFFORT_BY_SUFFIX[suffix[1]] || null;
   }
+  return { model, effort };
+}
+
+export function codexProfileConfigOverrides(profileName, opts = {}) {
+  let { model, effort } = resolveCodexProfileConfigValues(profileName, opts);
+  if (opts.enforceCanonicalProfile === true) {
+    const canonical = CANONICAL_PROFILE_VALUES[profileName];
+    if (canonical) ({ model, effort } = canonical);
+  }
+  if (opts.disallowUltra === true && effort?.toLowerCase() === "ultra") {
+    model = "gpt-5.6-sol";
+    effort = "max";
+  }
   const overrides = [];
   if (model) overrides.push(`model="${model}"`);
   if (effort) overrides.push(`model_reasoning_effort="${effort}"`);

package/scripts/lib/keyword-rules.mjs

@@ -26,6 +26,7 @@ function normalizeState(state) {
 
 function normalizeRule(rule) {
   if (!rule || typeof rule !== "object") return null;
+  if (rule.disabled === true) return null;
   if (typeof rule.id !== "string" || !rule.id.trim()) return null;
   if (!Array.isArray(rule.patterns) || rule.patterns.length === 0) return null;
   if (typeof rule.priority !== "number" || !Number.isFinite(rule.priority))
@@ -61,6 +62,13 @@ function normalizeRule(rule) {
   const state = normalizeState(rule.state);
   if (rule.state != null && state == null) return null;
 
+  // repo_scope: path segment 화이트리스트 (빈 배열 = 전역). explicit: 종결 라우팅 마커.
+  const repoScope = Array.isArray(rule.repo_scope)
+    ? rule.repo_scope
+        .filter((s) => typeof s === "string" && s.trim())
+        .map((s) => s.trim())
+    : [];
+
   return {
     id: rule.id.trim(),
     patterns,
@@ -72,6 +80,8 @@ function normalizeRule(rule) {
     exclusive: rule.exclusive === true,
     state,
     mcp_route: mcpRoute,
+    repo_scope: repoScope,
+    explicit: rule.explicit === true,
   };
 }
 
@@ -149,6 +159,8 @@ export function matchRules(compiledRules, cleanText) {
       exclusive: rule.exclusive === true,
       state: rule.state || null,
       mcp_route: rule.mcp_route || null,
+      repo_scope: rule.repo_scope || [],
+      explicit: rule.explicit === true,
     });
   }