triflux 10.42.0 → 10.44.0

package/hub/codex-adapter.mjs

@@ -11,6 +11,7 @@ import {
   shellQuote,
 } from "./cli-adapter-base.mjs";
 import { runPreflight } from "./codex-preflight.mjs";
+import { isActivityLifecycleEnabled } from "./lib/worker-lifecycle.mjs";
 
 // ── Codex-specific stall inference ──────────────────────────────
 
@@ -64,9 +65,10 @@ function buildAttempts(opts, preflight) {
     forceBypass: preflight.needsBypass,
   };
   if (opts.retryOnFail === false) return [base];
+  const retryTimeout = isActivityLifecycleEnabled() ? timeout : timeout * 2;
   return [
     base,
-    { ...base, timeout: timeout * 2, excluded: requested, forceBypass: true },
+    { ...base, timeout: retryTimeout, excluded: requested, forceBypass: true },
   ];
 }
 
@@ -116,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,
@@ -183,6 +188,8 @@ async function runCodex(prompt, workdir, preflight, attempt, lease) {
     resultFile,
     inferStallMode,
     spawnEnv,
+    cli: "codex",
+    codexHome: spawnEnv?.CODEX_HOME,
   });
 }
 

package/hub/dynamic-routing-engine.mjs

@@ -45,7 +45,7 @@ function makeFallback(policy, trigger, inputsHash, now) {
       {
         cli: fb.default_cli ?? "codex",
         accountId: null,
-        model: fb.default_model ?? "gpt-5.5",
+        model: fb.default_model ?? "gpt-5.6-terra",
         riskTier: "safe",
         reason: trigger,
       },

package/hub/gemini-adapter.mjs

@@ -9,6 +9,7 @@ import {
   normalizePathForShell,
   runProcess,
 } from "./cli-adapter-base.mjs";
+import { isActivityLifecycleEnabled } from "./lib/worker-lifecycle.mjs";
 import { whichCommandAsync } from "./platform.mjs";
 
 function shellSingleQuote(value) {
@@ -88,7 +89,8 @@ function buildAttempts(opts, preflight) {
     excludeMcpServers: [...(preflight.excludeMcpServers || [])],
   };
   if (opts.retryOnFail === false) return [base];
-  return [base, { ...base, timeout: timeout * 2, allowedMcpServers: [] }];
+  const retryTimeout = isActivityLifecycleEnabled() ? timeout : timeout * 2;
+  return [base, { ...base, timeout: retryTimeout, allowedMcpServers: [] }];
 }
 
 // ── Public: buildExecArgs ───────────────────────────────────────

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,27 +62,27 @@ function _tryCodexClassify(prompt) {
  * triflux 특화 의도 카테고리 (10개)
  */
 export const INTENT_CATEGORIES = {
-  // 모델 정책 (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: "gpt55_high" },
-  "quick-fix": {
-    agent: "build-fixer",
-    mcp: "implement",
-    effort: "gpt55_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 = [
   {
@@ -263,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,
     };
   }
 
@@ -304,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/lib/cto-env.mjs

@@ -15,6 +15,52 @@ function isExplicitlyOn(name) {
   return ON_VALUES.has(normalizeEnvValue(name));
 }
 
+function normalizeEnv(env, name) {
+  return String(env?.[name] ?? "")
+    .trim()
+    .toLowerCase();
+}
+
+function isEnvOff(env, name) {
+  return OFF_VALUES.has(normalizeEnv(env, name));
+}
+
+function isEnvOn(env, name) {
+  return ON_VALUES.has(normalizeEnv(env, name));
+}
+
+/**
+ * Resolve the C6a control plane without mutating environment or runtime
+ * state. Callers own storing and incrementing the returned generation.
+ */
+export function resolveRoleControlSnapshot(env = process.env, options = {}) {
+  const masterEnabled = !isEnvOff(env, "TFX_CTO");
+  const ctoManagerEnabled = masterEnabled && isEnvOn(env, "TFX_CTO_MANAGER");
+  const leadManagerEnabled =
+    ctoManagerEnabled && isEnvOn(env, "TFX_LEAD_MANAGER");
+  const northStarEnabled =
+    masterEnabled && !isEnvOff(env, "TFX_CTO_NORTH_STAR");
+  const autoCollectEnabled =
+    masterEnabled && !isEnvOff(env, "TFX_CTO_AUTO_COLLECT");
+  const values = {
+    master_enabled: masterEnabled,
+    cto_manager_enabled: ctoManagerEnabled,
+    lead_manager_enabled: leadManagerEnabled,
+    north_star_enabled: northStarEnabled,
+    auto_collect_enabled: autoCollectEnabled,
+  };
+  const previous = options.previous;
+  const changed = Object.keys(values).some(
+    (field) => previous?.[field] !== values[field],
+  );
+  const generation = previous
+    ? Number(previous.generation || 0) + (changed ? 1 : 0)
+    : Number.isSafeInteger(options.generation) && options.generation >= 0
+      ? options.generation
+      : 0;
+  return { generation, ...values };
+}
+
 export function isCtoDisabled() {
   return isExplicitlyOff("TFX_CTO");
 }

package/hub/lib/memory-store.mjs

@@ -1,6 +1,10 @@
 // hub/lib/memory-store.mjs — In-memory store (SQLite-free fallback for @triflux/core)
 
 import { recalcConfidence } from "../reflexion.mjs";
+import {
+  clampDurationMs,
+  DEFAULT_ASSIGN_TIMEOUT_MS,
+} from "./timeout-defaults.mjs";
 import { uuidv7 } from "./uuidv7.mjs";
 
 export function clone(value) {
@@ -19,12 +23,6 @@ function clampPriority(value, fallback = 5) {
   return Math.max(1, Math.min(Math.trunc(num), 9));
 }
 
-function clampDuration(value, fallback = 600000, min = 1000, max = 86400000) {
-  const num = Number(value);
-  if (!Number.isFinite(num)) return fallback;
-  return Math.max(min, Math.min(Math.trunc(num), max));
-}
-
 export function clampConfidence(value, fallback = 0.5) {
   const num = Number(value);
   if (!Number.isFinite(num)) return fallback;
@@ -200,6 +198,7 @@ export function createMemoryStore() {
           agent_id: agentId,
           lease_expires_ms: Date.now() + ttlMs,
           server_time_ms: Date.now(),
+          effective: { updated: false, store_type: "memory", db_path: null },
         };
       const now = Date.now();
       current.last_seen_ms = now;
@@ -209,6 +208,7 @@ export function createMemoryStore() {
         agent_id: agentId,
         lease_expires_ms: current.lease_expires_ms,
         server_time_ms: now,
+        effective: { updated: true, store_type: "memory", db_path: null },
       };
     },
 
@@ -464,9 +464,10 @@ export function createMemoryStore() {
       retry_count = 0,
       max_retries = 0,
       priority = 5,
-      ttl_ms = 600000,
-      timeout_ms = 600000,
+      ttl_ms = DEFAULT_ASSIGN_TIMEOUT_MS,
+      timeout_ms = DEFAULT_ASSIGN_TIMEOUT_MS,
       deadline_ms,
+      dispatched_at_ms = null,
       trace_id,
       correlation_id,
       last_message_id = null,
@@ -474,7 +475,10 @@ export function createMemoryStore() {
       error = null,
     }) {
       const now = Date.now();
-      const normalizedTimeout = clampDuration(timeout_ms, 600000);
+      const normalizedTimeout = clampDurationMs(
+        timeout_ms,
+        DEFAULT_ASSIGN_TIMEOUT_MS,
+      );
       const row = {
         job_id: job_id || uuidv7(),
         supervisor_agent,
@@ -487,7 +491,7 @@ export function createMemoryStore() {
         retry_count: Math.max(0, Number(retry_count) || 0),
         max_retries: Math.max(0, Number(max_retries) || 0),
         priority: clampPriority(priority, 5),
-        ttl_ms: clampDuration(ttl_ms, normalizedTimeout),
+        ttl_ms: clampDurationMs(ttl_ms, normalizedTimeout),
         timeout_ms: normalizedTimeout,
         deadline_ms: Number.isFinite(Number(deadline_ms))
           ? Math.trunc(Number(deadline_ms))
@@ -500,6 +504,10 @@ export function createMemoryStore() {
         created_at_ms: now,
         updated_at_ms: now,
         started_at_ms: status === "running" ? now : null,
+        dispatched_at_ms:
+          dispatched_at_ms == null || !Number.isFinite(Number(dispatched_at_ms))
+            ? null
+            : Math.trunc(Number(dispatched_at_ms)),
         completed_at_ms: ["succeeded", "failed", "timed_out"].includes(status)
           ? now
           : null,
@@ -524,7 +532,7 @@ export function createMemoryStore() {
       const isTerminal = ["succeeded", "failed", "timed_out"].includes(
         nextStatus,
       );
-      const nextTimeout = clampDuration(
+      const nextTimeout = clampDurationMs(
         patch.timeout_ms ?? current.timeout_ms,
         current.timeout_ms,
       );
@@ -552,7 +560,7 @@ export function createMemoryStore() {
           patch.priority ?? current.priority,
           current.priority || 5,
         ),
-        ttl_ms: clampDuration(
+        ttl_ms: clampDurationMs(
           patch.ttl_ms ?? current.ttl_ms,
           current.ttl_ms || nextTimeout,
         ),
@@ -589,6 +597,9 @@ export function createMemoryStore() {
           : nextStatus === "running"
             ? current.started_at_ms || now
             : current.started_at_ms,
+        dispatched_at_ms: Object.hasOwn(patch, "dispatched_at_ms")
+          ? patch.dispatched_at_ms
+          : current.dispatched_at_ms,
         completed_at_ms: Object.hasOwn(patch, "completed_at_ms")
           ? patch.completed_at_ms
           : isTerminal
@@ -654,7 +665,7 @@ export function createMemoryStore() {
         current.attempt + 1,
         Number(patch.attempt ?? current.attempt + 1) || 1,
       );
-      const nextTimeout = clampDuration(
+      const nextTimeout = clampDurationMs(
         patch.timeout_ms ?? current.timeout_ms,
         current.timeout_ms,
       );
@@ -666,6 +677,7 @@ export function createMemoryStore() {
         deadline_ms: Date.now() + nextTimeout,
         completed_at_ms: null,
         started_at_ms: null,
+        dispatched_at_ms: null,
         last_retry_at_ms: Date.now(),
         result: patch.result ?? null,
         error: Object.hasOwn(patch, "error") ? patch.error : current.error,

package/hub/lib/timeout-defaults.mjs

@@ -0,0 +1,45 @@
+// hub 조율 평면 타임아웃/TTL의 단일 기준값. 환경은 호출 시점에 읽는다.
+
+export const MIN_DURATION_MS = 1_000;
+export const MAX_DURATION_MS = 86_400_000;
+export const DEFAULT_ASSIGN_TIMEOUT_MS = 600_000;
+export const DEFAULT_ASSIGN_TTL_MS = 600_000;
+export const DEFAULT_HANDOFF_TTL_MS = 600_000;
+export const DEFAULT_SWARM_LOCK_TTL_MS = 600_000;
+export const DEFAULT_REGISTER_TIMEOUT_SEC = 600;
+export const REGISTER_HEARTBEAT_GRACE_MS = 120_000;
+export const DEFAULT_STALL_INTERVENTION_SEC = 1_200;
+export const DEFAULT_HARD_CEILING_SEC = 21_600;
+
+function readEnvSeconds(env, name, fallbackSec) {
+  const value = Number(env?.[name]);
+  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallbackSec;
+}
+
+export function resolveStallInterventionMs(env = process.env) {
+  return (
+    readEnvSeconds(env, "TFX_STALL_THRESHOLD", DEFAULT_STALL_INTERVENTION_SEC) *
+    1000
+  );
+}
+
+export function resolveHardCeilingMs(env = process.env) {
+  return (
+    readEnvSeconds(env, "TFX_HARD_CEILING_SEC", DEFAULT_HARD_CEILING_SEC) * 1000
+  );
+}
+
+export function resolveWorkerLeaseTtlMs(env = process.env) {
+  return resolveStallInterventionMs(env) + REGISTER_HEARTBEAT_GRACE_MS;
+}
+
+export function clampDurationMs(
+  value,
+  fallback = DEFAULT_ASSIGN_TIMEOUT_MS,
+  min = MIN_DURATION_MS,
+  max = MAX_DURATION_MS,
+) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(Math.trunc(numeric), max));
+}

package/hub/lib/worker-lifecycle.mjs

@@ -0,0 +1,101 @@
+// 활동 기반 워커 lifecycle. 시간 기본값은 timeout-defaults SSOT에서만 가져온다.
+import {
+  resolveHardCeilingMs,
+  resolveStallInterventionMs,
+} from "./timeout-defaults.mjs";
+
+export { resolveHardCeilingMs, resolveStallInterventionMs };
+
+export function isActivityLifecycleEnabled(env = process.env) {
+  return env.TFX_ACTIVITY_LIFECYCLE !== "0";
+}
+
+/**
+ * 활동 신호를 기준으로 무활동 개입과 절대 상한을 판정한다.
+ * 호출자는 observe()에 자기 채널의 기존 활동 서명을 전달하고, check()에
+ * 개입 대상 문맥을 제공한다. 이 모듈은 신호를 생성하거나 개입을 실행하지 않는다.
+ */
+export function createActivityLifecycle({
+  enabled = isActivityLifecycleEnabled(),
+  interventionMs = resolveStallInterventionMs(),
+  hardCeilingMs = resolveHardCeilingMs(),
+  maxInterventions = 1,
+  onIntervene,
+  now = Date.now,
+} = {}) {
+  const startedAt = now();
+  let lastActivityAt = startedAt;
+  let lastSignature;
+  let hasSignature = false;
+  let interventions = 0;
+  let timeoutReason = "";
+  let pendingIntervention = null;
+
+  const markActivity = () => {
+    lastActivityAt = now();
+  };
+
+  async function intervene(context = {}) {
+    if (!enabled || typeof onIntervene !== "function") return false;
+    if (interventions >= maxInterventions || pendingIntervention) return false;
+
+    interventions += 1;
+    const inactiveMs = Math.max(0, now() - lastActivityAt);
+    pendingIntervention = Promise.resolve(
+      onIntervene({ ...context, inactiveMs, interventions }),
+    )
+      .then((handled) => handled === true)
+      .catch(() => false);
+    try {
+      const handled = await pendingIntervention;
+      if (handled) markActivity();
+      return handled;
+    } finally {
+      pendingIntervention = null;
+    }
+  }
+
+  return Object.freeze({
+    observe(...args) {
+      if (!enabled) return false;
+      const [signature] = args;
+      const changed =
+        args.length === 0 || !hasSignature || signature !== lastSignature;
+      if (changed) {
+        lastSignature = signature;
+        hasSignature = true;
+        markActivity();
+      }
+      return changed;
+    },
+    async check(context = {}) {
+      if (!enabled || timeoutReason) return timeoutReason;
+      const current = now();
+      if (current - startedAt >= hardCeilingMs) {
+        timeoutReason = "hard_ceiling";
+        return timeoutReason;
+      }
+      if (current - lastActivityAt < interventionMs || pendingIntervention)
+        return "";
+      if (await intervene(context)) return "";
+      timeoutReason = "inactivity";
+      return timeoutReason;
+    },
+    intervene,
+    get enabled() {
+      return enabled;
+    },
+    get hardCeilingMs() {
+      return hardCeilingMs;
+    },
+    get interventionMs() {
+      return interventionMs;
+    },
+    get interventions() {
+      return interventions;
+    },
+    get timeoutReason() {
+      return timeoutReason;
+    },
+  });
+}

package/hub/middleware/request-logger.mjs

@@ -11,6 +11,7 @@
  * health/status 체크는 로깅을 건너뛴다.
  */
 
+import { HUB_REQUEST_MONITOR_CACHE_PATH } from "../../hud/constants.mjs";
 import { createContextMonitor } from "../../hud/context-monitor.mjs";
 import {
   getCorrelationId,
@@ -19,7 +20,9 @@ import {
 import { createModuleLogger } from "../../scripts/lib/logger.mjs";
 
 const log = createModuleLogger("hub");
-const contextMonitor = createContextMonitor();
+const contextMonitor = createContextMonitor({
+  cachePath: HUB_REQUEST_MONITOR_CACHE_PATH,
+});
 
 const SKIP_PATHS = new Set(["/health", "/healthz", "/status", "/ready"]);
 const MAX_CAPTURE_BYTES = 256 * 1024;

package/hub/pipe.mjs

@@ -269,6 +269,15 @@ export function createPipeServer({
           payload.heartbeat_ttl_ms || heartbeatTtlMs,
         );
         if (client) touchClient(client);
+        if (result?.effective?.updated === false) {
+          return {
+            ok: false,
+            error: {
+              code: "AGENT_NOT_FOUND",
+              message: `heartbeat target not registered: ${agentId}`,
+            },
+          };
+        }
         return { ok: true, data: result };
       }