fapony 0.1.0

package/src/mcp/tools/usage.ts

@@ -0,0 +1,211 @@
+// src/mcp/tools/usage.ts — fapony_usage tool
+
+import {
+  type ImputeSummary,
+  imputeResult,
+  loadPrices,
+  type PriceTable,
+} from "../../price/index.js";
+import {
+  CLIENTS,
+  mergeBytesByTool,
+  type PassiveUsageResult,
+} from "../../session/index.js";
+import { jsonResult, type ToolResult } from "../types.js";
+
+/** สรุป list-price ต่อ client — additive ไม่แตะบรรทัดเดิม */
+function imputationOf(
+  result: PassiveUsageResult,
+  prices: PriceTable | null,
+): (ImputeSummary & { prices_fetched_at: string }) | null {
+  if (result.session_count === 0 || !prices) return null;
+  return {
+    ...imputeResult(result, prices),
+    prices_fetched_at: prices.fetched_at,
+  };
+}
+
+function imputedTextLines(
+  label: string,
+  result: PassiveUsageResult,
+  prices: PriceTable | null,
+): string[] {
+  if (result.session_count === 0) return [];
+  const imp = imputationOf(result, prices);
+  if (!imp)
+    return [`  ${label}list-price equivalent: — (run \`fapony price-scan\`)`];
+  const parts = [
+    `~$${imp.total_imputed.toFixed(4)} over ${imp.priced_sessions} priced sessions`,
+  ];
+  if (imp.free_sessions > 0) parts.push(`${imp.free_sessions} free`);
+  if (imp.unpriced_sessions > 0)
+    parts.push(
+      `unpriced: ${imp.unpriced_sessions} sessions / ${imp.unpriced_tokens.toLocaleString()} tokens`,
+    );
+  return [`  ${label}list-price equivalent: ${parts.join(" · ")}`];
+}
+
+/** ราคา list ราย model ต่อท้ายชื่อรุ่น — เฉพาะแถวที่ client ไม่บันทึก cost */
+function imputedSuffix(
+  provider: string,
+  model: string,
+  imp: (ImputeSummary & { prices_fetched_at: string }) | null,
+): string {
+  if (!imp) return "";
+  const m = imp.by_model.find(
+    (b) => b.provider === provider && b.model === model,
+  );
+  if (m && m.status === "priced")
+    return ` (~$${m.imputed_cost.toFixed(4)} list-price)`;
+  return "";
+}
+
+export function toolPassiveUsage(args: Record<string, unknown>): ToolResult {
+  const worktree =
+    typeof args.worktree === "string" ? args.worktree : undefined;
+  const since = typeof args.since === "number" ? args.since : undefined;
+  const until = typeof args.until === "number" ? args.until : undefined;
+  const detail = args.detail === true;
+
+  const primary = CLIENTS.find((c) => c.primary)!;
+  const others = CLIENTS.filter((c) => !c.primary);
+
+  const data: PassiveUsageResult = primary.read(worktree, since, until, detail);
+
+  // Every non-primary client is always fetched when its own log exists.
+  const otherResults = others.map((client) => ({
+    client,
+    result: client.read(worktree, since, until, detail),
+  }));
+
+  // ราคา list จาก cache อย่างเดียว — อ่านครั้งเดียวต่อ call ไม่ใช่ต่อ section
+  const prices = loadPrices();
+
+  if (args.json === true) {
+    const json: Record<string, unknown> = {
+      ...data,
+      imputation: imputationOf(data, prices),
+    };
+    for (const { client, result } of otherResults) {
+      json[client.key] =
+        result.session_count > 0
+          ? { ...result, imputation: imputationOf(result, prices) }
+          : null;
+    }
+    return jsonResult(json);
+  }
+
+  const lines: string[] = [];
+  lines.push("Passive Usage Report");
+  lines.push("====================");
+  lines.push(`Sessions: ${data.session_count}`);
+  lines.push(`Total Input Tokens: ${data.total_tokens_input.toLocaleString()}`);
+  lines.push(
+    `Total Output Tokens: ${data.total_tokens_output.toLocaleString()}`,
+  );
+  lines.push(
+    `Total Reasoning Tokens: ${data.total_tokens_reasoning.toLocaleString()}`,
+  );
+  lines.push(`Cache Read: ${data.total_tokens_cache_read.toLocaleString()}`);
+  lines.push(`Cache Write: ${data.total_tokens_cache_write.toLocaleString()}`);
+  lines.push(`Total Cost: $${data.total_cost.toFixed(4)}`);
+  lines.push(...imputedTextLines("", data, prices));
+
+  if (data.by_model.length > 0) {
+    lines.push("");
+    lines.push("By Model:");
+    lines.push("--------");
+    for (const m of data.by_model) {
+      const prefix = m.provider ? `${m.provider}/` : "";
+      lines.push(
+        `  ${prefix}${m.model}: ${m.session_count} sessions, ` +
+          `${m.tokens_input.toLocaleString()} in / ${m.tokens_output.toLocaleString()} out, ` +
+          `$${m.cost.toFixed(4)}`,
+      );
+    }
+  }
+
+  // detail:true is opt-in — default text above is byte-identical to before.
+  if (detail && data.detail) {
+    lines.push("");
+    lines.push("Detail (tool activity — signal, not quality):");
+    lines.push(`  steps: ${data.detail.steps.toLocaleString()}`);
+    const tools = Object.entries(data.detail.tool_breakdown).sort(
+      (a, b) => b[1] - a[1],
+    );
+    if (tools.length > 0) {
+      lines.push("  by tool:");
+      for (const [tool, count] of tools.slice(0, 20)) {
+        lines.push(`    ${tool}: ${count.toLocaleString()}`);
+      }
+      if (tools.length > 20) {
+        lines.push(`    ... +${tools.length - 20} more (see json:true)`);
+      }
+    }
+    // Context bytes by tool — proportion of context window consumed per tool.
+    // Bytes are a proxy for tokens; shown as % of total, never as "tokens".
+    // Merged across all clients: OpenCode/ZCode (state.output), Claude Code
+    // and Codex (tool_result) each populate bytes_by_tool, so reading the
+    // top-level (opencode) detail alone would miss the other clients.
+    const bytes = mergeBytesByTool(
+      data.detail,
+      ...otherResults.map((r) => r.result.detail),
+    );
+    if (bytes) {
+      const entries = Object.entries(bytes).sort((a, b) => b[1] - a[1]);
+      const total = entries.reduce((s, e) => s + e[1], 0);
+      if (entries.length > 0 && total > 0) {
+        lines.push("  context bytes by tool (% of total):");
+        for (const [tool, b] of entries.slice(0, 10)) {
+          const pct = ((b / total) * 100).toFixed(1);
+          lines.push(`    ${tool}: ${pct}%`);
+        }
+        if (entries.length > 10) {
+          lines.push(`    ... +${entries.length - 10} more (see json:true)`);
+        }
+      }
+    }
+    lines.push(`  sessions with activity: ${data.detail.by_session.length}`);
+    const top = data.detail.by_session.slice(0, 10);
+    for (const s of top) {
+      const topTool = Object.entries(s.tools).sort((a, b) => b[1] - a[1])[0];
+      lines.push(
+        `    ${s.session_id}: ${s.steps} steps` +
+          (topTool ? `, top tool ${topTool[0]}×${topTool[1]}` : ""),
+      );
+    }
+    if (data.detail.by_session.length > 10) {
+      lines.push(
+        `    ... +${data.detail.by_session.length - 10} more (see json:true)`,
+      );
+    }
+  }
+
+  // One text section per non-primary client — same shape for every client,
+  // new ones need no new formatting code, only a registry.ts entry.
+  for (const { client, result } of otherResults) {
+    if (result.session_count === 0) continue;
+    const imp = imputationOf(result, prices);
+    const label = client.reportLabel ?? client.key;
+    lines.push("");
+    lines.push(`${label} usage:`);
+    lines.push(
+      `  total: ${result.total_tokens_input.toLocaleString()} in / ${result.total_tokens_output.toLocaleString()} out / ${result.total_tokens_reasoning.toLocaleString()} reasoning tokens over ${result.session_count} sessions`,
+    );
+    lines.push(
+      `  cache: ${result.total_tokens_cache_read.toLocaleString()} read / ${result.total_tokens_cache_write.toLocaleString()} write`,
+    );
+    if (result.by_model.length > 0) {
+      lines.push("  by model:");
+      for (const m of result.by_model) {
+        const prefix = m.provider ? `${m.provider}/` : "";
+        lines.push(
+          `    ${prefix}${m.model}: ${m.tokens_input.toLocaleString()} in / ${m.tokens_output.toLocaleString()} out (cache r/w: ${(m.tokens_cache_read ?? 0).toLocaleString()} / ${(m.tokens_cache_write ?? 0).toLocaleString()})${imputedSuffix(m.provider, m.model, imp)}`,
+        );
+      }
+    }
+    lines.push(...imputedTextLines("", result, prices));
+  }
+
+  return { content: [{ type: "text", text: lines.join("\n") }] };
+}

