triflux 10.13.0 → 10.13.2

package/bin/triflux.mjs

@@ -134,7 +134,8 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
     ],
   },
   doctor: {
-    usage: "tfx doctor [--fix] [--reset] [--audit] [--diagnose] [--json]",
+    usage:
+      "tfx doctor [--fix] [--reset] [--audit] [--diagnose] [--purge-logs] [--json]",
     description: "설치 상태 진단 및 자동 복구",
     options: [
       {
@@ -158,6 +159,12 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
         description:
           "진단 번들(zip) 생성: spawn-trace + hook timing + system info",
       },
+      {
+        name: "--purge-logs",
+        type: "boolean",
+        description:
+          "--fix 와 함께 사용. cli-issues.jsonl 에서 7일 초과 항목 물리 삭제 (#144)",
+      },
       {
         name: "--json",
         type: "boolean",
@@ -1742,7 +1749,12 @@ function ensureValidRegistryState() {
 }
 
 async function cmdDoctor(options = {}) {
-  const { fix = false, reset = false, json = false } = options;
+  const {
+    fix = false,
+    reset = false,
+    purgeLogs = false,
+    json = false,
+  } = options;
   const report = {
     status: "ok",
     mode: reset ? "reset" : fix ? "fix" : "check",
@@ -2357,9 +2369,20 @@ async function cmdDoctor(options = {}) {
           info(`업데이트 권장:\n${formatPsmuxUpdateGuidance("  ")}`);
         }
         if (psmuxSupport.missingOptionalCommands?.length > 0) {
+          // #144: 단순히 "detach-first hardening 경로에서만 사용" 만으로는 사용자가
+          // 영향 범위와 해결 방법을 알 수 없다. 각 capability 별 영향과 업그레이드 명령을 명시.
           info(
-            `선택 capability 미지원: ${psmuxSupport.missingOptionalCommands.join(", ")} (detach-first hardening 경로에서만 사용)`,
+            `선택 capability 미지원: ${psmuxSupport.missingOptionalCommands.join(", ")}`,
           );
+          if (psmuxSupport.missingOptionalCommands.includes("detach-client")) {
+            info(
+              "  detach-client: WT 1.24 ConPTY close-race 회피용. WT 기반 병렬 실행(swarm dashboard, tfx-multi wt 모드) 에서 pane freeze/ConPTY hang 위험 증가.",
+            );
+            info(
+              "  해결: psmux v3.4+ 로 업그레이드. 현재 psmux 업그레이드 명령:",
+            );
+            info(`${formatPsmuxUpdateGuidance("    ")}`);
+          }
         }
 
         // 기본 셸 확인: psmux 세션의 기본 셸이 PowerShell인지 cmd.exe인지
@@ -2771,6 +2794,10 @@ async function cmdDoctor(options = {}) {
           ).version;
           let cleaned = 0;
 
+          // #144: 오래된 로그 노이즈 완화 — 7일 초과 항목은 INFO 레벨로 downgrade.
+          // --fix --purge-logs 플래그가 있으면 해당 오래된 항목은 실제 삭제.
+          const STALE_AGE_MS = 7 * 24 * 3600 * 1000;
+          let purged = 0;
           for (const [key, g] of Object.entries(groups)) {
             const fixVer = KNOWN_FIXES[key];
             if (fixVer && semverGte(currentVer, fixVer)) {
@@ -2785,30 +2812,62 @@ async function cmdDoctor(options = {}) {
                 : age < 86400000
                   ? `${Math.round(age / 3600000)}시간 전`
                   : `${Math.round(age / 86400000)}일 전`;
-            const sev =
-              g.severity === "error"
+            const isStale = age >= STALE_AGE_MS;
+            if (isStale && fix && purgeLogs) {
+              purged += g.count;
+              continue;
+            }
+            const sev = isStale
+              ? `${CYAN}INFO${RESET}`
+              : g.severity === "error"
                 ? `${RED}ERROR${RESET}`
                 : `${YELLOW}WARN${RESET}`;
-            warn(`[${sev}] ${g.cli}/${g.pattern} x${g.count} (최근: ${ago})`);
+            const staleTag = isStale ? " [STALE]" : "";
+            if (isStale) {
+              info(
+                `[${sev}]${staleTag} ${g.cli}/${g.pattern} x${g.count} (최근: ${ago})`,
+              );
+            } else {
+              warn(`[${sev}] ${g.cli}/${g.pattern} x${g.count} (최근: ${ago})`);
+            }
             if (g.snippet) info(`  ${g.snippet.substring(0, 120)}`);
             if (fixVer)
               info(`  해결: triflux >= v${fixVer} (npm update -g triflux)`);
-            issues++;
+            if (isStale && !purgeLogs) {
+              info(`  7일 초과 — 삭제: tfx doctor --fix --purge-logs`);
+            }
+            if (!isStale) issues++;
           }
 
-          // 해결된 이슈 자동 정리
-          if (cleaned > 0) {
+          // #144 Codex review P2: 두 filter (stale purge + KNOWN_FIXES) 가 각각 원본 entries 로
+          // write 하면 두 번째 write 가 첫 번째 결과를 되살린다. 단일 통합 필터로 한 번만 저장.
+          if (purged > 0 || cleaned > 0) {
+            const now = Date.now();
             const remaining = entries.filter((e) => {
+              // purge-logs 로 물리 삭제 대상: 7일 초과
+              if (purged > 0 && now - e.ts >= STALE_AGE_MS) return false;
+              // KNOWN_FIXES 해결된 이슈 제거
               const key = `${e.cli}:${e.pattern}`;
               const fixVer = KNOWN_FIXES[key];
-              return !(fixVer && semverGte(currentVer, fixVer));
+              if (fixVer && semverGte(currentVer, fixVer)) return false;
+              return true;
             });
             writeFileSync(
               issuesFile,
               remaining.map((e) => JSON.stringify(e)).join("\n") +
                 (remaining.length ? "\n" : ""),
             );
-            ok(`${cleaned}개 해결된 이슈 자동 정리됨`);
+            if (purged > 0) {
+              ok(`${purged}개 stale 로그 항목 삭제 (7일 초과)`);
+              report.actions.push({
+                name: "purge-stale-logs",
+                status: "applied",
+                count: purged,
+              });
+            }
+            if (cleaned > 0) {
+              ok(`${cleaned}개 해결된 이슈 자동 정리됨`);
+            }
           }
           addDoctorCheck(report, {
             name: "cli-issues",
@@ -3373,6 +3432,56 @@ async function cmdDoctor(options = {}) {
           if (row.actualUrl) info(`actual   ${row.actualUrl}`);
         }
 
+        // #144: --fix 모드에서 tfx-hub URL 불일치를 hub status 기준으로 자동 갱신.
+        // Project MCP (.mcp.json) 와 Codex/Claude/Gemini settings 모두 대상.
+        // Codex review P2: fix 성공 시 issues 집계에서 차감해야 doctor 결과가 ok 로 반영됨.
+        let autoFixedMismatches = 0;
+        if (fix && mismatchRows.some((r) => r.name === "tfx-hub")) {
+          try {
+            const hubUrl = mismatchRows.find(
+              (r) => r.name === "tfx-hub",
+            )?.expectedUrl;
+            if (hubUrl) {
+              const { syncHubMcpSettings, syncProjectMcpJson } = await import(
+                "../scripts/sync-hub-mcp-settings.mjs"
+              );
+              const settingsResult = await syncHubMcpSettings({
+                hubUrl,
+                logger: { log() {}, warn() {}, error() {} },
+              });
+              const projectResult = await syncProjectMcpJson({
+                hubUrl,
+                projectRoot: process.cwd(),
+                logger: { log() {}, warn() {}, error() {} },
+              });
+              const totalUpdated =
+                (settingsResult?.updated?.length || 0) +
+                (projectResult?.updated?.length || 0);
+              if (totalUpdated > 0) {
+                ok(`tfx-hub URL ${totalUpdated}개 파일 자동 갱신 (${hubUrl})`);
+                report.actions.push({
+                  name: "sync-hub-url",
+                  status: "applied",
+                  files: [
+                    ...(settingsResult?.updated || []),
+                    ...(projectResult?.updated || []),
+                  ],
+                });
+                // fix 성공 — mismatchRows 중 tfx-hub 엔트리는 해결된 것으로 집계
+                autoFixedMismatches = mismatchRows.filter(
+                  (r) => r.name === "tfx-hub",
+                ).length;
+              } else {
+                info("tfx-hub URL 자동 갱신: 대상 파일 없음");
+              }
+            }
+          } catch (e) {
+            warn(
+              `tfx-hub URL 자동 갱신 실패: ${e?.message?.split(/\r?\n/)[0] || e}`,
+            );
+          }
+        }
+
         for (const row of missingFileRows) {
           info(
             `${row.label}: ${row.name} 미배치 (${formatPathForDisplay(row.filePath)})`,
@@ -3395,7 +3504,7 @@ async function cmdDoctor(options = {}) {
         }
 
         issues += invalidConfigs.length;
-        issues += mismatchRows.length;
+        issues += Math.max(0, mismatchRows.length - autoFixedMismatches);
         issues += stdioRows.length;
       }
     }
@@ -5508,7 +5617,8 @@ async function main() {
       }
       const fix = cmdArgs.includes("--fix");
       const reset = cmdArgs.includes("--reset");
-      await cmdDoctor({ fix, reset, json: JSON_OUTPUT });
+      const purgeLogs = cmdArgs.includes("--purge-logs");
+      await cmdDoctor({ fix, reset, purgeLogs, json: JSON_OUTPUT });
       return;
     }
     case "mcp":

package/hub/bridge.mjs

@@ -23,7 +23,6 @@ import { parseArgs as nodeParseArgs } from "node:util";
 import { getPipelineStateDbPath } from "./pipeline/state.mjs";
 import {
   createRetryStateMachine,
-  DEFAULT_ESCALATION_CHAIN,
   loadSnapshot,
   saveSnapshot,
 } from "./team/retry-state-machine.mjs";

package/hub/team/cli/commands/start/start-headless.mjs

@@ -45,7 +45,7 @@ export async function startHeadlessTeam({
   ok(`headless ${assignments.length}워커 시작`);
 
   const handle = await runHeadlessInteractive(sessionId, assignments, {
-    timeoutSec: timeoutSec || 300,
+    timeoutSec: timeoutSec || 900,
     layout,
     autoAttach: !!autoAttach,
     dashboard: !!dashboard,

package/hub/team/headless.mjs

@@ -11,6 +11,7 @@ import {
   mkdirSync,
   readFileSync,
   renameSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
@@ -240,16 +241,53 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   return `cd '${safeCwd.replace(/'/g, "'\\''")}' && ${backendCommand}`;
 }
 
+/**
+ * 이전 run 의 stale .txt / .partial / .err 를 제거한다.
+ * Issue #118 Codex review R1 HIGH: resultFile 경로 재사용 시 (워커 restart 또는
+ * 동일 세션명 재실행) 이전 run 의 HANDOFF 가 새 run 결과로 오인될 수 있다.
+ *
+ * Issue #118 R2 MEDIUM: Windows 에서 locked/open 파일로 인한 삭제 실패를
+ * silent swallow 하면 stale artifact 가 살아남아 bug 가 non-deterministic 하게
+ * 재발한다. ENOENT 외 에러는 경고 로그 + 재시도(1회) 후 계속.
+ * @param {string} resultFile
+ */
+export function cleanStaleResultArtifacts(resultFile) {
+  for (const suffix of ["", ".partial", ".err"]) {
+    const path = `${resultFile}${suffix}`;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        rmSync(path);
+        break;
+      } catch (err) {
+        if (err?.code === "ENOENT") break; // 이미 없음 — 정상
+        if (attempt === 0) continue; // 1회 재시도
+        // 재시도도 실패: locked 파일일 수 있음. 경고 로그 후 계속 진행
+        // (dispatch 중단 시 워커 자체가 시작 못하므로 best-effort 유지)
+        console.warn(
+          `[headless] cleanStaleResultArtifacts: ${path} 삭제 실패 (${err?.code || "unknown"}). stale leak 가능.`,
+        );
+      }
+    }
+  }
+}
+
 /**
  * 결과 파일 읽기 (없으면 capture-pane fallback)
+ * Issue #118 fallback chain: .txt → .partial ([partial] prefix) → .err → capture-pane
  * @param {string} resultFile
  * @param {string} paneId
  * @returns {string}
  */
-function readResult(resultFile, paneId) {
+export function readResult(resultFile, paneId) {
   if (existsSync(resultFile)) {
     return readFileSync(resultFile, "utf8").trim();
   }
+  // Issue #118 fallback 0: timeout 직전 persist 된 부분 출력 (.partial)
+  const partialFile = `${resultFile}.partial`;
+  if (existsSync(partialFile)) {
+    const partial = readFileSync(partialFile, "utf8").trim();
+    if (partial) return `[partial] ${partial}`;
+  }
   // fallback 1: stderr 파일 (codex 실패 시 원인 추적)
   const errFile = `${resultFile}.err`;
   if (existsSync(errFile)) {
@@ -417,6 +455,17 @@ export async function waitForCompletionWithStallDetect(
 
       // 전체 타임아웃
       if (now - startedAt > completionTimeout) {
+        // Issue #118: timeout kill 전에 capture-pane 출력을 .partial 파일로 persist.
+        // resultFile(`.txt`)이 아직 생성되지 않았을 수 있으므로 readResult 가 fallback 으로 읽는다.
+        try {
+          const partialSnapshot = _capture(currentPaneId, 200);
+          if (partialSnapshot && partialSnapshot.trim().length > 0) {
+            const writer = deps.writeFileSync || writeFileSync;
+            writer(`${resultFile}.partial`, partialSnapshot, "utf8");
+          }
+        } catch {
+          /* best-effort, timeout 은 이미 확정 */
+        }
         return {
           matched: false,
           exitCode: null,
@@ -610,6 +659,8 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       RESULT_DIR,
       `${sessionName}-${paneName}.txt`,
     ).replace(/\\/g, "/");
+    // Issue #118 review R1 HIGH: stale artifact 제거 (이전 run / restart 잔재)
+    cleanStaleResultArtifacts(resultFile);
     const cmd = buildHeadlessCommand(
       assignment.cli,
       assignment.prompt,
@@ -686,6 +737,8 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         RESULT_DIR,
         `${sessionName}-${paneName}.txt`,
       ).replace(/\\/g, "/");
+      // Issue #118 review R1 HIGH: stale artifact 제거 (이전 run / restart 잔재)
+      cleanStaleResultArtifacts(resultFile);
       const cmd = buildHeadlessCommand(
         assignment.cli,
         assignment.prompt,
@@ -832,9 +885,20 @@ async function awaitAll(
         );
       }
 
-      const output = completion.matched
-        ? readResult(d.resultFile, d.paneId)
-        : "";
+      // Issue #118: matched=false(timeout kill) 에도 capture-pane 스냅샷을
+      // .partial 로 persist 하여 readResult fallback chain 이 복구할 수 있도록 한다.
+      if (!completion.matched) {
+        try {
+          const snap = capturePsmuxPane(d.paneId || d.paneName, 200);
+          if (snap && snap.trim().length > 0) {
+            writeFileSync(`${d.resultFile}.partial`, snap, "utf8");
+          }
+        } catch {
+          /* best-effort */
+        }
+      }
+
+      const output = readResult(d.resultFile, d.paneId);
       unregisterHeadlessSynapseWorker(d.workerId);
 
       if (safeProgress) {
@@ -945,7 +1009,7 @@ function collectGitDiffFiles(cwd) {
  */
 export async function runHeadless(sessionName, assignments, opts = {}) {
   const {
-    timeoutSec = 300,
+    timeoutSec = 900,
     layout = "2x2",
     onProgress,
     progressIntervalSec = 0,

package/package.json

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

package/scripts/__tests__/setup-cleanup-stale-skills.test.mjs

@@ -0,0 +1,105 @@
+// scripts/__tests__/setup-cleanup-stale-skills.test.mjs
+// #144: cleanupStaleSkills 가 nested directory 를 가진 stale 스킬도 재귀 삭제하는지 확인.
+//
+// 이전 구현은 top-level 파일만 unlinkSync → 하위 폴더 있는 과거 스킬
+// (tfx-deep-*, tfx-codex-swarm 등) 은 제거 실패 → "triflux update 돌려도 13개 그대로" UX bug.
+
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { after, describe, it } from "node:test";
+
+const SETUP_MJS_URL = new URL("../setup.mjs", import.meta.url).href;
+const { cleanupStaleSkills } = await import(SETUP_MJS_URL);
+
+describe("#144 cleanupStaleSkills — 재귀 삭제", () => {
+  const cleanupDirs = [];
+  after(() => {
+    for (const d of cleanupDirs) rmSync(d, { recursive: true, force: true });
+  });
+
+  function setupFixture() {
+    const root = mkdtempSync(path.join(tmpdir(), "tfx-cleanup-"));
+    cleanupDirs.push(root);
+    const installedDir = path.join(root, "installed");
+    const pkgDir = path.join(root, "pkg");
+    mkdirSync(installedDir, { recursive: true });
+    mkdirSync(pkgDir, { recursive: true });
+    // pkg 에는 tfx-auto 만 있음 (나머지는 installed 에서 stale 로 감지)
+    mkdirSync(path.join(pkgDir, "tfx-auto"), { recursive: true });
+    return { installedDir, pkgDir };
+  }
+
+  it("nested directory 가 있는 stale 스킬도 전부 제거된다 (과거 회귀 bug)", () => {
+    const { installedDir, pkgDir } = setupFixture();
+    // stale 스킬: top-level 파일 + nested 디렉토리
+    const staleSkill = path.join(installedDir, "tfx-deep-review");
+    mkdirSync(staleSkill, { recursive: true });
+    writeFileSync(path.join(staleSkill, "SKILL.md"), "# deprecated");
+    const nested = path.join(staleSkill, "snapshot");
+    mkdirSync(nested, { recursive: true });
+    writeFileSync(path.join(nested, "data.json"), "{}");
+    mkdirSync(path.join(nested, "sub"), { recursive: true });
+    writeFileSync(path.join(nested, "sub", "more.txt"), "xxx");
+
+    // 유지해야 할 스킬 (pkg 에 있음)
+    mkdirSync(path.join(installedDir, "tfx-auto"), { recursive: true });
+    writeFileSync(path.join(installedDir, "tfx-auto", "SKILL.md"), "# ok");
+
+    const result = cleanupStaleSkills(installedDir, pkgDir);
+    assert.equal(result.count, 1);
+    assert.deepEqual(result.removed, ["tfx-deep-review"]);
+    assert.equal(existsSync(staleSkill), false, "nested dir 포함 전부 삭제");
+    assert.equal(
+      existsSync(path.join(installedDir, "tfx-auto")),
+      true,
+      "pkg 에 있는 스킬은 보존",
+    );
+  });
+
+  it("top-level 파일만 있는 stale 스킬도 제거된다 (legacy behavior 회귀 방지)", () => {
+    const { installedDir, pkgDir } = setupFixture();
+    const staleSkill = path.join(installedDir, "tfx-autoresearch");
+    mkdirSync(staleSkill, { recursive: true });
+    writeFileSync(path.join(staleSkill, "SKILL.md"), "# deprecated");
+    writeFileSync(path.join(staleSkill, "config.json"), "{}");
+
+    const result = cleanupStaleSkills(installedDir, pkgDir);
+    assert.equal(result.count, 1);
+    assert.equal(existsSync(staleSkill), false);
+  });
+
+  it("SKILL_ALIASES 에 있는 alias 는 유지된다", () => {
+    const { installedDir, pkgDir } = setupFixture();
+    // alias (tfx-autopilot) 는 SKILL_ALIASES 에 있으므로 pkgNames 에 자동 포함
+    mkdirSync(path.join(installedDir, "tfx-autopilot"), { recursive: true });
+    writeFileSync(
+      path.join(installedDir, "tfx-autopilot", "SKILL.md"),
+      "# alias",
+    );
+
+    const result = cleanupStaleSkills(installedDir, pkgDir);
+    assert.equal(result.count, 0);
+    assert.equal(existsSync(path.join(installedDir, "tfx-autopilot")), true);
+  });
+
+  it("tfx- 접두사 없는 디렉토리는 건드리지 않음", () => {
+    const { installedDir, pkgDir } = setupFixture();
+    mkdirSync(path.join(installedDir, "other-skill"), { recursive: true });
+    writeFileSync(
+      path.join(installedDir, "other-skill", "SKILL.md"),
+      "# other",
+    );
+
+    const result = cleanupStaleSkills(installedDir, pkgDir);
+    assert.equal(result.count, 0);
+    assert.equal(existsSync(path.join(installedDir, "other-skill")), true);
+  });
+});

package/scripts/setup.mjs

@@ -13,6 +13,7 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  rmSync,
   unlinkSync,
   writeFileSync,
 } from "fs";
@@ -56,10 +57,45 @@ const REQUIRED_CODEX_PROFILES = [
     name: "codex53_xhigh",
     lines: ['model = "gpt-5.3-codex"', 'model_reasoning_effort = "xhigh"'],
   },
+  {
+    name: "codex53_med",
+    lines: ['model = "gpt-5.3-codex"', 'model_reasoning_effort = "medium"'],
+  },
   {
     name: "spark53_low",
     lines: ['model = "gpt-5.3-codex-spark"', 'model_reasoning_effort = "low"'],
   },
+  {
+    name: "spark53_med",
+    lines: [
+      'model = "gpt-5.3-codex-spark"',
+      'model_reasoning_effort = "medium"',
+    ],
+  },
+  {
+    name: "gpt54_xhigh",
+    lines: ['model = "gpt-5.4"', 'model_reasoning_effort = "xhigh"'],
+  },
+  {
+    name: "gpt54_high",
+    lines: ['model = "gpt-5.4"', 'model_reasoning_effort = "high"'],
+  },
+  {
+    name: "gpt54_low",
+    lines: ['model = "gpt-5.4"', 'model_reasoning_effort = "low"'],
+  },
+  {
+    name: "mini54_low",
+    lines: ['model = "gpt-5.4-mini"', 'model_reasoning_effort = "low"'],
+  },
+  {
+    name: "mini54_med",
+    lines: ['model = "gpt-5.4-mini"', 'model_reasoning_effort = "medium"'],
+  },
+  {
+    name: "mini54_high",
+    lines: ['model = "gpt-5.4-mini"', 'model_reasoning_effort = "high"'],
+  },
 ];
 
 const HUD_SYNC_EXCLUDES = new Set(["omc-hud.mjs", "omc-hud.mjs.bak"]);
@@ -395,17 +431,15 @@ function cleanupStaleSkills(installedDir, pkgDir) {
     if (pkgNames.has(name)) continue;
 
     const skillPath = join(installedDir, name);
+    // #144: 재귀 삭제 필요 — 과거 구현은 파일만 unlink 하여 nested 디렉토리가 있는 스킬을
+    // 온전히 제거하지 못했다. `tfx-deep-*`, `tfx-codex-swarm` 같은 과거 잔재 디렉토리는
+    // workspace/snapshot 같은 하위 폴더를 가지므로 rmSync recursive 가 필수.
     try {
-      const entries = readdirSync(skillPath);
-      for (const f of entries) unlinkSync(join(skillPath, f));
-      // rmdir only works on empty dirs; ignore errors for nested
-      try {
-        readdirSync(skillPath).length === 0 && unlinkSync(skillPath);
-      } catch {}
+      rmSync(skillPath, { recursive: true, force: true });
+      removed.push(name);
     } catch {
-      /* best effort */
+      /* best effort — next setup/update cycle 에서 재시도 */
     }
-    removed.push(name);
   }
   return { count: removed.length, removed };
 }
@@ -556,6 +590,15 @@ function ensureCodexHubServerConfig({
   }
 }
 
+// Top-level config.toml keys that must exist with these defaults.
+// Only injected when the key is completely absent — existing user values are
+// never overwritten, regardless of what value was set.
+const REQUIRED_TOP_LEVEL_SETTINGS = [
+  { key: "model", value: '"gpt-5.4"' },
+  { key: "model_reasoning_effort", value: '"high"' },
+  { key: "service_tier", value: '"fast"' },
+];
+
 function ensureCodexProfiles() {
   try {
     if (!existsSync(CODEX_DIR)) mkdirSync(CODEX_DIR, { recursive: true });
@@ -564,9 +607,45 @@ function ensureCodexProfiles() {
       ? readFileSync(CODEX_CONFIG_PATH, "utf8")
       : "";
 
+    // Safety guard: if the file exists but is suspiciously small (< 100 bytes)
+    // skip all writes to avoid perpetuating a corrupted state.
+    if (original.length > 0 && original.length < 100) {
+      process.stderr.write(
+        `[tfx-setup] config.toml 크기 이상 (${original.length} bytes) — 쓰기 스킵. 수동 확인 필요: ${CODEX_CONFIG_PATH}\n`,
+      );
+      return { ok: false, changed: 0, message: "config too small, skipped" };
+    }
+
     let updated = original;
     let changed = 0;
 
+    // ── 1. top-level 필수 설정 주입 (없을 때만, 기존 값 보존) ──
+    // 파일 상단 [profiles.*] / [mcp_servers.*] 이전 영역만 검사한다.
+    // 프로필 섹션 내부의 동명 키(예: model = "gpt-5.3-codex")는 무시한다.
+    // 이미 존재하는 키는 절대 덮어쓰지 않는다.
+    for (const { key, value } of REQUIRED_TOP_LEVEL_SETTINGS) {
+      // top-level 영역 = 첫 번째 [profiles.*] / [mcp_servers.*] 헤더 이전
+      const firstSectionIdx = updated.search(/^\[(?:profiles|mcp_servers)\./m);
+      const topLevelRegion =
+        firstSectionIdx === -1 ? updated : updated.slice(0, firstSectionIdx);
+      const topLevelKeyRe = new RegExp(`^${key}\\s*=`, "m");
+      if (!topLevelKeyRe.test(topLevelRegion)) {
+        // firstSectionIdx already computed above for this iteration
+        const line = `${key} = ${value}\n`;
+        if (firstSectionIdx === -1) {
+          // 섹션이 없으면 파일 맨 앞에 추가
+          updated = line + updated;
+        } else {
+          updated =
+            updated.slice(0, firstSectionIdx) +
+            line +
+            updated.slice(firstSectionIdx);
+        }
+        changed++;
+      }
+    }
+
+    // ── 2. 필수 프로필 보장 ──
     for (const profile of REQUIRED_CODEX_PROFILES) {
       const desired = `[profiles.${profile.name}]\n${profile.lines.join("\n")}\n`;
 
@@ -898,6 +977,7 @@ export {
   LEGACY_CODEX_MODELS,
   PLUGIN_ROOT,
   REQUIRED_CODEX_PROFILES,
+  REQUIRED_TOP_LEVEL_SETTINGS,
   readMarker,
   replaceProfileSection,
   SETUP_MARKER_PATH,

package/scripts/tfx-route.sh

@@ -1348,6 +1348,32 @@ heartbeat_monitor() {
           echo "[tfx-heartbeat] pid=$pid elapsed=${elapsed}s output=${current_size}B status=draining(${post_exit_checks}/${max_post_exit_checks})" >&2
         fi
       elif [[ "$stall_count" -ge "$stall_threshold" ]]; then
+        # STALL kill (#144/#66 regression guard): stall=threshold+grace 이상 지속 시 SIGTERM→SIGKILL.
+        # 기본 활성화. TFX_STALL_KILL=0 으로 opt-out. grace=30s (기본) 은 SSE/MCP 정상 handshake 여유.
+        local kill_on_stall="${TFX_STALL_KILL:-1}"
+        local kill_grace="${TFX_STALL_KILL_GRACE:-30}"
+        if [[ "$kill_on_stall" -eq 1 && "$stall_count" -ge $((stall_threshold + kill_grace)) ]]; then
+          echo "[tfx-heartbeat] pid=$pid elapsed=${elapsed}s output=${current_size}B status=STALL_KILL stall=${stall_count}s — SIGTERM" >&2
+          kill -TERM "$pid" 2>/dev/null || true
+          local _grace_waited=0
+          while kill -0 "$pid" 2>/dev/null && [[ "$_grace_waited" -lt 5 ]]; do
+            sleep 1
+            _grace_waited=$((_grace_waited + 1))
+          done
+          if kill -0 "$pid" 2>/dev/null; then
+            # Windows/MSYS: POSIX SIGKILL 이 Win32 자식 트리까지 닿지 않는다.
+            # cleanup_workers 와 동일하게 taskkill /T /F 로 트리 종료.
+            case "$(uname -s)" in
+              MINGW*|MSYS*)
+                echo "[tfx-heartbeat] pid=$pid SIGTERM 무시 — taskkill /T /F" >&2
+                MSYS_NO_PATHCONV=1 cmd.exe //c "taskkill /T /F /PID $pid" 2>/dev/null || true ;;
+              *)
+                echo "[tfx-heartbeat] pid=$pid SIGTERM 무시 — SIGKILL 강제" >&2
+                kill -KILL "$pid" 2>/dev/null || true ;;
+            esac
+          fi
+          break
+        fi
         echo "[tfx-heartbeat] pid=$pid elapsed=${elapsed}s output=${current_size}B status=STALL stall=${stall_count}s" >&2
       else
         echo "[tfx-heartbeat] pid=$pid elapsed=${elapsed}s output=${current_size}B status=quiet stall=${stall_count}s" >&2
@@ -1445,15 +1471,63 @@ _codex_config_swap() {
       return 0
     fi
 
-    # 백업 생성 (이미 있으면 다른 워커가 swap 중 — 건드리지 않음)
-    if [[ -f "$backup" ]]; then
-      echo "[tfx-route] config.toml swap 스킵: 다른 워커가 사용 중 ($backup)" >&2
+    # Pre-validation: config.toml이 500 bytes 미만이면 이미 손상된 상태일 수 있음 — 스킵
+    local config_size
+    config_size=$(wc -c < "$config" 2>/dev/null | tr -d ' ') || config_size=0
+    if [[ "$config_size" -lt 500 ]]; then
+      echo "[tfx-route] 경고: config.toml 크기 ${config_size} bytes — 손상 의심, swap 스킵 (수동 확인 필요)" >&2
       return 0
     fi
+
+    # 백업 생성 (이미 있으면 다른 워커가 swap 중 — 단, owner-dead + 백업 안전 복원 시 이어받기)
+    if [[ -f "$backup" ]]; then
+      # Owner PID marker (P1 fix): mtime 만으로 stale 을 판정하면 장시간 정상 실행 워커도 오탐.
+      # $backup.owner 에 생성 워커 PID 기록 → kill -0 로 alive 확인. PID 파일 없거나 죽었으면 stale.
+      # mtime 은 신뢰성 낮아 soft 보조 지표로만 사용 (owner 파일 유실 대비 fallback).
+      local owner_file="${backup}.owner"
+      local owner_alive=false
+      local owner_pid=""
+      if [[ -f "$owner_file" ]]; then
+        owner_pid=$(cat "$owner_file" 2>/dev/null | tr -d '[:space:]')
+        if [[ -n "$owner_pid" ]] && kill -0 "$owner_pid" 2>/dev/null; then
+          owner_alive=true
+        fi
+      fi
+
+      if [[ "$owner_alive" == "true" ]]; then
+        echo "[tfx-route] config.toml swap 스킵: 소유 워커 살아있음 (pid=$owner_pid, $backup)" >&2
+        return 0
+      fi
+
+      # Owner dead or unknown — stale 후보. 다만 backup-loss 방지를 위해 원본 복원 먼저.
+      # P2 fix: `rm -f $backup` 후 현재 config 를 새 backup 으로 cp 하면, 이전 워커가 이미
+      # filter 한 상태에서 crash 했을 때 원본이 영구 소실. 여기서 먼저 restore 를 시도해
+      # backup 이 원본을 담고 있는 한 그것을 살린다.
+      local backup_restore_guard_size
+      backup_restore_guard_size=$(wc -c < "$backup" 2>/dev/null | tr -d ' ') || backup_restore_guard_size=0
+      if [[ "$backup_restore_guard_size" -lt 500 ]]; then
+        # 작은 backup 은 이미 손상된 state. 현재 config 도 필터된 상태일 수 있으므로
+        # 추가 swap 은 상황을 악화시킬 위험. 전체 스킵하고 수동 확인 유도.
+        echo "[tfx-route] stale backup 작음 (size=${backup_restore_guard_size}B, pid=${owner_pid:-?} dead) — swap 스킵, 수동 확인: $backup" >&2
+        return 0
+      fi
+      local stale_tmp="${config}.stale-restore.$$"
+      if cp "$backup" "$stale_tmp" && mv "$stale_tmp" "$config"; then
+        echo "[tfx-route] stale backup 감지 (pid=${owner_pid:-?} dead) — 원본 복원 후 swap 재진행" >&2
+      else
+        echo "[tfx-route] 경고: stale backup 복원 실패, swap 스킵 (수동 확인: $backup)" >&2
+        rm -f "$stale_tmp" 2>/dev/null
+        return 0
+      fi
+      rm -f "$backup" "$owner_file" 2>/dev/null || true
+    fi
     cp "$config" "$backup"
+    # Owner marker: 이 워커가 backup 소유자임을 기록. 다음 워커의 stale detection 기준.
+    echo "$$" > "${backup}.owner" 2>/dev/null || true
 
     # awk로 필터링: 비허용 MCP 서버 섹션 제거, 나머지 그대로 유지.
     # keep="" 은 진입 가드에서 return 됐지만 defense-in-depth 유지.
+    local tmp_filtered="${config}.filter.$$"
     awk -v keep="$allowed_pat" '
       BEGIN { skip=0 }
       /^\[mcp_servers\./ {
@@ -1464,7 +1538,26 @@ _codex_config_swap() {
       }
       /^\[/ && !/^\[mcp_servers\./ { skip=0 }
       !skip { print }
-    ' "$backup" > "$config"
+    ' "$backup" > "$tmp_filtered"
+
+    # Output sanity check: 필터 결과가 비었거나 백업의 30% 미만이면 적용 거부
+    local filtered_size backup_size threshold
+    filtered_size=$(wc -c < "$tmp_filtered" 2>/dev/null | tr -d ' ') || filtered_size=0
+    backup_size=$(wc -c < "$backup" 2>/dev/null | tr -d ' ') || backup_size=1
+    threshold=$(( backup_size * 30 / 100 ))
+    if [[ "$filtered_size" -eq 0 || "$filtered_size" -lt "$threshold" ]]; then
+      echo "[tfx-route] 경고: 필터 결과 크기 ${filtered_size} bytes (백업 ${backup_size} bytes의 30% 미만) — 적용 거부, 백업에서 복원" >&2
+      rm -f "$tmp_filtered" 2>/dev/null
+      rm -f "$backup" 2>/dev/null
+      return 1
+    fi
+
+    # 검증 통과 — atomic rename으로 적용
+    if ! mv "$tmp_filtered" "$config"; then
+      echo "[tfx-route] 경고: 필터 결과 적용 실패 (atomic rename), 백업 보존: $backup" >&2
+      rm -f "$tmp_filtered" 2>/dev/null
+      return 1
+    fi
 
     local kept
     kept=$(echo "$allowed_pat" | tr '|' '\n' | wc -l | tr -d ' ')
@@ -1475,6 +1568,15 @@ _codex_config_swap() {
     # `cat > $config` 는 cat 실행 전에 dest 가 truncate 되어 mid-stream 실패 시
     # 빈/부분 파일이 남는다. 같은 디렉토리 내 mv 는 POSIX 상 atomic 이므로
     # 실패해도 기존 config 와 backup 모두 보존된다.
+
+    # Restore sanity check: 백업 자체가 비었거나 500 bytes 미만이면 복원 중단
+    local backup_restore_size
+    backup_restore_size=$(wc -c < "$backup" 2>/dev/null | tr -d ' ') || backup_restore_size=0
+    if [[ "$backup_restore_size" -lt 500 ]]; then
+      echo "[tfx-route] 경고: backup 크기 ${backup_restore_size} bytes — 손상 의심, 복원 중단. 수동 확인 필요: $backup" >&2
+      return 1
+    fi
+
     local tmp="${config}.restore.$$"
     if ! cp "$backup" "$tmp"; then
       echo "[tfx-route] 경고: config.toml 복원 실패 (temp copy). backup 보존: $backup" >&2
@@ -1489,6 +1591,7 @@ _codex_config_swap() {
     if ! rm -f "$backup"; then
       echo "[tfx-route] 경고: backup 삭제 실패: $backup (수동 정리 필요)" >&2
     fi
+    rm -f "${backup}.owner" 2>/dev/null || true
     echo "[tfx-route] config.toml 복원 완료" >&2
   fi
 }