@triflux/core 10.27.0 → 10.28.1

package/hooks/pipeline-stop.mjs

@@ -142,7 +142,7 @@ function contextPercentsFromObject(value) {
   ];
 
   const currentUsage = value.current_usage ?? value.currentUsage ?? {};
-  const maxTokens =
+  const explicitMaxTokens =
     value.context_window_size ??
     value.contextWindowSize ??
     value.max_context_tokens ??
@@ -151,6 +151,18 @@ function contextPercentsFromObject(value) {
     value.maxTokens ??
     value.total_tokens ??
     value.totalTokens;
+  // Fall back to a 1M context window when the payload omits one — Opus 4.x
+  // [1M] and Codex gpt-5.5 both run on a 1M window, and assuming 200K there
+  // false-positives at ~15% real usage. Override via
+  // TFX_CONTEXT_DEFAULT_MAX_TOKENS for narrower setups.
+  const envFallback = Number(process.env.TFX_CONTEXT_DEFAULT_MAX_TOKENS);
+  const fallbackMaxTokens =
+    Number.isFinite(envFallback) && envFallback > 0 ? envFallback : 1_000_000;
+  const explicitNumeric = Number(explicitMaxTokens);
+  const maxTokens =
+    Number.isFinite(explicitNumeric) && explicitNumeric > 0
+      ? explicitNumeric
+      : fallbackMaxTokens;
   candidates.push(
     tokenPercent(value.used_tokens ?? value.usedTokens, maxTokens),
     tokenPercent(

package/hub/team/claude-daemon-control.mjs

@@ -1,8 +1,14 @@
+import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import {
+  buildClaudeSessionProjection,
+  removeClaudeSessionProjection,
+  writeClaudeSessionProjection,
+} from "./claude-session-projection.mjs";
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
@@ -26,12 +32,23 @@ export function deriveClaudeDaemonPaths({
     hash,
     daemonDir,
     controlSock: path.join(daemonDir, "control.sock"),
+    rendezvousDir: path.join(daemonDir, "rv"),
+    ptyDir: path.join(daemonDir, "pty"),
     rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
     sessionsDir: path.join(resolvedConfigDir, "sessions"),
     jobsDir: path.join(resolvedConfigDir, "jobs"),
   };
 }
 
+export function getProcStart(pid = process.pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    throw new Error(`invalid pid: ${pid}`);
+  return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+  }).trim();
+}
+
 export function readFirstJsonLine(text) {
   const line = String(text)
     .split("\n")
@@ -991,6 +1008,52 @@ export function buildDaemonExecDispatchPayload({
   };
 }
 
+export function buildClaudePromptDispatchPayload({
+  short = crypto.randomBytes(4).toString("hex"),
+  sessionId,
+  cwd = process.cwd(),
+  prompt,
+  name = "tfx uds claude prompt",
+  createdAt = Date.now(),
+  cols = 120,
+  rows = 40,
+} = {}) {
+  if (!prompt) throw new Error("prompt is required");
+  const uuid = crypto.randomUUID();
+  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
+  return {
+    proto: 1,
+    short,
+    sessionId: resolvedSessionId,
+    createdAt,
+    source: "shell",
+    cwd,
+    agent: "claude",
+    launch: {
+      mode: "prompt",
+      args: [
+        "--session-id",
+        resolvedSessionId,
+        "--agent",
+        "claude",
+        "--permission-mode",
+        "auto",
+        "--",
+        prompt,
+      ],
+    },
+    env: {},
+    isolation: "none",
+    respawnFlags: [],
+    seed: {
+      intent: "[redacted uds orchestration prompt]",
+      name,
+    },
+    cols,
+    rows,
+  };
+}
+
 export function findDaemonJobByShort(listResponse, short) {
   if (!Array.isArray(listResponse?.jobs)) return null;
   return listResponse.jobs.find((job) => job?.short === short) || null;
@@ -1128,3 +1191,154 @@ export async function sendKillBySessionId({
     };
   }
 }
+
+/**
+ * Claude 데몬 dispatch 한 건의 공통 시퀀스를 캡슐화한다.
+ * dispatch → waitForDaemonJobPid → resolveDaemonBridgeSessionId →
+ * buildClaudeSessionProjection → writeClaudeSessionProjection.
+ *
+ * 호출 측이 reference 로 들고 있는 record 를 헬퍼가 새로 만들지 않도록
+ * plain 필드만 반환한다. caller 는 이 결과를 자기 record 에 Object.assign 한다.
+ *
+ * @returns {Promise<{ok:boolean, short:string, sessionId:string, job:object,
+ *   pid:number, bridgeSessionId:string, sessionProjectionPath:string,
+ *   controlSock:string, paths:object}>}
+ */
+export async function dispatchClaudeDaemonJob({
+  paths,
+  controlSock,
+  payload,
+  agent,
+  name,
+  cwd,
+  projection = "write",
+  dispatchTimeoutMs = 5000,
+  pidTimeoutMs,
+  bridgeTimeoutMs,
+  accessControlSock,
+  _deps = {},
+} = {}) {
+  if (!payload) throw new Error("payload is required");
+  if (!payload.short) throw new Error("payload.short is required");
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  if (!resolvedControlSock) throw new Error("controlSock is required");
+
+  const sendControl =
+    _deps.sendClaudeControlRequest || sendClaudeControlRequest;
+  const waitForPid = _deps.waitForDaemonJobPid || waitForDaemonJobPid;
+  const resolveBridgeSessionId =
+    _deps.resolveDaemonBridgeSessionId || resolveDaemonBridgeSessionId;
+  const buildProjection =
+    _deps.buildClaudeSessionProjection || buildClaudeSessionProjection;
+  const writeProjection =
+    _deps.writeClaudeSessionProjection || writeClaudeSessionProjection;
+  const readProcStart = _deps.getProcStart || getProcStart;
+
+  const short = payload.short;
+  const sessionsDir =
+    paths?.sessionsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "sessions") : "");
+
+  // native-bridge 는 control.sock 존재를 미리 점검한다 (없으면 fast-fail).
+  if (accessControlSock) await accessControlSock(resolvedControlSock);
+
+  const dispatch = await sendControl(
+    resolvedControlSock,
+    {
+      proto: 1,
+      op: "dispatch",
+      d: payload,
+      timeoutMs: dispatchTimeoutMs,
+    },
+    { timeoutMs: dispatchTimeoutMs },
+  );
+  if (dispatch?.ok !== true) {
+    throw new Error(`Claude daemon dispatch failed for ${name || short}`);
+  }
+
+  const pidOpts =
+    pidTimeoutMs === undefined ? undefined : { timeoutMs: pidTimeoutMs };
+  const job = await waitForPid(resolvedControlSock, short, pidOpts);
+  const pid = job.pid;
+  const bridgeSessionId = await resolveBridgeSessionId({
+    daemonPaths: paths,
+    short,
+    job,
+    ...(bridgeTimeoutMs === undefined ? {} : { timeoutMs: bridgeTimeoutMs }),
+  });
+
+  let sessionProjectionPath = "";
+  if (projection !== "skip") {
+    const projectionRecord = buildProjection({
+      pid,
+      procStart: readProcStart(pid),
+      sessionId: payload.sessionId,
+      short,
+      cwd,
+      name,
+      agent,
+      startedAt: job.startedAt || Date.now(),
+      updatedAt: Date.now(),
+      bridgeSessionId,
+    });
+    sessionProjectionPath = await writeProjection(
+      sessionsDir,
+      projectionRecord,
+    );
+  }
+
+  return {
+    ok: true,
+    short,
+    sessionId: payload.sessionId,
+    job,
+    pid,
+    bridgeSessionId,
+    sessionProjectionPath,
+    controlSock: resolvedControlSock,
+    paths,
+  };
+}
+
+/**
+ * dispatchClaudeDaemonJob 의 대칭 정리 경로.
+ * removeProjection + killDaemonJob (+ optional removeClaudeJobState) 를
+ * 모두 시도하며, 각 스텝 오류는 기존 close()/cleanupDaemonDispatches 와
+ * 동일하게 .catch 로 삼킨다.
+ */
+export async function teardownClaudeDaemonJob({
+  controlSock,
+  paths,
+  short,
+  sessionProjectionPath,
+  sessionId,
+  jobsDir,
+  removeJobState = false,
+  _deps = {},
+} = {}) {
+  const removeProjection =
+    _deps.removeClaudeSessionProjection || removeClaudeSessionProjection;
+  const killJob = _deps.killDaemonJob || killDaemonJob;
+  const removeJobStateImpl = _deps.removeClaudeJobState;
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  const resolvedJobsDir =
+    jobsDir ||
+    paths?.jobsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "jobs") : "");
+
+  const steps = [];
+  if (sessionProjectionPath) {
+    steps.push(removeProjection(sessionProjectionPath).catch(() => {}));
+  }
+  if (sessionId && (paths?.controlSock || resolvedControlSock)) {
+    const daemonPaths = paths || { controlSock: resolvedControlSock };
+    steps.push(sendKillBySessionId({ daemonPaths, sessionId }).catch(() => {}));
+  }
+  if (resolvedControlSock && short) {
+    steps.push(killJob(resolvedControlSock, short).catch(() => {}));
+  }
+  if (removeJobState && removeJobStateImpl && resolvedJobsDir && short) {
+    steps.push(removeJobStateImpl(resolvedJobsDir, short).catch(() => {}));
+  }
+  await Promise.all(steps);
+}

