@triflux/remote 10.30.0 → 10.31.0

package/hub/server.mjs

@@ -2054,6 +2054,16 @@ export async function startHub({
   }, 60000);
   sessionTimer.unref();
 
+  const synapsePruneTimer = setInterval(() => {
+    try {
+      const { count } = synapseRegistry.pruneExpired();
+      if (count > 0) hubLog.info({ count }, "synapse.prune");
+    } catch (err) {
+      hubLog.warn({ err }, "synapse.prune_failed");
+    }
+  }, 60000);
+  synapsePruneTimer.unref();
+
   // 고아 node.exe 프로세스 + stale spawn 세션 주기적 정리 (5분마다)
   // TFX_DISABLE_ORPHAN_CLEANUP=1 로 비활성 (active SSH/swarm 세션 보호 회피용 hotfix gate)
   const orphanCleanupTimer = setInterval(
@@ -2288,6 +2298,7 @@ export async function startHub({
               router.stopSweeper();
               clearInterval(hitlTimer);
               clearInterval(sessionTimer);
+              clearInterval(synapsePruneTimer);
               clearInterval(rateLimitTimer);
               clearInterval(orphanCleanupTimer);
               if (idleTimer) {

package/hub/team/synapse-registry.mjs

@@ -5,6 +5,7 @@ const DEFAULT_LOCAL_HEARTBEAT_INTERVAL_MS = 5_000;
 const DEFAULT_LOCAL_TIMEOUT_MS = 30_000;
 const DEFAULT_REMOTE_HEARTBEAT_INTERVAL_MS = 15_000;
 const DEFAULT_REMOTE_TIMEOUT_MS = 90_000;
+const DEFAULT_EXPIRE_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 // Interactive (Claude/Codex) sessions idle for long stretches; a 30s local
 // timeout produces stale false-positives. 5-minute TTL + an `idle` state
 // distinguishes "alive but inactive" from "presumed dead".
@@ -133,6 +134,7 @@ export function createSynapseRegistry(opts = {}) {
     remoteTimeoutMs = DEFAULT_REMOTE_TIMEOUT_MS,
     interactiveHeartbeatIntervalMs = DEFAULT_INTERACTIVE_HEARTBEAT_INTERVAL_MS,
     interactiveTimeoutMs = DEFAULT_INTERACTIVE_TIMEOUT_MS,
+    expireTimeoutMs = DEFAULT_EXPIRE_TIMEOUT_MS,
   } = opts;
 
   const sessions = new Map();
@@ -355,10 +357,89 @@ export function createSynapseRegistry(opts = {}) {
     return true;
   }
 
+  // stale/expired 세션이 expireTimeoutMs 넘게 누적되면 Map에서 제거.
+  // live(active/idle)는 lastHeartbeat가 오래돼도 보존 — git-preflight dirty-file 가드가 의존.
+  function pruneExpired(opts2 = {}) {
+    if (destroyed) return { removed: [], count: 0 };
+
+    const cutoff =
+      typeof opts2.olderThanMs === "number"
+        ? opts2.olderThanMs
+        : expireTimeoutMs;
+    const removed = [];
+    const currentTime = now();
+
+    for (const [sessionId, session] of sessions) {
+      if (
+        isLiveStatus(session.status) ||
+        currentTime - session.lastHeartbeat <= cutoff
+      ) {
+        continue;
+      }
+
+      stopMonitor(sessionId);
+      sessions.delete(sessionId);
+      removed.push(sessionId);
+      notifyRemoved(session);
+    }
+
+    if (removed.length > 0) persist();
+    return { removed, count: removed.length };
+  }
+
   function heartbeat(sessionId, partialMeta = null) {
     const normalized = normalizeSessionId(sessionId);
     const session = sessions.get(normalized);
-    if (!session) return false;
+    if (!session) {
+      // self-heal은 위치 정보(worktreePath 또는 cwd)가 있는 heartbeat에서만
+      // 발동한다. UserPromptSubmit heartbeat는 항상 worktreePath를 보내므로
+      // SessionStart register POST drop 복구 경로는 커버되고, taskSummary만 담은
+      // 빈약한 heartbeat로 위치 없는 가비지 세션이 register 되는 것은 막는다
+      // (그 경우는 기존대로 false → 400/heartbeat failed).
+      const hasLocator =
+        partialMeta &&
+        typeof partialMeta === "object" &&
+        !Array.isArray(partialMeta) &&
+        ((typeof partialMeta.worktreePath === "string" &&
+          partialMeta.worktreePath.length > 0) ||
+          (typeof partialMeta.cwd === "string" && partialMeta.cwd.length > 0));
+      const canSelfHeal = Boolean(normalized) && hasLocator;
+      if (!canSelfHeal) return false;
+
+      // 미등록 세션 heartbeat = SessionStart register POST가 drop된 경우.
+      // self-heal로 register 복구(영구 미등록 방지).
+      //
+      // sessionKind는 명시값이 없으면 "interactive"로 본다. 실제 복구 경로인
+      // heartbeatInteractiveSession은 worktreePath/host/taskSummary만 보내고
+      // sessionKind는 생략하는데, sanitizeSession 기본값("headless")으로 떨어지면
+      // 복구된 Claude 세션이 30초 local timeout을 받아 idle/5분 TTL을 잃고 곧장
+      // stale로 전이돼 getActive()/peer discovery에서 사라진다(이 PRD가 고치려던
+      // 원래 증상의 재현). heartbeat 기반 liveness로 살아나는 세션은 interactive다.
+      const sanitizedKind =
+        typeof partialMeta.sessionKind === "string"
+          ? partialMeta.sessionKind
+          : "interactive";
+      const healed = sanitizeSession(
+        {
+          ...partialMeta,
+          sessionId: normalized,
+          sessionKind: sanitizedKind,
+          status: "active",
+          lastHeartbeat: now(),
+        },
+        normalized,
+      );
+      if (!healed) return false;
+
+      sessions.set(normalized, healed);
+      startMonitor(normalized);
+      persist();
+      emitter?.emit("synapse.session.started", {
+        sessionId: normalized,
+        session: cloneSession(healed),
+      });
+      return true;
+    }
 
     const wasRemote = session.isRemote;
     const updated = { ...session, lastHeartbeat: now(), status: "active" };
@@ -492,6 +573,7 @@ export function createSynapseRegistry(opts = {}) {
   return Object.freeze({
     register,
     unregister,
+    pruneExpired,
     heartbeat,
     getActive,
     getAll,

package/hub/workers/codex-mcp.mjs

@@ -1,4 +1,7 @@
 // hub/workers/codex-mcp.mjs — Codex MCP 서버 래퍼
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
@@ -94,13 +97,78 @@ function normalizeStructuredContent(structuredContent, fallbackText = "") {
   return { threadId, content };
 }
 
-function buildCodexArguments(prompt, opts = {}) {
+/**
+ * Read a top-level TOML scalar (`key = "value"` / `key = 'value'` /
+ * `key = value`), tolerating an inline `# comment` and surrounding whitespace.
+ * Returns the trimmed value, or null when the key is absent/empty. Intentionally
+ * tiny — the per-profile files only carry `model` + `model_reasoning_effort`.
+ *
+ * @param {string} raw
+ * @param {string} key
+ * @returns {string|null}
+ */
+function readTomlScalar(raw, key) {
+  const re = new RegExp(
+    `^\\s*${key}\\s*=\\s*(?:"([^"\\n]*)"|'([^'\\n]*)'|([^#\\n]*?))\\s*(?:#.*)?$`,
+    "m",
+  );
+  const match = raw.match(re);
+  if (!match) return null;
+  const value = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+  return value || null;
+}
+
+/**
+ * Resolve a Codex effort profile name (e.g. "gpt55_high") to its concrete
+ * `model` + reasoning effort. SSOT = the per-profile file written by
+ * `tfx setup` at `~/.codex/<profile>.config.toml`. Falls back to deriving the
+ * effort from the `<...>_<effort>` naming convention when the file is absent.
+ *
+ * codex 0.137 removed `profile` from the Codex MCP tool schema, so we translate
+ * the profile into the still-accepted `model` + `config` fields instead of
+ * forwarding `profile` (which now hard-fails with "unknown field `profile`").
+ *
+ * @param {string} profileName
+ * @returns {{ model: string|null, reasoningEffort: string|null }}
+ */
+export function resolveCodexProfileConfig(profileName) {
+  const result = { model: null, reasoningEffort: null };
+  if (typeof profileName !== "string" || !profileName) return result;
+
+  const codexHome = process.env.CODEX_HOME || join(homedir(), ".codex");
+  try {
+    const raw = readFileSync(
+      join(codexHome, `${profileName}.config.toml`),
+      "utf8",
+    );
+    result.model = readTomlScalar(raw, "model");
+    result.reasoningEffort = readTomlScalar(raw, "model_reasoning_effort");
+  } catch {
+    // Profile file absent (non-file alias). Derive effort from the naming
+    // convention; leave model unset so codex uses its config.toml default.
+    const suffix = /_(xhigh|high|med|medium|low)$/.exec(profileName);
+    if (suffix) {
+      const map = {
+        xhigh: "xhigh",
+        high: "high",
+        med: "medium",
+        medium: "medium",
+        low: "low",
+      };
+      result.reasoningEffort = map[suffix[1]] || null;
+    }
+  }
+  return result;
+}
+
+export function buildCodexArguments(prompt, opts = {}) {
   const args = { prompt };
 
   if (typeof opts.cwd === "string" && opts.cwd) args.cwd = opts.cwd;
   if (typeof opts.model === "string" && opts.model) args.model = opts.model;
-  if (typeof opts.profile === "string" && opts.profile)
-    args.profile = opts.profile;
+  // NOTE: `profile` is intentionally NOT forwarded as a Codex tool argument.
+  // codex 0.137 dropped it from the tool schema; it is resolved into
+  // `model` + `config.model_reasoning_effort` just before return (see below).
   if (typeof opts.approvalPolicy === "string" && opts.approvalPolicy) {
     args["approval-policy"] = opts.approvalPolicy;
   }
@@ -120,6 +188,22 @@ function buildCodexArguments(prompt, opts = {}) {
     args["compact-prompt"] = opts.compactPrompt;
   }
 
+  // Map the effort profile to model + reasoning effort instead of forwarding the
+  // (0.137-rejected) `profile` field. Explicit opts.model wins over the profile;
+  // profile effort merges on top of any opts.config.
+  if (typeof opts.profile === "string" && opts.profile) {
+    const resolved = resolveCodexProfileConfig(opts.profile);
+    if (resolved.model && typeof args.model !== "string") {
+      args.model = resolved.model;
+    }
+    if (resolved.reasoningEffort) {
+      args.config = {
+        ...(args.config || {}),
+        model_reasoning_effort: resolved.reasoningEffort,
+      };
+    }
+  }
+
   return args;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.30.0",
+  "version": "10.31.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",