triflux 10.9.31 → 10.9.32

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "Tri-CLI orchestrator for Claude Code. Routes tasks across Claude + Codex + Gemini with consensus intelligence, natural language routing, 42 skills, and cross-model review.",
-      "version": "10.9.31",
+      "version": "10.9.32",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "10.9.31"
+  "version": "10.9.32"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.9.31",
+  "version": "10.9.32",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

package/hooks/safety-guard.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 // hooks/safety-guard.mjs — PreToolUse:Bash 훅
 //
 // 위험한 Bash 명령을 사전 차단(exit 2)하거나 경고(additionalContext)한다.
@@ -8,6 +9,7 @@
 //   BLOCK (exit 2)  — 복구 불가능한 파괴적 명령
 //   WARN  (allow + context) — 주의가 필요한 명령
 
+import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -251,6 +253,60 @@ function hasSegmentInvocation(cmd, patterns) {
   });
 }
 
+function isGitCommitInvocation(command) {
+  const lines = command.split(/\n/);
+  let heredocDelimiter = null;
+  return lines.some((line) => {
+    if (heredocDelimiter !== null) {
+      if (line.trim() === heredocDelimiter) heredocDelimiter = null;
+      return false;
+    }
+
+    const heredocMatch = line.match(/<<['"]?(\w+)['"]?/);
+    if (heredocMatch) {
+      heredocDelimiter = heredocMatch[1];
+    }
+
+    return line
+      .split(/\s*(?:&&|;|\|\|)\s*/)
+      .some((segment) => /^\s*git\s+commit\b/i.test(segment.trim()));
+  });
+}
+
+function resolveHookCwd(input) {
+  return String(
+    input?.cwd ||
+      input?.tool_input?.cwd ||
+      process.env.CLAUDE_CWD ||
+      process.cwd() ||
+      process.env.PWD,
+  );
+}
+
+function getCurrentGitBranch(cwd) {
+  try {
+    const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0) return "";
+    return String(result.stdout || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+function isProtectedMainBranch(branch) {
+  return /^(main|master)$/i.test(String(branch || "").trim());
+}
+
+function isSwarmWorktreeCwd(cwd) {
+  return /(?:^|\/)\.codex-swarm\/wt-[^/]+(?:\/|$)/.test(
+    String(cwd || "").replace(/\\/g, "/"),
+  );
+}
+
 function blockCommand(message, command) {
   process.stderr.write(
     `${message}\n` +
@@ -275,6 +331,7 @@ function main() {
 
   const command = (input.tool_input?.command || "").trim();
   if (!command) process.exit(0);
+  const hookCwd = resolveHookCwd(input);
 
   // psmux 명령이 실제 CLI 호출인지 판별 (오탐 방지)
   // git commit 메시지, echo, grep, cat, heredoc 안의 텍스트는 무시
@@ -298,6 +355,20 @@ function main() {
     process.exit(0);
   }
 
+  const codexPrdActive = process.env.CODEX_PRD_ACTIVE === "1";
+  if (codexPrdActive && isGitCommitInvocation(command)) {
+    const branch = getCurrentGitBranch(hookCwd);
+    if (isProtectedMainBranch(branch)) {
+      const locationHint = isSwarmWorktreeCwd(hookCwd)
+        ? "swarm worktree 내부에서도 main/master 직접 commit은 금지됩니다."
+        : "현재 PWD가 swarm worktree가 아닙니다.";
+      blockCommand(
+        `[safety-guard] Codex PRD 실행 중 ${branch} 직접 commit 차단됨. ${locationHint}`,
+        command,
+      );
+    }
+  }
+
   // 0.1. reflexion 적응형 패널티 — 이전 세션에서 차단된 패턴 사전 경고
   const penalties = loadReflexionPenalties();
   if (penalties.length > 0) {

package/hub/lib/process-utils.mjs

@@ -102,7 +102,11 @@ function killWithEscalation(orphanPids, procMap) {
           }
         }
       }
-      killProcess(pid, { signal: "SIGKILL", force: true });
+      killProcess(pid, {
+        signal: "SIGKILL",
+        force: true,
+        tree: IS_WINDOWS,
+      });
     }
     if (!isPidAlive(pid)) killed++;
   }

package/hub/middleware/quota-middleware.mjs

@@ -0,0 +1,70 @@
+const FAILURE_STATUSES = new Set(["quota_hit", "error"]);
+
+function buildFailureRecord(result = {}) {
+  const failure = {
+    id: result.id ?? "unknown",
+    status: result.status ?? "unknown",
+  };
+
+  if (Number.isFinite(result.http)) {
+    failure.http = result.http;
+  }
+
+  if (typeof result.message === "string" && result.message.length > 0) {
+    failure.message = result.message;
+  }
+
+  if (result.headers && Object.keys(result.headers).length > 0) {
+    failure.headers = result.headers;
+  }
+
+  return failure;
+}
+
+export function summarizeQuotaResults(results = []) {
+  const metrics = {
+    checked: results.length,
+    ok: 0,
+    quotaHit: 0,
+    error: 0,
+    failed: 0,
+  };
+  const failures = [];
+
+  for (const result of results) {
+    const status = result?.status ?? "unknown";
+
+    if (status === "ok") {
+      metrics.ok += 1;
+    } else if (status === "quota_hit") {
+      metrics.quotaHit += 1;
+    } else if (status === "error") {
+      metrics.error += 1;
+    }
+
+    if (FAILURE_STATUSES.has(status)) {
+      failures.push(buildFailureRecord(result));
+    }
+  }
+
+  metrics.failed = failures.length;
+  return { metrics, failures };
+}
+
+export function logQuotaRefreshFailures(logger, results = []) {
+  const { metrics, failures } = summarizeQuotaResults(results);
+  if (failures.length === 0) {
+    return { logged: false, metrics, failures };
+  }
+
+  logger.warn(
+    {
+      tag: "hub-quota",
+      metrics,
+      failures,
+    },
+    "broker.quota_refresh_degraded",
+  );
+
+  return { logged: true, metrics, failures };
+}

package/hub/server.mjs

@@ -29,6 +29,7 @@ import { DelegatorService } from "./delegator/index.mjs";
 import { createHitlManager } from "./hitl.mjs";
 import { cleanupOrphanNodeProcesses } from "./lib/process-utils.mjs";
 import * as spawnTrace from "./lib/spawn-trace.mjs";
+import { logQuotaRefreshFailures } from "./middleware/quota-middleware.mjs";
 import { wrapRequestHandler } from "./middleware/request-logger.mjs";
 import { createPipeServer } from "./pipe.mjs";
 import { createRouter } from "./router.mjs";
@@ -299,6 +300,9 @@ async function syncHubMcpSettingsIfAvailable({ hubUrl }) {
       return;
     }
     await mod.syncHubMcpSettings({ hubUrl });
+    if (typeof mod?.syncCodexHubUrl === "function") {
+      await mod.syncCodexHubUrl({ hubUrl });
+    }
   } catch (error) {
     const message = error?.message || String(error);
     if (error?.code === "ERR_MODULE_NOT_FOUND") {
@@ -988,6 +992,7 @@ export async function startHub({
       ) {
         try {
           const results = await refreshAllAccountQuotas();
+          logQuotaRefreshFailures(hubLog, results);
           return writeJson(res, 200, { ok: true, results, ts: Date.now() });
         } catch (err) {
           hubLog.error(

package/hub/team/process-cleanup.mjs

@@ -12,10 +12,17 @@ const execFileAsync = promisify(nodeExecFile);
 const TARGET_PROCESS_NAMES = ["node", "python", "python3"];
 const SIGTERM_GRACE_MS = 5000;
 
-function forceKillPid(pid) {
-  if (IS_WINDOWS) {
+export function forceKillPid(
+  pid,
+  {
+    isWindows = IS_WINDOWS,
+    execFileSyncFn = execFileSync,
+    killFn = process.kill,
+  } = {},
+) {
+  if (isWindows) {
     try {
-      execFileSync("taskkill", ["/F", "/PID", String(pid)], {
+      execFileSyncFn("taskkill", ["/F", "/T", "/PID", String(pid)], {
         stdio: "ignore",
         timeout: 5000,
         windowsHide: true,
@@ -23,7 +30,7 @@ function forceKillPid(pid) {
       return;
     } catch (taskkillError) {
       try {
-        process.kill(pid);
+        killFn(pid);
         return;
       } catch {
         throw taskkillError;
@@ -31,7 +38,7 @@ function forceKillPid(pid) {
     }
   }
 
-  process.kill(pid, "SIGKILL");
+  killFn(pid, "SIGKILL");
 }
 
 // cmdLine 패턴 기반 화이트리스트 (고아 후보에서 제외)
@@ -296,6 +303,12 @@ export async function findOrphanProcesses(opts = {}) {
 export function createProcessCleanup(opts = {}) {
   const execFileFn = opts.execFileFn ?? execFileAsync;
   const dryRun = opts.dryRun ?? false;
+  const isWindows = opts.isWindows ?? IS_WINDOWS;
+  const execFileSyncFn = opts.execFileSyncFn ?? execFileSync;
+  const killFn = opts.killFn ?? process.kill;
+  const sleepFn =
+    opts.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sigtermGraceMs = opts.sigtermGraceMs ?? SIGTERM_GRACE_MS;
 
   let lastOrphans = [];
 
@@ -332,16 +345,16 @@ export function createProcessCleanup(opts = {}) {
       lastOrphans.map(async (p) => {
         try {
           // SIGTERM
-          process.kill(p.pid, "SIGTERM");
+          killFn(p.pid, "SIGTERM");
 
           // 5초 대기 후 살아있으면 강제 종료
-          await new Promise((resolve) => setTimeout(resolve, SIGTERM_GRACE_MS));
+          await sleepFn(sigtermGraceMs);
 
           try {
             // 프로세스가 아직 살아있는지 확인 (signal 0)
-            process.kill(p.pid, 0);
+            killFn(p.pid, 0);
             // 여전히 살아있음 → Windows는 taskkill/process.kill, 그 외는 SIGKILL
-            forceKillPid(p.pid);
+            forceKillPid(p.pid, { isWindows, execFileSyncFn, killFn });
           } catch {
             // ESRCH: 이미 종료됨 — 정상
           }

package/hud/context-monitor.mjs

@@ -10,9 +10,40 @@ import {
 import { clampPercent, formatTokenCount, readJsonMigrate } from "./utils.mjs";
 
 const DEFAULT_CONTEXT_LIMIT = 200_000;
+const MILLION_CONTEXT_LIMIT = 1_000_000;
 const MAX_CAPTURE_BYTES = 256 * 1024;
 const MAX_TOP_KEYS = 20;
 
+// stdin 이 context_window_size 를 제공하지 않을 때 모델 ID 로 한도를 추정한다.
+// Anthropic 공식 문서(2026-04 기준): Opus 4.7 / Opus 4.6 / Sonnet 4.6 = 1M,
+// Sonnet 4.5 / Haiku 4.5 = 200K. 그 외 모델은 [1m] suffix 로 opt-in 가능.
+const MODEL_HINT_1M_PREFIXES = [
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+];
+
+function normalizeModelId(modelId) {
+  if (!modelId) return "";
+  return String(modelId).toLowerCase();
+}
+
+function resolveModelLimit(modelId) {
+  const id = normalizeModelId(modelId);
+  if (!id) return DEFAULT_CONTEXT_LIMIT;
+  if (id.includes("[1m]")) return MILLION_CONTEXT_LIMIT;
+  for (const prefix of MODEL_HINT_1M_PREFIXES) {
+    if (id.startsWith(prefix)) return MILLION_CONTEXT_LIMIT;
+  }
+  return DEFAULT_CONTEXT_LIMIT;
+}
+
+export function shouldSuppressInfoOnlyContextStatus(modelId) {
+  const id = normalizeModelId(modelId);
+  if (!id) return false;
+  return id.startsWith("claude-opus-4-7") || id.includes("[1m]");
+}
+
 const WARNING_LEVELS = Object.freeze({
   ok: { min: 0, message: "" },
   info: { min: 60, message: "컨텍스트 절반 이상 사용" },
@@ -239,10 +270,21 @@ function getStdinContextUsage(stdin) {
   return null;
 }
 
+export function deriveContextLimit(stdin) {
+  const explicit = Number(stdin?.context_window?.context_window_size || 0);
+  if (explicit > 0) return explicit;
+  return resolveModelLimit(stdin?.model?.id ?? stdin?.model);
+}
+
 export function buildContextUsageView(stdin, snapshot = null) {
   const stdinUsage = getStdinContextUsage(stdin);
   const monitor = snapshot || readContextMonitorSnapshot();
-  const fallbackLimit = Number(monitor?.limitTokens || DEFAULT_CONTEXT_LIMIT);
+  const modelId = stdin?.model?.id ?? stdin?.model;
+  const modelHintLimit = resolveModelLimit(modelId);
+  const fallbackLimit = Math.max(
+    modelHintLimit,
+    Number(monitor?.limitTokens || 0),
+  );
 
   const usedTokens = stdinUsage?.usedTokens ?? Number(monitor?.usedTokens || 0);
   const limitTokens = stdinUsage?.limitTokens ?? Math.max(1, fallbackLimit);
@@ -251,15 +293,19 @@ export function buildContextUsageView(stdin, snapshot = null) {
     (limitTokens > 0 ? clampPercent((usedTokens / limitTokens) * 100) : 0);
 
   const warning = classifyContextThreshold(percent);
+  const showInfoOnlyStatus = !(
+    warning.level === "info" && shouldSuppressInfoOnlyContextStatus(modelId)
+  );
   return {
     usedTokens,
     limitTokens,
     percent,
     display: formatContextUsage(usedTokens, limitTokens, percent),
     warningLevel: warning.level,
-    warningMessage: warning.message,
-    warningTag:
-      warning.level === "warn"
+    warningMessage: showInfoOnlyStatus ? warning.message : "",
+    warningTag: !showInfoOnlyStatus
+      ? ""
+      : warning.level === "warn"
         ? "⚠ 압축 권장"
         : warning.level === "critical"
           ? "‼ 분할 권장"

package/hud/hud-qos-status.mjs

@@ -26,7 +26,10 @@ import {
   GEMINI_SESSION_REFRESH_FLAG,
   QOS_PATH,
 } from "./constants.mjs";
-import { buildContextUsageView } from "./context-monitor.mjs";
+import {
+  buildContextUsageView,
+  deriveContextLimit,
+} from "./context-monitor.mjs";
 import { getMissionBoardState } from "./mission-board.mjs";
 // Claude provider
 import {
@@ -153,7 +156,7 @@ async function main() {
     svSavings?.totalSaved || svAccumulator?.totalCostSaved || 0;
 
   // 세션/누적 토큰 → context 대비 절약 배수 (개별 provider sv%)
-  const ctxCapacity = stdin?.context_window?.context_window_size || 200000;
+  const ctxCapacity = deriveContextLimit(stdin);
   let codexSv = null;
   if (svAccumulator?.codex?.tokens > 0) {
     codexSv = svAccumulator.codex.tokens / ctxCapacity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.9.31",
+  "version": "10.9.32",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/hub-ensure.mjs

@@ -22,6 +22,22 @@ function buildHubBaseUrl(host, port) {
   return `http://${formatHostForUrl(host)}:${port}`;
 }
 
+async function syncHubConfigsIfAvailable({ hubUrl }) {
+  try {
+    const mod = await import(
+      new URL("./sync-hub-mcp-settings.mjs", import.meta.url)
+    );
+    if (typeof mod?.syncHubMcpSettings === "function") {
+      await mod.syncHubMcpSettings({ hubUrl });
+    }
+    if (typeof mod?.syncCodexHubUrl === "function") {
+      await mod.syncCodexHubUrl({ hubUrl });
+    }
+  } catch {
+    // sync는 best-effort이며 hub-ensure 성공/실패를 좌우하지 않는다.
+  }
+}
+
 function resolveHubTarget() {
   const envPortRaw = Number(process.env.TFX_HUB_PORT || "");
   const envPort =
@@ -96,7 +112,9 @@ export async function run(stdinData) {
   void stdinData;
 
   const { host, port } = resolveHubTarget();
+  const hubUrl = `${buildHubBaseUrl(host, port)}/mcp`;
   if (await isHubHealthy(host, port)) {
+    await syncHubConfigsIfAvailable({ hubUrl });
     return { code: 0, stdout: "hub: ok", stderr: "" };
   }
 
@@ -106,6 +124,9 @@ export async function run(stdinData) {
   }
 
   const ready = await waitForHubReady(host, port, 5000);
+  if (ready) {
+    await syncHubConfigsIfAvailable({ hubUrl });
+  }
   return {
     code: ready ? 0 : 2,
     stdout: ready ? "hub: ok" : "hub: starting (timeout)",

package/scripts/mcp-cleanup.ps1

@@ -9,9 +9,9 @@ $ErrorActionPreference = 'SilentlyContinue'
 # + omc bridge
 Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'" |
   Where-Object { $_.CommandLine -match 'npx-cli|oh-my-codex[\\/]dist[\\/]mcp|omc.*bridge.*mcp-server' } |
-  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }
+  ForEach-Object { taskkill /F /T /PID $_.ProcessId 2>$null }
 
 # serena (uvx) + python MCP orphans
 Get-CimInstance Win32_Process -Filter "Name='python.exe' OR Name='uvx.exe'" |
   Where-Object { $_.CommandLine -match 'serena|uv[\\/](cache|python)' } |
-  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }
+  ForEach-Object { taskkill /F /T /PID $_.ProcessId 2>$null }

package/scripts/setup.mjs

@@ -1237,7 +1237,12 @@ export async function runDeferred(stdinData) {
       changed = true;
     }
 
-    // ── PreToolUse 훅: headless-guard (auto-route) ──
+    // ── PreToolUse 훅: headless-guard + tfx-gate-activate ──
+    // orchestrator 가 registry 기반으로 omc-headless-guard / omc-tfx-gate-activate 를
+    // 이미 디스패치하므로, `*` orchestrator entry 와 별도로 등록된 직접 entry 는
+    // 2배 발화를 유발한다 (#76). 이 블록은 orchestrator 유무에 따라 다르게 동작한다:
+    //   - orchestrator 가 있으면: 직접 등록된 중복 entry 를 제거 (prune).
+    //   - orchestrator 가 없으면: legacy ADD 경로로 직접 entry 주입 (구 설치 fallback).
     if (!Array.isArray(s.hooks.PreToolUse)) s.hooks.PreToolUse = [];
 
     const guardScriptPath = join(
@@ -1245,85 +1250,110 @@ export async function runDeferred(stdinData) {
       "scripts",
       "headless-guard-fast.sh",
     ).replace(/\\/g, "/");
-    const hasGuardHook = s.hooks.PreToolUse.some(
-      (entry) =>
-        Array.isArray(entry.hooks) &&
-        entry.hooks.some(
-          (h) =>
-            typeof h.command === "string" &&
-            h.command.includes("headless-guard"),
-        ),
-    );
-
-    if (!hasGuardHook && existsSync(guardScriptPath.replace(/\//g, "\\"))) {
-      s.hooks.PreToolUse.push({
-        matcher: "Bash|Agent",
-        hooks: [
-          {
-            type: "command",
-            command: `bash "${guardScriptPath}"`,
-            timeout: 3,
-          },
-        ],
-      });
-      changed = true;
-    } else if (hasGuardHook) {
-      // 기존 훅 경로를 동기화된 경로로 업데이트
-      for (const entry of s.hooks.PreToolUse) {
-        if (!Array.isArray(entry.hooks)) continue;
-        for (const h of entry.hooks) {
-          if (
-            typeof h.command === "string" &&
-            h.command.includes("headless-guard") &&
-            !h.command.includes(guardScriptPath)
-          ) {
-            h.command = `bash "${guardScriptPath}"`;
-            changed = true;
-          }
-        }
-      }
-    }
-
-    // ── PreToolUse 훅: tfx-gate-activate (Skill 감지 → A+B gate) ──
     const gateScriptPath = join(
       CLAUDE_DIR,
       "scripts",
       "tfx-gate-activate.mjs",
     ).replace(/\\/g, "/");
-    const hasGateHook = s.hooks.PreToolUse.some(
+
+    const hasPreToolUseOrchestrator = s.hooks.PreToolUse.some(
       (entry) =>
+        entry.matcher === "*" &&
         Array.isArray(entry.hooks) &&
         entry.hooks.some(
           (h) =>
             typeof h.command === "string" &&
-            h.command.includes("tfx-gate-activate"),
+            h.command.includes("hook-orchestrator.mjs"),
         ),
     );
 
-    if (!hasGateHook && existsSync(gateScriptPath.replace(/\//g, "\\"))) {
-      s.hooks.PreToolUse.push({
-        matcher: "Skill",
-        hooks: [
-          {
-            type: "command",
-            command: `node "${gateScriptPath}"`,
-            timeout: 2,
-          },
-        ],
-      });
-      changed = true;
-    } else if (hasGateHook) {
-      for (const entry of s.hooks.PreToolUse) {
-        if (!Array.isArray(entry.hooks)) continue;
-        for (const h of entry.hooks) {
-          if (
+    if (hasPreToolUseOrchestrator) {
+      // prune: 직접 등록된 headless-guard / tfx-gate-activate 전용 entry 제거
+      const DUP_MARKERS = ["headless-guard", "tfx-gate-activate"];
+      const before = s.hooks.PreToolUse.length;
+      s.hooks.PreToolUse = s.hooks.PreToolUse.filter((entry) => {
+        if (entry.matcher === "*") return true;
+        if (!Array.isArray(entry.hooks) || entry.hooks.length === 0)
+          return true;
+        const allDup = entry.hooks.every(
+          (h) =>
             typeof h.command === "string" &&
-            h.command.includes("tfx-gate-activate") &&
-            !h.command.includes(gateScriptPath)
-          ) {
-            h.command = `node "${gateScriptPath}"`;
-            changed = true;
-          }
+            !h.command.includes("hook-orchestrator") &&
+            DUP_MARKERS.some((m) => h.command.includes(m)),
+        );
+        return !allDup;
+      });
+      if (s.hooks.PreToolUse.length !== before) changed = true;
+    } else {
+      // legacy: orchestrator 부재 시 직접 entry 주입
+      const hasGuardHook = s.hooks.PreToolUse.some(
+        (entry) =>
+          Array.isArray(entry.hooks) &&
+          entry.hooks.some(
+            (h) =>
+              typeof h.command === "string" &&
+              h.command.includes("headless-guard"),
+          ),
+      );
+
+      if (!hasGuardHook && existsSync(guardScriptPath.replace(/\//g, "\\"))) {
+        s.hooks.PreToolUse.push({
+          matcher: "Bash|Agent",
+          hooks: [
+            {
+              type: "command",
+              command: `bash "${guardScriptPath}"`,
+              timeout: 3,
+            },
+          ],
+        });
+        changed = true;
+      }
+
+      const hasGateHook = s.hooks.PreToolUse.some(
+        (entry) =>
+          Array.isArray(entry.hooks) &&
+          entry.hooks.some(
+            (h) =>
+              typeof h.command === "string" &&
+              h.command.includes("tfx-gate-activate"),
+          ),
+      );
+
+      if (!hasGateHook && existsSync(gateScriptPath.replace(/\//g, "\\"))) {
+        s.hooks.PreToolUse.push({
+          matcher: "Skill",
+          hooks: [
+            {
+              type: "command",
+              command: `node "${gateScriptPath}"`,
+              timeout: 2,
+            },
+          ],
+        });
+        changed = true;
+      }
+    }
+
+    // 남아있는 직접 entry 경로 동기화 (legacy 또는 외부 등록 대응)
+    for (const entry of s.hooks.PreToolUse) {
+      if (!Array.isArray(entry.hooks)) continue;
+      for (const h of entry.hooks) {
+        if (typeof h.command !== "string") continue;
+        if (h.command.includes("hook-orchestrator")) continue;
+        if (
+          h.command.includes("headless-guard") &&
+          !h.command.includes(guardScriptPath)
+        ) {
+          h.command = `bash "${guardScriptPath}"`;
+          changed = true;
+        }
+        if (
+          h.command.includes("tfx-gate-activate") &&
+          !h.command.includes(gateScriptPath)
+        ) {
+          h.command = `node "${gateScriptPath}"`;
+          changed = true;
         }
       }
     }

package/scripts/sync-hub-mcp-settings.mjs

@@ -8,6 +8,8 @@ const TARGET_FILES = [
   [".claude", "settings.json"],
   [".claude", "settings.local.json"],
 ];
+const CODEX_CONFIG_FILE = [".codex", "config.toml"];
+const TFX_HUB_SECTION = "tfx-hub";
 const FILE_LOCKS = new Map();
 
 function getSettingsPaths() {
@@ -15,6 +17,14 @@ function getSettingsPaths() {
   return TARGET_FILES.map((segments) => join(home, ...segments));
 }
 
+function getCodexConfigPath(codexConfigPath) {
+  if (typeof codexConfigPath === "string" && codexConfigPath.length > 0) {
+    return codexConfigPath;
+  }
+  const home = process.env.HOME || homedir();
+  return join(home, ...CODEX_CONFIG_FILE);
+}
+
 function getReason(error, fallback) {
   if (typeof error?.message === "string" && error.message.length > 0) {
     return error.message;
@@ -63,9 +73,8 @@ async function fileExists(filePath) {
   }
 }
 
-async function writeJsonAtomic(filePath, value) {
+async function writeTextAtomic(filePath, payload) {
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  const payload = `${JSON.stringify(value, null, 2)}\n`;
 
   try {
     await writeFile(tmpPath, payload, "utf8");
@@ -89,6 +98,53 @@ async function writeJsonAtomic(filePath, value) {
   }
 }
 
+async function writeJsonAtomic(filePath, value) {
+  const payload = `${JSON.stringify(value, null, 2)}\n`;
+  await writeTextAtomic(filePath, payload);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function formatTomlString(value) {
+  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function parseTomlScalar(rawValue) {
+  const value = String(rawValue || "").trim();
+  if (!value) return "";
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d[\d_]*$/.test(value)) return Number(value.replace(/_/g, ""));
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return value;
+}
+
+function findMcpServerSection(raw, sectionName) {
+  const headerRegex = new RegExp(
+    `^\\[mcp_servers\\.${escapeRegExp(sectionName)}\\]\\s*$`,
+    "m",
+  );
+  const headerMatch = headerRegex.exec(raw);
+  if (!headerMatch) return null;
+
+  const headerLineEnd = raw.indexOf("\n", headerMatch.index);
+  const bodyStart = headerLineEnd === -1 ? raw.length : headerLineEnd + 1;
+  const nextSectionRegex = /^\s*\[/gm;
+  nextSectionRegex.lastIndex = bodyStart;
+  const nextSectionMatch = nextSectionRegex.exec(raw);
+  const sectionEnd = nextSectionMatch ? nextSectionMatch.index : raw.length;
+
+  return {
+    body: raw.slice(bodyStart, sectionEnd),
+    bodyStart,
+    sectionEnd,
+  };
+}
+
 async function syncSingleFile({ filePath, hubUrl, dryRun, logger }) {
   return withFileLock(filePath, async () => {
     if (!(await fileExists(filePath))) {
@@ -157,6 +213,75 @@ async function syncSingleFile({ filePath, hubUrl, dryRun, logger }) {
   });
 }
 
+async function syncCodexConfigFile({ filePath, hubUrl, dryRun, logger }) {
+  return withFileLock(filePath, async () => {
+    if (!(await fileExists(filePath))) {
+      log(logger, "info", `[codex-mcp-sync] skipped: ${filePath}`);
+      return { kind: "skipped", path: filePath };
+    }
+
+    let raw;
+    try {
+      raw = await readFile(filePath, "utf8");
+    } catch (error) {
+      const reason = getReason(error, "read failed");
+      log(logger, "error", `[codex-mcp-sync] error: ${filePath} (${reason})`);
+      return { kind: "error", path: filePath, reason };
+    }
+
+    const section = findMcpServerSection(raw, TFX_HUB_SECTION);
+    if (!section) {
+      log(logger, "info", `[codex-mcp-sync] skipped: ${filePath}`);
+      return { kind: "skipped", path: filePath };
+    }
+
+    const urlMatch = /^(\s*url\s*=\s*)(.+?)(\s*(?:#.*)?)$/m.exec(section.body);
+    if (!urlMatch) {
+      const reason = "missing tfx-hub url";
+      log(logger, "error", `[codex-mcp-sync] error: ${filePath} (${reason})`);
+      return { kind: "error", path: filePath, reason };
+    }
+
+    const currentUrl = parseTomlScalar(urlMatch[2]);
+    if (typeof currentUrl !== "string" || currentUrl.length === 0) {
+      const reason = "invalid tfx-hub url";
+      log(logger, "error", `[codex-mcp-sync] error: ${filePath} (${reason})`);
+      return { kind: "error", path: filePath, reason };
+    }
+
+    if (currentUrl === hubUrl) {
+      log(logger, "info", `[codex-mcp-sync] skipped: ${filePath}`);
+      return { kind: "skipped", path: filePath };
+    }
+
+    const nextBody = section.body.replace(
+      /^(\s*url\s*=\s*)(.+?)(\s*(?:#.*)?)$/m,
+      (_, prefix, _value, suffix = "") =>
+        `${prefix}${formatTomlString(hubUrl)}${suffix}`,
+    );
+    const nextRaw = `${raw.slice(0, section.bodyStart)}${nextBody}${raw.slice(section.sectionEnd)}`;
+
+    log(
+      logger,
+      "debug",
+      `[codex-mcp-sync] ${filePath} url: ${String(currentUrl)} -> ${hubUrl}`,
+    );
+
+    if (!dryRun) {
+      try {
+        await writeTextAtomic(filePath, nextRaw);
+      } catch (error) {
+        const reason = getReason(error, "write failed");
+        log(logger, "error", `[codex-mcp-sync] error: ${filePath} (${reason})`);
+        return { kind: "error", path: filePath, reason };
+      }
+    }
+
+    log(logger, "info", `[codex-mcp-sync] updated: ${filePath}`);
+    return { kind: "updated", path: filePath };
+  });
+}
+
 export async function syncHubMcpSettings({
   hubUrl,
   dryRun = false,
@@ -183,3 +308,33 @@ export async function syncHubMcpSettings({
 
   return result;
 }
+
+export async function syncCodexHubUrl({
+  hubUrl,
+  codexConfigPath,
+  dryRun = false,
+  logger = console,
+}) {
+  const result = {
+    updated: [],
+    skipped: [],
+    errors: [],
+  };
+
+  const outcome = await syncCodexConfigFile({
+    filePath: getCodexConfigPath(codexConfigPath),
+    hubUrl,
+    dryRun,
+    logger,
+  });
+
+  if (outcome.kind === "updated") {
+    result.updated.push(outcome.path);
+  } else if (outcome.kind === "skipped") {
+    result.skipped.push(outcome.path);
+  } else {
+    result.errors.push({ path: outcome.path, reason: outcome.reason });
+  }
+
+  return result;
+}