package/hub/team/claude-session-projection.mjs

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export function normalizeClaudeBridgeSessionId(bridgeSessionId, short) {
+  const value = String(bridgeSessionId || "").trim();
+  if (value.startsWith("session_")) return value;
+  if (value.startsWith("cse_")) return `session_${value.slice(4)}`;
+  if (value) return value;
+  return `session_${short}`;
+}
+
+export function buildClaudeSessionProjection({
+  pid,
+  procStart,
+  sessionId,
+  short,
+  cwd,
+  name,
+  agent,
+  startedAt = Date.now(),
+  updatedAt = Date.now(),
+  status = "busy",
+  version = "triflux-native-bridge",
+  bridgeSessionId,
+} = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) throw new Error("pid is required");
+  if (!procStart) throw new Error("procStart is required");
+  if (!sessionId) throw new Error("sessionId is required");
+  if (!short) throw new Error("short is required");
+  if (!cwd) throw new Error("cwd is required");
+  if (!name) throw new Error("name is required");
+  if (!agent) throw new Error("agent is required");
+  return {
+    pid,
+    sessionId,
+    cwd,
+    startedAt,
+    procStart,
+    version,
+    peerProtocol: 1,
+    kind: "bg",
+    entrypoint: "cli",
+    name,
+    agent,
+    jobId: short,
+    status,
+    updatedAt,
+    bridgeSessionId: normalizeClaudeBridgeSessionId(bridgeSessionId, short),
+  };
+}
+
+export async function writeClaudeSessionProjection(sessionsDir, projection) {
+  await fs.mkdir(sessionsDir, { recursive: true });
+  const sessionPath = path.join(sessionsDir, `${projection.pid}.json`);
+  const tmpPath = `${sessionPath}.${process.pid}.tmp`;
+  await fs.writeFile(tmpPath, `${JSON.stringify(projection)}\n`, "utf8");
+  await fs.rename(tmpPath, sessionPath);
+  return sessionPath;
+}
+
+export async function updateClaudeSessionProjection(sessionPath, patch) {
+  const parsed = JSON.parse(await fs.readFile(sessionPath, "utf8"));
+  const next = {
+    ...parsed,
+    ...patch,
+    updatedAt: patch.updatedAt || Date.now(),
+  };
+  await fs.writeFile(sessionPath, `${JSON.stringify(next)}\n`, "utf8");
+  return next;
+}
+
+export async function removeClaudeSessionProjection(sessionPath) {
+  await fs.rm(sessionPath, { force: true });
+}