package/src/mcp/tools/verdict.ts

@@ -0,0 +1,148 @@
+// src/mcp/tools/verdict.ts — verdict_submit tool
+
+import {
+  findOpenRun,
+  findOpenRunWithNullPlan,
+  getRun,
+  newRun,
+  openDb,
+  patchLastGateEvent,
+} from "../../db/index.js";
+import { gateOnce } from "../../gate.js";
+import { VERDICT_GRADES, type VerdictGrade } from "../../parse.js";
+import {
+  errorResult,
+  jsonResult,
+  REASON_CODES,
+  REGIME_CODES,
+  type ReasonCode,
+  type RegimeCode,
+  type ToolResult,
+} from "../types.js";
+import { resolveWorktreeArg } from "../worktree.js";
+
+// --- Tool implementation ---
+
+export function toolVerdictSubmit(args: Record<string, unknown>): ToolResult {
+  const {
+    run_id,
+    verdict,
+    reason_code,
+    regime,
+    note,
+    worktree,
+    plan,
+    session_id,
+    files,
+  } = args;
+
+  if (typeof verdict !== "string" || !VERDICT_GRADES.has(verdict)) {
+    return errorResult(
+      `verdict must be one of: ${[...VERDICT_GRADES].join(", ")}`,
+    );
+  }
+  const grade = verdict as VerdictGrade;
+  if (!REASON_CODES.includes(reason_code as ReasonCode)) {
+    return errorResult(
+      `reason_code must be one of: ${REASON_CODES.join(", ")}`,
+    );
+  }
+  if (reason_code === "other" && (!note || typeof note !== "string")) {
+    return errorResult("reason_code 'other' requires a note");
+  }
+  if (!REGIME_CODES.includes(regime as RegimeCode)) {
+    return errorResult(`regime must be one of: ${REGIME_CODES.join(", ")}`);
+  }
+  const regimeCode = regime as RegimeCode;
+
+  const db = openDb();
+
+  // Resolve or create run_id
+  let resolvedRunId: number;
+  if (typeof run_id === "number" && Number.isInteger(run_id)) {
+    const run = getRun(db, run_id);
+    if (!run) {
+      return jsonResult({ stored: false, error: "run not found" });
+    }
+    resolvedRunId = run_id;
+  } else {
+    // Bind to the latest still-open run for the same worktree+plan so a
+    // round-2+ verdict lands on the original row (round keeps counting and
+    // review.maxRounds can actually trigger). Only when no open run matches
+    // is a fresh row created. plan=null always opens a new run (no guess).
+    // Free-text plans are normalized (trim+lowercase) so "Fix Login" and
+    // "fix login" bind to the same run. When no exact match exists, falls
+    // back to any open run with plan=null (the "no PLAN file" flow).
+    const resolvedWorktree =
+      typeof worktree === "string" && worktree
+        ? resolveWorktreeArg(worktree)
+        : "mcp-external";
+    const resolvedPlan =
+      typeof plan === "string" && plan ? plan.trim().toLowerCase() : null;
+    let open = resolvedPlan
+      ? findOpenRun(db, resolvedWorktree, resolvedPlan)
+      : null;
+    // Fallback: if no exact match and plan is non-null, try any open run with
+    // plan=null.  This lets a verdict with free-text intent bind to a run that
+    // was created without a plan (the common "no PLAN file" flow).
+    if (!open && resolvedPlan) {
+      open = findOpenRunWithNullPlan(db, resolvedWorktree);
+    }
+    if (open) {
+      resolvedRunId = open.id;
+    } else {
+      // worktree/plan let callers (e.g. move-to-done) attribute the verdict
+      // so byReasonCode/bestPassing aggregate correctly instead of collapsing
+      // into "mcp-external".
+      resolvedRunId = newRun(db, resolvedWorktree, resolvedPlan, null, "mcp");
+    }
+  }
+
+  // Normalize files: must be a non-empty array of strings.
+  const resolvedFiles =
+    Array.isArray(files) && files.length > 0
+      ? files.filter((f): f is string => typeof f === "string" && f.length > 0)
+      : undefined;
+
+  // Route through gateOnce for consistent status/round/memory handling.
+  const mcpNote =
+    typeof note === "string" && note
+      ? `[${reason_code}] ${note}`
+      : `[${reason_code}]`;
+  const result = gateOnce(resolvedRunId, grade, mcpNote, resolvedFiles);
+
+  if (result.error) {
+    return jsonResult({
+      stored: false,
+      error: result.error,
+      run_id: resolvedRunId,
+      status: result.status,
+      round: result.round,
+    });
+  }
+
+  // Patch the gate event with MCP-specific fields (reason_code, source).
+  // session_id lets gates.ts resolve model from client session logs when the
+  // window has no spawn events (the old execute→review loop that wrote spawns
+  // is gone). Optional — agents that can't expose it just omit it.
+  const patch: Record<string, unknown> = {
+    reason_code,
+    regime: regimeCode,
+    source: "mcp",
+  };
+  if (typeof session_id === "string" && session_id) {
+    patch.session_id = session_id;
+  }
+  patchLastGateEvent(db, resolvedRunId, patch);
+
+  return jsonResult({
+    stored: true,
+    run_id: resolvedRunId,
+    verdict: grade,
+    reason_code,
+    regime: regimeCode,
+    status: result.status,
+    round: result.round,
+    ...(resolvedFiles ? { files: resolvedFiles } : {}),
+  });
+}

