triflux 10.9.21 → 10.9.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.9.21",
+  "version": "10.9.23",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {
@@ -13,26 +13,75 @@
     "tfx-doctor-tui": "bin/tfx-doctor-tui.mjs",
     "tfx-setup-tui": "bin/tfx-setup-tui.mjs"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@triflux/core": "10.0.1",
-    "@triflux/remote": "^10.0.0-alpha.1"
-  },
   "files": [
     "bin",
+    "tui",
+    "hub",
+    "config",
     "skills",
+    "!skills/tfx-workspace",
+    "!**/failure-reports",
+    "scripts",
     "hooks",
     "hud",
-    "scripts",
-    "hub",
     "mesh",
-    "references",
-    "CLAUDE.md",
+    ".claude-plugin",
     "README.md",
+    "README.ko.md",
     "LICENSE"
   ],
+  "workspaces": [
+    "packages/core",
+    "packages/remote",
+    "packages/triflux"
+  ],
+  "scripts": {
+    "pack": "node scripts/pack.mjs all",
+    "pack:core": "node scripts/pack.mjs core",
+    "pack:remote": "node scripts/pack.mjs remote",
+    "setup": "node scripts/setup.mjs",
+    "preinstall": "node scripts/preinstall.mjs",
+    "postinstall": "node scripts/setup.mjs",
+    "lint": "biome check bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
+    "lint:fix": "biome check --write bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
+    "health": "npm test && npm run lint",
+    "test": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 \"tests/**/*.test.mjs\" \"scripts/__tests__/**/*.test.mjs\"",
+    "test:unit": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/unit/**/*.test.mjs",
+    "test:integration": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/integration/**/*.test.mjs",
+    "test:route-smoke": "node scripts/test-lock.mjs --test scripts/test-tfx-route-no-claude-native.mjs",
+    "test:contract": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/contract/**/*.test.mjs",
+    "test:coverage": "node --experimental-test-coverage --test-coverage-lines=60 --test-coverage-functions=60 --test --test-force-exit --test-concurrency=8 \"tests/**/*.test.mjs\"",
+    "gen:skill-docs": "node scripts/gen-skill-docs.mjs",
+    "gen:skill-manifest": "node scripts/gen-skill-manifest.mjs",
+    "release:check-sync": "node scripts/release/check-sync.mjs",
+    "release:check-sync:fix": "node scripts/release/check-sync.mjs --fix",
+    "release:bump": "node scripts/release/bump-version.mjs",
+    "release:prepare": "node scripts/release/prepare.mjs",
+    "release:publish": "node scripts/release/publish.mjs",
+    "release:verify": "node scripts/release/verify.mjs"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tellang/triflux.git"
+  },
+  "homepage": "https://github.com/tellang/triflux#readme",
+  "author": "tellang",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^12.6.2",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "systray2": "^2.1.4",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "knip": "^6.3.0"
+  },
   "keywords": [
     "claude-code",
     "plugin",
@@ -43,13 +92,5 @@
     "multi-model",
     "triflux",
     "tfx"
-  ],
-  "author": "tellang",
-  "license": "MIT",
-  "homepage": "https://github.com/tellang/triflux#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tellang/triflux.git",
-    "directory": "packages/triflux"
-  }
+  ]
 }

package/scripts/__tests__/keyword-detector.test.mjs

@@ -34,7 +34,7 @@ const { extractPrompt, sanitizeForKeywordDetection } = detectorModule;
 
 function loadCompiledRules() {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 32);
+  assert.ok(rules.length >= 32);
   return compileRules(rules);
 }
 
@@ -108,8 +108,8 @@ test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제
 
 test("loadRules: 유효한 JSON 로드", () => {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 32);
-  assert.equal(rules.filter((rule) => rule.skill).length, 18);
+  assert.ok(rules.length >= 32);
+  assert.ok(rules.filter((rule) => rule.skill).length >= 18);
   assert.equal(rules.filter((rule) => rule.mcp_route).length, 10);
 });
 