package/hub/team/retry-state-machine.mjs

@@ -42,10 +42,10 @@ const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
 
 // Escalation chain (2026-05-27 정책):
 //   1. codex gpt-5.5   — 코드/추론/비용에서 mini/5.3-codex 중간 단계를 대체
-//   2. claude opus-4-7 — 최종 수단
+//   2. claude opus-4-8 — 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({ cli: "codex", model: "gpt-5.5" }),
-  Object.freeze({ cli: "claude", model: "opus-4-7" }),
+  Object.freeze({ cli: "claude", model: "opus-4-8" }),
 ]);
 
 const STUCK_THRESHOLD = 3;

package/hud/context-monitor.mjs

@@ -15,9 +15,10 @@ const MAX_CAPTURE_BYTES = 256 * 1024;
 const MAX_TOP_KEYS = 20;
 
 // stdin 이 context_window_size 를 제공하지 않을 때 모델 ID 로 한도를 추정한다.
-// Anthropic 공식 문서(2026-04 기준): Opus 4.7 / Opus 4.6 / Sonnet 4.6 = 1M,
+// Anthropic 공식 문서(2026-04 기준): Opus 4.8 / Opus 4.7 / Opus 4.6 / Sonnet 4.6 = 1M,
 // Sonnet 4.5 / Haiku 4.5 = 200K. 그 외 모델은 [1m] suffix 로 opt-in 가능.
 const MODEL_HINT_1M_PREFIXES = [
+  "claude-opus-4-8",
   "claude-opus-4-7",
   "claude-opus-4-6",
   "claude-sonnet-4-6",
@@ -41,7 +42,11 @@ function resolveModelLimit(modelId) {
 export function shouldSuppressInfoOnlyContextStatus(modelId) {
   const id = normalizeModelId(modelId);
   if (!id) return false;
-  return id.startsWith("claude-opus-4-7") || id.includes("[1m]");
+  return (
+    id.startsWith("claude-opus-4-8") ||
+    id.startsWith("claude-opus-4-7") ||
+    id.includes("[1m]")
+  );
 }
 
 const WARNING_LEVELS = Object.freeze({
@@ -283,11 +288,16 @@ export function buildContextUsageView(stdin, snapshot = null) {
   const modelHintLimit = resolveModelLimit(modelId);
   const monitorLimit = Number(monitor?.limitTokens || 0);
   const stdinLimit = stdinUsage?.limitTokens;
+  // When a model id is known it is the authoritative per-model ceiling: the
+  // monitor's cached limitTokens is just a default-derived accumulator (now 1M
+  // by default) and must not override a known model's real window in either
+  // direction — it would inflate a 200K model (Sonnet 4.5 / Haiku) up to 1M.
+  // The model hint already upgrades a stale-low monitor on its own (#88).
   const limitTokens =
     stdinLimit != null && stdinLimit > 0
       ? Math.max(1, stdinLimit)
       : modelId
-        ? Math.max(1, monitorLimit, modelHintLimit)
+        ? Math.max(1, modelHintLimit)
         : Math.max(1, monitorLimit || modelHintLimit);
 
   const usedTokens = stdinUsage?.usedTokens ?? Number(monitor?.usedTokens || 0);
@@ -319,7 +329,19 @@ export function buildContextUsageView(stdin, snapshot = null) {
 }
 
 export function createContextMonitor(options = {}) {
-  const limitTokens = Number(options.limitTokens || DEFAULT_CONTEXT_LIMIT);
+  // Default to a 1M context window (Opus 4.x [1M] / Codex gpt-5.5 both run on
+  // a 1M window) when no explicit limit is supplied, so the cached percent the
+  // Stop hook reads is not inflated against a 200K assumption — assuming 200K
+  // there false-positives at ~15% real usage and blocks legitimate stops.
+  // Narrower setups override via TFX_CONTEXT_DEFAULT_MAX_TOKENS.
+  const explicitLimit = Number(options.limitTokens);
+  const envLimit = Number(process.env.TFX_CONTEXT_DEFAULT_MAX_TOKENS);
+  const limitTokens =
+    Number.isFinite(explicitLimit) && explicitLimit > 0
+      ? explicitLimit
+      : Number.isFinite(envLimit) && envLimit > 0
+        ? envLimit
+        : MILLION_CONTEXT_LIMIT;
   const cachePath = options.cachePath || CONTEXT_MONITOR_CACHE_PATH;
   const logsDir = options.logsDir || CONTEXT_MONITOR_LOG_DIR;
   const sessionId = options.sessionId || randomUUID().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.27.0",
+  "version": "10.28.1",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/mcp-gateway-health-check.mjs

@@ -14,6 +14,7 @@
 // 침묵한다 (false-positive 방지).
 
 import { readFileSync, statSync } from "node:fs";
+import { createConnection } from "node:net";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -33,6 +34,27 @@ const START_RE = /^\[START\]\s+(\S+)\s+on\s+:(\d+)$/;
 const SKIP_RUNNING_RE = /^\[SKIP\]\s+(\S+)\s+already running on\s+:(\d+)$/;
 const SKIP_DISABLED_RE = /^\[SKIP\]\s+(\S+)\s+—\s+manifest에서 비활성$/;
 
+function probePortListening(
+  port,
+  { host = "127.0.0.1", timeoutMs = 800 } = {},
+) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ host, port });
+    let settled = false;
+
+    function finish(value) {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    }
+
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(timeoutMs, () => finish(false));
+  });
+}
+
 export function checkMcpGatewayHealth({
   fs = { readFileSync, statSync },
   logPath = DEFAULT_LOG_PATH,
@@ -130,6 +152,40 @@ export function checkMcpGatewayHealth({
   };
 }
 
+export async function checkMcpGatewayHealthLive({
+  probePort = probePortListening,
+  ...options
+} = {}) {
+  const result = checkMcpGatewayHealth(options);
+  if (!result.available || result.started.length === 0) {
+    return {
+      ...result,
+      live: [],
+    };
+  }
+
+  const live = [];
+  const findings = [...result.findings];
+  for (const entry of result.started) {
+    const listening = await probePort(entry.port);
+    live.push({ ...entry, listening });
+    if (!listening) {
+      findings.push({
+        server: entry.server,
+        reason: "port-down",
+        detail: `expected listener on :${entry.port}`,
+        port: entry.port,
+      });
+    }
+  }
+
+  return {
+    ...result,
+    findings,
+    live,
+  };
+}
+
 export function summarizeMcpGatewayHealth(result) {
   if (!result?.available) {
     return {
@@ -152,6 +208,15 @@ export function summarizeMcpGatewayHealth(result) {
       fix: "secrets 를 ~/.config/triflux/secrets.env 에 추가하고 `launchctl kickstart -k gui/$(id -u)/com.tellang.mcp-gateway` (macOS) 또는 `systemctl --user restart mcp-gateway` (linux)",
     };
   }
+  const portDown = result.findings.filter((f) => f.reason === "port-down");
+  if (portDown.length > 0) {
+    const list = portDown.map((f) => `${f.server} (:${f.port})`).join(", ");
+    return {
+      level: "warn",
+      message: `${portDown.length}개 MCP gateway port down: ${list}`,
+      fix: "gateway 를 재기동하세요: `node scripts/mcp-gateway-start.mjs` 또는 macOS `launchctl kickstart -k gui/$(id -u)/com.tellang.mcp-gateway`",
+    };
+  }
   return {
     level: "warn",
     message: `${result.findings.length}개 gateway 이슈`,

package/scripts/lib/mcp-guard-engine.mjs

@@ -22,7 +22,12 @@ const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
 const DEFAULT_REGISTRY_PATH = join(PROJECT_ROOT, "config", "mcp-registry.json");
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
 const DEFAULT_HUB_PATH = "/mcp";
-const SERVER_POLICIES = new Set(["hosted", "gateway-sse", "stdio"]);
+const SERVER_POLICIES = new Set([
+  "hosted",
+  "gateway-sse",
+  "gateway-http",
+  "stdio",
+]);
 const GATEWAY_PORTS = Object.freeze({
   context7: 8100,
   "brave-search": 8101,
@@ -792,6 +797,23 @@ function gatewaySseUrl(name, serverConfig = {}) {
   return `http://127.0.0.1:${port}/sse`;
 }
 
+function gatewayHttpUrl(name, serverConfig = {}) {
+  if (typeof serverConfig.url === "string" && serverConfig.url.trim()) {
+    return normalizeUrl(serverConfig.url);
+  }
+  const port =
+    Number(serverConfig.gateway_port || serverConfig.port || 0) ||
+    GATEWAY_PORTS[name];
+  if (!Number.isFinite(port) || port <= 0) return "";
+  const path =
+    typeof serverConfig.gateway_path === "string" &&
+    serverConfig.gateway_path.trim()
+      ? serverConfig.gateway_path.trim()
+      : "/mcp";
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `http://127.0.0.1:${port}${normalizedPath}`;
+}
+
 function syncDenylistEntries(policy = {}) {
   if (!Array.isArray(policy?.sync_denylist)) return new Set();
   return new Set(
@@ -836,9 +858,11 @@ export function buildDesiredServerRecord(name, serverConfig, filePath) {
   const url =
     policy === "gateway-sse"
       ? gatewaySseUrl(name, serverConfig)
-      : serverConfig?.transport === "hub-url"
-        ? resolveHubUrl()
-        : normalizeUrl(serverConfig?.url || "");
+      : policy === "gateway-http"
+        ? gatewayHttpUrl(name, serverConfig)
+        : serverConfig?.transport === "hub-url"
+          ? resolveHubUrl()
+          : normalizeUrl(serverConfig?.url || "");
   const basenameValue = pathBasename(filePath);
   const resolvedHeaders = resolveHeaderDescriptors(
     name,
@@ -849,6 +873,26 @@ export function buildDesiredServerRecord(name, serverConfig, filePath) {
     ? { headers: resolvedHeaders.headers }
     : {};
 
+  if (policy === "gateway-http") {
+    if (isCodexConfig(filePath)) {
+      return {
+        name,
+        config: { url },
+        headerDescriptors: {},
+        codex: {},
+        warnings: [],
+      };
+    }
+
+    return {
+      name,
+      config: { type: "http", url },
+      headerDescriptors: {},
+      codex: {},
+      warnings: [],
+    };
+  }
+
   if (policy === "gateway-sse") {
     if (isCodexConfig(filePath)) {
       return {
@@ -1237,7 +1281,7 @@ export function validateRegistry(registry) {
         !SERVER_POLICIES.has(server.policy)
       ) {
         errors.push(
-          `registry.servers.${name}.policy must be hosted, gateway-sse, or stdio`,
+          `registry.servers.${name}.policy must be hosted, gateway-sse, gateway-http, or stdio`,
         );
       }
       const transport = server.transport || registry.defaults?.transport;
@@ -1252,7 +1296,7 @@ export function validateRegistry(registry) {
       ) {
         errors.push(`registry.servers.${name}.url must be a non-empty string`);
       }
-      if (policy === "gateway-sse") {
+      if (policy === "gateway-sse" || policy === "gateway-http") {
         const port = Number(server.gateway_port || server.port || 0);
         const hasGatewayUrl =
           typeof server.url === "string" && server.url.trim().length > 0;
@@ -1261,7 +1305,7 @@ export function validateRegistry(registry) {
           (!Number.isInteger(port) || port <= 0 || port > 65535)
         ) {
           errors.push(
-            `registry.servers.${name}.gateway_port must be a valid TCP port for gateway-sse`,
+            `registry.servers.${name}.gateway_port must be a valid TCP port for ${policy}`,
           );
         }
       }
@@ -1913,7 +1957,7 @@ export function addRegistryServer(name, url, options = {}) {
     (transport === "stdio"
       ? "stdio"
       : options.gateway_port || options.port
-        ? "gateway-sse"
+        ? "gateway-http"
         : "hosted");
 
   registry.servers[trimmedName] = {