triflux 10.43.0 → 10.44.0

package/hub/workers/delegator-mcp.mjs

@@ -11,6 +11,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod";
+import { resolveCodexAgentPolicy } from "../../scripts/lib/agent-route-policy.mjs";
 import { resolveBashExecutable } from "../lib/bash-path.mjs";
 import { runHeadlessWithCleanup } from "../team/headless.mjs";
 import { buildWorkerSandboxEnv } from "../team/worker-sandbox.mjs";
@@ -33,57 +34,11 @@ const { buildPromptHint, getCodexMcpConfig, SUPPORTED_MCP_PROFILES } =
   await import(pathToFileURL(mcpFilterPath).href);
 const SERVER_INFO = { name: "triflux-delegator", version: "1.0.0" };
 const DEFAULT_CONTEXT_BYTES = 32 * 1024;
-const DEFAULT_ROUTE_TIMEOUT_SEC = 120;
 const DIRECT_PROGRESS_START = 5;
 const DIRECT_PROGRESS_RUNNING = 60;
 const DIRECT_PROGRESS_DONE = 100;
 const SEARCH_ENGINE_CACHE_PATH = [".omc", "state", "search-engines.json"];
 
-const AGENT_TIMEOUT_SEC = Object.freeze({
-  executor: 1080,
-  "build-fixer": 540,
-  debugger: 900,
-  "deep-executor": 3600,
-  architect: 3600,
-  planner: 3600,
-  critic: 3600,
-  analyst: 3600,
-  "code-reviewer": 1800,
-  "security-reviewer": 1800,
-  "quality-reviewer": 1800,
-  scientist: 1440,
-  "scientist-deep": 3600,
-  "document-specialist": 1440,
-  designer: 900,
-  writer: 900,
-  explore: 300,
-  verifier: 1200,
-  "test-engineer": 300,
-  "qa-tester": 300,
-  spark: 180,
-});
-
-const CODEX_PROFILE_BY_AGENT = Object.freeze({
-  executor: "gpt56_terra_high",
-  "build-fixer": "gpt56_luna_low",
-  debugger: "gpt56_sol_xhigh",
-  "deep-executor": "gpt56_sol_xhigh",
-  architect: "gpt56_sol_xhigh",
-  planner: "gpt56_sol_xhigh",
-  critic: "gpt56_sol_xhigh",
-  analyst: "gpt56_sol_xhigh",
-  "code-reviewer": "gpt56_terra_high",
-  "security-reviewer": "gpt56_sol_xhigh",
-  "quality-reviewer": "gpt56_terra_high",
-  scientist: "gpt56_terra_high",
-  "scientist-deep": "gpt56_sol_xhigh",
-  "document-specialist": "gpt56_terra_high",
-  verifier: "gpt56_terra_high",
-  designer: "gpt56_sol_xhigh",
-  writer: "gpt56_luna_low",
-  spark: "gpt56_luna_low",
-});
-
 const REVIEW_INSTRUCTION_BY_AGENT = Object.freeze({
   "code-reviewer":
     "코드 리뷰 모드로 동작하라. 버그, 리스크, 회귀, 테스트 누락을 우선 식별하라.",
@@ -137,7 +92,7 @@ function resolveRouteScript(explicitPath, cwd = process.cwd()) {
 }
 
 function resolveCodexProfile(agentType) {
-  return CODEX_PROFILE_BY_AGENT[agentType] || "high";
+  return resolveCodexAgentPolicy(agentType).profile;
 }
 
 function normalizeProvider(provider = "auto") {
@@ -154,8 +109,7 @@ function resolveTimeoutMs(agentType, timeoutMs) {
     return Math.trunc(timeoutMs);
   }
 
-  const timeoutSec = AGENT_TIMEOUT_SEC[agentType] || DEFAULT_ROUTE_TIMEOUT_SEC;
-  return timeoutSec * 1000;
+  return resolveCodexAgentPolicy(agentType).timeoutSec * 1000;
 }
 
 function resolveTimeoutSec(agentType, timeoutMs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.43.0",
+  "version": "10.44.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
     "playwright-core": "^1.53.0"
   },
   "files": [
+    "adapters",
     "bin",
     "tui",
     "config",

package/scripts/__tests__/lint-skills.test.mjs

@@ -98,4 +98,72 @@ describe("lint-skills", () => {
       rmSync(root, { recursive: true, force: true });
     }
   });
+
+  it("실행형 Agent 호출은 model=이 없으면 실패한다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      writeSkill(
+        root,
+        "tfx-agent",
+        '---\nname: tfx-agent\ndescription: 한국어 설명\n---\nAgent(subagent_type="explore", prompt="x")',
+      );
+      const result = lintSkills({ skillsDir });
+      assert.equal(result.ok, false);
+      assert.equal(result.problems[0]?.code, "agent-model-required");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("model=이 있는 실행형 Agent와 prose signature는 통과한다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      writeSkill(
+        root,
+        "tfx-agent-ok",
+        '---\nname: tfx-agent-ok\ndescription: 한국어 설명\n---\nAgent()\nAgent(subagent_type="explore", model="haiku", prompt="x")',
+      );
+      const result = lintSkills({ skillsDir });
+      assert.equal(result.ok, true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("문자열 안의 괄호가 있어도 model=이 있는 실행형 Agent를 통과시킨다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      writeSkill(
+        root,
+        "tfx-agent-nested-model",
+        '---\nname: tfx-agent-nested-model\ndescription: 한국어 설명\n---\nAgent(subagent_type="x", prompt="do (this)", model="haiku")',
+      );
+      const result = lintSkills({ skillsDir });
+      assert.equal(result.ok, true);
+      assert.deepEqual(result.problems, []);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("문자열 안의 괄호가 있어도 model= 없는 실행형 Agent를 실패 처리한다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      writeSkill(
+        root,
+        "tfx-agent-nested-missing-model",
+        '---\nname: tfx-agent-nested-missing-model\ndescription: 한국어 설명\n---\nAgent(prompt="foo(bar)", subagent_type="x")',
+      );
+      const result = lintSkills({ skillsDir });
+      assert.equal(result.ok, false);
+      assert.equal(result.problems.length, 1);
+      assert.equal(result.problems[0]?.code, "agent-model-required");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
 });

package/scripts/__tests__/tfx-route-node-entry.test.mjs

@@ -262,6 +262,42 @@ describe("cli-codex.mjs — 핵심 매핑", () => {
     assert.equal(p.mcpProfile, "analyze");
   });
 
+  test("explicit max override selects the canonical Sol max profile", () => {
+    const p = codexAdapter.plan({
+      agent: "architect",
+      prompt: "x",
+      mcpProfile: "auto",
+      profileOverride: "max",
+    });
+    assert.equal(p.profile, "gpt56_sol_max");
+    assert.equal(p.effort, "gpt56_sol_max");
+  });
+
+  test("ultra is limited to top-level deep execution and research", () => {
+    const topLevel = codexAdapter.plan({
+      agent: "deep-executor",
+      prompt: "x",
+      profileOverride: "ultra",
+      nested: false,
+    });
+    const nested = codexAdapter.plan({
+      agent: "deep-executor",
+      prompt: "x",
+      profileOverride: "ultra",
+      nested: true,
+    });
+    const ineligible = codexAdapter.plan({
+      agent: "architect",
+      prompt: "x",
+      profileOverride: "ultra",
+      nested: false,
+    });
+
+    assert.equal(topLevel.profile, "gpt56_sol_ultra");
+    assert.equal(nested.profile, "gpt56_sol_max");
+    assert.equal(ineligible.profile, "gpt56_sol_max");
+  });
+
   test("security-reviewer → review 서브커맨드 + opus oversight", () => {
     const p = codexAdapter.plan({
       agent: "security-reviewer",

package/scripts/keyword-detector.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   compileRules,
@@ -90,6 +90,27 @@ export function sanitizeForKeywordDetection(text) {
     .trim();
 }
 
+// repo_scope 는 path segment 단위로 매칭한다 — "triflux" 는 .../tools/triflux/... 에만
+// 매칭되고 .../triflux-ideas 같은 부분 문자열에는 매칭되지 않는다. 빈 scope = 전역.
+export function matchesRepoScope(path, scopes) {
+  if (!Array.isArray(scopes) || scopes.length === 0) return true;
+  if (typeof path !== "string" || !path) return false;
+  const segments = path.split(/[\\/]+/).filter(Boolean);
+  return scopes.some((scope) => segments.includes(scope));
+}
+
+// resolvedMatches[0] 단일 승자의 우선순위 역전 방지 — explicit(종결 라우팅) 규칙이
+// 있으면 정렬 순서와 무관하게 그 규칙이 이긴다. 없으면 정렬 선두 유지.
+export function selectPrimaryMatch(resolvedMatches) {
+  if (!Array.isArray(resolvedMatches) || resolvedMatches.length === 0) {
+    return null;
+  }
+  const explicitMatch = resolvedMatches.find(
+    (match) => match?.explicit === true,
+  );
+  return explicitMatch ?? resolvedMatches[0];
+}
+
 function createHookOutput(additionalContext) {
   return {
     continue: true,
@@ -263,7 +284,6 @@ function main() {
     return;
   }
 
-  const selected = resolvedMatches[0];
   const baseDir =
     typeof payload.cwd === "string" && payload.cwd
       ? payload.cwd
@@ -271,6 +291,15 @@ function main() {
         ? payload.directory
         : process.cwd();
 
+  const scopedMatches = resolvedMatches.filter((match) =>
+    matchesRepoScope(baseDir, match.repo_scope),
+  );
+  const selected = selectPrimaryMatch(scopedMatches);
+  if (!selected) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
   activateState(baseDir, selected.state, prompt, payload);
 
   if (selected.action === "context_hint" && selected.hint) {
@@ -308,9 +337,27 @@ function main() {
   console.log(JSON.stringify(createSuppressOutput()));
 }
 
-try {
-  main();
-} catch (error) {
-  console.error(`[triflux-keyword-detector] 예외 발생: ${error.message}`);
-  console.log(JSON.stringify(createSuppressOutput()));
+// 훅 실행(node scripts/keyword-detector.mjs)일 때만 main 구동 — 테스트 import 시
+// stdin 대기로 행이 걸리지 않도록 direct-run 가드.
+const isDirectRun = (() => {
+  try {
+    if (typeof process.argv[1] !== "string" || !process.argv[1]) return false;
+    const selfPath = fileURLToPath(import.meta.url);
+    const argvPath = resolve(process.argv[1]);
+    if (selfPath === argvPath) return true;
+    // 심링크 설치 경로: argv[1]이 심링크면 import.meta.url(실경로)과 어긋난다.
+    // canonical 경로로 재비교 (realpath 실패 시 non-direct 취급).
+    return selfPath === realpathSync(argvPath);
+  } catch {
+    return false;
+  }
+})();
+
+if (isDirectRun) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`[triflux-keyword-detector] 예외 발생: ${error.message}`);
+    console.log(JSON.stringify(createSuppressOutput()));
+  }
 }

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;
+  }
+}