triflux 10.14.3 → 10.16.0

package/CLAUDE.md

@@ -159,3 +159,11 @@ background로 실행한 headless 결과는 **반드시 task-notification 완료
 | `.claude/rules/tfx-stack-coexistence.md` | gstack / superpowers / triflux 공존 원칙, 레이어 분리, 의존 방향, 충돌 해소 |
 
 Claude Code는 `.claude/rules/*.md` 를 자동 로드한다. Codex CLI는 `@import` 미지원이므로 필요 시 `AGENTS.md` 를 독립 유지한다.
+
+## GBrain Configuration (configured by /setup-gbrain)
+- Engine: pglite
+- Config file: ~/.gbrain/config.json (mode 0600)
+- Setup date: 2026-04-25
+- MCP registered: yes (user scope, absolute path)
+- Memory sync: artifacts-only (repo: github.com/tellang/gstack-brain-tellang)
+- Current repo policy: read-write (github.com/tellang/triflux)

package/README.md

@@ -101,6 +101,21 @@ Then run `tfx setup` to configure your environment.
 
 > **Note**: Deep skills require **psmux** (or tmux), **triflux Hub**, **Codex CLI**, and **Gemini CLI** for full Tri-CLI consensus. Without these, skills automatically degrade to Claude-only mode. Run `tfx doctor` to check your environment.
 
+### State Snapshots
+
+Hub startup also takes a best-effort daily snapshot of selected `~/.codex/` and
+`~/.gemini/` state into `references/codex-snapshots/` and
+`references/gemini-snapshots/`. Snapshot archives are rolling backups capped at
+10 files per tool and are ignored by git.
+
+Manual commands:
+
+```bash
+npm run snapshot:codex
+npm run snapshot:gemini
+npm run snapshot:all
+```
+
 ---
 
 ## Core Engine

package/bin/triflux.mjs

@@ -5030,6 +5030,16 @@ function stopHubForUpdate() {
   return info;
 }
 
