@triflux/core 10.50.2 → 10.52.0

package/scripts/lib/claudemd-scanner.mjs

@@ -1,223 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const TFX_START = "<!-- TFX:START -->";
-export const TFX_END = "<!-- TFX:END -->";
-export const OMC_END = "<!-- OMC:END -->";
-const TFX_VERSION_RE = /<!-- TFX:VERSION:([\d.]+) -->/u;
-
-const LEGACY_PATTERNS = [
-  /<user_cli_routing>/u,
-  /Codex Pro 무료 기간/u,
-  /codex exec --dangerously-bypass.*skip-git-repo-check/u,
-  /OMC 에이전트 → CLI 매핑/u,
-  /Spark 가드레일/u,
-];
-
-const DEFAULT_TFX_TEMPLATE = [
-  "### triflux CLI routing (managed)",
-  "- 이 블록은 triflux setup에서 자동으로 관리됩니다.",
-  "- 직접 수정이 필요하면 블록 바깥에 사용자 섹션을 추가하세요.",
-].join("\n");
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_TEMPLATE_PATH = join(
-  SCRIPT_DIR,
-  "..",
-  "templates",
-  "claudemd-tfx-section.md",
-);
-
-function resolveVersion(version) {
-  if (version) return version;
-  try {
-    const pkgPath = join(SCRIPT_DIR, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-function resolveTemplate(template, templatePath = DEFAULT_TEMPLATE_PATH) {
-  if (typeof template === "string" && template.trim()) {
-    return template.trim();
-  }
-  if (existsSync(templatePath)) {
-    const raw = readFileSync(templatePath, "utf8").trim();
-    if (raw) return raw;
-  }
-  return DEFAULT_TFX_TEMPLATE;
-}
-
-function findManagedSection(rawText) {
-  const raw = String(rawText || "");
-  const startIdx = raw.indexOf(TFX_START);
-  const endMarkerIdx = raw.indexOf(TFX_END);
-  if (startIdx === -1 || endMarkerIdx === -1 || endMarkerIdx <= startIdx) {
-    return {
-      found: false,
-      content: null,
-      version: null,
-      startIdx: -1,
-      endIdx: -1,
-    };
-  }
-
-  const endIdx = endMarkerIdx + TFX_END.length;
-  const content = raw.slice(startIdx, endIdx);
-  const versionMatch = content.match(TFX_VERSION_RE);
-
-  return {
-    found: true,
-    content,
-    version: versionMatch ? versionMatch[1] : null,
-    startIdx,
-    endIdx,
-  };
-}
-
-function detectLegacyRange(rawText) {
-  const raw = String(rawText || "");
-  const matches = LEGACY_PATTERNS.some((pattern) => pattern.test(raw));
-  if (!matches) {
-    return { found: false, startIdx: -1, endIdx: -1 };
-  }
-
-  const startTag = raw.indexOf("<user_cli_routing>");
-  const endTag = raw.indexOf("</user_cli_routing>");
-  if (startTag === -1 || endTag === -1 || endTag <= startTag) {
-    return { found: true, startIdx: -1, endIdx: -1 };
-  }
-
-  let removeStart = startTag;
-  const userOverridesComment = "<!-- USER OVERRIDES";
-  const commentIdx = raw.lastIndexOf(userOverridesComment, startTag);
-  if (commentIdx !== -1 && startTag - commentIdx < 200) {
-    removeStart = commentIdx;
-  }
-
-  return {
-    found: true,
-    startIdx: removeStart,
-    endIdx: endTag + "</user_cli_routing>".length,
-  };
-}
-
-function normalizeSpacing(text) {
-  return String(text || "").replace(/\n{3,}/gu, "\n\n");
-}
-
-export function findAllClaudeMdPaths(options = {}) {
-  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-  const homeDir = options.homeDir ? resolve(options.homeDir) : homedir();
-  const includeGlobal = options.includeGlobal !== false;
-  const includeProject = options.includeProject !== false;
-
-  const candidates = [];
-  if (includeGlobal) candidates.push(join(homeDir, ".claude", "CLAUDE.md"));
-  if (includeProject) candidates.push(join(cwd, "CLAUDE.md"));
-
-  const seen = new Set();
-  const paths = [];
-  for (const candidate of candidates) {
-    const normalized = resolve(candidate);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    if (existsSync(normalized)) {
-      paths.push(normalized);
-    }
-  }
-  return paths;
-}
-
-export function writeSection(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  const version = resolveVersion(options.version);
-  const template = resolveTemplate(options.template, options.templatePath);
-  const block = [
-    TFX_START,
-    `<!-- TFX:VERSION:${version} -->`,
-    template,
-    TFX_END,
-  ].join("\n");
-
-  if (!existsSync(absolutePath)) {
-    writeFileSync(absolutePath, `${block}\n`, "utf8");
-    return { action: "created", version, path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-
-  if (existing.found) {
-    const nextContent = `${raw.slice(0, existing.startIdx)}${block}${raw.slice(existing.endIdx)}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return {
-      action: "updated",
-      oldVersion: existing.version,
-      version,
-      path: absolutePath,
-    };
-  }
-
-  const omcEndIdx = raw.indexOf(OMC_END);
-  if (omcEndIdx !== -1) {
-    const insertAt = omcEndIdx + OMC_END.length;
-    const before = raw.slice(0, insertAt);
-    const after = raw.slice(insertAt);
-    const nextContent = `${before}\n${block}${after}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return { action: "inserted_after_omc", version, path: absolutePath };
-  }
-
-  const separator = raw.endsWith("\n") ? "" : "\n";
-  writeFileSync(absolutePath, `${raw}${separator}${block}\n`, "utf8");
-  return { action: "appended", version, path: absolutePath };
-}
-
-export function migrateClaudeMd(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  if (!existsSync(absolutePath)) {
-    return { action: "no_file", removed: [], path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-  const legacy = detectLegacyRange(raw);
-
-  if (existing.found && !legacy.found) {
-    return {
-      action: "already_managed",
-      removed: [],
-      version: existing.version,
-      path: absolutePath,
-    };
-  }
-
-  const removed = [];
-  let nextContent = raw;
-
-  if (legacy.found && legacy.startIdx !== -1 && legacy.endIdx !== -1) {
-    nextContent = `${nextContent.slice(0, legacy.startIdx)}${nextContent.slice(legacy.endIdx)}`;
-    removed.push("<user_cli_routing> block");
-  }
-
-  const existingAfterLegacy = findManagedSection(nextContent);
-  if (existingAfterLegacy.found) {
-    nextContent = `${nextContent.slice(0, existingAfterLegacy.startIdx)}${nextContent.slice(existingAfterLegacy.endIdx)}`;
-    removed.push("old TFX block");
-  }
-
-  writeFileSync(absolutePath, normalizeSpacing(nextContent), "utf8");
-  const writeResult = writeSection(absolutePath, options);
-
-  return {
-    action: "migrated",
-    removed,
-    version: writeResult.version,
-    path: absolutePath,
-  };
-}

package/scripts/lib/context.mjs

@@ -1,67 +0,0 @@
-/**
- * 요청별 로그 컨텍스트 전파 (AsyncLocalStorage 기반).
- *
- * Hub HTTP 서버의 요청마다 correlationId를 자동 할당하여,
- * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
- *
- * 사용법:
- *   import { getLogger, getCorrelationId, withRequestContext } from './lib/context.mjs';
- *
- *   // 미들웨어에서 컨텍스트 생성
- *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
- *     const log = getLogger();
- *     log.info({ agentId }, 'bridge.result_received');
- *   });
- *
- *   // 내부 함수에서 자동 상관 ID
- *   function processResult() {
- *     const log = getLogger();
- *     log.info('result.processed'); // correlationId 자동 포함
- *   }
- */
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-
-import { logger } from "./logger.mjs";
-
-/** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
-export const asyncLocalStorage = new AsyncLocalStorage();
-
-/**
- * 현재 요청 컨텍스트의 로거를 반환한다.
- * 요청 컨텍스트 밖에서 호출하면 기본 로거를 반환한다.
- *
- * @returns {import('pino').Logger}
- */
-export function getLogger() {
-  return asyncLocalStorage.getStore()?.logger || logger;
-}
-
-/**
- * 현재 요청의 상관 ID를 반환한다.
- *
- * @returns {string|undefined}
- */
-export function getCorrelationId() {
-  return asyncLocalStorage.getStore()?.correlationId;
-}
-
-/**
- * 요청 컨텍스트를 생성하고 콜백을 실행한다.
- *
- * @param {object} context — 컨텍스트 필드 (method, path 등)
- * @param {string} [context.correlationId] — 외부에서 전달된 상관 ID (없으면 자동 생성)
- * @param {function} callback — 컨텍스트 내에서 실행할 함수
- * @returns {*}
- */
-export function withRequestContext(context, callback) {
-  const correlationId = context.correlationId || randomUUID();
-  const { correlationId: _, ...rest } = context;
-
-  const store = {
-    correlationId,
-    logger: logger.child({ correlationId, ...rest }),
-  };
-
-  return asyncLocalStorage.run(store, callback);
-}

package/scripts/lib/dynamic-route-cli.mjs

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-// scripts/lib/dynamic-route-cli.mjs
-//
-// Phase 1 Wire-up 3 helper — tfx-route.sh 등 sh 경로에서 dynamic routing
-// decision 을 받아 단일 CLI 문자열 (또는 JSON) 으로 출력한다.
-//
-// 사용:
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex
-//   → "codex"
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex --json
-//   → {"scenario":"fallback","mode":"codex-default","shards":[{"cli":"codex",...}]}
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex --field scenario
-//   → "fallback"
-//
-// 정책:
-//   - opt-in env TRIFLUX_DYNAMIC_ROUTING=1|true 미설정 시 즉시 silent exit 0
-//     (override 없음 = stdout empty, sh caller 가 graceful no-op).
-//   - error 발생 시 stderr 에 한 줄 + exit 0 (sh caller 가 fallback path 진행).
-
-import { createDynamicRouter } from "../../hub/dynamic-routing-engine.mjs";
-
-function parseArgs(argv) {
-  const args = {
-    taskId: `tfx-route-${process.pid}-${Date.now()}`,
-    agentHint: "codex",
-    teamSize: 1,
-    json: false,
-    field: null,
-  };
-  for (let i = 2; i < argv.length; i++) {
-    const v = argv[i];
-    switch (v) {
-      case "--task-id":
-        args.taskId = argv[++i] || args.taskId;
-        break;
-      case "--agent-hint":
-        args.agentHint = argv[++i] || args.agentHint;
-        break;
-      case "--team-size":
-        args.teamSize = Number(argv[++i]) || args.teamSize;
-        break;
-      case "--json":
-        args.json = true;
-        break;
-      case "--field":
-        args.field = argv[++i] || null;
-        break;
-      case "--help":
-      case "-h":
-        process.stdout.write(
-          "Usage: dynamic-route-cli.mjs [--task-id ID] [--agent-hint CLI] [--team-size N] [--json|--field FIELD]\n",
-        );
-        process.exit(0);
-        break;
-    }
-  }
-  return args;
-}
-
-async function main() {
-  const args = parseArgs(process.argv);
-
-  // opt-in env 미설정 시 silent no-op (sh caller graceful path)
-  const flag = process.env.TRIFLUX_DYNAMIC_ROUTING;
-  if (flag !== "1" && flag !== "true") return;
-
-  let decision;
-  try {
-    const router = createDynamicRouter();
-    decision = await router.routeRequest({
-      task_id: args.taskId,
-      team_size: args.teamSize,
-      agent_hint: args.agentHint,
-    });
-  } catch (err) {
-    process.stderr.write(
-      `[dynamic-route-cli] error: ${err?.message || String(err)}\n`,
-    );
-    return;
-  }
-
-  if (args.json) {
-    process.stdout.write(JSON.stringify(decision));
-    return;
-  }
-
-  if (args.field) {
-    const value = decision?.[args.field];
-    if (value !== undefined && value !== null) {
-      process.stdout.write(String(value));
-    }
-    return;
-  }
-
-  // 기본 — shards[0].cli 만 stdout 으로 (sh caller 가 즉시 비교)
-  const cli = decision?.shards?.[0]?.cli;
-  if (cli) {
-    process.stdout.write(String(cli));
-  }
-}
-
-main().catch((err) => {
-  process.stderr.write(
-    `[dynamic-route-cli] fatal: ${err?.message || String(err)}\n`,
-  );
-  process.exit(0); // sh caller 가 정상 fallback 하도록 always 0
-});

package/scripts/lib/handoff.mjs

@@ -1,187 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { findAllClaudeMdPaths } from "./claudemd-scanner.mjs";
-
-function runCommand(command, cwd, executor = execSync) {
-  try {
-    const output = executor(command, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true,
-    });
-    return String(output || "").trimEnd();
-  } catch {
-    return "";
-  }
-}
-
-function parseStatusLines(statusText) {
-  const lines = String(statusText || "")
-    .split(/\r?\n/u)
-    .filter(Boolean);
-  const changedFiles = [];
-  const status = [];
-
-  for (const line of lines) {
-    const normalized = line.trimEnd();
-    if (!normalized) continue;
-
-    const rawStatus = normalized.slice(0, 2).trim() || "??";
-    const rawPath = normalized.slice(3).trim();
-    const filePath = rawPath.includes(" -> ")
-      ? rawPath.split(" -> ").at(-1)?.trim()
-      : rawPath;
-    if (!filePath) continue;
-
-    changedFiles.push(filePath);
-    status.push({ path: filePath, status: rawStatus });
-  }
-
-  return {
-    changedFiles: Array.from(new Set(changedFiles)),
-    status,
-  };
-}
-
-function normalizeDecisionLine(line) {
-  return String(line || "")
-    .trim()
-    .replace(/^[-*]\s+/u, "")
-    .trim();
-}
-
-function parseDecisionFile(decisionFile) {
-  if (!decisionFile) return [];
-  const absolute = resolve(decisionFile);
-  if (!existsSync(absolute)) return [];
-
-  const raw = readFileSync(absolute, "utf8");
-  return raw
-    .split(/\r?\n/u)
-    .map(normalizeDecisionLine)
-    .filter((line) => line.length > 0);
-}
-
-function normalizeDecisions(decisions, decisionFile) {
-  const merged = [
-    ...(Array.isArray(decisions) ? decisions : []),
-    ...parseDecisionFile(decisionFile),
-  ]
-    .map(normalizeDecisionLine)
-    .filter(Boolean);
-
-  return Array.from(new Set(merged));
-}
-
-function formatAheadBehind(value) {
-  if (!value) return null;
-  const [behindRaw, aheadRaw] = value.split(/\s+/u);
-  const behind = Number.parseInt(behindRaw, 10);
-  const ahead = Number.parseInt(aheadRaw, 10);
-  if (!Number.isFinite(behind) || !Number.isFinite(ahead)) return null;
-  return { ahead, behind };
-}
-
-export function collectHandoffContext(options = {}) {
-  const cwd = resolve(options.cwd || process.cwd());
-  const executor =
-    typeof options.commandRunner === "function"
-      ? options.commandRunner
-      : execSync;
-  const target = options.target === "local" ? "local" : "remote";
-  const decisions = normalizeDecisions(options.decisions, options.decisionFile);
-  const generatedAt = options.generatedAt || new Date().toISOString();
-  const claudeMdPaths = Array.isArray(options.claudeMdPaths)
-    ? options.claudeMdPaths
-    : findAllClaudeMdPaths({
-        cwd,
-        homeDir: options.homeDir,
-      });
-
-  const gitRoot = runCommand("git rev-parse --show-toplevel", cwd, executor);
-  const branch =
-    runCommand("git rev-parse --abbrev-ref HEAD", cwd, executor) || null;
-  const shortStatus = runCommand("git status --short", cwd, executor);
-  const diffStat = runCommand("git diff --stat --no-color", cwd, executor);
-  const upstreamRaw = runCommand(
-    "git rev-list --left-right --count @{upstream}...HEAD",
-    cwd,
-    executor,
-  );
-  const parsedStatus = parseStatusLines(shortStatus);
-
-  return {
-    generatedAt,
-    target,
-    cwd,
-    gitRoot: gitRoot || null,
-    repository: gitRoot ? basename(gitRoot) : basename(cwd),
-    branch,
-    upstream: formatAheadBehind(upstreamRaw),
-    changedFiles: parsedStatus.changedFiles,
-    fileStatus: parsedStatus.status,
-    diffStat,
-    decisions,
-    claudeMdPaths,
-  };
-}
-
-export function buildHandoffPrompt(context) {
-  const safeContext = context || collectHandoffContext();
-  const branch = safeContext.branch || "unknown";
-  const upstream = safeContext.upstream
-    ? `ahead ${safeContext.upstream.ahead}, behind ${safeContext.upstream.behind}`
-    : "unknown";
-  const changedFiles =
-    safeContext.changedFiles.length > 0
-      ? safeContext.changedFiles.map((file) => `- ${file}`).join("\n")
-      : "- 변경 파일 없음";
-  const decisions =
-    safeContext.decisions.length > 0
-      ? safeContext.decisions.map((decision) => `- ${decision}`).join("\n")
-      : "- 명시된 결정사항 없음";
-  const claudeMdList =
-    Array.isArray(safeContext.claudeMdPaths) &&
-    safeContext.claudeMdPaths.length > 0
-      ? safeContext.claudeMdPaths.map((path) => `- ${path}`).join("\n")
-      : "- 자동 탐지된 CLAUDE.md 없음";
-  const diffStat = safeContext.diffStat || "(diff stat 없음)";
-
-  return [
-    "## TFX Remote Handoff",
-    `- generated_at: ${safeContext.generatedAt}`,
-    `- target: ${safeContext.target}`,
-    `- repository: ${safeContext.repository}`,
-    `- branch: ${branch} (${upstream})`,
-    `- cwd: ${safeContext.cwd}`,
-    "",
-    "### 변경 파일",
-    changedFiles,
-    "",
-    "### 변경 요약 (git diff --stat)",
-    "```",
-    diffStat,
-    "```",
-    "",
-    "### 결정사항",
-    decisions,
-    "",
-    "### CLAUDE.md 참조",
-    claudeMdList,
-    "",
-    "### 다음 세션 지시",
-    "- 위 변경사항을 먼저 검토하고 누락된 테스트를 확인하세요.",
-    "- 필요 시 CLAUDE.md 지침을 재확인한 뒤 작업을 이어가세요.",
-    "- 작업 완료 후 변경 파일과 검증 결과를 요약하세요.",
-  ].join("\n");
-}
-
-export function serializeHandoff(options = {}) {
-  const context = collectHandoffContext(options);
-  return {
-    ...context,
-    prompt: buildHandoffPrompt(context),
-  };
-}

package/scripts/lib/logger.mjs

@@ -1,122 +0,0 @@
-/**
- * Logify — triflux 구조화 로깅 설정
- *
- * 사용법:
- *   import { logger, createModuleLogger } from './lib/logger.mjs';
- *
- *   // 기본 로거
- *   logger.info({ taskId: 'abc' }, 'task.started');
- *
- *   // 모듈별 로거
- *   const log = createModuleLogger('hub');
- *   log.info({ port: 27888 }, 'server.started');
- *   log.error({ err }, 'server.error');
- *
- * 이벤트 네이밍: {도메인}.{액션} 형식
- *   hub.started, hub.stopped, route.started, route.completed,
- *   worker.spawned, worker.completed, worker.timeout,
- *   mcp.connected, mcp.disconnected, mcp.error,
- *   team.created, team.deleted, task.claimed, task.completed,
- *   pipe.connected, pipe.message, pipe.error,
- *   http.request, http.response, http.error
- *
- * 로그 레벨 가이드:
- *   debug  — 개발/트러블슈팅용 (변수 값, MCP 메시지, 캐시 키)
- *   info   — 정상 흐름 상태 변경 (서버 시작, 워커 완료, 팀 생성)
- *   warn   — 위험 신호 (재시도 발생, 쿼타 임박, 느린 워커)
- *   error  — 작업 실패 (CLI 실행 실패, MCP 연결 끊김)
- *   fatal  — 프로세스 위협 (DB 연결 불가, 포트 충돌)
- */
-import pino from "pino";
-
-const isDev = process.env.NODE_ENV !== "production";
-
-// 로그는 항상 stderr(fd 2)로 보낸다.
-//
-// Claude Code 훅은 stdout 을 훅의 JSON 페이로드로 파싱한다. 로그가 stdout 으로
-// 나가면 페이로드와 한 스트림에 섞여, 훅이 돌려준 hookSpecificOutput 이 JSON 으로
-// 해석되지 않고 그냥 본문 텍스트가 된다. Claude Code 2.1.257 부터는 stdout 이
-// "{" 로 시작하는데 유효한 JSON 이 아니면 훅 오류로 보고하므로, 로그가 먼저 나가느냐
-// 페이로드가 먼저 나가느냐에 따라 훅 전체가 실패로 뒤집힌다.
-//
-// stderr 로 보내면 Claude Code 가 verbose/transcript 에서 그대로 보여주고 stdout 은
-// 페이로드만 남는다. CLI 관례상으로도 구조화 로그는 stderr 가 맞다.
-const LOG_FD = 2;
-
-export const logger = pino(
-  {
-    level: process.env.LOG_LEVEL || (isDev ? "debug" : "info"),
-
-    // 모든 로그에 포함되는 기본 필드
-    base: {
-      service: process.env.SERVICE_NAME || "triflux",
-      env: process.env.NODE_ENV || "development",
-    },
-
-    // 레벨을 대문자로 출력 (AI 파싱 용이)
-    formatters: {
-      level: (label) => ({ level: label.toUpperCase() }),
-    },
-
-    // ISO 8601 타임스탬프
-    timestamp: pino.stdTimeFunctions.isoTime,
-
-    // 민감정보 자동 필터링
-    redact: {
-      paths: [
-        "password",
-        "token",
-        "apiKey",
-        "secret",
-        "authorization",
-        "*.password",
-        "*.token",
-        "*.apiKey",
-        "*.secret",
-        "req.headers.authorization",
-        "req.headers.cookie",
-        "hubToken",
-      ],
-      remove: true,
-    },
-
-    // 개발 환경: 컬러 콘솔 출력 (stderr)
-    transport: isDev
-      ? {
-          target: "pino-pretty",
-          options: {
-            colorize: true,
-            translateTime: "yyyy-mm-dd HH:MM:ss",
-            ignore: "pid,hostname",
-            destination: LOG_FD,
-          },
-        }
-      : undefined,
-  },
-  // 운영 환경(transport 미사용)에서도 stdout 이 아니라 stderr 로 쓴다.
-  isDev ? undefined : pino.destination({ dest: LOG_FD, sync: false }),
-);
-
-/**
- * 모듈별 Child Logger 생성.
- * 모듈 이름이 모든 로그에 자동 포함된다.
- *
- * @param {string} module — 모듈 이름 (hub, route, worker, mcp, team 등)
- * @returns {import('pino').Logger}
- */
-export function createModuleLogger(module) {
-  return logger.child({ module });
-}
-
-// 정상 종료 시 버퍼 flush 보장
-process.on("uncaughtException", (err) => {
-  logger.fatal({ err }, "process.uncaught_exception");
-  logger.flush();
-  process.exit(1);
-});
-
-process.on("unhandledRejection", (reason) => {
-  logger.fatal({ reason: String(reason) }, "process.unhandled_rejection");
-  logger.flush();
-  process.exit(1);
-});