@polderlabs/bizar 6.2.5 → 6.3.0

package/bizar-dash/src/server/claude-info.mjs

@@ -0,0 +1,412 @@
+/**
+ * src/server/claude-info.mjs
+ *
+ * v6.3.0 — Dashboard-side documentation + discovery for the Claude
+ * Code runtime. Replaces serve-info.mjs (which documented the Cline
+ * HTTP serve subprocess contract).
+ *
+ * Why this module exists:
+ *   Claude Code does NOT have an out-of-process serve child like
+ *   Cline's `cline serve`. Instead, the dashboard talks to the
+ *   `claude` CLI directly:
+ *
+ *     - `claude -p "<prompt>"`     — one-shot, runs to completion
+ *     - `claude --bg`              — background daemon session
+ *     - `claude --resume <id> -p …` — resume an existing session
+ *
+ *   And the SDK (`@anthropic-ai/claude-agent-sdk`) gives us in-process
+ *   `query()` + `ClaudeSDKClient` for typed access to streaming events.
+ *
+ * This module:
+ *   1. Documents the CLI flag contract (so other modules don't have
+ *      to hardcode flag names).
+ *   2. Documents the on-disk session storage at `~/.claude/sessions/`.
+ *   3. Resolves the `claude` binary path (PATH first, then `npx
+ *      @anthropic-ai/claude-agent-sdk/cli`).
+ *   4. Provides small JSONL helpers for reading session message
+ *      history that the rest of the dashboard can use.
+ *
+ * Reference:
+ *   https://code.claude.com/docs/en/cli-reference
+ *
+ * No HTTP serve handshake, no Basic auth header, no SQLite DB. Claude
+ * Code reads API keys from the environment itself.
+ */
+
+import { existsSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { warn as loggerWarn } from './logger.mjs';
+
+const HOME = homedir();
+
+/**
+ * Canonical on-disk paths for Claude Code.
+ *
+ *   ~/.claude/             — root config + data dir (per Claude docs)
+ *   ~/.claude/sessions/    — one subdir per session
+ *     <sessionId>/
+ *       messages.jsonl     — conversation history (one JSON per line)
+ *
+ * Each messages.jsonl line is one of:
+ *   - {type:"user", message:{role:"user", content:[...]}}
+ *   - {type:"assistant", message:{role:"assistant", content:[...]}}
+ *   - {type:"system", subtype:"init", session_id, model, ...}
+ *   - {type:"result", subtype:"success"|"error_during_execution", ...}
+ */
+export const CLAUDE_HOME = join(HOME, '.claude');
+export const CLAUDE_SESSIONS_DIR = join(CLAUDE_HOME, 'sessions');
+
+/**
+ * Resolve the `claude` binary path. Tries (in order):
+ *   1. `process.env.CLAUDE_BIN` (override)
+ *   2. `claude` on PATH (the user-installed case)
+ *   3. `npx -y @anthropic-ai/claude-agent-sdk/cli` as a fallback
+ *
+ * Returns `{ bin, args }` so the caller can construct the right
+ * subprocess argv. The fallback uses `npx -y` so a fresh checkout
+ * can spawn Claude Code even when the CLI isn't installed globally.
+ *
+ * @returns {{ bin: string, args: string[] }}
+ */
+export function resolveClaudeCommand() {
+  if (process.env.CLAUDE_BIN && process.env.CLAUDE_BIN.trim()) {
+    return { bin: process.env.CLAUDE_BIN.trim(), args: [] };
+  }
+  return { bin: 'claude', args: [] };
+}
+
+/**
+ * Claude Code CLI flag contract (verified against
+ * https://code.claude.com/docs/en/cli-reference). Single source of
+ * truth — every other module reads flags from here so a Claude
+ * update only changes one file.
+ */
+export const CLAUDE_CLI_FLAGS = Object.freeze({
+  // Print / run modes
+  PRINT: '-p',
+  BACKGROUND: '--bg',
+  RESUME: '--resume',
+  SESSION_ID: '--session-id',
+  SESSION_TITLE: '--session-title',
+
+  // Model + agent
+  MODEL: '--model',
+  AGENT: '--agent',
+
+  // Working directory
+  ADD_DIR: '--add-dir',
+
+  // Output / wire format
+  OUTPUT_FORMAT: '--output-format',
+  VERBOSE: '--verbose',
+  JSON_FORMAT: 'json',
+
+  // Permission / autonomy
+  PERMISSION_MODE: '--permission-mode',
+  PERMISSION_BYPASS: 'bypassPermissions',
+  PERMISSION_PLAN: 'plan',
+  PERMISSION_DEFAULT: 'default',
+
+  // MCP + skills
+  MCP_CONFIG: '--mcp-config',
+
+  // Limits
+  MAX_TURNS: '--max-turns',
+});
+
+/**
+ * Claude Code stores sessions as JSONL. Normalize one parsed line
+ * into the dashboard's chat shape:
+ *
+ *   { id, role, content, ts, kind? }
+ *
+ * Accepts both v1 shapes (text directly on the message) and v2
+ * shapes (parts / blocks under `content`).
+ *
+ * @param {object} line  one entry from messages.jsonl
+ * @returns {{ id: string, role: string, content: string, ts: number, kind?: string }}
+ */
+export function normalizeClaudeMessage(line) {
+  if (!line || typeof line !== 'object') {
+    return { id: '', role: 'assistant', content: '', ts: Date.now() };
+  }
+  const t = typeof line.type === 'string' ? line.type : null;
+  const message = line.message || line;
+  const id =
+    (typeof message?.id === 'string' && message.id) ||
+    (typeof line.id === 'string' && line.id) ||
+    (typeof line.uuid === 'string' && line.uuid) ||
+    (typeof line.timestamp === 'string' && line.timestamp) ||
+    '';
+  const role = typeof message?.role === 'string' ? message.role : (t === 'user' ? 'user' : 'assistant');
+  const ts =
+    (typeof line.timestamp === 'string' ? Date.parse(line.timestamp) : NaN) ||
+    (typeof line.ts === 'number' ? line.ts : NaN) ||
+    (typeof message?.ts === 'number' ? message.ts : NaN) ||
+    Date.now();
+  const content = extractClaudeContent(message);
+  const out = { id: String(id), role: String(role), content, ts: typeof ts === 'number' && Number.isFinite(ts) ? ts : Date.now() };
+  if (t) out.kind = t;
+  return out;
+}
+
+/**
+ * Flatten a Claude Code message's `content` field into a single
+ * string. Handles:
+ *   - string content ("hello")
+ *   - array of blocks (text, tool_use, tool_result, image, …)
+ *   - legacy { text } wrapper
+ *
+ * Non-text blocks are skipped — they don't contribute to the chat
+ * surface but still appear in the JSONL for tooling.
+ */
+function extractClaudeContent(message) {
+  if (!message) return '';
+  if (typeof message.text === 'string') return stripThinkingTags(message.text);
+  const c = message.content;
+  if (typeof c === 'string') return stripThinkingTags(c);
+  if (!Array.isArray(c)) return '';
+  const text = c
+    .filter((p) => p && (p.type === 'text' || typeof p.text === 'string'))
+    .map((p) => (typeof p.text === 'string' ? p.text : ''))
+    .filter(Boolean)
+    .join('\n\n');
+  return stripThinkingTags(text);
+}
+
+/**
+ * Strip `<thinking>...</thinking>` blocks from model output so the
+ * chat UI doesn't render them as visible escaped HTML.
+ *
+ * Same shape as the v5.0.0 cline helper — kept here so chat
+ * rendering stays consistent across the migration.
+ */
+function stripThinkingTags(text) {
+  if (typeof text !== 'string') return '';
+  const cleaned = text
+    .replace(/<thinking\b[^>]*>[\s\S]*?<\/thinking>/gi, '')
+    .replace(/<thinking\b[^>]*\/?>/gi, '')
+    .replace(/<\/thinking>/gi, '');
+  return cleaned.replace(/\n{3,}/g, '\n\n').trim();
+}
+
+/**
+ * List every Claude Code session currently on disk. Reads
+ * `~/.claude/sessions/` and returns metadata derived from each
+ * `messages.jsonl` (first system/init line carries the model +
+ * session id; first user message carries the title).
+ *
+ * Returns `[]` when the directory doesn't exist (a fresh user has
+ * never run `claude`). Never throws.
+ *
+ * @returns {Array<{ id: string, title: string, createdAt: number, updatedAt: number, model?: string }>}
+ */
+export function listClaudeSessions() {
+  if (!existsSync(CLAUDE_SESSIONS_DIR)) return [];
+  let dirs;
+  try {
+    dirs = readdirSync(CLAUDE_SESSIONS_DIR, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch (err) {
+    loggerWarn('claude-info: listClaudeSessions readdir failed', { err: err instanceof Error ? err.message : String(err) });
+    return [];
+  }
+  const out = [];
+  for (const id of dirs) {
+    const file = join(CLAUDE_SESSIONS_DIR, id, 'messages.jsonl');
+    if (!existsSync(file)) continue;
+    const meta = readSessionMeta(file, id);
+    if (meta) out.push(meta);
+  }
+  out.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+  return out;
+}
+
+/**
+ * Read the metadata header for a single session (first init line +
+ * first user message + last mtime). Returns `null` on any failure.
+ *
+ * @param {string} file  absolute path to messages.jsonl
+ * @param {string} id    session id (the directory name)
+ */
+function readSessionMeta(file, id) {
+  let firstUserText = '';
+  let model = '';
+  let createdAt = 0;
+  let lastTs = 0;
+  let size = 0;
+  try {
+    const stat = statSync(file);
+    size = stat.size;
+    lastTs = stat.mtimeMs || 0;
+  } catch {
+    /* fall through — stat is best-effort */
+  }
+  try {
+    const text = readFileSync(file, 'utf8');
+    const lines = text.split('\n');
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line) continue;
+      let parsed;
+      try { parsed = JSON.parse(line); } catch { continue; }
+      if (parsed?.type === 'system' && parsed?.subtype === 'init') {
+        if (typeof parsed.session_id === 'string') id = parsed.session_id;
+        if (typeof parsed.model === 'string') model = parsed.model;
+        if (typeof parsed.timestamp === 'string') {
+          const t = Date.parse(parsed.timestamp);
+          if (Number.isFinite(t)) createdAt = createdAt || t;
+        }
+      }
+      if (parsed?.type === 'user' && !firstUserText) {
+        const content = parsed?.message?.content;
+        if (typeof content === 'string') firstUserText = content;
+        else if (Array.isArray(content)) {
+          const t = content.find((b) => b && (b.type === 'text' || typeof b.text === 'string'));
+          if (t && typeof t.text === 'string') firstUserText = t.text;
+        }
+        if (typeof parsed.timestamp === 'string') {
+          const t = Date.parse(parsed.timestamp);
+          if (Number.isFinite(t)) createdAt = createdAt || t;
+        }
+      }
+      if (typeof parsed?.timestamp === 'string') {
+        const t = Date.parse(parsed.timestamp);
+        if (Number.isFinite(t)) lastTs = Math.max(lastTs, t);
+      }
+    }
+  } catch {
+    return null;
+  }
+  const title = firstUserText
+    ? firstUserText.replace(/\s+/g, ' ').trim().slice(0, 80) || `Session ${id}`
+    : `Session ${id}`;
+  return {
+    id,
+    title,
+    createdAt: createdAt || lastTs || 0,
+    updatedAt: lastTs || createdAt || 0,
+    model: model || undefined,
+    size,
+  };
+}
+
+/**
+ * List every message in a session. Reads `messages.jsonl` from
+ * `~/.claude/sessions/<id>/` and normalizes each line via
+ * {@link normalizeClaudeMessage}.
+ *
+ * Returns `{ ok, messages }` on success; `{ ok: false, error }`
+ * when the file is missing or unreadable. Never throws.
+ *
+ * @param {string} sessionId
+ * @returns {{ ok: true, messages: ReturnType<typeof normalizeClaudeMessage>[] } | { ok: false, error: string }}
+ */
+export function listClaudeMessages(sessionId) {
+  if (!sessionId || typeof sessionId !== 'string') {
+    return { ok: false, error: 'sessionId is required' };
+  }
+  const file = join(CLAUDE_SESSIONS_DIR, sessionId, 'messages.jsonl');
+  if (!existsSync(file)) {
+    return { ok: false, error: `session ${sessionId} not found at ${file}` };
+  }
+  let text;
+  try {
+    text = readFileSync(file, 'utf8');
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+  const out = [];
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    let parsed;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    out.push(normalizeClaudeMessage(parsed));
+  }
+  return { ok: true, messages: out };
+}
+
+/**
+ * Read the most recent assistant text from a session — used by the
+ * bg-poller's html-artifact scanner (replaces the old
+ * `extractContentFromClineMessage` + `listClineMessages` flow).
+ *
+ * @param {string} sessionId
+ * @returns {string}
+ */
+export function readLastAssistantText(sessionId) {
+  const res = listClaudeMessages(sessionId);
+  if (!res.ok) return '';
+  for (let i = res.messages.length - 1; i >= 0; i -= 1) {
+    const m = res.messages[i];
+    if (m && m.role === 'assistant' && m.content) return m.content;
+  }
+  return '';
+}
+
+/**
+ * Resolve the on-disk worktree (directory) for a session by looking
+ * at the JSONL init line. Claude Code stores `cwd` and `addDir` on
+ * the system init event.
+ *
+ * Returns `null` when the session can't be found or has no cwd field.
+ *
+ * @param {string} sessionId
+ * @returns {string|null}
+ */
+export function resolveSessionWorktree(sessionId) {
+  if (!sessionId) return null;
+  const file = join(CLAUDE_SESSIONS_DIR, sessionId, 'messages.jsonl');
+  if (!existsSync(file)) return null;
+  try {
+    const text = readFileSync(file, 'utf8');
+    for (const raw of text.split('\n')) {
+      const line = raw.trim();
+      if (!line) continue;
+      let parsed;
+      try { parsed = JSON.parse(line); } catch { continue; }
+      if (parsed?.type === 'system' && parsed?.subtype === 'init') {
+        if (typeof parsed.cwd === 'string' && parsed.cwd) return resolve(parsed.cwd);
+        if (Array.isArray(parsed.addDir) && parsed.addDir.length > 0) {
+          const first = parsed.addDir.find((d) => typeof d === 'string' && d);
+          if (first) return resolve(first);
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Best-effort deletion of a session's on-disk directory. Idempotent.
+ *
+ * @param {string} sessionId
+ * @returns {{ ok: boolean, error?: string }}
+ */
+export function deleteClaudeSession(sessionId) {
+  if (!sessionId || typeof sessionId !== 'string') {
+    return { ok: false, error: 'sessionId is required' };
+  }
+  const dir = join(CLAUDE_SESSIONS_DIR, sessionId);
+  if (!existsSync(dir)) return { ok: true };
+  try {
+    rmSync(dir, { recursive: true, force: true });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// Exposed for tests / introspection.
+export const _claudeInfoInternals = {
+  CLAUDE_HOME,
+  CLAUDE_SESSIONS_DIR,
+  CLAUDE_CLI_FLAGS,
+  resolveClaudeCommand,
+  normalizeClaudeMessage,
+  listClaudeSessions,
+  listClaudeMessages,
+};

package/bizar-dash/src/server/{cline-runner.mjs → claude-runner.mjs}

@@ -1,16 +1,26 @@
 /**
- * bizar-dash/src/server/cline-runner.mjs
+ * bizar-dash/src/server/claude-runner.mjs
  *
- * v3.11.1 — Node child_process version of the cline-runner.
+ * v6.3.0 — Claude Code-native agent runner. Replaces the legacy
+ * cline-runner.mjs that spawned `cline run` subprocesses. This module
+ * spawns `claude -p` (print mode, blocking) or `claude --bg`
+ * (background, returns session id immediately).
  *
- * The plugin uses Bun.spawn (see plugins/bizar/src/cline-runner.ts);
- * the dashboard runs under Node and uses child_process.spawn. This
- * module keeps the two implementations in sync — same surface, same
- * log-format parsing, same exit semantics.
+ * Claude Code's CLI flags (from https://code.claude.com/docs/en/cli-reference):
+ *   -p "<prompt>"        : print mode (run, output, exit)
+ *   --output-format json : JSON-lines output (one message per line)
+ *   --model <model>      : sonnet | opus | haiku (or full ID)
+ *   --agent <name>       : pre-defined subagent name from .claude/agents/
+ *   --add-dir <path>     : add a working directory
+ *   --mcp-config <path>  : load MCP config from JSON
+ *   --session-id <id>    : resume a specific session
+ *   --verbose            : verbose logging to stderr
  *
- * See plugins/bizar/src/cline-runner.ts for the design rationale
- * and the structured-log wire format we parse.
+ * Background mode (--bg) keeps the agent alive in a daemon process.
+ * The output is monitored via the SDK (query() streams events) — for
+ * the dashboard's HTTP layer we just need: spawn, list, kill, status.
  */
+
 import { spawn } from 'node:child_process';
 import { createWriteStream, mkdirSync, existsSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -29,12 +39,13 @@ import { dirname } from 'node:path';
  *
  * @typedef {Object} SpawnAgentOptions
  * @property {string} prompt
- * @property {string} agent
- * @property {{ providerID: string, modelID: string }} [model]
+ * @property {string} [agent]          subagent name from .claude/agents/
+ * @property {string} [model]          sonnet | opus | haiku | provider/model
  * @property {string} worktree
  * @property {string} logPath
  * @property {string} [title]
  * @property {Object<string,string>} [env]
+ * @property {boolean} [background]    if true, run via `claude --bg` (persistent)
  * @property {number} [sessionIdTimeoutMs]
  *
  * @typedef {Object} SpawnAgentResult
@@ -48,8 +59,8 @@ import { dirname } from 'node:path';
 const agents = new Map();
 
 /**
- * Spawn a single `cline run` process. Resolves once the cline
- * child has reported its session id in the structured log stream
+ * Spawn a single `claude` (or `claude --bg`) process. Resolves once
+ * the child has reported its session id in the JSON output stream
  * (or once the process exits before that).
  *
  * @param {SpawnAgentOptions} opts
@@ -69,30 +80,32 @@ export function spawnAgent(opts) {
     }
   }
 
-  // 2. Build argv.
-  const args = [
-    'run',
-    '--dir', opts.worktree,
-    '--print-logs',
-    '--log-level', 'INFO',
-    '--title', opts.title || `bgr:${opts.agent}:${Date.now()}`,
-  ];
-  if (opts.model) {
-    args.push('--model', `${opts.model.providerID}/${opts.model.modelID}`);
-  }
-  args.push('--', opts.prompt);
+  // 2. Build argv. `claude --bg` keeps the session alive as a daemon;
+  // `claude -p` runs to completion and exits.
+  const args = [];
+  if (opts.background) args.push('--bg');
+  else args.push('-p', opts.prompt);
+
+  args.push('--output-format', 'json');
+  args.push('--verbose');
+  args.push('--add-dir', opts.worktree);
+  if (opts.title) args.push('--session-title', opts.title);
+  if (opts.agent) args.push('--agent', opts.agent);
+  if (opts.model) args.push('--model', opts.model);
 
-  // 3. Spawn the process.
+  // 3. Spawn the process. Prefer the `claude` binary on PATH; fall
+  //    back to `npx @anthropic-ai/claude-agent-sdk/cli` if not found.
   let proc;
   try {
-    proc = spawn('cline', args, {
+    proc = spawn('claude', args, {
+      cwd: opts.worktree,
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env, ...(opts.env || {}) },
     });
   } catch (err) {
     return Promise.resolve({
       ok: false,
-      error: `failed to spawn cline run: ${err.message}`,
+      error: `failed to spawn claude: ${err.message}`,
     });
   }
 
@@ -107,7 +120,10 @@ export function spawnAgent(opts) {
 
   // 5. Pipe stdout+stderr to the log file.
   const logStream = createWriteStream(opts.logPath, { flags: 'a' });
-  const sessionIdRegex = /message=created id=(ses_[A-Za-z0-9_]+)/;
+
+  // Claude Code prints session-id in the JSON-line stream as soon as
+  // the run starts. Pattern: {"type":"system","subtype":"init","session_id":"..."}
+  const sessionIdRegex = /"session_id"\s*:\s*"([A-Za-z0-9_-]{6,})"/;
   let sessionId;
 
   const resolveSpawnIfReady = (forceError) => {
@@ -123,15 +139,14 @@ export function spawnAgent(opts) {
     }
   };
 
-  // 6. Stream readers — line-buffered by splitting on newlines. We
-  //    append a [stdout]/[stderr] prefix for human readability.
+  // 6. Stream readers — line-buffered by splitting on newlines.
   const attachLineReader = (stream, label) => {
     let buf = '';
     stream.setEncoding('utf8');
     stream.on('data', (chunk) => {
       const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
       logStream.write(`[${label}] ${text}`);
-      if (label === 'stderr' && !sessionId) {
+      if (!sessionId) {
         buf += text;
         const m = buf.match(sessionIdRegex);
         if (m && m[1]) {
@@ -142,8 +157,7 @@ export function spawnAgent(opts) {
       }
     });
     stream.on('end', () => {
-      // Final flush attempt.
-      if (label === 'stderr' && !sessionId && buf) {
+      if (!sessionId && buf) {
         const m = buf.match(sessionIdRegex);
         if (m && m[1]) {
           sessionId = m[1];
@@ -171,11 +185,11 @@ export function spawnAgent(opts) {
         rec.status.state = 'done';
       } else {
         rec.status.state = 'failed';
-        rec.status.error = rec.status.error || `cline run exited with code ${exitCode}`;
+        rec.status.error = rec.status.error || `claude exited with code ${exitCode}`;
       }
     }
     if (!sessionId) {
-      resolveSpawnIfReady(rec.status.error || 'cline run exited before reporting session id');
+      resolveSpawnIfReady(rec.status.error || 'claude exited before reporting session id');
     }
     const cbs = rec.onExit.splice(0);
     for (const cb of cbs) {
@@ -199,7 +213,7 @@ export function spawnAgent(opts) {
     setTimeout(() => {
       if (!sessionId) {
         resolveSpawnIfReady(
-          `cline run did not report a session id within ${sessionIdTimeoutMs}ms`,
+          `claude did not report a session id within ${sessionIdTimeoutMs}ms`,
         );
       }
     }, sessionIdTimeoutMs);
@@ -208,8 +222,6 @@ export function spawnAgent(opts) {
 
 /**
  * Snapshot the current status of an agent.
- * @param {number} processId
- * @returns {AgentStatus | null}
  */
 export function getStatus(processId) {
   const rec = agents.get(processId);
@@ -218,11 +230,8 @@ export function getStatus(processId) {
 }
 
 /**
- * Subscribe to the exit event. Callback fires exactly once when
- * the process exits.
- * @param {number} processId
- * @param {(status: AgentStatus) => void} cb
- * @returns {() => void} unsubscribe
+ * Subscribe to the exit event. Callback fires exactly once when the
+ * process exits.
  */
 export function onExit(processId, cb) {
   const rec = agents.get(processId);
@@ -241,9 +250,6 @@ export function onExit(processId, cb) {
 
 /**
  * Kill the agent. Sends SIGTERM, waits up to 5s, then SIGKILL.
- * @param {number} processId
- * @param {'SIGTERM'|'SIGKILL'} [signal]
- * @returns {{ ok: boolean, error?: string }}
  */
 export function killAgent(processId, signal = 'SIGTERM') {
   const rec = agents.get(processId);
@@ -267,7 +273,6 @@ export function killAgent(processId, signal = 'SIGTERM') {
 
 /**
  * List every tracked agent.
- * @returns {AgentStatus[]}
  */
 export function list() {
   return Array.from(agents.values()).map((r) => ({ ...r.status }));
@@ -276,4 +281,4 @@ export function list() {
 /** For tests: clear the in-memory registry. */
 export function _resetForTests() {
   agents.clear();
-}
+}