@triflux/remote 10.50.2 → 10.52.0

package/hub/workers/factory.mjs

@@ -1,101 +1,23 @@
 // hub/workers/factory.mjs — Worker 생성 팩토리
 //
 // Supported worker types:
-//   - 'gemini'           → AntigravityRouteWorker (deprecated alias)
-//   - 'antigravity'      → AntigravityRouteWorker
-//   - 'claude'           → ClaudeWorker
-//   - 'codex'            → CodexMcpWorker (default) or CodexAppServerWorker when
-//                          opts.transport === 'app-server'
-//   - 'codex-app-server' → CodexAppServerWorker (explicit alias)
-//   - 'delegator'        → DelegatorMcpWorker
+//   - 'claude' → ClaudeWorker
+//   - 'codex'  → CodexMcpWorker
 //
-// For the codex app-server transport the factory injects a default
-// `publishCallback` that forwards each envelope to `/bridge/publish` via the
-// existing `requestJson` helper. Callers can override by passing their own
-// `publishCallback` or swap the transport with `requestJsonFn`.
-
-import { AntigravityRouteWorker } from "./antigravity-route-worker.mjs";
 import { ClaudeWorker } from "./claude-worker.mjs";
-import { CodexAppServerWorker } from "./codex-app-server-worker.mjs";
-
-/**
- * Build a best-effort publishCallback that posts the envelope to
- * `/bridge/publish`. Failures are swallowed so publish pressure never crashes
- * a running worker turn.
- * @param {(path: string, opts?: object) => Promise<unknown>} [requestJsonFn]
- * @returns {(publishMessage: object) => Promise<void>}
- */
-function defaultPublishCallback(requestJsonFn = null) {
-  return async (publishMessage) => {
-    try {
-      const publishRequestJson =
-        requestJsonFn || (await import("@triflux/core/hub/bridge.mjs")).requestJson;
-      await publishRequestJson("/bridge/publish", { body: publishMessage });
-    } catch {
-      // best-effort; publish failures must not crash the worker
-    }
-  };
-}
-
-/**
- * Construct a CodexAppServerWorker with a default publishCallback wired to
- * `requestJson('/bridge/publish', ...)` unless the caller supplied one.
- *
- * Issue #95 P1 #4 validation: the app-server transport does not yet implement
- * the server-initiated approval / `tool/requestUserInput` round-trip. Any
- * `approvalPolicy !== 'never'` would cause a codex turn to hang waiting for
- * an approval response the worker cannot produce. Reject such configs at
- * factory time with a clear, actionable message.
- *
- * @param {object} [opts]
- */
-async function createCodexWorker(opts = {}) {
-  const { transport, requestJsonFn, publishCallback, ...rest } = opts;
-
-  if (transport === "app-server") {
-    const policy = rest.approvalPolicy;
-    if (policy !== undefined && policy !== null && policy !== "never") {
-      throw new Error(
-        `codex app-server transport currently requires approvalPolicy='never' (got '${policy}'). ` +
-          "The server-initiated approval / tool/requestUserInput round-trip is not yet implemented. " +
-          "Set approvalPolicy='never' or use transport='mcp'. " +
-          "Tracked in follow-up issue.",
-      );
-    }
-    return new CodexAppServerWorker({
-      ...rest,
-      publishCallback:
-        typeof publishCallback === "function"
-          ? publishCallback
-          : defaultPublishCallback(requestJsonFn),
-    });
-  }
-
-  // Default (and transport === 'mcp'): CodexMcpWorker with zero new deps.
-  const { CodexMcpWorker } = await import("./codex-mcp.mjs");
-  return new CodexMcpWorker(rest);
-}
 
 /**
- * @param {'gemini'|'antigravity'|'agy'|'claude'|'codex'|'codex-app-server'|'delegator'} type
+ * @param {'claude'|'codex'} type
  * @param {object} [opts]
  * @returns {Promise<import('./interface.mjs').IWorker>}
  */
 export async function createWorker(type, opts = {}) {
   switch (type) {
-    case "gemini":
-    case "antigravity":
-    case "agy":
-      return new AntigravityRouteWorker(opts);
     case "claude":
       return new ClaudeWorker(opts);
-    case "codex":
-      return createCodexWorker(opts);
-    case "codex-app-server":
-      return createCodexWorker({ ...opts, transport: "app-server" });
-    case "delegator": {
-      const { DelegatorMcpWorker } = await import("./delegator-mcp.mjs");
-      return new DelegatorMcpWorker(opts);
+    case "codex": {
+      const { CodexMcpWorker } = await import("./codex-mcp.mjs");
+      return new CodexMcpWorker(opts);
     }
     default:
       throw new Error(`Unknown worker type: ${type}`);

package/hub/workers/interface.mjs

@@ -16,15 +16,11 @@
  * @property {string} [developerInstructions] - 개발자 지침
  * @property {string} [compactPrompt] - 컴팩션 프롬프트
  * @property {number} [timeoutMs] - MCP 요청 타임아웃(ms)
- * @property {'mcp'|'app-server'} [transport] - Codex 전송 계층 선택 (팩토리 전용)
  */
 
 /**
  * Codex 워커 생성 옵션 (팩토리 레벨)
  * @typedef {object} CodexWorkerFactoryOptions
- * @property {'mcp'|'app-server'} [transport] - 'mcp' (기본) 또는 'app-server'
- * @property {(publishMessage: object) => void|Promise<void>} [publishCallback] - app-server 전용 publish 후크
- * @property {(path: string, opts?: object) => Promise<unknown>} [requestJsonFn] - 테스트/리팩터용 requestJson 주입
  * @property {string} [command] - codex 실행 바이너리 경로
  * @property {string[]} [args] - codex CLI 인자 배열
  * @property {string} [cwd] - 워커 작업 디렉터리
@@ -61,14 +57,12 @@
  * @property {() => Promise<void>} start
  * @property {() => Promise<void>} stop
  * @property {() => boolean} isReady
- * @property {'codex'|'codex-app-server'|'gemini'|'antigravity'|'claude'|'delegator'} type
+ * @property {'codex'|'gemini'|'antigravity'|'claude'} type
  */
 
 export const WORKER_TYPES = Object.freeze([
   "codex",
-  "codex-app-server",
   "gemini",
   "antigravity",
   "claude",
-  "delegator",
 ]);

package/hub/workers/lib/jsonrpc-core.mjs

@@ -12,6 +12,17 @@ export class JsonRpcProtocolError extends Error {
   }
 }
 
+/**
+ * Thrown when the underlying stream closes unexpectedly.
+ */
+export class JsonRpcTransportError extends Error {
+  /** @param {string} message @param {{ cause?: unknown }} [options] */
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "JsonRpcTransportError";
+  }
+}
+
 export class JsonRpcDispatchBase {
   /**
    * @param {object} options

package/hub/workers/lib/jsonrpc-ws-uds.mjs

@@ -5,27 +5,26 @@
 // on the socket — it speaks WebSocket (RFC 6455) after a standard HTTP/1.1
 // Upgrade handshake, one JSON-RPC message per text frame. Confirmed live against
 // codex-cli 0.135.0 (see experiments/native-bridge-feasibility/
-// codex-app-server-uds-probe.mjs). This is the UDS sibling of the stdio
-// `JsonRpcStdioClient`: same public surface (request/notify/onNotification/
-// close/isOpen), different framing.
+// codex-app-server-uds-smoke.mjs). Public surface: request/notify/
+// onNotification/close/isOpen.
 //
 // Wire framing notes:
 //   - client -> server frames MUST be masked (RFC 6455 §5.3).
 //   - server -> client frames are unmasked.
 //   - one JSON-RPC object per text frame; fragmented frames are reassembled.
 //   - outbound JSON-RPC omits the `"jsonrpc":"2.0"` header (OpenAI App Server
-//     JSONL variant), matching JsonRpcStdioClient.
+//     JSONL variant).
 //
 // Zero new dependencies — minimal hand-rolled WS client (no `ws` package).
 
 import { createHash, randomBytes } from "node:crypto";
 import net from "node:net";
 
-import { JsonRpcDispatchBase } from "./jsonrpc-core.mjs";
 import {
+  JsonRpcDispatchBase,
   JsonRpcProtocolError,
   JsonRpcTransportError,
-} from "./jsonrpc-stdio.mjs";
+} from "./jsonrpc-core.mjs";
 
 const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 const DEFAULT_MAX_FRAME_SIZE = 16 * 1024 * 1024; // 16 MiB
@@ -475,5 +474,3 @@ export class JsonRpcWsUdsClient extends JsonRpcDispatchBase {
     this._closeWith("closed", wrapped);
   }
 }
-
-export default JsonRpcWsUdsClient;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@triflux/remote",
-  "version": "10.50.2",
-  "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
+  "version": "10.52.0",
+  "description": "triflux remote — team mode, psmux, MCP workers.",
   "type": "module",
   "main": "hub/index.mjs",
   "exports": {
@@ -15,12 +15,7 @@
     "@triflux/core": "^10.0.0-alpha.1"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "ajv": "^8.18.0",
-    "better-sqlite3": "^12.10.0",
-    "pino": "^10.3.1",
-    "pino-pretty": "^13.1.3",
-    "zod": "^4.0.0"
+    "@modelcontextprotocol/sdk": "^1.27.1"
   },
   "files": [
     "hub",

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,