@triflux/remote 10.42.0 → 10.44.0

package/hub/workers/codex-app-server-worker.mjs

@@ -12,6 +12,12 @@ import { createHash, randomUUID } from "node:crypto";
 import { isAbsolute } from "node:path";
 import process from "node:process";
 
+import {
+  createActivityLifecycle,
+  isActivityLifecycleEnabled,
+  resolveHardCeilingMs,
+  resolveStallInterventionMs,
+} from "@triflux/core/hub/lib/worker-lifecycle.mjs";
 import {
   JsonRpcProtocolError,
   JsonRpcStdioClient,
@@ -25,6 +31,7 @@ export const CODEX_APP_SERVER_TRANSPORT_EXIT_CODE = 70;
 export const CODEX_APP_SERVER_TIMEOUT_EXIT_CODE = 124;
 
 export const DEFAULT_CODEX_APP_SERVER_BOOTSTRAP_TIMEOUT_MS = 10_000;
+// Legacy wall-clock default retained for TFX_ACTIVITY_LIFECYCLE=0 compatibility.
 export const DEFAULT_CODEX_APP_SERVER_EXECUTION_TIMEOUT_MS = 10 * 60 * 1000;
 export const DEFAULT_UNKNOWN_METHOD_WARN_THRESHOLD = 5;
 /**
@@ -327,6 +334,7 @@ export class CodexAppServerWorker {
    * @param {number} [options.unknownMethodWarnThreshold]
    * @param {(method: string) => void} [options.onUnknownMethod]
    * @param {(label: string, payload: object) => void} [options.warn]
+   * @param {(context: object) => Promise<boolean|string>|boolean|string} [options.interveneFn]
    */
   constructor(options = {}) {
     this.command = options.command || process.env.CODEX_BIN || "codex";
@@ -370,6 +378,8 @@ export class CodexAppServerWorker {
       typeof options.onUnknownMethod === "function"
         ? options.onUnknownMethod
         : null;
+    this._interveneFn =
+      typeof options.interveneFn === "function" ? options.interveneFn : null;
 
     /** @type {import('node:child_process').ChildProcess | null} */
     this.child = null;
@@ -643,6 +653,8 @@ export class CodexAppServerWorker {
     }
 
     const outputParts = [];
+    let lastActivityAt = Date.now();
+    let activityLifecycle = null;
     const unknownMethodsThisTurn = new Set();
     let threadId =
       typeof opts.threadId === "string" && opts.threadId ? opts.threadId : null;
@@ -714,6 +726,10 @@ export class CodexAppServerWorker {
       };
 
       const handleNotification = (method, params) => {
+        // Any notification, including unknown and opt-out methods, proves the
+        // transport is live. Content filtering below remains unchanged.
+        lastActivityAt = Date.now();
+        activityLifecycle?.observe();
         // AC5 defense: opt-out should already be filtered server-side.
         if (OPT_OUT_METHODS.includes(method)) return;
 
@@ -854,16 +870,40 @@ export class CodexAppServerWorker {
         };
       }
 
-      // Timeout: SIGTERM + partial WorkerResult (AC8)
+      // In activity mode timeoutMs is the inactivity window. Notifications
+      // re-arm the lifecycle; hardCeilingMs remains the leak-prevention bound.
+      const activityEnabled = isActivityLifecycleEnabled();
       const timeoutMs = Number.isFinite(opts.timeoutMs)
         ? opts.timeoutMs
-        : DEFAULT_CODEX_APP_SERVER_EXECUTION_TIMEOUT_MS;
+        : activityEnabled
+          ? resolveStallInterventionMs()
+          : DEFAULT_CODEX_APP_SERVER_EXECUTION_TIMEOUT_MS;
+      const hardCeilingMs = Number.isFinite(opts.hardCeilingMs)
+        ? opts.hardCeilingMs
+        : resolveHardCeilingMs();
       // Capture current child so a stale timer (post-result) cannot SIGTERM a
       // later reused worker's child process.
       const capturedChild = this.child;
+      activityLifecycle = createActivityLifecycle({
+        enabled: activityEnabled,
+        interventionMs: timeoutMs,
+        hardCeilingMs,
+        onIntervene: async (context) => {
+          if (this._interveneFn) {
+            const result = await this._interveneFn({
+              threadId,
+              client,
+              lastActivityAt,
+              ...context,
+            });
+            return result === true || result === "resolved";
+          }
+          return false;
+        },
+      });
       const timeoutPromise = new Promise((resolve) => {
-        timer = setTimeout(() => {
-          this._warn("execution timeout", { timeoutMs });
+        const fire = (reason) => {
+          this._warn("execution timeout", { timeoutMs, reason });
           try {
             capturedChild?.kill?.("SIGTERM");
           } catch {}
@@ -878,7 +918,16 @@ export class CodexAppServerWorker {
             ),
             raw: null,
           });
-        }, timeoutMs);
+        };
+        const arm = () => {
+          timer = setTimeout(async () => {
+            if (!activityEnabled) return fire("timeout");
+            const reason = await activityLifecycle.check({ threadId, client });
+            if (reason) return fire(reason);
+            arm();
+          }, timeoutMs);
+        };
+        arm();
       });
 
       const result = await Promise.race([resultPromise, timeoutPromise]);

package/hub/workers/codex-mcp.mjs

@@ -119,7 +119,7 @@ function readTomlScalar(raw, key) {
 }
 
 /**
- * Resolve a Codex effort profile name (e.g. "gpt55_high") to its concrete
+ * Resolve a Codex effort profile name (e.g. "gpt56_terra_high") to its concrete
  * `model` + reasoning effort. SSOT = the per-profile file written by
  * `tfx setup` at `~/.codex/<profile>.config.toml`. Falls back to deriving the
  * effort from the `<...>_<effort>` naming convention when the file is absent.
@@ -146,9 +146,11 @@ export function resolveCodexProfileConfig(profileName) {
   } catch {
     // Profile file absent (non-file alias). Derive effort from the naming
     // convention; leave model unset so codex uses its config.toml default.
-    const suffix = /_(xhigh|high|med|medium|low)$/.exec(profileName);
+    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(profileName);
     if (suffix) {
       const map = {
+        ultra: "ultra",
+        max: "max",
         xhigh: "xhigh",
         high: "high",
         med: "medium",
@@ -193,16 +195,27 @@ export function buildCodexArguments(prompt, opts = {}) {
   // profile effort merges on top of any opts.config.
   if (typeof opts.profile === "string" && opts.profile) {
     const resolved = resolveCodexProfileConfig(opts.profile);
-    if (resolved.model && typeof args.model !== "string") {
-      args.model = resolved.model;
+    const profileDerivedUltra =
+      resolved.reasoningEffort?.toLowerCase() === "ultra";
+    if (typeof args.model !== "string") {
+      if (profileDerivedUltra) args.model = "gpt-5.6-sol";
+      else if (resolved.model) args.model = resolved.model;
     }
     if (resolved.reasoningEffort) {
       args.config = {
         ...(args.config || {}),
-        model_reasoning_effort: resolved.reasoningEffort,
+        model_reasoning_effort: profileDerivedUltra
+          ? "max"
+          : resolved.reasoningEffort,
       };
     }
   }
+  if (typeof opts.reasoningEffort === "string" && opts.reasoningEffort) {
+    args.config = {
+      ...(args.config || {}),
+      model_reasoning_effort: opts.reasoningEffort,
+    };
+  }
 
   return args;
 }
@@ -694,6 +707,9 @@ function parseCliArgs(argv) {
       case "--model":
         options.model = next();
         break;
+      case "--reasoning-effort":
+        options.reasoningEffort = next();
+        break;
       case "--approval-policy":
         options.approvalPolicy = next();
         break;

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 "@triflux/core/scripts/lib/agent-route-policy.mjs";
 import { resolveBashExecutable } from "@triflux/core/hub/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: "gpt55_high",
-  "build-fixer": "gpt55_low",
-  debugger: "gpt55_xhigh",
-  "deep-executor": "gpt55_xhigh",
-  architect: "gpt55_xhigh",
-  planner: "gpt55_xhigh",
-  critic: "gpt55_xhigh",
-  analyst: "gpt55_xhigh",
-  "code-reviewer": "gpt55_high",
-  "security-reviewer": "gpt55_xhigh",
-  "quality-reviewer": "gpt55_high",
-  scientist: "gpt55_high",
-  "scientist-deep": "gpt55_xhigh",
-  "document-specialist": "gpt55_high",
-  verifier: "gpt55_high",
-  designer: "gpt55_xhigh",
-  writer: "gpt55_low",
-  spark: "gpt55_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/remote",
-  "version": "10.42.0",
+  "version": "10.44.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

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

@@ -0,0 +1,307 @@
+// 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],
+  );
+}
+
+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;
+}
+
+export function resolveNestedCodexAgentProfile(
+  agent,
+  { profileOverride = "auto", globalProfile = "auto", retryProfile = null, codexHome } = {},
+) {
+  const explicitProfile = String(profileOverride || "auto").trim();
+  const globalOverride = String(globalProfile || "auto").trim();
+  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";