@triflux/core 10.49.0 → 10.50.1

package/hub/team/claude-transcript.mjs

@@ -0,0 +1,240 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { modelContext } from "./session-context.mjs";
+
+const transcriptCache = new Map();
+
+export async function findClaudeTranscript({
+  configDir,
+  sourceConfigDir,
+  sessionId,
+  cwd,
+}) {
+  if (!configDir || !sessionId || /[/\\]/u.test(sessionId)) return null;
+  for (const dir of new Set([configDir, sourceConfigDir].filter(Boolean))) {
+    const projectsDir = path.join(dir, "projects");
+    const preferred = cwd
+      ? path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-")
+      : null;
+    const projects = [
+      ...(preferred ? [preferred] : []),
+      ...(await fs.readdir(projectsDir).catch(() => [])).filter(
+        (project) => project !== preferred,
+      ),
+    ];
+    for (const project of projects) {
+      const candidate = path.join(projectsDir, project, `${sessionId}.jsonl`);
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {
+        // Continue looking for this session.
+      }
+    }
+  }
+  return null;
+}
+
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+function beginTurn(state) {
+  state.userSeen = true;
+  state.queued = false;
+  state.response = "";
+  state.error = null;
+  state.turnEnded = false;
+  state.sectionClosed = false;
+}
+
+function acceptEntry(state, entry, marker) {
+  if (entry?.isSidechain) return;
+  const message = entry?.message;
+  if (entry?.type === "system" && entry.subtype === "compact_boundary") {
+    state.compactCount += 1;
+    state.compact = {
+      preTokens: entry.compactMetadata?.preTokens ?? null,
+      postTokens: entry.compactMetadata?.postTokens ?? null,
+    };
+    state.estimatedContextTokens = state.compact.postTokens;
+    state.measuredAt = entry.timestamp || null;
+  }
+  if (entry?.type === "assistant") {
+    if (entry.isApiErrorMessage === true || message?.model === "<synthetic>") {
+      if (state.userSeen && !state.sectionClosed && entry.isApiErrorMessage) {
+        state.error = messageText(message?.content) || "Claude API error";
+        state.turnEnded = true;
+      }
+      return;
+    }
+    const usage = message?.usage;
+    if (usage) {
+      state.estimatedContextTokens =
+        (usage.input_tokens || 0) +
+        (usage.cache_read_input_tokens || 0) +
+        (usage.cache_creation_input_tokens || 0);
+      state.model = message.model || state.model;
+      state.measuredAt = entry.timestamp || state.measuredAt;
+    }
+    if (state.userSeen && !state.sectionClosed) {
+      const text = messageText(message?.content);
+      if (text) state.response = text;
+      if (message?.stop_reason === "end_turn") state.turnEnded = true;
+    }
+    return;
+  }
+  if (entry?.type === "user") {
+    const content = message?.content;
+    // Tool results are not a new human turn.
+    const humanText =
+      typeof content === "string" ||
+      (Array.isArray(content) && content.some((part) => part?.type === "text"))
+        ? messageText(content)
+        : "";
+    const marked =
+      marker &&
+      (humanText.includes(marker) ||
+        JSON.stringify(
+          entry.attachments ?? message?.attachments ?? [],
+        ).includes(marker));
+    if (humanText || marked) {
+      if (!marker || marked) beginTurn(state);
+      else if (state.userSeen) state.sectionClosed = true;
+    }
+    return;
+  }
+  if (
+    entry?.type === "attachment" &&
+    entry.attachment?.type === "queued_command" &&
+    marker &&
+    JSON.stringify(entry.attachment).includes(marker)
+  ) {
+    beginTurn(state);
+    return;
+  }
+  if (entry?.type === "queue-operation") {
+    const marked =
+      marker &&
+      typeof entry.content === "string" &&
+      entry.content.includes(marker);
+    if (marked && entry.operation === "enqueue") {
+      state.queued = true;
+      state.queuedContent = entry.content;
+    } else if (
+      state.queued &&
+      (marked || entry.content === state.queuedContent)
+    ) {
+      if (entry.operation === "remove") beginTurn(state);
+    } else if (marked && entry.operation === "remove") {
+      beginTurn(state);
+    }
+    return;
+  }
+  if (
+    state.userSeen &&
+    !state.sectionClosed &&
+    entry?.type === "system" &&
+    entry.subtype === "turn_duration"
+  ) {
+    state.turnEnded = true;
+  }
+}
+
+function acceptLine(state, line, marker) {
+  try {
+    acceptEntry(state, JSON.parse(line), marker);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
+  if (!transcriptPath) return null;
+  const marker = requestId ? `[tfx-live req=${requestId}]` : null;
+  const key = `${transcriptPath}\0${requestId || ""}`;
+  let stat;
+  try {
+    stat = await fs.stat(transcriptPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  let state = transcriptCache.get(key);
+  if (
+    !state ||
+    state.ino !== stat.ino ||
+    stat.size < state.offset ||
+    (stat.size === state.offset && stat.mtimeMs !== state.mtimeMs)
+  ) {
+    state = {
+      ino: stat.ino,
+      offset: 0,
+      pending: "",
+      decoder: new StringDecoder("utf8"),
+      userSeen: false,
+      queued: false,
+      queuedContent: null,
+      response: "",
+      error: null,
+      turnEnded: false,
+      sectionClosed: false,
+      estimatedContextTokens: null,
+      model: null,
+      measuredAt: null,
+      compactCount: 0,
+      compact: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(transcriptPath, {
+        start: state.offset,
+        end: stat.size - 1,
+      });
+      for await (const chunk of stream) {
+        const lines = (state.pending + state.decoder.write(chunk)).split("\n");
+        state.pending = lines.pop();
+        for (const line of lines) acceptLine(state, line, marker);
+      }
+      if (state.pending && acceptLine(state, state.pending, marker))
+        state.pending = "";
+    }
+  } catch (error) {
+    transcriptCache.delete(key);
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  transcriptCache.set(key, state);
+  return {
+    context:
+      state.estimatedContextTokens === null && state.model === null
+        ? null
+        : {
+            ...modelContext(
+              "claude",
+              state.model,
+              state.estimatedContextTokens,
+            ),
+            model: state.model,
+            measuredAt: state.measuredAt,
+          },
+    userSeen: state.userSeen,
+    response: state.response,
+    error: state.error,
+    turnEnded: state.turnEnded,
+    sectionClosed: state.sectionClosed,
+    compactCount: state.compactCount,
+    compact: state.compact,
+  };
+}

package/hub/team/session-context.mjs

@@ -0,0 +1,203 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// https://platform.claude.com/docs/en/build-with-claude/context-windows 2026-10-08
+// https://developers.openai.com/api/docs/models 2026-10-08
+const MODEL_CONTEXT = [
+  {
+    cli: "claude",
+    model: /^(?:claude-)?(?:fable-5[.-]1|opus-5[.-]5|sonnet-5[.-]5)(?:$|[-[])/i,
+    tokens: 1_000_000,
+    source:
+      "https://platform.claude.com/docs/en/build-with-claude/context-windows",
+  },
+  {
+    cli: "codex",
+    model: /^gpt-6(?:\.\d+)?(?:$|[-_])/i,
+    tokens: 1_050_000,
+    source: "https://developers.openai.com/api/docs/models",
+  },
+];
+
+export const CONTEXT_THRESHOLDS = {
+  claude: { warnContextPct: 60, maxContextPct: 90 },
+  codex: { warnContextPct: 15, maxContextPct: 22 },
+};
+
+const rolloutCache = new Map();
+
+export function modelContext(cli, model, estimatedContextTokens = null) {
+  const entry = MODEL_CONTEXT.find(
+    (item) => item.cli === cli && item.model.test(model || ""),
+  );
+  const contextLimitTokens = entry?.tokens ?? null;
+  const executionContextLimitTokens =
+    cli === "claude" && process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT === "1"
+      ? 200_000
+      : null;
+  const effectiveLimit = Math.min(
+    contextLimitTokens ?? Infinity,
+    executionContextLimitTokens ?? Infinity,
+  );
+  return {
+    estimatedContextTokens,
+    contextLimitTokens,
+    contextLimitSource: entry?.source ?? null,
+    ...(executionContextLimitTokens ? { executionContextLimitTokens } : {}),
+    contextPct:
+      contextLimitTokens && Number.isFinite(estimatedContextTokens)
+        ? (estimatedContextTokens / effectiveLimit) * 100
+        : null,
+  };
+}
+
+export function contextGuard(
+  cli,
+  context,
+  { warnContextPct, maxContextPct } = {},
+) {
+  const defaults = CONTEXT_THRESHOLDS[cli];
+  const warn = warnContextPct ?? defaults?.warnContextPct ?? 0;
+  const max = maxContextPct ?? defaults?.maxContextPct ?? 0;
+  const fields = {
+    estimatedContextTokens: context?.estimatedContextTokens ?? null,
+    contextLimitTokens: context?.contextLimitTokens ?? null,
+    contextLimitSource: context?.contextLimitSource ?? null,
+    executionContextLimitTokens: context?.executionContextLimitTokens ?? null,
+    contextPct: context?.contextPct ?? null,
+  };
+  if (fields.contextPct === null) {
+    return warn > 0
+      ? {
+          contextWarning: {
+            ...fields,
+            reason:
+              fields.contextLimitTokens === null
+                ? "unknown-model"
+                : "usage-unavailable",
+          },
+        }
+      : {};
+  }
+  if (max > 0 && fields.contextPct >= max) {
+    return {
+      ok: false,
+      errorCode: "context-limit",
+      inputSent: false,
+      hint: "세션을 승계한 뒤 새 세션에 요청하라.",
+      ...fields,
+    };
+  }
+  return warn > 0 && fields.contextPct >= warn
+    ? { contextWarning: { ...fields, thresholdPct: warn } }
+    : {};
+}
+
+async function findCodexRollout(threadId) {
+  if (!/^[a-zA-Z0-9-]+$/u.test(threadId || "")) return null;
+  const root = path.join(
+    process.env.CODEX_HOME || path.join(homedir(), ".codex"),
+    "sessions",
+  );
+  for (const year of (await fs.readdir(root).catch(() => []))
+    .sort()
+    .reverse()) {
+    if (!/^\d{4}$/u.test(year)) continue;
+    for (const month of (
+      await fs.readdir(path.join(root, year)).catch(() => [])
+    )
+      .sort()
+      .reverse()) {
+      if (!/^\d{2}$/u.test(month)) continue;
+      for (const day of (
+        await fs.readdir(path.join(root, year, month)).catch(() => [])
+      )
+        .sort()
+        .reverse()) {
+        if (!/^\d{2}$/u.test(day)) continue;
+        const dir = path.join(root, year, month, day);
+        const file = (await fs.readdir(dir).catch(() => [])).find((name) =>
+          name.endsWith(`-${threadId}.jsonl`),
+        );
+        if (file) return path.join(dir, file);
+      }
+    }
+  }
+  return null;
+}
+
+function acceptCodexLine(state, line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (entry?.type === "turn_context")
+    state.model = entry.payload?.model || state.model;
+  if (entry?.type === "event_msg" && entry.payload?.type === "token_count") {
+    const info = entry.payload.info;
+    if (Number.isFinite(info?.last_token_usage?.total_tokens))
+      state.tokens = info.last_token_usage.total_tokens;
+    if (Number.isFinite(info?.model_context_window))
+      state.executionContextLimitTokens = info.model_context_window;
+  }
+  return true;
+}
+
+export async function readCodexContext(rolloutPath, threadId) {
+  rolloutPath ||= await findCodexRollout(threadId);
+  if (!rolloutPath) return { ...modelContext("codex", null), model: null };
+  let stat;
+  try {
+    stat = await fs.stat(rolloutPath);
+  } catch {
+    return { ...modelContext("codex", null), model: null };
+  }
+  let state = rolloutCache.get(rolloutPath);
+  if (
+    !state ||
+    state.ino !== stat.ino ||
+    stat.size < state.offset ||
+    (stat.size === state.offset && stat.mtimeMs !== state.mtimeMs)
+  ) {
+    state = {
+      ino: stat.ino,
+      offset: 0,
+      pending: "",
+      decoder: new StringDecoder("utf8"),
+      model: null,
+      tokens: null,
+      executionContextLimitTokens: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(rolloutPath, {
+        start: state.offset,
+        end: stat.size - 1,
+      });
+      for await (const chunk of stream) {
+        const lines = (state.pending + state.decoder.write(chunk)).split("\n");
+        state.pending = lines.pop();
+        for (const line of lines) acceptCodexLine(state, line);
+      }
+      if (state.pending && acceptCodexLine(state, state.pending))
+        state.pending = "";
+    }
+  } catch {
+    rolloutCache.delete(rolloutPath);
+    return { ...modelContext("codex", null), model: null };
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  rolloutCache.set(rolloutPath, state);
+  return {
+    ...modelContext("codex", state.model, state.tokens),
+    model: state.model,
+    executionContextLimitTokens: state.executionContextLimitTokens,
+  };
+}

package/hud/constants.mjs

@@ -28,6 +28,16 @@ export const ACCOUNTS_STATE_PATH = join(
   "cli_accounts_state.json",
 );
 
+// triflux-mods 의 Claude band 가 세션마다 갱신하는 표식. 있으면 Claude 행을 뺀다.
+export const CLAUDE_BAND_MARKER_DIR = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "triflux",
+  "claude-band",
+);
+export const CLAUDE_BAND_MARKER_TTL_MS = 12 * 60 * 60 * 1000;
+
 // tfx-multi 상태 (v2.2 HUD 통합)
 export const TEAM_STATE_PATH = join(
   homedir(),

package/hud/hud-qos-status.mjs

@@ -5,6 +5,8 @@
 // 각 모듈에서 색상, 터미널, 프로바이더, 렌더러를 가져와 조합한다.
 // ============================================================================
 
+import { statSync } from "node:fs";
+import { join } from "node:path";
 import {
   resolveHudCliVisibility,
   shouldRenderGeminiFallbackRow,
@@ -22,6 +24,8 @@ import {
 import {
   ACCOUNTS_CONFIG_PATH,
   ACCOUNTS_STATE_PATH,
+  CLAUDE_BAND_MARKER_DIR,
+  CLAUDE_BAND_MARKER_TTL_MS,
   CLAUDE_REFRESH_FLAG,
   CODEX_REFRESH_FLAG,
   GEMINI_FLASH_POOL,
@@ -54,8 +58,8 @@ import {
   buildGeminiAuthContext,
   deriveGeminiFamilyBucket,
   fetchGeminiQuota,
+  getAntigravityAccountLabel,
   getAntigravityCurrentModel,
-  getAntigravityEmail,
   getAntigravityModelAbbrev,
   getAntigravityModelFamily,
   getGeminiEmail,
@@ -167,7 +171,7 @@ async function main() {
     : claudeUsageSnapshot.data;
   const codexEmail = getCodexEmail();
   const geminiEmail = getGeminiEmail();
-  const antigravityEmail = getAntigravityEmail();
+  const antigravityAccountLabel = getAntigravityAccountLabel();
   const codexBuckets = codexSnapshot.buckets;
   const geminiSession = geminiSessionSnapshot.session;
   const geminiQuota = geminiQuotaSnapshot.quota;
@@ -237,7 +241,11 @@ async function main() {
     session: geminiSession,
   };
 
-  const rows = [...getClaudeRows(CURRENT_TIER, contextView, claudeUsage)];
+  const rows = [
+    ...(isClaudeBandActive(stdin?.session_id)
+      ? []
+      : getClaudeRows(CURRENT_TIER, contextView, claudeUsage)),
+  ];
 
   // 정책으로 생략된 행이 있으면 뒤따르는 행의 인덱스가 밀린다. dim 래핑이
   // 하드코딩 인덱스를 쓰지 않도록 실제 위치를 기록해 둔다.
@@ -284,7 +292,7 @@ async function main() {
               currentFamily: antigravityModelFamily,
             }
           : geminiQuotaData,
-        antigravityReady ? antigravityEmail : geminiEmail,
+        antigravityReady ? antigravityAccountLabel : geminiEmail,
         null,
       ),
     );
@@ -357,3 +365,14 @@ main().catch(() => {
     `\x1b[0m${bold(claudeOrange("c"))}: ${dim("5h:")}${green("0%")} ${dim("(n/a)")} ${dim("1w:")}${green("0%")} ${dim("(n/a)")} ${dim("|")} ${dim("ctx:")}${green("0%")}\n`,
   );
 });
+
+// 프롬프트 위 band 가 같은 정보를 그리는 세션에서는 Claude 행을 중복해 그리지 않는다.
+function isClaudeBandActive(sessionId) {
+  if (!sessionId) return false;
+  try {
+    const { mtimeMs } = statSync(join(CLAUDE_BAND_MARKER_DIR, sessionId));
+    return Date.now() - mtimeMs < CLAUDE_BAND_MARKER_TTL_MS;
+  } catch {
+    return false;
+  }
+}

package/hud/providers/gemini.mjs

@@ -136,7 +136,10 @@ export function getGeminiEmail() {
   }
 }
 
-export function getAntigravityEmail() {
+// GCP 프로젝트 인증이면 계정 이메일 대신 프로젝트 ID 를 보여 준다.
+export function getAntigravityAccountLabel() {
+  const project = readJson(ANTIGRAVITY_SETTINGS_PATH, null)?.gcp?.project;
+  if (project) return project;
   for (const oauthPath of ANTIGRAVITY_OAUTH_PATHS) {
     try {
       const oauth = readJson(oauthPath, null);

package/hud/renderers.mjs

@@ -314,12 +314,16 @@ export function getMicroLine(
   if (showGemini) {
     segments.push(`${bold(geminiBlue(geminiMarker))}${dim(":")}${gVal}`);
   }
-  segments.push(
-    `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}`,
-  );
+  segments.push(`${dim("CTX:")}${contextPercentText(ctxView)}`);
   return truncateAnsi(segments.join(" "), cols);
 }
 
+// context 는 토큰 수 대신 사용률만 보여 준다.
+function contextPercentText(ctxView) {
+  const text = ctxView.display === "--" ? "--" : `${ctxView.percent}%`;
+  return colorByPercent(ctxView.percent, text);
+}
+
 // ============================================================================
 // Claude 행 렌더러
 // ============================================================================
@@ -381,7 +385,7 @@ export function getClaudeRows(currentTier, contextView, claudeUsage) {
   if (currentTier === "minimal") {
     const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
     const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}${staleTag}`;
-    const right = `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}`;
+    const right = `${dim("CTX:")}${contextPercentText(ctxView)}`;
     return [{ prefix, left: quotaSection, right }];
   }
 
@@ -391,7 +395,7 @@ export function getClaudeRows(currentTier, contextView, claudeUsage) {
     const warning = ctxView.warningTag
       ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
       : "";
-    const contextSection = `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}${warning}`;
+    const contextSection = `${dim("CTX:")}${contextPercentText(ctxView)}${warning}`;
     return [{ prefix, left: quotaSection, right: contextSection }];
   }
 
@@ -401,7 +405,7 @@ export function getClaudeRows(currentTier, contextView, claudeUsage) {
   const warning = ctxView.warningTag
     ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
     : "";
-  const contextSection = `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}${warning}`;
+  const contextSection = `${dim("CTX:")}${contextPercentText(ctxView)}${warning}`;
   return [{ prefix, left: quotaSection, right: contextSection }];
 }
 

package/package.json

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

package/scripts/lib/doctor-env-checks.mjs

@@ -34,88 +34,3 @@ export function inspectMacTimeoutDependency({
     fix: "brew install coreutils",
   };
 }
-
-export function addPluginRootFallbackToCommand(command, pluginRoot) {
-  if (typeof command !== "string") return command;
-  const fallbackRoot = String(pluginRoot || "").replace(/\\/g, "/");
-  if (!fallbackRoot) return command;
-  return command
-    .replaceAll("${PLUGIN_ROOT}", `\${PLUGIN_ROOT:-${fallbackRoot}}`)
-    .replaceAll(
-      "${CLAUDE_PLUGIN_ROOT}",
-      `\${CLAUDE_PLUGIN_ROOT:-${fallbackRoot}}`,
-    )
-    .replace(
-      /(^|[\s"'])\/(hooks|scripts)\//g,
-      `$1\${PLUGIN_ROOT:-${fallbackRoot}}/$2/`,
-    );
-}
-
-function hasBarePluginRootReference(command) {
-  if (typeof command !== "string") return false;
-  return (
-    command.includes("${PLUGIN_ROOT}/") ||
-    command.includes("${CLAUDE_PLUGIN_ROOT}/")
-  );
-}
-
-function hasCollapsedRootHookPath(command) {
-  if (typeof command !== "string") return false;
-  return /(^|[\s"'])\/(?:hooks|scripts)\//.test(command);
-}
-
-export function findPluginRootHookIssues(settings) {
-  const hooksByEvent =
-    settings?.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
-  const issues = [];
-
-  for (const [event, entries] of Object.entries(hooksByEvent)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
-      for (const hook of hooks) {
-        const command = hook?.command;
-        if (
-          !hasBarePluginRootReference(command) &&
-          !hasCollapsedRootHookPath(command)
-        ) {
-          continue;
-        }
-        issues.push({
-          event,
-          matcher: entry?.matcher || "*",
-          command,
-          reason: hasCollapsedRootHookPath(command)
-            ? "collapsed-root-path"
-            : "missing-plugin-root-fallback",
-        });
-      }
-    }
-  }
-
-  return issues;
-}
-
-export function applyPluginRootHookFallbacks(settings, { pluginRoot } = {}) {
-  if (!settings?.hooks || typeof settings.hooks !== "object") {
-    return { changed: false, count: 0, settings };
-  }
-
-  let count = 0;
-  for (const entries of Object.values(settings.hooks)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
-      for (const hook of hooks) {
-        if (typeof hook?.command !== "string") continue;
-        const next = addPluginRootFallbackToCommand(hook.command, pluginRoot);
-        if (next !== hook.command) {
-          hook.command = next;
-          count++;
-        }
-      }
-    }
-  }
-
-  return { changed: count > 0, count, settings };
-}