@triflux/remote 10.53.0 → 10.55.0

package/scripts/lib/mcp-filter.mjs

@@ -137,31 +137,6 @@ const PROFILE_DEFINITIONS = Object.freeze({
   }),
 });
 
-/**
- * 파이프라인 단계별 MCP 서버/도구 제한 (post-filter).
- * role-based 프로필 위에 추가 적용. 빈 배열 = 전체 차단, 미정의 = 제한 없음.
- */
-const PHASE_OVERRIDES = Object.freeze({
-  plan: Object.freeze({
-    description: "계획 단계: 읽기 전용 탐색만 허용",
-    allowedServers: Object.freeze(["context7"]),
-    blockedServers: Object.freeze(["playwright", "tavily", "exa"]),
-  }),
-  prd: Object.freeze({
-    description: "PRD 단계: 읽기 전용 탐색 + 문서 조회",
-    allowedServers: Object.freeze(["context7", "brave-search"]),
-    blockedServers: Object.freeze(["playwright"]),
-  }),
-  exec: Object.freeze({
-    description: "실행 단계: 프로필 기반 전체 허용 (제한 없음)",
-  }),
-  verify: Object.freeze({
-    description: "검증 단계: 읽기 전용 + 분석 도구",
-    allowedServers: Object.freeze(["context7", "brave-search", "exa"]),
-    blockedServers: Object.freeze(["playwright"]),
-  }),
-});
-
 const LEGACY_PROFILE_ALIASES = Object.freeze({
   implement: "executor",
   analyze: "analyze",
@@ -762,17 +737,9 @@ export function buildMcpPolicy(options = {}) {
     options.agentType,
     options.requestedProfile,
   );
-  let allowedServers = resolveAllowedServers(resolvedOptions);
+  const allowedServers = resolveAllowedServers(resolvedOptions);
   const hint = buildPromptHint(resolvedOptions);
 
-  // Phase-aware post-filter: 파이프라인 단계별 서버 제한 적용
-  const phase = options.phase;
-  const phaseOverride = phase && PHASE_OVERRIDES[phase];
-  if (phaseOverride?.blockedServers) {
-    const blocked = new Set(phaseOverride.blockedServers);
-    allowedServers = allowedServers.filter((s) => !blocked.has(s));
-  }
-
   // 플러그인 서버는 transport 설정이 없어 CLI override를 받으면 부팅이 실패한다.
   const codexOptions = {
     ...resolvedOptions,
@@ -785,7 +752,6 @@ export function buildMcpPolicy(options = {}) {
         ? options.requestedProfile
         : "auto",
     resolvedProfile,
-    resolvedPhase: phase || null,
     allowedServers,
     hint,
     codexConfig: getCodexMcpConfig(codexOptions),
@@ -810,7 +776,6 @@ function toDelimited(policy) {
     policy.allowedServers.join(","),
     policy.codexConfigOverrides.flatMap((o) => ["-c", o]).join("\x1f"),
     JSON.stringify(policy.codexConfig),
-    policy.resolvedPhase || "",
   ].join(RS);
 }
 
@@ -826,9 +791,6 @@ function toShellExports(policy) {
     ),
     `CODEX_CONFIG_JSON=${shellEscape(JSON.stringify(policy.codexConfig))}`,
   ];
-  if (policy.resolvedPhase) {
-    lines.push(`MCP_PIPELINE_PHASE=${shellEscape(policy.resolvedPhase)}`);
-  }
   return lines.join("\n");
 }
 
@@ -889,9 +851,6 @@ function parseCliArgs(argv) {
       case "--worker-index":
         args.workerIndex = Number.parseInt(next(), 10);
         break;
-      case "--phase":
-        args.phase = next();
-        break;
       default:
         throw new Error(`알 수 없는 옵션: ${token}`);
     }

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

@@ -6,6 +6,7 @@ import {
   readFileSync,
   writeFileSync,
 } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import {
   basename,
@@ -16,6 +17,7 @@ import {
   resolve,
 } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 
 const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
 const DEFAULT_REGISTRY_PATH = join(PROJECT_ROOT, "config", "mcp-registry.json");
@@ -155,6 +157,10 @@ function isMigratedAntigravityConfig(filePath, raw = null) {
   return String(contents || "").trim() === "";
 }
 
+function isProjectMcpJson(filePath) {
+  return /(^|\/)\.mcp\.json$/.test(normalizeForMatch(filePath));
+}
+
 function plaintextSecretHeaderClient(filePath) {
   const client = detectClient(filePath);
   return client === "gemini" || client === "antigravity" ? client : null;
@@ -214,8 +220,6 @@ function detectLabel(filePath) {
   if (normalized.endsWith("/.gemini/config/mcp_config.json"))
     return "Antigravity";
   if (normalized.endsWith("/.gemini/settings.json")) return "Gemini";
-  if (normalized.endsWith("/.gemini/config/mcp_config.json"))
-    return "Antigravity";
   if (normalized.endsWith("/.codex/config.toml")) return "Codex";
   if (normalized.endsWith("/.claude.json")) return "Claude User MCP";
   if (normalized.endsWith("/.claude/settings.json")) return "Claude User";
@@ -484,6 +488,12 @@ function resolveHeaderDescriptors(name, serverConfig, filePath) {
       continue;
     }
 
+    // 프로젝트 .mcp.json 은 저장소에 커밋될 수 있다. Claude Code 가 실행 시 ${VAR} 를 확장하므로 값 대신 참조를 쓴다.
+    if (isProjectMcpJson(filePath)) {
+      headers[headerName] = `${prefix}\${${envName}}`;
+      continue;
+    }
+
     headers[headerName] = `${prefix}${envValue}`;
 
     const plaintextClient = plaintextSecretHeaderClient(filePath);
@@ -624,20 +634,31 @@ function formatTomlArray(values = []) {
   return `[${values.map((value) => formatTomlString(value)).join(", ")}]`;
 }
 
+// 한 줄에서 열린 [ 와 닫힌 ] 의 차. 문자열과 주석 안의 괄호는 세지 않는다.
+function arrayDepth(text) {
+  const code = text
+    .replace(/"""[\s\S]*?"""|'''[\s\S]*?'''/g, "")
+    .replace(/"(?:[^"\\]|\\.)*"|'[^']*'/g, "")
+    .replace(/#.*$/, "");
+  return (code.match(/\[/g) || []).length - (code.match(/\]/g) || []).length;
+}
+
+const TOML_MANAGED_KEYS = new Set([
+  "url",
+  "transport",
+  "command",
+  "args",
+  "bearer_token_env_var",
+  "http_headers",
+  "env_http_headers",
+  "env",
+  "env_vars",
+]);
+
 function upsertTomlServer(raw, name, config, codex = {}) {
   const lines = String(raw || "").split(/\r?\n/);
   const header = `[mcp_servers.${name}]`;
-  const managedKeys = new Set([
-    "url",
-    "transport",
-    "command",
-    "args",
-    "bearer_token_env_var",
-    "http_headers",
-    "env_http_headers",
-    "env",
-    "env_vars",
-  ]);
+  const managedKeys = TOML_MANAGED_KEYS;
   const nextManagedLines = [];
   if (typeof config.url === "string") {
     nextManagedLines.push(`url = ${formatTomlString(config.url)}`);
@@ -688,6 +709,21 @@ function upsertTomlServer(raw, name, config, codex = {}) {
       const keyMatch = lines[index].match(/^\s*([A-Za-z0-9_]+)\s*=/);
       if (!keyMatch || !managedKeys.has(keyMatch[1])) {
         preserved.push(lines[index]);
+      } else {
+        // 여러 줄 배열 값은 닫는 ] 까지 함께 걷어낸다. 남기면 다음 줄들이 고아가 되어 파일이 깨진다.
+        // 배열 값일 때만, 다음 키나 표 머리글 앞에서는 멈춘다.
+        const value = lines[index].slice(keyMatch[0].length);
+        let depth = value.trimStart().startsWith("[") ? arrayDepth(value) : 0;
+        while (
+          depth > 0 &&
+          index + 1 < lines.length &&
+          !/^\s*(?:[A-Za-z0-9_-]+\s*=|\[\[?\s*[A-Za-z0-9_"'-])/.test(
+            lines[index + 1],
+          )
+        ) {
+          index += 1;
+          depth += arrayDepth(lines[index]);
+        }
       }
       index += 1;
     }
@@ -743,6 +779,29 @@ function syncDenylistKey(client, serverName) {
     .toLowerCase()}`;
 }
 
+// 범위 이름(@scope/name)의 첫 @ 는 이름에 속한다.
+function splitPackageSpec(spec) {
+  const match = /^((?:@[^/@\s]+\/)?[^@\s]+)(?:@(\S+))?$/.exec(spec);
+  return match ? { name: match[1], version: match[2] ?? null } : null;
+}
+
+// 명령과 인자 수가 같고, 다른 자리는 레지스트리의 고정 패키지와 이름만 같을 때 고정 인자를 돌려준다.
+export function pinnedArgs(entry, server) {
+  if (entry?.command !== server.command || !Array.isArray(entry.args))
+    return null;
+  if (entry.args.length !== server.args.length) return null;
+  let changed = false;
+  for (const [index, want] of server.args.entries()) {
+    const have = entry.args[index];
+    if (have === want) continue;
+    const pin = splitPackageSpec(want);
+    if (!pin?.version || typeof have !== "string") return null;
+    if (splitPackageSpec(have)?.name !== pin.name) return null;
+    changed = true;
+  }
+  return changed ? [...server.args] : null;
+}
+
 export function buildDesiredServerRecord(name, serverConfig, filePath) {
   const policy = serverPolicy(serverConfig);
   if (policy === "stdio") {
@@ -1099,9 +1158,31 @@ function updateCodexConfig(filePath, updates = [], removals = []) {
   if (finalRaw === previousRaw) {
     return { modified: false, filePath: resolvedPath };
   }
+  // 줄 단위 치환이 파일을 깨뜨리거나 관리 키 밖의 값을 지우면 쓰지 않는다.
+  // 파서가 원본부터 못 읽는 표기(파서가 모르는 TOML 1.0 문법)는 판정할 수 없어 예전처럼 쓴다.
+  const toml = tomlParser();
+  try {
+    if (
+      toml &&
+      parsesAsToml(toml, previousRaw) &&
+      !isDeepStrictEqual(
+        withoutManagedServers(toml.parse(previousRaw), updates, removals),
+        withoutManagedServers(toml.parse(finalRaw), updates, removals),
+      )
+    )
+      throw new Error("unmanaged TOML changed");
+  } catch {
+    return {
+      modified: false,
+      filePath: resolvedPath,
+      skipped: true,
+      reason: "toml-rewrite-unsafe",
+    };
+  }
 
   mkdirSync(dirname(resolvedPath), { recursive: true });
-  writeFileSync(resolvedPath, finalRaw, "utf8");
+  // 헤더 비밀이 들어갈 수 있다. 새 파일은 0600, 기존 파일은 권한이 그대로 유지된다.
+  writeFileSync(resolvedPath, finalRaw, { encoding: "utf8", mode: 0o600 });
   return { modified: true, filePath: resolvedPath };
 }
 
@@ -1121,10 +1202,6 @@ function scanConfig(filePath) {
   };
 }
 
-export function getRegistryPath() {
-  return registryPath();
-}
-
 export function createDefaultRegistry() {
   return cloneDefaultRegistry();
 }
@@ -1588,7 +1665,26 @@ export function inspectRegistryStatus(registry = loadRegistryOrDefault()) {
         : descriptorsFromJsonConfig(desired.config);
       const actual =
         config.servers.find((server) => server.name === name) || null;
-      const actualHeaders = actual?.headerDescriptors || {};
+      // JSON 설정의 기대 헤더는 지금 셸의 env 로 만든다. 키를 export 하지 않은 셸에서는
+      // 기대 헤더가 비어 같은 설정도 mismatch 로 보였다. 그 env 를 가리키는 참조이거나
+      // 확인할 수 없는 평문 값이면 비교에서 빼고, 다른 참조면 불일치로 남긴다.
+      const unverifiableHeader = (headerName, actualDescriptor) => {
+        const expected = desired.headerDescriptors?.[headerName];
+        if (isCodexConfig(config.filePath) || !expected?.env) return false;
+        if (process.env[expected.env]) return false;
+        const value = String(actualDescriptor?.value ?? "");
+        const prefix = expected.prefix || "";
+        return value.includes("${")
+          ? value === `${prefix}\${${expected.env}}`
+          : value.startsWith(prefix) &&
+              value.slice(prefix.length).trim() !== "";
+      };
+      const actualHeaders = Object.fromEntries(
+        Object.entries(actual?.headerDescriptors || {}).filter(
+          ([headerName, descriptor]) =>
+            !unverifiableHeader(headerName, descriptor),
+        ),
+      );
       const currentHeaderStatus = headerStatus(expectedHeaders, actualHeaders);
       let status = "missing";
 
@@ -1623,8 +1719,10 @@ export function inspectRegistryStatus(registry = loadRegistryOrDefault()) {
         filePath: config.filePath,
         expectedUrl,
         expectedCommand,
+        expectedArgs: desired.config.args || [],
         actualUrl: actual?.url || "",
         actualCommand: actual?.command || "",
+        actualArgs: actual?.args || [],
         status,
         migrated: Boolean(config.migrated),
         message: config.message || "",
@@ -1804,6 +1902,52 @@ export function removeServerFromTargets(name, options = {}) {
   return { actions };
 }
 
+// packages/remote 는 @iarna/toml 을 의존으로 두지 않아 늦게 불러오고, 없으면 null.
+function tomlParser() {
+  try {
+    return createRequire(import.meta.url)("@iarna/toml");
+  } catch {
+    return null;
+  }
+}
+
+// 갱신한 서버의 관리 키만 뺀다. 남은 값이 원본과 같아야 치환이 사용자 값을 건드리지 않은 것이다.
+function withoutManagedServers(data, updates, removals) {
+  for (const name of removals) delete data.mcp_servers?.[name];
+  for (const { name } of updates) {
+    const server = data.mcp_servers?.[name];
+    if (!server) continue;
+    for (const key of TOML_MANAGED_KEYS) delete server[key];
+    if (!Object.keys(server).length) delete data.mcp_servers[name];
+  }
+  if (data.mcp_servers && !Object.keys(data.mcp_servers).length)
+    delete data.mcp_servers;
+  return data;
+}
+
+function parsesAsToml(toml, raw) {
+  try {
+    toml.parse(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 간이 TOML 스캐너는 작은따옴표와 줄 끝 주석을 잘못 읽으므로 보호 판정에 쓸 Codex 항목은 실제 파서로 읽는다.
+function existingServerEntry(filePath, snapshot, name) {
+  const scanned = snapshot.servers.find((server) => server.name === name);
+  const toml = isCodexConfig(filePath) && tomlParser();
+  if (!toml) return scanned;
+  try {
+    const entry = toml.parse(readFileSync(resolveFilePath(filePath), "utf8"))
+      .mcp_servers?.[name];
+    return entry && { ...entry, args: entry.args ?? [] };
+  } catch {
+    return scanned;
+  }
+}
+
 export function syncRegistryTargets(options = {}) {
   const registry = options.registry || loadRegistryOrDefault();
   const syncTargets = Array.isArray(options.targets)
@@ -1908,6 +2052,29 @@ export function syncRegistryTargets(options = {}) {
         continue;
       }
 
+      // 사용자가 바꾼 stdio 항목은 덮어쓰지 않는다. 같은 패키지의 버전 차이만 고정 버전으로 맞춘다.
+      const existing = existingServerEntry(target.filePath, snapshot, name);
+      if (
+        serverPolicy(serverConfig) === "stdio" &&
+        typeof existing?.command === "string" &&
+        existing.command &&
+        !(
+          existing.command === serverConfig.command &&
+          JSON.stringify(existing.args) === JSON.stringify(serverConfig.args)
+        ) &&
+        !pinnedArgs(existing, serverConfig)
+      ) {
+        actions.push({
+          type: "sync",
+          filePath: target.filePath,
+          label: target.label,
+          status: "warning",
+          server: name,
+          message: `${name}: 레지스트리와 다른 사용자 항목이라 덮어쓰지 않음 (${[existing.command, ...(existing.args ?? [])].join(" ")})`,
+        });
+        continue;
+      }
+
       updates.push(
         buildDesiredServerRecord(name, serverConfig, target.filePath),
       );
@@ -1924,6 +2091,18 @@ export function syncRegistryTargets(options = {}) {
       continue;
     }
 
+    if (result.reason === "toml-rewrite-unsafe") {
+      actions.push({
+        type: "sync",
+        filePath: target.filePath,
+        label: target.label,
+        status: "warning",
+        message:
+          "줄 단위로 고칠 수 없는 TOML 표기(여러 줄 값 등)라 파일을 바꾸지 않음",
+      });
+      continue;
+    }
+
     actions.push({
       type: "sync",
       filePath: target.filePath,

package/scripts/lib/mcp-manifest.mjs

@@ -16,23 +16,6 @@ export const MANIFEST_PATH = join(
 /** API 키 불필요 서버 (현재 없음) */
 export const CORE_SERVERS = Object.freeze([]);
 
-/** 검색 MCP — API 키 필요 */
-export const SEARCH_SERVERS = Object.freeze([
-  { name: "brave-search", envVars: ["BRAVE_API_KEY"] },
-  { name: "exa", envVars: ["EXA_API_KEY"] },
-  { name: "tavily", envVars: ["TAVILY_API_KEY"] },
-]);
-
-/** 통합 MCP — API 키 + 추가 설정 필요 */
-export const INTEGRATION_SERVERS = Object.freeze([
-  {
-    name: "jira",
-    envVars: ["JIRA_API_TOKEN", "JIRA_EMAIL", "JIRA_INSTANCE_URL"],
-  },
-  { name: "notion", envVars: ["NOTION_TOKEN"] },
-  { name: "notion-guest", envVars: ["NOTION_TOKEN"] },
-]);
-
 export function readManifest() {
   if (!existsSync(MANIFEST_PATH)) return null;
   try {
@@ -54,21 +37,6 @@ export function writeManifest(enabledServers) {
   return manifest;
 }
 
-/**
- * 매니페스트 기준으로 활성 서버만 필터링.
- * @param {Array<string|{name:string}>} allServers — 전체 서버 목록
- * @returns {Array} 활성 서버 목록. 매니페스트 미존재 시 null (레거시 모드).
- */
-export function filterByManifest(allServers) {
-  const manifest = readManifest();
-  if (!manifest) return null;
-  const enabled = new Set(manifest.enabled || []);
-  for (const core of CORE_SERVERS) enabled.add(core);
-  return allServers.filter((s) =>
-    enabled.has(typeof s === "string" ? s : s.name),
-  );
-}
-
 /**
  * 단일 서버 활성화 여부 확인.
  * 매니페스트 미존재 시 true (레거시 호환).
@@ -79,11 +47,3 @@ export function isServerEnabled(serverName) {
   if (CORE_SERVERS.includes(serverName)) return true;
   return (manifest.enabled || []).includes(serverName);
 }
-
-/** 특정 서버에 필요한 환경변수 중 누락된 것 반환 */
-export function getMissingEnvVars(serverName) {
-  const all = [...SEARCH_SERVERS, ...INTEGRATION_SERVERS];
-  const entry = all.find((s) => s.name === serverName);
-  if (!entry) return [];
-  return entry.envVars.filter((k) => !process.env[k]);
-}

package/scripts/lib/process-utils.mjs

@@ -4,6 +4,10 @@
 // Note: hub/lib/process-utils.mjs에는 더 포괄적인 orphan cleanup 로직이 있습니다.
 // 이 파일은 단순 alive 체크만 필요한 훅/스크립트용 (상위 의존성 없이 동작).
 
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
 /**
  * 주어진 PID의 프로세스가 살아있는지 확인합니다.
  * - EPERM: 프로세스는 존재하지만 signal 권한 없음 → alive
@@ -24,3 +28,18 @@ export function isProcessAlive(pid) {
     return false;
   }
 }
+
+// 직접 실행 판정. 문자열로 붙인 file:// 은 공백, 한글 경로에서 어긋나므로 양쪽 실제 경로로 비교한다.
+export function isMainModule(moduleUrl) {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return realPathOf(entry) === realPathOf(fileURLToPath(moduleUrl));
+}
+
+function realPathOf(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}

package/scripts/lib/stable-node.mjs

@@ -0,0 +1,35 @@
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+
+// process.execPath 는 Homebrew 의 bin/node 링크를 따라가 버전이 박힌 Cellar 경로가 된다.
+// 그 경로는 brew upgrade node 뒤 사라지므로, 같은 바이너리를 가리키는 bin/node 별칭이 있으면 그쪽을 쓴다.
+// 그 밖(nvm, volta, 시스템 node, Windows)은 fallback 을 쓴다. 기본은 execPath 이고,
+// 오래 남는 명령(HUD statusLine)은 버전이 박힌 경로 대신 "node" 를 넘겨 PATH 에 맡긴다.
+export function resolveStableNodeBin(execPath = process.execPath, opts = {}) {
+  const env = opts.env || process.env;
+  const realpath = opts.realpath || realpathSync;
+  const fallback = opts.fallback ?? execPath;
+  const candidates = [];
+  if (env.HOMEBREW_PREFIX)
+    candidates.push(join(env.HOMEBREW_PREFIX, "bin", "node"));
+  candidates.push(
+    "/opt/homebrew/bin/node",
+    "/usr/local/bin/node",
+    "/home/linuxbrew/.linuxbrew/bin/node",
+  );
+  let target;
+  try {
+    target = realpath(execPath);
+  } catch {
+    return fallback;
+  }
+  for (const candidate of candidates) {
+    if (candidate === execPath) return execPath;
+    try {
+      if (realpath(candidate) === target) return candidate;
+    } catch {
+      // 이 기기에 없는 후보
+    }
+  }
+  return fallback;
+}

package/scripts/lib/test-env.mjs

@@ -0,0 +1,20 @@
+// 테스트 실행 신호. node --test 자식과 test-lock 아래에서 켜진다.
+export function isTestRun(env = process.env) {
+  return (
+    env.NODE_ENV === "test" ||
+    env.TFX_TEST === "1" ||
+    Boolean(
+      env.TEST_LOCK_PID || env.NODE_TEST_CONTEXT || env.NODE_TEST_WORKER_ID,
+    )
+  );
+}
+
+// 테스트인데 홈을 임시 디렉터리로 돌렸다는 신호가 없으면 실제 홈에 쓰게 된다(#529).
+// TRIFLUX_TEST_HOME 은 테스트가 직접 주고, TFX_TEST_HOME_ISOLATED 는 test-lock 이 준다.
+export function writesRealHomeInTest(env = process.env) {
+  return (
+    isTestRun(env) &&
+    !env.TRIFLUX_TEST_HOME &&
+    env.TFX_TEST_HOME_ISOLATED !== "1"
+  );
+}

package/cto/brief.mjs

@@ -1,73 +0,0 @@
-const BRIEF_VERSION = "cto-lake.v1";
-const MAX_BRIEF_BYTES = 2048;
-const TRUNCATION_MARKER = "... truncated";
-
-function oneLine(value, fallback = "n/a") {
-  const text =
-    typeof value === "string"
-      ? value
-      : value === null || value === undefined
-        ? fallback
-        : JSON.stringify(value);
-  return String(text).replace(/\s+/g, " ").trim() || fallback;
-}
-
-function formatGoal(goal) {
-  const id = oneLine(goal?.id, "goal");
-  const status = oneLine(goal?.status, "unknown");
-  const title = oneLine(
-    goal?.title || goal?.objective || goal?.summary,
-    "untitled",
-  );
-  return `- ${id} ${status}: ${title}`;
-}
-
-function formatEvent(event) {
-  const ts = oneLine(event?.ts, "unknown_ts");
-  const name = oneLine(event?.event, "event");
-  const summary = oneLine(event?.summary, "");
-  return summary ? `- ${ts} ${name}: ${summary}` : `- ${ts} ${name}`;
-}
-
-function enforceCap(text) {
-  if (Buffer.byteLength(text, "utf8") <= MAX_BRIEF_BYTES) return text;
-  const marker = `\n${TRUNCATION_MARKER}`;
-  let candidate = text;
-  while (
-    candidate.length > 0 &&
-    Buffer.byteLength(`${candidate}${marker}`, "utf8") > MAX_BRIEF_BYTES
-  ) {
-    candidate = candidate.slice(0, -1);
-  }
-  return `${candidate.replace(/\s+$/u, "")}${marker}`;
-}
-
-export function renderBrief(current) {
-  const repo = current?.repo || {};
-  const summary = current?.summary || {};
-  const activeGoals = Array.isArray(summary.active_goals)
-    ? summary.active_goals.slice(0, 3)
-    : [];
-  const recentEvents = Array.isArray(current?.ledger_tail)
-    ? current.ledger_tail.slice(-2)
-    : [];
-
-  const lines = [
-    `brief_version: ${BRIEF_VERSION}`,
-    "repo_state",
-    `branch: ${oneLine(repo.branch, "unknown")} head: ${oneLine(repo.head, "unknown")} dirty: ${repo.dirty === true}`,
-    `summary: ${oneLine(summary.repo_state, "no repo summary")}`,
-    "active_goals",
-    ...(activeGoals.length > 0 ? activeGoals.map(formatGoal) : ["- none"]),
-    "recent_events",
-    ...(recentEvents.length > 0 ? recentEvents.map(formatEvent) : ["- none"]),
-    "generated_at",
-    oneLine(current?.generated_at, "unknown"),
-    "injection_note",
-    "read by agent hooks; align to this north-star",
-  ];
-
-  return enforceCap(`${lines.join("\n")}\n`);
-}
-
-export { BRIEF_VERSION, MAX_BRIEF_BYTES };