@triflux/core 10.43.0 → 10.44.0

package/hooks/keyword-rules.json

@@ -96,6 +96,102 @@
       "state": null,
       "mcp_route": null
     },
+    {
+      "id": "tfx-review",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?review\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-review",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
+    {
+      "id": "tfx-analysis",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?analysis\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-analysis",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
+    {
+      "id": "tfx-plan",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?plan\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-plan",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
+    {
+      "id": "tfx-qa",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?qa\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-qa",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
+    {
+      "id": "tfx-research",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?research\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-research",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
+    {
+      "id": "tfx-find",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?find\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-find",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
     {
       "id": "tfx-unified",
       "patterns": [
@@ -127,10 +223,6 @@
           "source": "(?:찾아봐|조사해|검색해)",
           "flags": "i"
         },
-        {
-          "source": "(?:정리해|슬롭|클린업)",
-          "flags": "i"
-        },
         {
           "source": "(?:병렬|동시에|parallel|concurrent)",
           "flags": "i"
@@ -155,6 +247,41 @@
       "state": null,
       "mcp_route": null
     },
+    {
+      "id": "host-ai-slop-cleaner",
+      "patterns": [
+        {
+          "source": "(?:AI\\s*슬롭|ai\\s*slop|anti[\\s-]?slop|deslop)",
+          "flags": "i"
+        },
+        {
+          "source": "(?:슬롭|클린업)",
+          "flags": "i"
+        }
+      ],
+      "skill": "ai-slop-cleaner",
+      "priority": 1,
+      "supersedes": [],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
+    },
+    {
+      "id": "tfx-prune",
+      "patterns": [
+        {
+          "source": "\\btfx[\\s-]?prune\\b",
+          "flags": "i"
+        }
+      ],
+      "skill": "tfx-prune",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null,
+      "explicit": true
+    },
     {
       "id": "tfx-codex",
       "patterns": [
@@ -586,7 +713,6 @@
     },
     {
       "id": "gstack-ship",
-      "disabled": true,
       "patterns": [
         {
           "source": "(?:배포해|PR\\s*만들|릴리스\\s*해|머지하고\\s*배포)",
@@ -598,7 +724,7 @@
         }
       ],
       "skill": "ship",
-      "priority": 5,
+      "priority": 1,
       "supersedes": [],
       "exclusive": false,
       "state": null,
@@ -627,12 +753,12 @@
       "id": "gstack-cso",
       "patterns": [
         {
-          "source": "(?:보안\\s*(?:감사|점검|리뷰|스캔)|\\bcso\\b|\\bOWASP\\b|\\bSTRIDE\\b)",
+          "source": "(?:보안\\s*(?:감사|점검|리뷰|검토|스캔)|\\bcso\\b|\\bOWASP\\b|\\bSTRIDE\\b)",
           "flags": "i"
         }
       ],
       "skill": "cso",
-      "priority": 5,
+      "priority": 1,
       "supersedes": [],
       "exclusive": false,
       "state": null,
@@ -651,7 +777,7 @@
         }
       ],
       "skill": "qa",
-      "priority": 5,
+      "priority": 1,
       "supersedes": [],
       "exclusive": false,
       "state": null,
@@ -722,14 +848,6 @@
           "source": "/ship\\b",
           "flags": "i"
         },
-        {
-          "source": "\\brelease\\b",
-          "flags": "i"
-        },
-        {
-          "source": "\\bpublish\\b",
-          "flags": "i"
-        },
         {
           "source": "배포(?!자|사|장|처)",
           "flags": ""
@@ -744,11 +862,13 @@
         }
       ],
       "skill": "tfx-ship",
-      "priority": 3,
+      "priority": 1,
       "supersedes": ["gstack-ship"],
       "exclusive": false,
       "state": null,
-      "mcp_route": null
+      "mcp_route": null,
+      "repo_scope": ["triflux"],
+      "explicit": true
     }
   ]
 }

package/hub/cli-adapter-base.mjs

@@ -167,7 +167,7 @@ export const CODEX_MCP_EXECUTION_EXIT_CODE = 1;
  *
  * @param {string} prompt
  * @param {string|null} resultFile — null이면 --output-last-message 생략
- * @param {{ profile?: string, skipGitRepoCheck?: boolean, sandboxBypass?: boolean, cwd?: string, mcpServers?: string[], stdinPrompt?: boolean }} [opts]
+ * @param {{ profile?: string, codexHome?: string, disallowUltra?: boolean, enforceCanonicalProfile?: boolean, skipGitRepoCheck?: boolean, sandboxBypass?: boolean, cwd?: string, mcpServers?: string[], stdinPrompt?: boolean }} [opts]
  * @returns {string} 실행할 셸 커맨드
  */
 export function buildExecCommand(prompt, resultFile = null, opts = {}) {
@@ -177,6 +177,9 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
     sandboxBypass = true,
     mcpServers,
     stdinPrompt,
+    codexHome,
+    disallowUltra,
+    enforceCanonicalProfile,
   } = opts;
 
   const parts = ["codex"];
@@ -185,7 +188,13 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
   // still contains an inline [profiles.X] table (and codex re-injects such
   // tables when it rewrites config.toml), so the `-c model=.. -c
   // model_reasoning_effort=..` form is immune and mutates no config.
-  const profileOverrides = profile ? codexProfileConfigOverrides(profile) : [];
+  const profileOverrides = profile
+    ? codexProfileConfigOverrides(profile, {
+        codexHome,
+        disallowUltra,
+        enforceCanonicalProfile,
+      })
+    : [];
 
   if (FEATURES.execSubcommand) {
     parts.push("exec");

package/hub/codex-adapter.mjs

@@ -118,6 +118,9 @@ export function buildExecArgs(opts = {}) {
   const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
   const command = buildExecCommand(prompt, opts.resultFile || null, {
     profile: opts.profile,
+    codexHome: opts.codexHome,
+    disallowUltra: opts.disallowUltra,
+    enforceCanonicalProfile: opts.enforceCanonicalProfile,
     skipGitRepoCheck: true,
     sandboxBypass: true,
     cwd: opts.cwd,

package/hub/intent.mjs

@@ -3,6 +3,7 @@
 
 import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
+import { resolveCodexAgentPolicy } from "../scripts/lib/agent-route-policy.mjs";
 import { whichCommand } from "./platform.mjs";
 
 /** 캐시 엔트리: { category, confidence, ts } */
@@ -61,31 +62,27 @@ function _tryCodexClassify(prompt) {
  * triflux 특화 의도 카테고리 (10개)
  */
 export const INTENT_CATEGORIES = {
-  // 모델 정책 (2026-04-25):
-  // - GPT-5.6 family = 기존 semantic tier를 Sol/Terra/Luna lane으로 매핑
-  // - gpt-5.4-mini = 자잘/부가/가성비 (fast tier 가능)
-  // - gpt-5.3-codex = escalation 가성비 중간 (fast 미지원)
-  // - 기존 effort는 유지하고 모델만 GPT-5.6 family로 교체
-  implement: {
-    agent: "executor",
-    mcp: "implement",
-    effort: "gpt56_terra_high",
-  },
-  debug: { agent: "debugger", mcp: "implement", effort: "gpt56_sol_xhigh" },
-  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt56_sol_xhigh" },
-  design: { agent: "architect", mcp: "analyze", effort: "gpt56_sol_xhigh" },
-  review: { agent: "code-reviewer", mcp: "review", effort: "gpt56_terra_high" },
-  document: { agent: "writer", mcp: "docs", effort: "pro" },
-  research: { agent: "scientist", mcp: "analyze", effort: "gpt56_terra_high" },
-  "quick-fix": {
-    agent: "build-fixer",
-    mcp: "implement",
-    effort: "gpt56_luna_low",
-  },
-  explain: { agent: "writer", mcp: "docs", effort: "flash" },
-  test: { agent: "test-engineer", mcp: null, effort: null },
+  implement: { agent: "executor", mcp: "implement" },
+  debug: { agent: "debugger", mcp: "implement" },
+  analyze: { agent: "analyst", mcp: "analyze" },
+  design: { agent: "architect", mcp: "analyze" },
+  review: { agent: "code-reviewer", mcp: "review" },
+  document: { agent: "writer", mcp: "docs" },
+  research: { agent: "scientist", mcp: "analyze" },
+  "quick-fix": { agent: "build-fixer", mcp: "implement" },
+  explain: { agent: "writer", mcp: "docs" },
+  test: { agent: "test-engineer", mcp: null },
 };
 
+function routingFor(category) {
+  const route = INTENT_CATEGORIES[category] || INTENT_CATEGORIES.implement;
+  return {
+    agent: route.agent,
+    mcp: route.mcp,
+    effort: resolveCodexAgentPolicy(route.agent).profile,
+  };
+}
+
 /** @internal 키워드 → 카테고리 매핑 패턴 */
 const KEYWORD_PATTERNS = [
   {
@@ -267,17 +264,12 @@ export function classifyIntent(prompt) {
   // 캐시 확인
   const cached = _getCached(hash);
   if (cached) {
-    const routing =
-      INTENT_CATEGORIES[cached.category] || INTENT_CATEGORIES.implement;
+    const routing = routingFor(cached.category);
     return {
       category: cached.category,
       confidence: cached.confidence,
       reasoning: `cache-hit: ${cached.category} (${cached.confidence.toFixed(2)})`,
-      routing: {
-        agent: routing.agent,
-        mcp: routing.mcp,
-        effort: routing.effort,
-      },
+      routing,
     };
   }
 
@@ -308,12 +300,12 @@ export function classifyIntent(prompt) {
   // 캐시 저장
   _intentCache.set(hash, { category, confidence, ts: Date.now() });
 
-  const routing = INTENT_CATEGORIES[category] || INTENT_CATEGORIES.implement;
+  const routing = routingFor(category);
   return {
     category,
     confidence,
     reasoning,
-    routing: { agent: routing.agent, mcp: routing.mcp, effort: routing.effort },
+    routing,
   };
 }
 

package/hub/router.mjs

@@ -9,6 +9,7 @@ import {
   resolveHardCeilingMs,
 } from "./lib/timeout-defaults.mjs";
 import { uuidv7 } from "./lib/uuidv7.mjs";
+import { normalizeRoleKey } from "./role-contract.mjs";
 
 const ASSIGN_PENDING_STATUSES = new Set(["queued", "running"]);
 const ROLE_TOPICS = new Set(["cto"]);
@@ -16,6 +17,258 @@ const ROLE_SOURCE_RANK = Object.freeze({
   explicit: 2,
   "topic-fallback": 1,
 });
+const TRANSPORT_LOCATOR_SCHEMA_VERSION = "tfx.transport-locator.v1";
+const TRANSPORT_KINDS = new Set(["claude-uds", "tmux"]);
+const TRANSPORT_CAPABILITIES = new Set([
+  "probe",
+  "wake",
+  "activate",
+  "interrupt",
+]);
+const HOST_ID_RE = /^hst_[A-Za-z0-9_-]+$/u;
+
+function registrationError(code, message = code) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function registrationString(value, code, { maxLength = 256 } = {}) {
+  if (typeof value !== "string" || !value.trim() || value.length > maxLength) {
+    throw registrationError(code);
+  }
+  return value.trim();
+}
+
+function registrationLogicalRef(value, code, { maxLength = 128 } = {}) {
+  const normalized = registrationString(value, code, { maxLength });
+  if (!/^[A-Za-z0-9._:-]+$/u.test(normalized)) {
+    throw registrationError(code);
+  }
+  return normalized;
+}
+
+function assertExactFields(value, allowed, code) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).some((field) => !allowed.has(field))
+  ) {
+    throw registrationError(code);
+  }
+}
+
+function normalizeTransportLocator(
+  value,
+  { cli, hostId, now, leaseExpiresMs },
+) {
+  assertExactFields(
+    value,
+    new Set([
+      "schema_version",
+      "transport_id",
+      "kind",
+      "host_id",
+      "capabilities",
+      "priority",
+      "expires_at_ms",
+      "locator",
+    ]),
+    "TRANSPORT_LOCATOR_INVALID",
+  );
+  if (value.schema_version !== TRANSPORT_LOCATOR_SCHEMA_VERSION) {
+    throw registrationError("TRANSPORT_LOCATOR_SCHEMA_UNSUPPORTED");
+  }
+  const transportId = registrationLogicalRef(
+    value.transport_id,
+    "TRANSPORT_ID_INVALID",
+    { maxLength: 128 },
+  );
+  if (!TRANSPORT_KINDS.has(value.kind)) {
+    throw registrationError("TRANSPORT_KIND_UNSUPPORTED");
+  }
+  if (cli === "codex" && value.kind !== "tmux") {
+    throw registrationError("CODEX_TRANSPORT_UNSUPPORTED");
+  }
+  const locatorHostId = registrationString(value.host_id, "HOST_ID_INVALID", {
+    maxLength: 128,
+  });
+  if (!HOST_ID_RE.test(locatorHostId) || (hostId && locatorHostId !== hostId)) {
+    throw registrationError("HOST_ID_INVALID");
+  }
+  if (!Array.isArray(value.capabilities)) {
+    throw registrationError("TRANSPORT_CAPABILITIES_INVALID");
+  }
+  const capabilities = uniqueStrings(value.capabilities);
+  if (
+    capabilities.length !== value.capabilities.length ||
+    capabilities.some((capability) => !TRANSPORT_CAPABILITIES.has(capability))
+  ) {
+    throw registrationError("TRANSPORT_CAPABILITIES_INVALID");
+  }
+  if (!Number.isSafeInteger(value.priority)) {
+    throw registrationError("TRANSPORT_PRIORITY_INVALID");
+  }
+  if (
+    !Number.isSafeInteger(value.expires_at_ms) ||
+    value.expires_at_ms <= now ||
+    value.expires_at_ms > leaseExpiresMs
+  ) {
+    throw registrationError("TRANSPORT_EXPIRY_INVALID");
+  }
+
+  let locator;
+  if (value.kind === "claude-uds") {
+    assertExactFields(
+      value.locator,
+      new Set(["session_id", "short", "bridge_id"]),
+      "TRANSPORT_LOCATOR_INVALID",
+    );
+    const sessionId = value.locator.session_id;
+    const short = value.locator.short;
+    if (!sessionId && !short) {
+      throw registrationError("CLAUDE_UDS_SESSION_REQUIRED");
+    }
+    locator = {
+      ...(sessionId
+        ? {
+            session_id: registrationLogicalRef(
+              sessionId,
+              "CLAUDE_UDS_SESSION_INVALID",
+            ),
+          }
+        : {}),
+      ...(short
+        ? {
+            short: registrationLogicalRef(short, "CLAUDE_UDS_SHORT_INVALID", {
+              maxLength: 128,
+            }),
+          }
+        : {}),
+      bridge_id: registrationLogicalRef(
+        value.locator.bridge_id,
+        "CLAUDE_UDS_BRIDGE_INVALID",
+        { maxLength: 128 },
+      ),
+    };
+  } else {
+    assertExactFields(
+      value.locator,
+      new Set(["session_name", "mux_server_id"]),
+      "TRANSPORT_LOCATOR_INVALID",
+    );
+    locator = {
+      session_name: registrationLogicalRef(
+        value.locator.session_name,
+        "TMUX_SESSION_INVALID",
+        { maxLength: 128 },
+      ),
+      mux_server_id: registrationLogicalRef(
+        value.locator.mux_server_id,
+        "TMUX_SERVER_INVALID",
+        { maxLength: 128 },
+      ),
+    };
+  }
+
+  return {
+    schema_version: TRANSPORT_LOCATOR_SCHEMA_VERSION,
+    transport_id: transportId,
+    kind: value.kind,
+    host_id: locatorHostId,
+    capabilities,
+    priority: value.priority,
+    expires_at_ms: value.expires_at_ms,
+    locator,
+  };
+}
+
+export function normalizeRegistrationIdentity(args = {}, now = Date.now()) {
+  const hasProjectId = Object.hasOwn(args, "project_id");
+  const hasSessionId = Object.hasOwn(args, "session_id");
+  const hasHostId = Object.hasOwn(args, "host_id");
+  const hasLocatorJson = Object.hasOwn(args, "transport_locators_json");
+  const hasLocators = Object.hasOwn(args, "transport_locators");
+  if (
+    !hasProjectId &&
+    !hasSessionId &&
+    !hasHostId &&
+    !hasLocatorJson &&
+    !hasLocators
+  ) {
+    return null;
+  }
+
+  const projectId = hasProjectId
+    ? normalizeRoleKey({ project_id: args.project_id, role_kind: "cto" })
+        .project_id
+    : null;
+  const sessionId = hasSessionId
+    ? registrationString(args.session_id, "SESSION_ID_INVALID")
+    : null;
+  const hostId = hasHostId
+    ? registrationString(args.host_id, "HOST_ID_INVALID", { maxLength: 128 })
+    : null;
+  if (hostId && !HOST_ID_RE.test(hostId)) {
+    throw registrationError("HOST_ID_INVALID");
+  }
+
+  let rawLocators = [];
+  if (hasLocatorJson) {
+    if (Array.isArray(args.transport_locators_json)) {
+      rawLocators = args.transport_locators_json;
+    } else if (typeof args.transport_locators_json === "string") {
+      try {
+        rawLocators = JSON.parse(args.transport_locators_json);
+      } catch {
+        throw registrationError("TRANSPORT_LOCATORS_JSON_INVALID");
+      }
+    } else {
+      throw registrationError("TRANSPORT_LOCATORS_JSON_INVALID");
+    }
+  } else if (hasLocators) {
+    rawLocators = args.transport_locators;
+  }
+  if (!Array.isArray(rawLocators)) {
+    throw registrationError("TRANSPORT_LOCATORS_INVALID");
+  }
+
+  const ttlMs = Number(args.heartbeat_ttl_ms ?? 30000);
+  if (rawLocators.length > 0 && (!Number.isFinite(ttlMs) || ttlMs <= 0)) {
+    throw registrationError("HEARTBEAT_TTL_INVALID");
+  }
+  const leaseExpiresMs = now + ttlMs;
+  const normalizedLocators = rawLocators
+    .map((locator) =>
+      normalizeTransportLocator(locator, {
+        cli: args.cli,
+        hostId,
+        now,
+        leaseExpiresMs,
+      }),
+    )
+    .sort(
+      (left, right) =>
+        right.priority - left.priority ||
+        left.transport_id.localeCompare(right.transport_id),
+    );
+  const resolvedHostId = hostId || normalizedLocators[0]?.host_id || null;
+  if (
+    resolvedHostId &&
+    normalizedLocators.some((locator) => locator.host_id !== resolvedHostId)
+  ) {
+    throw registrationError("HOST_ID_INVALID");
+  }
+
+  return {
+    project_id: projectId,
+    session_id: sessionId,
+    host_id: resolvedHostId,
+    transport_locators_json:
+      hasLocatorJson || hasLocators ? JSON.stringify(normalizedLocators) : null,
+  };
+}
 
 function uniqueStrings(values = []) {
   return Array.from(
@@ -123,6 +376,18 @@ export function createRouter(store) {
   const queuesByAgent = new Map();
   const liveMessages = new Map();
   const roleStates = new Map();
+  const updateRegistrationIdentity = store.db?.prepare
+    ? store.db.prepare(`
+        UPDATE agents SET
+          project_id=COALESCE(@project_id, project_id),
+          session_id=COALESCE(@session_id, session_id),
+          host_id=COALESCE(@host_id, host_id),
+          transport_locators_json=COALESCE(
+            @transport_locators_json,
+            transport_locators_json
+          )
+        WHERE agent_id=@agent_id`)
+    : null;
   const MAX_LATENCY_SAMPLES = 100;
   let latencyIdx = 0;
   const deliveryLatencies = new Array(MAX_LATENCY_SAMPLES).fill(0);
@@ -855,10 +1120,17 @@ export function createRouter(store) {
     deliveryEmitter,
 
     registerAgent(args) {
+      const identity = normalizeRegistrationIdentity(args);
       const result = store.registerAgent(args);
       if (!registerPresenceIsEffective(result)) {
         return registerPresenceFailure(args.agent_id, result);
       }
+      if (identity && updateRegistrationIdentity) {
+        updateRegistrationIdentity.run({
+          agent_id: args.agent_id,
+          ...identity,
+        });
+      }
       upsertRuntimeTopics(args.agent_id, args.topics || [], { replace: true });
       refreshRoleCandidateForAgent(args.agent_id);
       for (const roleName of ROLE_TOPICS) {

package/hub/team/intervention.mjs

@@ -5,11 +5,11 @@ import { statSync } from "node:fs";
 import { readdir, readlink } from "node:fs/promises";
 import { promisify } from "node:util";
 import { isPidAlive } from "../lib/process-utils.mjs";
-import { killProcess } from "../platform.mjs";
 import {
   resolveHardCeilingMs,
   resolveStallInterventionMs as resolveStallThresholdMs,
 } from "../lib/timeout-defaults.mjs";
+import { killProcess } from "../platform.mjs";
 
 export { resolveHardCeilingMs, resolveStallThresholdMs };