package/src/mcp/transport.ts

@@ -0,0 +1,241 @@
+// src/mcp/transport.ts — JSON-RPC dispatch + stdio entry point
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { mergeBytesByTool, type UsageDetail } from "../session/index.js";
+import { getServerSha } from "./primitives.js";
+import {
+  TOOLS,
+  toolFaponyStats,
+  toolMemFind,
+  toolPassiveUsage,
+  toolPlanList,
+  toolProjectHealthContext,
+  toolVerdictSubmit,
+} from "./tools/index.js";
+import { errorResult, type ToolResult } from "./types.js";
+
+// --- Server instructions ---
+//
+// MCP's initialize response carries an `instructions` string that clients
+// inject into the model's context. This is the vendor-neutral place for the
+// habit fapony depends on — a user should never have to paste rules
+// into their own CLAUDE.md (or AGENTS.md, or a hook) to make the tools work,
+// and a rule pasted there would only cover one client anyway.
+//
+// Kept short on purpose: this text is spent on every session of every user.
+// Both habits degrade silently — an agent that ignores them still gets
+// correct answers from every tool, just a thinner history.
+
+const SERVER_INSTRUCTIONS = `fapony is a ledger of how work in this project turned out: which model, on which shape of task, produced work that held up. One habit feeds it.
+
+When a unit of work is finished, call verdict_submit to grade it — pass-excellent..pass when it holds, fail when the first attempt was wrong, uncertain when you could not verify it (never guess pass). This is a grade on the work, not a confession: grade routinely, including work that went right the first time, because a model's record is only as good as the number of graded units behind it.
+
+worktree must be the absolute path (git rev-parse --show-toplevel): every query scopes by it, so a bare name or none files the verdict where nothing reads it, and nothing errors to say so. Write the note standalone — what the work was and how it held up — it is read months later with no access to this conversation. Never leave a run non-terminal; an open run absorbs later unrelated verdicts for that worktree.
+
+Skip it and every tool still answers correctly, on a thinner history.`;
+
+// --- Statusline cache ---
+//
+// Written after every MCP tool call. The Claude Code statusline script reads
+// this file (< 1ms, no spawn, no db). Format: single line of text.
+// Only fapony_usage with detail:true produces meaningful data (bytes_by_tool,
+// aggregated across all clients — the bytes live on the claude_code
+// sub-object, never top-level); other tools write a minimal "fapony" marker.
+
+const STATUSLINE_PATH = join(homedir(), ".config", "fapony", "statusline");
+
+function writeStatuslineCache(toolResult: ToolResult): void {
+  try {
+    // Extract bytes_by_tool from fapony_usage detail JSON response.
+    let line = "fapony";
+    if (
+      toolResult &&
+      typeof toolResult === "object" &&
+      "content" in toolResult &&
+      Array.isArray(toolResult.content)
+    ) {
+      for (const c of toolResult.content) {
+        if (
+          c &&
+          typeof c === "object" &&
+          c.type === "text" &&
+          typeof c.text === "string"
+        ) {
+          // Try to extract bytes_by_tool from JSON text response.
+          // Aggregated across all clients: the bytes live on the Claude Code
+          // sub-object (claude_code.detail), never on the top-level detail,
+          // so reading top-level alone would always miss.
+          try {
+            const parsed = JSON.parse(c.text) as {
+              detail?: UsageDetail | null;
+              zcode?: { detail?: UsageDetail | null } | null;
+              claude_code?: { detail?: UsageDetail | null } | null;
+              codex?: { detail?: UsageDetail | null } | null;
+            };
+            const bbt = mergeBytesByTool(
+              parsed?.detail,
+              parsed?.zcode?.detail,
+              parsed?.claude_code?.detail,
+              parsed?.codex?.detail,
+            );
+            const entries = Object.entries(bbt).sort((a, b) => b[1] - a[1]);
+            const total = entries.reduce((s, e) => s + e[1], 0);
+            if (total > 0) {
+              // Format: "84.2k" for total, or "Read 42k · Grep 31k" for top tools.
+              const fmt = (n: number) =>
+                n >= 1024 ? `${(n / 1024).toFixed(1)}k` : `${Math.round(n)}`;
+              if (entries.length <= 3) {
+                line = `fapony ${entries.map((e) => `${e[0]} ${fmt(e[1])}`).join(" · ")}`;
+              } else {
+                line = `fapony ${fmt(total)}`;
+              }
+            }
+          } catch {
+            // Not JSON — that's fine, use default "fapony" marker.
+          }
+          break;
+        }
+      }
+    }
+    const dir = join(homedir(), ".config", "fapony");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(STATUSLINE_PATH, line, "utf-8");
+  } catch {
+    // Cache write is best-effort — never block MCP on it.
+  }
+}
+
+// --- MCP protocol constants ---
+
+const MCP_PROTOCOL_VERSION = "2025-03-26";
+const SERVER_NAME = "fapony-handcheck";
+const SERVER_VERSION = "0.1.0";
+
+// --- JSON-RPC dispatch ---
+
+export function dispatch(
+  method: string,
+  params: unknown,
+): object | ToolResult | null {
+  switch (method) {
+    case "initialize":
+      return {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+        instructions: SERVER_INSTRUCTIONS,
+      };
+    case "notifications/initialized":
+      return null; // no response needed
+    case "tools/list":
+      return { tools: TOOLS };
+    case "tools/call":
+      return dispatchToolCall(
+        params as { name: string; arguments?: Record<string, unknown> },
+      );
+    default:
+      return {
+        code: -32601,
+        message: `method not found: ${method}`,
+      };
+  }
+}
+
+function dispatchToolCall(params: {
+  name: string;
+  arguments?: Record<string, unknown>;
+}): ToolResult {
+  const args = params.arguments ?? {};
+  let result: ToolResult;
+  switch (params.name) {
+    case "verdict_submit":
+      result = toolVerdictSubmit(args);
+      break;
+    case "fapony_stats":
+      result = toolFaponyStats(args);
+      break;
+    case "fapony_usage":
+      result = toolPassiveUsage(args);
+      break;
+    case "project_health_context":
+      result = toolProjectHealthContext(args);
+      break;
+    case "plan_list":
+      result = toolPlanList(args);
+      break;
+    case "mem_find":
+      result = toolMemFind(args);
+      break;
+    default:
+      return errorResult(`unknown tool: ${params.name}`);
+  }
+  // Write statusline cache after every tool call — best-effort, never blocks.
+  writeStatuslineCache(result);
+  return result;
+}
+
+// --- Entry point ---
+
+export function cmdMcp(): void {
+  getServerSha(); // cache while the process is still fresh, not on first report call
+  const rl = createInterface({ input: process.stdin });
+
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    let msg: { id?: number; method: string; params?: unknown };
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      // Invalid JSON — send error
+      const resp = {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Parse error" },
+      };
+      process.stdout.write(`${JSON.stringify(resp)}\n`);
+      return;
+    }
+
+    const result = dispatch(msg.method, msg.params ?? {});
+
+    // notifications don't get a response
+    if (result === null) return;
+
+    const resp: Record<string, unknown> = {
+      jsonrpc: "2.0",
+      id: msg.id ?? null,
+    };
+
+    if (
+      result &&
+      typeof result === "object" &&
+      "content" in result &&
+      "isError" in result
+    ) {
+      // Tool result
+      resp.result = result;
+    } else if (
+      result &&
+      typeof result === "object" &&
+      "code" in result &&
+      "message" in result
+    ) {
+      // Error response
+      resp.error = result;
+    } else {
+      // Normal result
+      resp.result = result;
+    }
+
+    process.stdout.write(`${JSON.stringify(resp)}\n`);
+  });
+
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}

