@triflux/core 10.50.2 → 10.52.0

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

@@ -1,176 +1,137 @@
 // Canonical Codex role policy. Concrete model IDs stay in profile config files.
 
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 import {
   normalizeCodexProfileName,
   resolveCodexProfileConfigValues,
 } from "./codex-profile-config.mjs";
+import { resolveGeminiProfileForPurpose } from "./gemini-profiles.mjs";
 
 const policy = {
   executor: {
     profile: "gpt61_sol_high",
     timeoutSec: 1080,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   codex: {
     profile: "gpt61_sol_high",
     timeoutSec: 1080,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "build-fixer": {
     profile: "gpt6_luna_high",
     timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   cleanup: {
     profile: "gpt61_sol_med",
     timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   deslop: {
     profile: "gpt61_sol_med",
     timeoutSec: 540,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   debugger: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "deep-executor": {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
     mcpHint: "implement",
     subcommand: "exec",
   },
   architect: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   critic: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: true,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   planner: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "fg",
-    opusOversight: true,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   analyst: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "fg",
-    opusOversight: true,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "code-reviewer": {
     profile: "gpt61_sol_high",
     timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "review",
     subcommand: "review",
   },
   "quality-reviewer": {
     profile: "gpt61_sol_high",
     timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "review",
     subcommand: "review",
   },
   "security-reviewer": {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 1800,
-    runMode: "bg",
-    opusOversight: true,
     mcpHint: "review",
     subcommand: "review",
   },
   scientist: {
     profile: "gpt61_sol_high",
     timeoutSec: 1440,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "document-specialist": {
     profile: "gpt61_sol_high",
     timeoutSec: 1440,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "scientist-deep": {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 3600,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   verifier: {
     profile: "gpt61_sol_high",
     timeoutSec: 1200,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "review",
     subcommand: "review",
   },
   "test-engineer": {
     profile: "gpt61_sol_high",
     timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "qa-tester": {
     profile: "gpt61_sol_high",
     timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "review",
     subcommand: "review",
   },
   spark: {
     profile: "gpt6_luna_low",
     timeoutSec: 180,
-    runMode: "fg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
@@ -179,16 +140,12 @@ const policy = {
   designer: {
     profile: "gpt6_astra_xhigh",
     timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
   writer: {
     profile: "gpt6_luna_high",
     timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
     mcpHint: "implement",
     subcommand: "exec",
   },
@@ -198,7 +155,7 @@ function freezePolicy(entry) {
   return Object.freeze({ ...entry });
 }
 
-export const CODEX_AGENT_POLICY = Object.freeze(
+const CODEX_AGENT_POLICY = Object.freeze(
   Object.fromEntries(
     Object.entries(policy).map(([agent, entry]) => [
       agent,
@@ -206,9 +163,9 @@ export const CODEX_AGENT_POLICY = Object.freeze(
     ]),
   ),
 );
-export const DEFAULT_CODEX_AGENT = "executor";
+const DEFAULT_CODEX_AGENT = "executor";
 
-export const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
+const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
   new Set([
     "gpt6_luna_low",
     "gpt6_luna_high",
@@ -219,7 +176,7 @@ export const CANONICAL_CODEX_PROFILE_OVERRIDES = Object.freeze(
     "gpt6_astra_ultra",
   ]),
 );
-export const ULTRA_ELIGIBLE_CODEX_AGENTS = Object.freeze(
+const ULTRA_ELIGIBLE_CODEX_AGENTS = Object.freeze(
   new Set(["deep-executor", "scientist-deep"]),
 );
 
@@ -316,39 +273,163 @@ export function resolveNestedCodexAgentProfile(
   return effort.toLowerCase() === "ultra" ? "gpt6_astra_max" : candidate;
 }
 
-export function describeCodexAgentPolicy() {
-  return {
-    defaultAgent: DEFAULT_CODEX_AGENT,
-    agents: Object.keys(CODEX_AGENT_POLICY),
-  };
+const EXPECTED_DURATION_BY_AGENT = Object.freeze({
+  writer: 90,
+  verifier: 90,
+  "qa-tester": 90,
+  executor: 300,
+  debugger: 300,
+  "test-engineer": 300,
+  "code-reviewer": 600,
+  "security-reviewer": 600,
+  architect: 600,
+  planner: 600,
+  critic: 600,
+  analyst: 600,
+  scientist: 900,
+  "scientist-deep": 900,
+  "deep-executor": 900,
+  "document-specialist": 900,
+});
+
+const NATIVE_CODEX_AGENTS = new Set([
+  "explore",
+  "verifier",
+  "test-engineer",
+  "qa-tester",
+]);
+
+function resolveDirectCodexRoutePolicy(agent) {
+  if (agent === "explore") {
+    return { ...CODEX_AGENT_POLICY.spark, timeoutSec: 600, mcpHint: "analyze" };
+  }
+  if (agent === "antigravity" || agent === "agy") {
+    return CODEX_AGENT_POLICY.designer;
+  }
+  return resolveCodexAgentPolicy(agent);
+}
+
+export function resolveAgentRoute(
+  agent,
+  map,
+  profileOverride = "auto",
+  nested = false,
+  geminiProfileResolver = resolveGeminiProfileForPurpose,
+) {
+  if (!/^[A-Za-z0-9_.-]+$/.test(agent)) {
+    throw new Error(`invalid agent: ${agent}`);
+  }
+  if (!Object.hasOwn(map, agent)) {
+    throw new Error(
+      `알 수 없는 에이전트 타입: ${agent}; available: ${Object.keys(map).join(", ")}`,
+    );
+  }
+  const provider = map[agent];
+  if (!["codex", "antigravity", "claude"].includes(provider)) {
+    throw new Error(`invalid provider for ${agent}: ${provider}`);
+  }
+  const policy = resolveDirectCodexRoutePolicy(agent);
+  const normalizedOverride = normalizeCodexProfileName(profileOverride);
+  let resolvedOverride = policy.profile;
+  if (normalizedOverride !== "auto") {
+    try {
+      resolvedOverride = resolveCodexAgentProfile(agent, {
+        profileOverride: normalizedOverride,
+        nested,
+      });
+    } catch {
+      throw new Error(
+        `TFX_CODEX_PROFILE 값이 유효하지 않습니다: ${profileOverride}`,
+      );
+    }
+  }
+  return [
+    provider,
+    policy.profile,
+    policy.timeoutSec,
+    policy.mcpHint,
+    policy.subcommand,
+    normalizedOverride,
+    resolvedOverride,
+    geminiProfileResolver(agent),
+    EXPECTED_DURATION_BY_AGENT[agent] ?? 30,
+    NATIVE_CODEX_AGENTS.has(agent),
+  ];
 }
 
 function parseCliArgs(argv) {
   const args = [...argv];
   let format = "json";
   let agent = DEFAULT_CODEX_AGENT;
+  let mapFile = "";
+  let profileOverride = "auto";
+  let geminiProfilesModule = "";
+  let nested = false;
   while (args.length > 0) {
     const flag = args.shift();
     if (flag === "--format") format = args.shift() || "";
     else if (flag === "--agent") agent = args.shift() || "";
+    else if (flag === "--map-file") mapFile = args.shift() || "";
+    else if (flag === "--profile-override")
+      profileOverride = args.shift() || "";
+    else if (flag === "--gemini-profiles-module")
+      geminiProfilesModule = args.shift() || "";
+    else if (flag === "--nested") nested = true;
     else throw new Error(`unknown argument: ${flag}`);
   }
-  if (!new Set(["json", "tsv"]).has(format)) {
+  if (!new Set(["json", "tsv", "route"]).has(format)) {
     throw new Error(`unsupported format: ${format}`);
   }
-  return { format, agent };
+  return {
+    format,
+    agent,
+    mapFile,
+    profileOverride,
+    geminiProfilesModule,
+    nested,
+  };
 }
 
-function runCli() {
-  const { format, agent } = parseCliArgs(process.argv.slice(2));
+async function runCli() {
+  const {
+    format,
+    agent,
+    mapFile,
+    profileOverride,
+    geminiProfilesModule,
+    nested,
+  } = parseCliArgs(process.argv.slice(2));
+  if (format === "route") {
+    if (!mapFile) throw new Error("--map-file is required for route format");
+    const map = JSON.parse(readFileSync(mapFile, "utf8"));
+    let resolver = resolveGeminiProfileForPurpose;
+    if (geminiProfilesModule) {
+      try {
+        const module = await import(pathToFileURL(geminiProfilesModule).href);
+        resolver = (agent) => {
+          try {
+            return module.resolveGeminiProfileForPurpose(agent) || "flash38";
+          } catch {
+            return "flash38";
+          }
+        };
+      } catch {
+        resolver = () => "flash38";
+      }
+    }
+    process.stdout.write(
+      resolveAgentRoute(agent, map, profileOverride, nested, resolver).join(
+        "\x1e",
+      ),
+    );
+    return;
+  }
   const resolved = resolveCodexAgentPolicy(agent);
   if (format === "tsv") {
     process.stdout.write(
       [
         resolved.profile,
         resolved.timeoutSec,
-        resolved.runMode,
-        resolved.opusOversight,
         resolved.mcpHint,
         resolved.subcommand,
       ].join("\t"),
@@ -360,7 +441,7 @@ function runCli() {
 
 if (import.meta.url === new URL(process.argv[1], "file:").href) {
   try {
-    runCli();
+    await runCli();
   } catch (error) {
     process.stderr.write(`[agent-route-policy] ${error.message}\n`);
     process.exitCode = 1;

package/scripts/lib/cli-claude.mjs

@@ -3,8 +3,6 @@
 // 책임: Claude 는 외부 CLI 가 아닌 Claude Code Agent 도구로 dispatch 된다. plan() 은
 // command=null 을 반환하고 호출자가 Agent() 로 라우팅하도록 신호한다.
 //
-// 출처: 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";
@@ -14,32 +12,22 @@ export const command = null;
 const AGENT_PROFILES = {
   explore: {
     timeoutSec: 600,
-    runMode: "fg",
-    opusOversight: false,
     model: "haiku",
   },
   claude: {
     timeoutSec: 600,
-    runMode: "fg",
-    opusOversight: false,
     model: "haiku",
   },
   "test-engineer": {
     timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
     model: "sonnet",
   },
   "qa-tester": {
     timeoutSec: 1200,
-    runMode: "bg",
-    opusOversight: false,
     model: "sonnet",
   },
   verifier: {
     timeoutSec: 1200,
-    runMode: "fg",
-    opusOversight: false,
     model: "sonnet",
   },
 };
@@ -64,8 +52,6 @@ export function plan({
     profile: "claude-native",
     effort: "n/a",
     timeoutMs: effectiveTimeoutSec * 1000,
-    runMode: cfg.runMode,
-    opusOversight: cfg.opusOversight,
     model: cfg.model,
     mcpProfile: mcpProfile === "auto" ? null : mcpProfile,
     promptLength: prompt.length,

package/scripts/lib/env-probe.mjs

@@ -1,76 +1,12 @@
-import { execSync, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { resolveHubPortForContext } from "../../hub/hub-lifecycle.mjs";
+import { join } from "node:path";
 import { whichCommand, whichCommandAsync } from "../../hub/platform.mjs";
 
-const HUB_DEFAULT_PORT = 27888;
-const DEFAULT_STATUS_URL = "http://127.0.0.1:27888/status";
-const _sab = new Int32Array(new SharedArrayBuffer(4));
 const CLI_PROBE_CACHE = new Map();
 const CLI_PROBE_PROMISES = new Map();
 
-const __filename = fileURLToPath(import.meta.url);
-const DEFAULT_PKG_ROOT = join(dirname(__filename), "..", "..");
-
-function sleepSync(ms) {
-  Atomics.wait(_sab, 0, 0, ms);
-}
-
-function fetchHubStatus({
-  execSyncFn = execSync,
-  statusUrl = resolveDefaultStatusUrl(),
-  timeout = 3000,
-} = {}) {
-  const response = execSyncFn(`curl -sf ${statusUrl}`, {
-    timeout,
-    encoding: "utf8",
-    windowsHide: true,
-  });
-  const data = JSON.parse(response);
-  return {
-    ok: true,
-    state: data?.hub?.state || "unknown",
-    pid: data?.pid,
-  };
-}
-
-export function resolveDefaultStatusUrl(
-  env = process.env,
-  cwd = process.cwd(),
-) {
-  const port = resolveHubPortForContext({
-    env,
-    cwd,
-    defaultPort: HUB_DEFAULT_PORT,
-  });
-  return `http://127.0.0.1:${port}/status`;
-}
-
-function resolveStatusUrlForContext({
-  statusUrl,
-  env = process.env,
-  cwd = process.cwd(),
-} = {}) {
-  try {
-    const url = new URL(String(statusUrl));
-    url.port = String(
-      resolveHubPortForContext({
-        port: url.port,
-        env,
-        cwd,
-        defaultPort: HUB_DEFAULT_PORT,
-      }),
-    );
-    return url.toString();
-  } catch {
-    return resolveDefaultStatusUrl(env, cwd);
-  }
-}
-
 function normalizeCliName(name) {
   return String(name ?? "").trim() || null;
 }
@@ -125,7 +61,7 @@ async function resolveCliProbe(name, options = {}) {
   return toCliResult(path);
 }
 
-export async function checkCli(name, options = {}) {
+async function checkCli(name, options = {}) {
   const cliName = normalizeCliName(name);
   if (!cliName) return { ok: false };
 
@@ -168,11 +104,6 @@ export async function probeClis(names, options = {}) {
   return mapCliResults(cliNames, results);
 }
 
-export function resetCliProbeCache() {
-  CLI_PROBE_CACHE.clear();
-  CLI_PROBE_PROMISES.clear();
-}
-
 export function detectCodexAuthState({
   homeDir = homedir(),
   existsSyncFn = existsSync,
@@ -237,63 +168,3 @@ export function detectCodexPlan(options = {}) {
   const { plan, source } = detectCodexAuthState(options);
   return { plan, source };
 }
-
-export function checkHub({
-  env = process.env,
-  cwd = process.cwd(),
-  pkgRoot = DEFAULT_PKG_ROOT,
-  statusUrl = resolveDefaultStatusUrl(env, cwd),
-  restart = true,
-  requestTimeoutMs = 3000,
-  pollAttempts = 8,
-  pollIntervalMs = 500,
-  execSyncFn = execSync,
-  spawnFn = spawn,
-  existsSyncFn = existsSync,
-  sleepSyncFn = sleepSync,
-} = {}) {
-  const guardedStatusUrl = resolveStatusUrlForContext({ statusUrl, env, cwd });
-  try {
-    return fetchHubStatus({
-      execSyncFn,
-      statusUrl: guardedStatusUrl,
-      timeout: requestTimeoutMs,
-    });
-  } catch {}
-
-  if (!restart) return { ok: false, state: "unreachable", restart: "disabled" };
-
-  const serverPath = join(pkgRoot, "hub", "server.mjs");
-  if (!existsSyncFn(serverPath))
-    return { ok: false, state: "unreachable", restart: "no_server" };
-
-  try {
-    const child = spawnFn(process.execPath, [serverPath], {
-      env: { ...env, TFX_HUB_PORT: String(new URL(guardedStatusUrl).port) },
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-    });
-    child.unref();
-  } catch {
-    return { ok: false, state: "unreachable", restart: "spawn_failed" };
-  }
-
-  for (let i = 0; i < pollAttempts; i++) {
-    sleepSyncFn(pollIntervalMs);
-    try {
-      const status = fetchHubStatus({
-        execSyncFn,
-        statusUrl: guardedStatusUrl,
-        timeout: Math.min(requestTimeoutMs, 1000),
-      });
-      if (status.state === "healthy") {
-        return { ...status, restarted: true };
-      }
-    } catch {}
-  }
-
-  return { ok: false, state: "unreachable", restart: "timeout" };
-}
-
-export { DEFAULT_PKG_ROOT, DEFAULT_STATUS_URL };