+function openHubLogFd() {
+  try {
+    const logDir = join(homedir(), ".claude", "cache", "tfx-hub");
+    mkdirSync(logDir, { recursive: true });
+    return openSync(join(logDir, "hub.log"), "a");
+  } catch {
+    return undefined;
+  }
+}
+
 function startHubAfterUpdate(info) {
   if (!info) return false;
   const serverPath = join(PKG_ROOT, "hub", "server.mjs");
@@ -5040,13 +5050,19 @@ function startHubAfterUpdate(info) {
       : String(process.env.TFX_HUB_PORT || "27888");
 
   try {
+    const logFd = openHubLogFd();
     const child = spawn(process.execPath, [serverPath], {
       env: { ...process.env, TFX_HUB_PORT: port },
-      stdio: "ignore",
+      stdio: ["ignore", logFd ?? "ignore", logFd ?? "ignore"],
       detached: true,
       windowsHide: true,
     });
     child.unref();
+    if (logFd !== undefined) {
+      try {
+        closeSync(logFd);
+      } catch {}
+    }
     return true;
   } catch {
     return false;
@@ -5211,7 +5227,9 @@ async function cmdHub(args = [], options = {}) {
         });
       }
 
-      // Issue #102: spawn stderr 를 임시 파일로 캡처해 실패 시 root cause 노출.
+      // Issue #102 + hub-detach fix: spawn stdout/stderr 를 두 채널로 redirect.
+      // - startupErrPath (tmp): 3초 안의 startup 실패 진단 (성공 시 cleanup)
+      // - hub.log (cache): runtime stdout/stderr 영구 보존 (crash 추적)
       // detached spawn 은 pipe 유지가 까다로우니 fd 리다이렉트로 접근.
       const { openSync: _openSync, closeSync: _closeSync } = await import(
         "node:fs"
@@ -5227,10 +5245,11 @@ async function cmdHub(args = [], options = {}) {
       } catch {
         errFd = undefined;
       }
+      const logFd = openHubLogFd();
 
       const child = spawn(process.execPath, [serverPath], {
         env: { ...process.env, TFX_HUB_PORT: port },
-        stdio: ["ignore", "ignore", errFd ?? "ignore"],
+        stdio: ["ignore", logFd ?? "ignore", errFd ?? logFd ?? "ignore"],
         detached: true,
         windowsHide: true,
       });
@@ -5240,6 +5259,11 @@ async function cmdHub(args = [], options = {}) {
           _closeSync(errFd);
         } catch {}
       }
+      if (logFd !== undefined) {
+        try {
+          _closeSync(logFd);
+        } catch {}
+      }
 
       // PID 파일 확인 (최대 3초 대기, 100ms 폴링)
       let started = false;

package/hub/intent.mjs

@@ -61,17 +61,22 @@ function _tryCodexClassify(prompt) {
  * triflux 특화 의도 카테고리 (10개)
  */
 export const INTENT_CATEGORIES = {
-  implement: { agent: "executor", mcp: "implement", effort: "codex53_high" },
-  debug: { agent: "debugger", mcp: "implement", effort: "codex53_high" },
-  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt54_xhigh" },
-  design: { agent: "architect", mcp: "analyze", effort: "gpt54_xhigh" },
-  review: { agent: "code-reviewer", mcp: "review", effort: "codex53_high" },
+  // 모델 정책 (2026-04-25):
+  // - gpt-5.5 = 메인 (코드 포함 모든 메인 직무, fast tier 가능)
+  // - gpt-5.4-mini = 자잘/부가/가성비 (fast tier 가능)
+  // - gpt-5.3-codex = escalation 가성비 중간 (fast 미지원)
+  // - gpt-5.4 폐기, gpt-5.5 로 격상
+  implement: { agent: "executor", mcp: "implement", effort: "gpt55_high" },
+  debug: { agent: "debugger", mcp: "implement", effort: "gpt55_xhigh" },
+  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt55_xhigh" },
+  design: { agent: "architect", mcp: "analyze", effort: "gpt55_xhigh" },
+  review: { agent: "code-reviewer", mcp: "review", effort: "gpt55_high" },
   document: { agent: "writer", mcp: "docs", effort: "pro" },
-  research: { agent: "scientist", mcp: "analyze", effort: "codex53_high" },
+  research: { agent: "scientist", mcp: "analyze", effort: "gpt55_high" },
   "quick-fix": {
     agent: "build-fixer",
     mcp: "implement",
-    effort: "codex53_low",
+    effort: "gpt55_low",
   },
   explain: { agent: "writer", mcp: "docs", effort: "flash" },
   test: { agent: "test-engineer", mcp: null, effort: null },

package/hub/lib/hosts-compat.mjs

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 
 const HOSTS_LOCATIONS = [
   ["references", "hosts.json"],
@@ -7,13 +8,70 @@ const HOSTS_LOCATIONS = [
   ["packages", "triflux", "references", "hosts.json"],
 ];
 
+let migrated = false;
+
 function readJsonFile(path) {
   return JSON.parse(readFileSync(path, "utf8"));
 }
 
+export function userStateHostsPath() {
+  if (process.env.TFX_HOSTS_USER_STATE_DISABLE === "1") return null;
+  if (process.env.TFX_HOSTS_USER_STATE) return process.env.TFX_HOSTS_USER_STATE;
+  if (process.platform === "win32") {
+    return join(
+      process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
+      "triflux",
+      "hosts.json",
+    );
+  }
+  return join(homedir(), ".config", "triflux", "hosts.json");
+}
+
 function candidatePaths(repoRoot) {
   const root = repoRoot || process.cwd();
-  return HOSTS_LOCATIONS.map((segments) => join(root, ...segments));
+  const repoRootCandidates = HOSTS_LOCATIONS.map((segments) =>
+    join(root, ...segments),
+  );
+  const userPath = userStateHostsPath();
+  return userPath ? [userPath, ...repoRootCandidates] : repoRootCandidates;
+}
+
+export function migrateLegacyHosts(repoRoot) {
+  const to = userStateHostsPath();
+  let from = null;
+  if (!to) {
+    return {
+      migrated: false,
+      from: null,
+      to: null,
+      reason: "user-state-disabled",
+    };
+  }
+  try {
+    if (existsSync(to)) {
+      return { migrated: false, from: null, to, reason: "already-exists" };
+    }
+
+    const root = repoRoot || process.cwd();
+    from =
+      HOSTS_LOCATIONS.map((segments) => join(root, ...segments)).find((path) =>
+        existsSync(path),
+      ) || null;
+    if (!from) {
+      return { migrated: false, from: null, to, reason: "not-found" };
+    }
+
+    mkdirSync(dirname(to), { recursive: true });
+    copyFileSync(from, to);
+    return { migrated: true, from, to };
+  } catch (error) {
+    return {
+      migrated: false,
+      from,
+      to,
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
 }
 
 function canonicalOs(rawOs) {
@@ -123,6 +181,11 @@ export function normalizeHost(rawHost = {}, name = "") {
 }
 
 export function readHosts(repoRoot) {
+  if (!migrated) {
+    migrateLegacyHosts(repoRoot);
+    migrated = true;
+  }
+
   for (const path of candidatePaths(repoRoot)) {
     if (!existsSync(path)) continue;
     const parsed = readJsonFile(path);

package/hub/lib/state-snapshot.mjs

@@ -0,0 +1,293 @@
+import { execFile } from "node:child_process";
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_MAX_SNAPSHOTS = 10;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+export const CODEX_STATE_INCLUDES = Object.freeze([
+  "config.toml",
+  "AGENTS.md",
+  "skills",
+  "agents",
+  "prompts",
+  "plugins",
+]);
+
+export const CODEX_STATE_EXCLUDES = Object.freeze([
+  "*.sqlite*",
+  ".sandbox*",
+  ".tmp",
+  "_archived_skills",
+  "memories",
+  "cache",
+  "log",
+  "logs",
+  "sessions",
+  "auth.json",
+  ".credentials.json",
+  "*.bak*",
+  "*.tmp-*",
+  "cap_sid",
+  "installation_id",
+  "history.jsonl",
+  "models_cache.json",
+]);
+
+export const GEMINI_STATE_INCLUDES = Object.freeze([
+  "settings.json",
+  "settings.local.json",
+  "GEMINI.md",
+  "commands",
+  "extensions",
+  "plugins",
+  "skills",
+  "agents",
+]);
+
+export const GEMINI_STATE_EXCLUDES = Object.freeze([
+  "*.sqlite*",
+  "cache",
+  "log",
+  "logs",
+  "sessions",
+  "auth.json",
+  ".credentials.json",
+  "*.bak*",
+]);
+
+export const STATE_SNAPSHOT_THRESHOLD_MS = DAY_MS;
+export const STATE_SNAPSHOT_MAX_SNAPSHOTS = DEFAULT_MAX_SNAPSHOTS;
+
+function normalizePath(path) {
+  return String(path || "")
+    .replace(/\\/gu, "/")
+    .replace(/^\/+/u, "");
+}
+
+function globToRegExp(pattern) {
+  const escaped = String(pattern).replace(/[.+^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`^${escaped.replace(/\*/gu, ".*")}$`, "u");
+}
+
+function compileExclude(pattern) {
+  const text = normalizePath(pattern).replace(/\/+$/u, "");
+  if (text.includes("*")) {
+    const regex = globToRegExp(text);
+    return (relativePath) => {
+      const normalized = normalizePath(relativePath);
+      return normalized.split("/").some((part) => regex.test(part));
+    };
+  }
+
+  return (relativePath) => {
+    const normalized = normalizePath(relativePath);
+    return normalized.split("/").includes(text);
+  };
+}
+
+function isSubpath(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+async function pathStats(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+async function collectFiles({ sourceDir, includes, excludeMatchers }) {
+  const sourceRoot = resolve(sourceDir);
+  const files = [];
+
+  async function visit(absPath, relativePath) {
+    if (excludeMatchers.some((matcher) => matcher(relativePath))) return;
+
+    const info = await pathStats(absPath);
+    if (!info) return;
+    if (info.isDirectory()) {
+      const children = await readdir(absPath, { withFileTypes: true });
+      for (const child of children) {
+        await visit(join(absPath, child.name), join(relativePath, child.name));
+      }
+      return;
+    }
+    if (info.isFile()) {
+      files.push({
+        absPath,
+        relativePath: normalizePath(relativePath),
+        size: info.size,
+      });
+    }
+  }
+
+  for (const include of includes || []) {
+    const relativeInclude = normalizePath(include);
+    if (!relativeInclude || relativeInclude.startsWith("../")) continue;
+    const absPath = resolve(sourceRoot, relativeInclude);
+    if (!isSubpath(sourceRoot, absPath)) continue;
+    await visit(absPath, relativeInclude);
+  }
+
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return files;
+}
+
+async function listSnapshots(destDir) {
+  const names = await readdir(destDir).catch((error) => {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  });
+  const snapshots = [];
+  for (const name of names) {
+    if (!name.endsWith(".tar.gz")) continue;
+    const path = join(destDir, name);
+    const info = await pathStats(path);
+    if (info?.isFile()) snapshots.push({ name, path, mtimeMs: info.mtimeMs });
+  }
+  snapshots.sort(
+    (a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name),
+  );
+  return snapshots;
+}
+
+async function copyToStaging(files, stagingDir) {
+  for (const file of files) {
+    const targetPath = join(stagingDir, ...file.relativePath.split("/"));
+    await mkdir(dirname(targetPath), { recursive: true });
+    await copyFile(file.absPath, targetPath);
+  }
+}
+
+async function createArchive({ stagingDir, archivePath, files }) {
+  const listPath = join(stagingDir, ".snapshot-files");
+  const archiveName = normalizePath(relative(stagingDir, archivePath));
+  await writeFile(
+    listPath,
+    `${files.map((file) => file.relativePath).join("\n")}\n`,
+    "utf8",
+  );
+  await execFileAsync(
+    "tar",
+    ["-czf", archiveName, "-C", ".", "-T", ".snapshot-files"],
+    {
+      cwd: stagingDir,
+      windowsHide: true,
+    },
+  );
+  await rm(listPath, { force: true });
+}
+
+async function pruneSnapshots(destDir, maxSnapshots) {
+  const snapshots = await listSnapshots(destDir);
+  const keep = Math.max(1, Number(maxSnapshots) || DEFAULT_MAX_SNAPSHOTS);
+  for (const snapshot of snapshots.slice(keep)) {
+    await rm(snapshot.path, { force: true });
+  }
+}
+
+function formatStamp(date) {
+  return date
+    .toISOString()
+    .replace(/[-:]/gu, "")
+    .replace(/\.\d{3}Z$/u, "Z");
+}
+
+function uniqueSuffix() {
+  return `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+/**
+ * Snapshot selected user state into a rolling tar.gz archive.
+ *
+ * @param {object} options
+ * @param {string} options.sourceDir
+ * @param {string} options.destDir
+ * @param {string[]} options.includes
+ * @param {string[]} options.excludes
+ * @param {number} options.thresholdMs
+ * @param {number} [options.maxSnapshots=10]
+ * @returns {Promise<{skipped: boolean, reason?: string, path?: string, sizeBytes?: number, fileCount?: number}>}
+ */
+export async function snapshotState({
+  sourceDir,
+  destDir,
+  includes,
+  excludes = [],
+  thresholdMs = 0,
+  maxSnapshots = DEFAULT_MAX_SNAPSHOTS,
+}) {
+  const sourceRoot = resolve(sourceDir || "");
+  const destRoot = resolve(destDir || "");
+  const sourceInfo = await pathStats(sourceRoot);
+  if (!sourceInfo?.isDirectory()) {
+    return { skipped: true, reason: "source-missing" };
+  }
+
+  await mkdir(destRoot, { recursive: true });
+  const snapshots = await listSnapshots(destRoot);
+  const newest = snapshots[0];
+  if (
+    newest &&
+    Number(thresholdMs) > 0 &&
+    Date.now() - newest.mtimeMs < Number(thresholdMs)
+  ) {
+    return { skipped: true, reason: "threshold", path: newest.path };
+  }
+
+  const excludeMatchers = excludes.map((pattern) => compileExclude(pattern));
+  const files = await collectFiles({
+    sourceDir: sourceRoot,
+    includes,
+    excludeMatchers,
+  });
+  if (files.length === 0) {
+    return { skipped: true, reason: "empty" };
+  }
+
+  const suffix = uniqueSuffix();
+  const stagingDir = join(tmpdir(), `tfx-state-snapshot-${suffix}`);
+  const tempArchivePath = join(stagingDir, `.state-${suffix}.tar.gz.tmp`);
+  const finalArchivePath = join(
+    destRoot,
+    `state-${formatStamp(new Date())}-${suffix}.tar.gz`,
+  );
+
+  try {
+    await mkdir(stagingDir, { recursive: true });
+    await copyToStaging(files, stagingDir);
+    await createArchive({
+      stagingDir,
+      archivePath: tempArchivePath,
+      files,
+    });
+    await rename(tempArchivePath, finalArchivePath);
+    await pruneSnapshots(destRoot, maxSnapshots);
+    const archiveInfo = await stat(finalArchivePath);
+    const sizeBytes = files.reduce((sum, file) => sum + file.size, 0);
+    return {
+      skipped: false,
+      path: finalArchivePath,
+      sizeBytes: archiveInfo.size || sizeBytes,
+      fileCount: files.length,
+    };
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+    await rm(tempArchivePath, { force: true });
+  }
+}

package/hub/server.mjs

@@ -140,7 +140,7 @@ export async function tryReuseExistingHub({
 } = {}) {
   const existing = readCurrentState();
   const existingPort = Number(existing?.port);
-  const requestedPort = parseHubPort(port);
+  const requestedPort = parseHubPort(port) ?? HUB_DEFAULT_PORT;
   const livePeer = detectPeer();
   const livePidPort = parseHubPort(livePeer?.port);
   if (
@@ -150,11 +150,7 @@ export async function tryReuseExistingHub({
   ) {
     return null;
   }
-  if (requestedPort && existingPort !== requestedPort) {
-    if (portSpecified) return null;
-    if (!livePeer?.alive || !livePidPort || existingPort !== livePidPort) {
-      return null;
-    }
+  if (existingPort !== requestedPort) {
     log.warn(
       {
         requestedPort,
@@ -162,8 +158,9 @@ export async function tryReuseExistingHub({
         pid: livePeer.pid,
         livePidPort,
       },
-      "hub.port_mismatch_reusing_live_pid",
+      "hub.port_mismatch_not_reusing_live_pid",
     );
+    return null;
   }
   if (!(await checkHealth(existingPort))) return null;
 
@@ -237,18 +234,9 @@ function readHubPidFile(
 }
 
 export function resolveHubPort(env = process.env, opts = {}) {
-  const {
-    preferLivePid = true,
-    detectPeer = detectLivePeer,
-    pidFilePath = PID_FILE,
-  } = opts;
+  void opts;
   const envPort = parseHubPort(env?.TFX_HUB_PORT);
   if (envPort) return envPort;
-  if (preferLivePid) {
-    const peer = detectPeer(pidFilePath);
-    const peerPort = parseHubPort(peer?.port);
-    if (peer?.alive && peerPort) return peerPort;
-  }
   return HUB_DEFAULT_PORT;
 }
 

package/hub/team/check-mcp-hub.mjs

@@ -0,0 +1,49 @@
+// hub/team/check-mcp-hub.mjs — health-probe L2 용 hub /health ping 체커.
+// health-probe.mjs 의 checkMcp 로 주입되어 `mcp_initializing` state 판정에 사용.
+// hub /health 가 200 이면 OK (MCP transport 인프라 살아있음), 그 외는 fail.
+
+const DEFAULT_HUB_URL = "http://127.0.0.1:27888";
+const DEFAULT_TIMEOUT_MS = 3000;
+
+function resolveHubHealthUrl(hubUrl) {
+  const base = hubUrl || process.env.TFX_HUB_URL || DEFAULT_HUB_URL;
+  // `/mcp` suffix 제거 (triflux convention — bridge.mjs:54, hub-client.mjs,
+  // lead-control.mjs, session-sync.mjs 전부 TFX_HUB_URL 을 MCP transport URL
+  // 로 쓰고 base URL 이 필요할 때 `/mcp$` 를 strip 한다). 제거하지 않으면
+  // `.../mcp/health` 가 되어 hub 가 404 로 응답 → L2 영구 fail → heartbeat
+  // 이 지속적으로 `mcp_initializing` 로 grace — #173 Codex P2 review.
+  return base.replace(/\/mcp\/?$/, "").replace(/\/+$/, "") + "/health";
+}
+
+/**
+ * Hub /health 기반 L2 checker factory.
+ * @param {object} [opts]
+ * @param {string} [opts.hubUrl] — override. 미지정 시 TFX_HUB_URL env 또는 default.
+ * @param {number} [opts.timeoutMs=3000] — fetch timeout (ms).
+ * @param {typeof fetch} [opts.fetchFn] — fetch 오버라이드 (테스트용).
+ * @returns {() => Promise<boolean>} — true = hub healthy, false = degraded/down/timeout.
+ */
+export function createHubHealthChecker(opts = {}) {
+  const url = resolveHubHealthUrl(opts.hubUrl);
+  const timeoutMs = Number.isFinite(opts.timeoutMs)
+    ? opts.timeoutMs
+    : DEFAULT_TIMEOUT_MS;
+  const fetchFn = opts.fetchFn || globalThis.fetch;
+
+  return async function checkMcpHubHealth() {
+    if (typeof fetchFn !== "function") return false;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchFn(url, {
+        method: "GET",
+        signal: controller.signal,
+      });
+      return res.ok === true;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}

package/hub/team/conductor.mjs

@@ -22,6 +22,7 @@ import { createRegistry } from "../../mesh/mesh-registry.mjs";
 import { broker } from "../account-broker.mjs";
 import { execFile, spawn } from "../lib/spawn-trace.mjs";
 import { killProcess } from "../platform.mjs";
+import { createHubHealthChecker } from "./check-mcp-hub.mjs";
 import { createConductorMeshBridge } from "./conductor-mesh-bridge.mjs";
 import {
   ensureConductorRegistry,
@@ -700,6 +701,16 @@ export function createConductor(opts = {}) {
         // opt-out: TFX_PROBE_WRITE_STATE=0 명시.
         writeStateFile:
           probeOpts.writeStateFile ?? process.env.TFX_PROBE_WRITE_STATE !== "0",
+        // #168 P3: L2 (hub /health) checker wiring. probeOpts 가 명시 주입하면
+        // 그걸 우선. 아니면 TFX_PROBE_L2=0 로 opt-out. 나머지 경우 hub URL 기반
+        // default checker 주입 → deriveState 가 `mcp_initializing` 라벨을 생산 →
+        // heartbeat (read_probe_state) 가 probe-grace 분기로 감.
+        enableL2: probeOpts.enableL2 ?? process.env.TFX_PROBE_L2 !== "0",
+        checkMcp:
+          probeOpts.checkMcp ||
+          (process.env.TFX_PROBE_L2 === "0"
+            ? undefined
+            : createHubHealthChecker({ hubUrl: process.env.TFX_HUB_URL })),
         onProbe: (result) => handleProbeResult(session, result),
       },
     );

package/hub/team/health-probe.mjs

@@ -28,7 +28,10 @@ export const PROBE_DEFAULTS = Object.freeze({
   l1ThresholdMs: 30_000,
   l2ThresholdMs: 30_000,
   l3ThresholdMs: 120_000,
-  enableL2: false,
+  // #168 P3: default off → on. checkMcp 미주입 시에도 probeL2 가 skip 반환하므로
+  // safe. conductor wiring 이 checkMcp 를 주입하면 실제 L2 판정이 활성화된다.
+  // opt-out: TFX_PROBE_L2=0 (conductor 에서 false 주입).
+  enableL2: true,
   writeStateFile: false,
   stateDir: join(tmpdir(), "tfx-probe"),
 });

package/hub/team/retry-state-machine.mjs

@@ -38,10 +38,17 @@ export const MODES = Object.freeze({
   ESCALATE: "auto-escalate",
 });
 
+// Escalation chain (2026-04-25 정책):
+//   1. gpt-5.4-mini   — 비용 최저, fast tier, 단순 task 대부분 해결
+//   2. gpt-5.3-codex  — 가성비 중간, code specialized (Plus/free 모두 OK, fast 미지원)
+//   3. gpt-5.5         — top reasoning + 코드 강함, fast tier
+//   4. claude opus-4-7 — 최종 수단
+// sonnet-4-6 단계는 제거: gpt-5.5 가 코드/추론/비용 모두 우위 + 5.3-codex 가성비
+// 단계가 더 적합한 중간 격상.
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({ cli: "codex", model: "gpt-5.4-mini" }),
+  Object.freeze({ cli: "codex", model: "gpt-5.3-codex" }),
   Object.freeze({ cli: "codex", model: "gpt-5.5" }),
-  Object.freeze({ cli: "claude", model: "sonnet-4-6" }),
   Object.freeze({ cli: "claude", model: "opus-4-7" }),
 ]);