@@ -130,7 +130,7 @@ test("loadRules: 잘못된 파일 처리", () => {
 test("compileRules: 정규식 컴파일 성공", () => {
   const rules = loadRules(rulesPath);
   const compiled = compileRules(rules);
-  assert.equal(compiled.length, 32);
+  assert.equal(compiled.length, rules.length);
   for (const rule of compiled) {
     assert.ok(Array.isArray(rule.compiledPatterns));
     assert.ok(rule.compiledPatterns.length > 0);

package/scripts/__tests__/release-governance.test.mjs

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+import { bumpVersion } from "../release/bump-version.mjs";
+import { assertVersionSync, writeJson } from "../release/lib.mjs";
+import { prepareRelease } from "../release/prepare.mjs";
+import { publishRelease } from "../release/publish.mjs";
+import { verifyRelease } from "../release/verify.mjs";
+
+function makeRepo() {
+  const root = mkdtempSync(join(tmpdir(), "tfx-release-"));
+  mkdirSync(join(root, "scripts", "release"), { recursive: true });
+  mkdirSync(join(root, ".claude-plugin"), { recursive: true });
+  mkdirSync(join(root, "packages", "triflux"), { recursive: true });
+  mkdirSync(join(root, ".omx", "plans"), { recursive: true });
+
+  writeJson(join(root, "package.json"), { name: "triflux", version: "1.2.3" });
+  writeJson(join(root, "packages", "triflux", "package.json"), {
+    name: "triflux",
+    version: "1.2.0",
+  });
+  writeJson(join(root, ".claude-plugin", "plugin.json"), {
+    name: "triflux",
+    version: "1.1.0",
+  });
+  writeJson(join(root, ".claude-plugin", "marketplace.json"), {
+    version: "1.2.0",
+    plugins: [{ name: "triflux", version: "1.0.0" }],
+  });
+  writeJson(join(root, "package-lock.json"), {
+    name: "triflux",
+    version: "1.2.0",
+    packages: {
+      "": {
+        version: "1.0.0",
+      },
+    },
+  });
+  writeJson(join(root, "scripts", "release", "version-manifest.json"), {
+    canonicalFile: "package.json",
+    canonicalPath: ["version"],
+    targets: [
+      { file: "package.json", paths: [["version"]] },
+      { file: "packages/triflux/package.json", paths: [["version"]] },
+      { file: ".claude-plugin/plugin.json", paths: [["version"]] },
+      {
+        file: ".claude-plugin/marketplace.json",
+        paths: [["version"], ["plugins", 0, "version"]],
+      },
+      {
+        file: "package-lock.json",
+        paths: [["version"], ["packages", "", "version"]],
+      },
+    ],
+  });
+  return root;
+}
+
+describe("release governance scripts", () => {
+  it("assertVersionSync detects mismatches and fixes them", () => {
+    const root = makeRepo();
+    try {
+      const before = assertVersionSync({ rootDir: root });
+      assert.equal(before.ok, false);
+      assert.ok(before.mismatches.length >= 4);
+
+      const after = assertVersionSync({ rootDir: root, fix: true });
+      assert.equal(after.ok, true);
+      assert.deepEqual(
+        JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"))),
+        { name: "triflux", version: "1.2.3" },
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("bumpVersion writes canonical version and syncs targets", async () => {
+    const root = makeRepo();
+    try {
+      const result = await bumpVersion({
+        rootDir: root,
+        nextVersion: "2.0.0",
+        write: true,
+      });
+      assert.equal(result.ok, true);
+      assert.equal(
+        JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version,
+        "2.0.0",
+      );
+      assert.equal(
+        JSON.parse(
+          readFileSync(
+            join(root, "packages", "triflux", "package.json"),
+            "utf8",
+          ),
+        ).version,
+        "2.0.0",
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("prepare/publish/verify support dry-run planning", async () => {
+    const root = makeRepo();
+    try {
+      assertVersionSync({ rootDir: root, fix: true });
+      const execStub = (command, args) => {
+        if (command === "git" && args[0] === "status") return "";
+        if (command === "git" && args[0] === "describe") return "v1.2.2";
+        if (command === "git" && args[0] === "log")
+          return "abc1234 feat: sample\n";
+        return "";
+      };
+
+      const prepare = await prepareRelease({
+        rootDir: root,
+        version: "1.2.3",
+        allowDirty: true,
+        dryRun: true,
+        execFileSyncFn: execStub,
+      });
+      assert.equal(prepare.ok, true);
+      assert.equal(prepare.commands.length, 3);
+
+      const publish = await publishRelease({
+        rootDir: root,
+        version: "1.2.3",
+        dryRun: true,
+      });
+      assert.equal(publish.steps.length >= 3, true);
+
+      const verify = await verifyRelease({
+        rootDir: root,
+        version: "1.2.3",
+        dryRun: true,
+      });
+      assert.equal(verify.ok, true);
+      assert.equal(verify.checks[1].name, "npm-view");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/scripts/doctor-diagnose.mjs

@@ -139,14 +139,13 @@ function collectSystemInfo() {
     freeMemMB: Math.round(freemem() / 1024 / 1024),
   };
 
-  // Windows Terminal version
+  // Windows Terminal version (wt.exe --version은 GUI 다이얼로그를 띄우므로 AppxPackage로 조회)
   try {
-    const wtVer = execSync("wt.exe --version 2>&1", {
-      encoding: "utf8",
-      timeout: 5000,
-      windowsHide: true,
-    }).trim();
-    info.wtVersion = wtVer;
+    const wtVer = execSync(
+      'powershell.exe -NoProfile -NoLogo -Command "(Get-AppxPackage Microsoft.WindowsTerminal).Version"',
+      { encoding: "utf8", timeout: 5000, windowsHide: true },
+    ).trim();
+    info.wtVersion = wtVer || "not found";
   } catch {
     info.wtVersion = "not found";
   }

package/scripts/lib/cross-review-utils.mjs

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 
 export const SESSION_TTL_SEC = 30 * 60;
-export const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+export const STATE_REL_PATH = join(".triflux", "state", "cross-review.json");
 
 export function readStdin() {
   return new Promise((resolve) => {
@@ -39,7 +39,7 @@ export function shouldTrackPath(filePath) {
   if (typeof filePath !== "string" || !filePath.trim()) return false;
 
   const lower = filePath.toLowerCase();
-  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower.startsWith(".triflux/") || lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
   if (lower === "package-lock.json" || lower.endsWith("/package-lock.json"))
     return false;
   if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;

package/scripts/lib/mcp-filter.mjs

@@ -36,28 +36,12 @@ const PROFILE_DEFINITIONS = Object.freeze({
     }),
   }),
   executor: Object.freeze({
-    description: "구현 워커용. 문서/검색/브라우징 보조 MCP 허용",
-    allowedServers: Object.freeze([
-      "context7",
-      "playwright",
-      "brave-search",
-      "tavily",
-      "exa",
-    ]),
+    description: "구현 워커용. 문서 조회 전용 MCP만 허용 (검색/브라우징은 Codex stall 유발)",
+    allowedServers: Object.freeze(["context7"]),
     alwaysOnServers: Object.freeze(["context7"]),
-    maxSearchServers: 2,
+    maxSearchServers: 0,
     allowedToolsByServer: Object.freeze({
       context7: Object.freeze(["resolve-library-id", "query-docs"]),
-      "brave-search": Object.freeze(["brave_web_search", "brave_news_search"]),
-      exa: Object.freeze(["web_search_exa", "get_code_context_exa"]),
-      tavily: Object.freeze(["tavily_search", "tavily_extract"]),
-      playwright: Object.freeze([
-        "browser_navigate",
-        "browser_navigate_back",
-        "browser_snapshot",
-        "browser_take_screenshot",
-        "browser_wait_for",
-      ]),
     }),
   }),
   designer: Object.freeze({
@@ -672,18 +656,22 @@ export function getCodexMcpConfig(options = {}) {
   const targetServers = registeredServers;
 
   if (resolvedProfile === "none") {
-    // Codex 0.115+: transport 없는 서버에 enabled=false를 보내면 "invalid transport" 에러.
-    // 비허용 서버는 override에서 제외하고, 허용 서버만 명시적으로 설정한다.
-    return { mcp_servers: {} };
+    // 등록된 서버를 전부 enabled=false로 비활성화.
+    // 미등록 서버에 보내면 "invalid transport" 에러지만, registeredServers는 등록 확인 완료.
+    const config = { mcp_servers: {} };
+    for (const server of targetServers) {
+      config.mcp_servers[server] = { enabled: false };
+    }
+    return config;
   }
 
   const config = { mcp_servers: {} };
   const allowedToolsByServer =
     getProfileDefinition(resolvedProfile).allowedToolsByServer;
   for (const server of targetServers) {
-    // Codex 0.115+: transport 없는 서버에 enabled=false를 보내면 "invalid transport" 에러.
-    // 비허용 서버는 override에서 제외한다 (Codex 기본 설정이 유지됨).
     if (!allowedServers.has(server)) {
+      // 비허용 서버는 명시적으로 비활성화하여 MCP 시작 자체를 방지.
+      config.mcp_servers[server] = { enabled: false };
       continue;
     }
 

package/scripts/release/bump-version.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  assertVersionSync,
+  isSemver,
+  parseArgs,
+  ROOT,
+  readJson,
+  syncVersionTargets,
+  writeJson,
+} from "./lib.mjs";
+
+export async function bumpVersion({
+  nextVersion,
+  rootDir = ROOT,
+  write = false,
+} = {}) {
+  if (!isSemver(nextVersion)) {
+    throw new Error(`Invalid semver version: ${nextVersion}`);
+  }
+
+  const packagePath = join(rootDir, "package.json");
+  const packageJson = readJson(packagePath);
+  const previousVersion = packageJson.version;
+  packageJson.version = nextVersion;
+
+  if (write) {
+    writeJson(packagePath, packageJson);
+    const syncedFiles = syncVersionTargets({
+      rootDir,
+      expectedVersion: nextVersion,
+    });
+    const post = assertVersionSync({ rootDir, expectedVersion: nextVersion });
+    return {
+      ok: post.ok,
+      previousVersion,
+      nextVersion,
+      updatedFiles: ["package.json", ...syncedFiles],
+      targets: post.targets,
+    };
+  }
+
+  const preview = assertVersionSync({
+    rootDir,
+    expectedVersion: nextVersion,
+  });
+  return {
+    ok: true,
+    previousVersion,
+    nextVersion,
+    updatedFiles: ["package.json"],
+    targets: preview.targets.map((target) => ({
+      ...target,
+      expected: nextVersion,
+      inSync: target.file === "package.json",
+    })),
+  };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const nextVersion = args.next || args.version;
+  const result = await bumpVersion({
+    nextVersion,
+    rootDir: args.root,
+    write: Boolean(args.write),
+  });
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(
+      `${args.write ? "Bumped" : "Planned"} version ${result.previousVersion} -> ${result.nextVersion}`,
+    );
+    console.log(`Updated files: ${result.updatedFiles.join(", ")}`);
+  }
+}

package/scripts/release/check-sync.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+
+import { assertVersionSync, formatPathSegments, parseArgs } from "./lib.mjs";
+
+export { assertVersionSync } from "./lib.mjs";
+
+function toJson(result) {
+  return {
+    ok: result.ok,
+    rootVersion: result.rootVersion,
+    fixedFiles: result.fixedFiles,
+    mismatches: result.mismatches.map((target) => ({
+      file: target.file,
+      path: formatPathSegments(target.path),
+      found: target.found ?? null,
+      expected: target.expected,
+      missing: target.missing,
+    })),
+  };
+}
+
+function printHuman(result) {
+  if (result.ok) {
+    console.log(`Version sync OK (${result.rootVersion})`);
+    return;
+  }
+  console.log(`Version sync mismatch (${result.rootVersion})`);
+  for (const target of result.mismatches) {
+    console.log(
+      `- ${target.file} :: ${formatPathSegments(target.path)} => found=${target.found ?? "missing"}, expected=${target.expected}`,
+    );
+  }
+  if (result.fixedFiles.length) {
+    console.log(`Fixed files: ${result.fixedFiles.join(", ")}`);
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = assertVersionSync({
+    rootDir: args.root,
+    fix: Boolean(args.fix),
+  });
+  if (args.json) {
+    console.log(JSON.stringify(toJson(result), null, 2));
+  } else {
+    printHuman(result);
+  }
+  process.exitCode = result.ok ? 0 : 1;
+}