@triflux/remote 10.50.1 → 10.51.0

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

@@ -1,9 +1,12 @@
 // 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: {
@@ -198,7 +201,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 +209,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 +222,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,31 +319,176 @@ 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 MIN_TIMEOUT_BY_AGENT = Object.freeze({
+  "deep-executor": 900,
+  architect: 900,
+  planner: 900,
+  critic: 900,
+  analyst: 900,
+  "document-specialist": 900,
+  scientist: 900,
+  "scientist-deep": 900,
+  "code-reviewer": 600,
+  "security-reviewer": 600,
+  "quality-reviewer": 600,
+  executor: 300,
+  debugger: 300,
+});
+
+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.runMode,
+    policy.opusOversight,
+    policy.mcpHint,
+    policy.subcommand,
+    normalizedOverride,
+    resolvedOverride,
+    geminiProfileResolver(agent),
+    MIN_TIMEOUT_BY_AGENT[agent] ?? 120,
+    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(
@@ -360,7 +508,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/claudemd-scanner.mjs

@@ -1,114 +1,6 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const TFX_START = "<!-- TFX:START -->";
-export const TFX_END = "<!-- TFX:END -->";
-export const OMC_END = "<!-- OMC:END -->";
-const TFX_VERSION_RE = /<!-- TFX:VERSION:([\d.]+) -->/u;
-
-const LEGACY_PATTERNS = [
-  /<user_cli_routing>/u,
-  /Codex Pro 무료 기간/u,
-  /codex exec --dangerously-bypass.*skip-git-repo-check/u,
-  /OMC 에이전트 → CLI 매핑/u,
-  /Spark 가드레일/u,
-];
-
-const DEFAULT_TFX_TEMPLATE = [
-  "### triflux CLI routing (managed)",
-  "- 이 블록은 triflux setup에서 자동으로 관리됩니다.",
-  "- 직접 수정이 필요하면 블록 바깥에 사용자 섹션을 추가하세요.",
-].join("\n");
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_TEMPLATE_PATH = join(
-  SCRIPT_DIR,
-  "..",
-  "templates",
-  "claudemd-tfx-section.md",
-);
-
-function resolveVersion(version) {
-  if (version) return version;
-  try {
-    const pkgPath = join(SCRIPT_DIR, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-function resolveTemplate(template, templatePath = DEFAULT_TEMPLATE_PATH) {
-  if (typeof template === "string" && template.trim()) {
-    return template.trim();
-  }
-  if (existsSync(templatePath)) {
-    const raw = readFileSync(templatePath, "utf8").trim();
-    if (raw) return raw;
-  }
-  return DEFAULT_TFX_TEMPLATE;
-}
-
-function findManagedSection(rawText) {
-  const raw = String(rawText || "");
-  const startIdx = raw.indexOf(TFX_START);
-  const endMarkerIdx = raw.indexOf(TFX_END);
-  if (startIdx === -1 || endMarkerIdx === -1 || endMarkerIdx <= startIdx) {
-    return {
-      found: false,
-      content: null,
-      version: null,
-      startIdx: -1,
-      endIdx: -1,
-    };
-  }
-
-  const endIdx = endMarkerIdx + TFX_END.length;
-  const content = raw.slice(startIdx, endIdx);
-  const versionMatch = content.match(TFX_VERSION_RE);
-
-  return {
-    found: true,
-    content,
-    version: versionMatch ? versionMatch[1] : null,
-    startIdx,
-    endIdx,
-  };
-}
-
-function detectLegacyRange(rawText) {
-  const raw = String(rawText || "");
-  const matches = LEGACY_PATTERNS.some((pattern) => pattern.test(raw));
-  if (!matches) {
-    return { found: false, startIdx: -1, endIdx: -1 };
-  }
-
-  const startTag = raw.indexOf("<user_cli_routing>");
-  const endTag = raw.indexOf("</user_cli_routing>");
-  if (startTag === -1 || endTag === -1 || endTag <= startTag) {
-    return { found: true, startIdx: -1, endIdx: -1 };
-  }
-
-  let removeStart = startTag;
-  const userOverridesComment = "<!-- USER OVERRIDES";
-  const commentIdx = raw.lastIndexOf(userOverridesComment, startTag);
-  if (commentIdx !== -1 && startTag - commentIdx < 200) {
-    removeStart = commentIdx;
-  }
-
-  return {
-    found: true,
-    startIdx: removeStart,
-    endIdx: endTag + "</user_cli_routing>".length,
-  };
-}
-
-function normalizeSpacing(text) {
-  return String(text || "").replace(/\n{3,}/gu, "\n\n");
-}
+import { join, resolve } from "node:path";
 
 export function findAllClaudeMdPaths(options = {}) {
   const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
@@ -132,92 +24,3 @@ export function findAllClaudeMdPaths(options = {}) {
   }
   return paths;
 }
-
-export function writeSection(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  const version = resolveVersion(options.version);
-  const template = resolveTemplate(options.template, options.templatePath);
-  const block = [
-    TFX_START,
-    `<!-- TFX:VERSION:${version} -->`,
-    template,
-    TFX_END,
-  ].join("\n");
-
-  if (!existsSync(absolutePath)) {
-    writeFileSync(absolutePath, `${block}\n`, "utf8");
-    return { action: "created", version, path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-
-  if (existing.found) {
-    const nextContent = `${raw.slice(0, existing.startIdx)}${block}${raw.slice(existing.endIdx)}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return {
-      action: "updated",
-      oldVersion: existing.version,
-      version,
-      path: absolutePath,
-    };
-  }
-
-  const omcEndIdx = raw.indexOf(OMC_END);
-  if (omcEndIdx !== -1) {
-    const insertAt = omcEndIdx + OMC_END.length;
-    const before = raw.slice(0, insertAt);
-    const after = raw.slice(insertAt);
-    const nextContent = `${before}\n${block}${after}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return { action: "inserted_after_omc", version, path: absolutePath };
-  }
-
-  const separator = raw.endsWith("\n") ? "" : "\n";
-  writeFileSync(absolutePath, `${raw}${separator}${block}\n`, "utf8");
-  return { action: "appended", version, path: absolutePath };
-}
-
-export function migrateClaudeMd(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  if (!existsSync(absolutePath)) {
-    return { action: "no_file", removed: [], path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-  const legacy = detectLegacyRange(raw);
-
-  if (existing.found && !legacy.found) {
-    return {
-      action: "already_managed",
-      removed: [],
-      version: existing.version,
-      path: absolutePath,
-    };
-  }
-
-  const removed = [];
-  let nextContent = raw;
-
-  if (legacy.found && legacy.startIdx !== -1 && legacy.endIdx !== -1) {
-    nextContent = `${nextContent.slice(0, legacy.startIdx)}${nextContent.slice(legacy.endIdx)}`;
-    removed.push("<user_cli_routing> block");
-  }
-
-  const existingAfterLegacy = findManagedSection(nextContent);
-  if (existingAfterLegacy.found) {
-    nextContent = `${nextContent.slice(0, existingAfterLegacy.startIdx)}${nextContent.slice(existingAfterLegacy.endIdx)}`;
-    removed.push("old TFX block");
-  }
-
-  writeFileSync(absolutePath, normalizeSpacing(nextContent), "utf8");
-  const writeResult = writeSection(absolutePath, options);
-
-  return {
-    action: "migrated",
-    removed,
-    version: writeResult.version,
-    path: absolutePath,
-  };
-}

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";

package/scripts/lib/context.mjs

@@ -5,19 +5,13 @@
  * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
  *
  * 사용법:
- *   import { getLogger, getCorrelationId, withRequestContext } from './lib/context.mjs';
+ *   import { getCorrelationId, withRequestContext } from './lib/context.mjs';
  *
  *   // 미들웨어에서 컨텍스트 생성
  *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
- *     const log = getLogger();
- *     log.info({ agentId }, 'bridge.result_received');
+ *     const correlationId = getCorrelationId();
  *   });
  *
- *   // 내부 함수에서 자동 상관 ID
- *   function processResult() {
- *     const log = getLogger();
- *     log.info('result.processed'); // correlationId 자동 포함
- *   }
  */
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
@@ -25,17 +19,7 @@ import { randomUUID } from "node:crypto";
 import { logger } from "./logger.mjs";
 
 /** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
-export const asyncLocalStorage = new AsyncLocalStorage();
-
-/**
- * 현재 요청 컨텍스트의 로거를 반환한다.
- * 요청 컨텍스트 밖에서 호출하면 기본 로거를 반환한다.
- *
- * @returns {import('pino').Logger}
- */
-export function getLogger() {
-  return asyncLocalStorage.getStore()?.logger || logger;
-}
+const asyncLocalStorage = new AsyncLocalStorage();
 
 /**
  * 현재 요청의 상관 ID를 반환한다.

package/scripts/lib/env-probe.mjs

@@ -1,25 +1,15 @@
-import { execSync, spawn } from "node:child_process";
+import { execSync } 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 { join } from "node:path";
 import { resolveHubPortForContext } from "../../hub/hub-lifecycle.mjs";
 import { whichCommand, whichCommandAsync } from "@triflux/core/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(),
@@ -38,10 +28,7 @@ function fetchHubStatus({
   };
 }
 
-export function resolveDefaultStatusUrl(
-  env = process.env,
-  cwd = process.cwd(),
-) {
+function resolveDefaultStatusUrl(env = process.env, cwd = process.cwd()) {
   const port = resolveHubPortForContext({
     env,
     cwd,
@@ -125,7 +112,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 +155,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,
@@ -241,16 +223,9 @@ export function detectCodexPlan(options = {}) {
 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 {
@@ -259,41 +234,7 @@ export function checkHub({
       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" };
+    return { ok: false, state: "unreachable", restart: "disabled" };
   }
-
-  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 };