package/src/mcp/types.ts

@@ -0,0 +1,54 @@
+// src/mcp/types.ts — ReasonCode enum, ToolResult, helpers
+
+// --- ReasonCode enum (locked in step 0, append-only) ---
+
+export const REASON_CODES = [
+  "missing_test",
+  "scope_mismatch",
+  "unsafe_command",
+  "spec_gap",
+  "timeout",
+  "blocked",
+  "incomplete",
+  "none",
+  "other",
+] as const;
+
+export type ReasonCode = (typeof REASON_CODES)[number];
+
+// --- RegimeCode enum (task-shape axis for model × project × regime × quality) ---
+
+export const REGIME_CODES = [
+  "code",
+  "fix",
+  "review",
+  "plan",
+  "inquiry",
+  "test",
+] as const;
+
+export type RegimeCode = (typeof REGIME_CODES)[number];
+
+// --- Tool result types ---
+
+export interface ToolResult {
+  content: { type: "text"; text: string }[];
+  isError?: boolean;
+}
+
+export function jsonResult(data: unknown): ToolResult {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }],
+  };
+}
+
+export function errorResult(message: string): ToolResult {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true,
+  };
+}
+
+export function parseToolResult(result: ToolResult): unknown {
+  return JSON.parse(result.content[0].text);
+}

package/src/mcp/worktree.ts

@@ -0,0 +1,27 @@
+// src/mcp/worktree.ts — resolve worktree argument to absolute path
+
+import { loadConfig } from "../db/load.js";
+
+const SENTINEL_MCP_EXTERNAL = "mcp-external";
+
+/**
+ * Resolve a worktree argument to an absolute path.
+ * - Absolute paths (contain "/") pass through unchanged
+ * - Keys are looked up in config.worktrees
+ * - "mcp-external" sentinel passes through (set by verdict_submit itself)
+ * - Throws if key not found in config
+ */
+export function resolveWorktreeArg(value: string): string {
+  if (value === SENTINEL_MCP_EXTERNAL) return value;
+  if (value.includes("/")) return value;
+
+  const config = loadConfig();
+  const resolved = config.worktrees[value];
+  if (resolved) return resolved;
+
+  const keys = Object.keys(config.worktrees);
+  throw new Error(
+    `worktree "${value}" is not an absolute path and not found in config.worktrees. ` +
+      `Send an absolute path (containing "/") or one of these keys: ${keys.length ? keys.join(", ") : "(none configured)"}`,
+  );
+}