@cirvix_ai/agent-control 0.1.5 → 0.2.0

package/src/core/theme.mjs

@@ -0,0 +1,240 @@
+/**
+ * Cirvix semantic theme system.
+ *
+ * Every color in the product goes through here. No file outside this one
+ * (and its thin re-export in `format.mjs`) may hardcode an ANSI code or call
+ * a raw color helper for a product meaning.
+ *
+ * Why semantic, not literal:
+ * - `allow` always means "this proceeded". If it is green-on-dark today and
+ *   bright-green-on-light tomorrow, every call site updates at once.
+ * - Themes become data: `cirvix theme light` swaps one table, not 40 files.
+ * - Accessibility (high-contrast, monochrome) is a theme, not a refactor.
+ * - Tests can assert meaning ("blocked renders with the block role") without
+ *   asserting escape bytes.
+ *
+ * Zero dependencies. Works with NO_COLOR / dumb terminals / pipes by
+ * producing plain text (same contract `format.mjs` always had).
+ */
+
+const ANSI = {
+  reset: "\x1b[0m",
+  bold: ["\x1b[1m", "\x1b[22m"],
+  dim: ["\x1b[2m", "\x1b[22m"],
+};
+
+/** Role names. Adding a role = adding a key here + every theme below. */
+export const ROLES = [
+  "text",
+  "muted",
+  "accent",
+  "allow",
+  "sanitize",
+  "block",
+  "hold",
+  "info",
+  "warning",
+  "error",
+  "border",
+  "surface",
+  "selection",
+];
+
+/**
+ * Themes are { role: [open, close] } ANSI pairs, or null for "no styling".
+ * Keep the numbers standard (30-37 / 90-97) so they survive SSH, tmux,
+ * Windows Terminal, and CI log renderers.
+ */
+const THEMES = {
+  dark: {
+    text: [37, 39], // white
+    muted: [90, 39], // bright black (grey)
+    accent: [36, 39], // cyan
+    allow: [32, 39], // green
+    sanitize: [36, 39], // cyan
+    block: [31, 39], // red
+    hold: [33, 39], // yellow
+    info: [34, 39], // blue
+    warning: [33, 39], // yellow
+    error: [31, 39], // red
+    border: [90, 39],
+    surface: null,
+    selection: [36, 39],
+  },
+  light: {
+    text: [30, 39], // black
+    muted: [90, 39],
+    accent: [36, 39],
+    allow: [32, 39], // green reads on light bg; darker terminals vary but stay legible
+    sanitize: [36, 39],
+    block: [31, 39],
+    hold: [33, 39],
+    info: [34, 39],
+    warning: [33, 39],
+    error: [31, 39],
+    border: [90, 39],
+    surface: null,
+    selection: [36, 39],
+  },
+  midnight: {
+    text: [97, 39], // bright white
+    muted: [34, 39], // dim blue-grey feel
+    accent: [95, 39], // bright magenta
+    allow: [92, 39], // bright green
+    sanitize: [96, 39], // bright cyan
+    block: [91, 39], // bright red
+    hold: [93, 39], // bright yellow
+    info: [94, 39], // bright blue
+    warning: [93, 39],
+    error: [91, 39],
+    border: [35, 39], // magenta borders
+    surface: null,
+    selection: [95, 39],
+  },
+  "high-contrast": {
+    text: [97, 39],
+    muted: [37, 39], // no dim grey — everything legible
+    accent: [93, 39],
+    allow: [92, 39],
+    sanitize: [96, 39],
+    block: [91, 39],
+    hold: [93, 39],
+    info: [94, 39],
+    warning: [93, 39],
+    error: [91, 39],
+    border: [97, 39],
+    surface: null,
+    selection: [93, 39],
+  },
+  monochrome: {
+    text: null,
+    muted: null,
+    accent: null,
+    allow: null,
+    sanitize: null,
+    block: null,
+    hold: null,
+    info: null,
+    warning: null,
+    error: null,
+    border: null,
+    surface: null,
+    selection: null,
+  },
+};
+
+export const THEME_NAMES = Object.keys(THEMES);
+
+let current = process.env.CIRVIX_THEME && THEMES[process.env.CIRVIX_THEME]
+  ? process.env.CIRVIX_THEME
+  : "dark";
+
+function colorEnabled() {
+  if (process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true") return true;
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.TERM === "dumb") return false;
+  if (process.env.CIRVIX_THEME === "monochrome") return false;
+  // Non-TTY (pipes, CI logs) → plain text. Same rule format.mjs always had.
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+
+function wrapAnsi(open, close) {
+  return (s) => (colorEnabled() ? `\x1b[${open}m${String(s)}\x1b[${close}m` : String(s));
+}
+
+/** Set the active theme. Returns the name set. Throws on unknown names. */
+export function setTheme(name) {
+  if (!THEMES[name]) throw new Error(`Unknown theme "${name}". Available: ${THEME_NAMES.join(", ")}`);
+  current = name;
+  return current;
+}
+
+/** Active theme name. */
+export function themeName() {
+  return current;
+}
+
+/** Raw role → ANSI pair for the active theme (or null). */
+export function roleAnsi(role) {
+  return THEMES[current]?.[role] ?? null;
+}
+
+/**
+ * Style a string with a semantic role: `style("BLOCKED", "block")`.
+ * Unknown roles pass through unstyled rather than throwing — a theme
+ * must never break enforcement output.
+ */
+export function style(text, role) {
+  const pair = THEMES[current]?.[role];
+  if (!pair || !colorEnabled()) return String(text);
+  return `\x1b[${pair[0]}m${String(text)}\x1b[${pair[1]}m`;
+}
+
+/** Bold / dim are emphasis, not color — they survive monochrome. */
+export function bold(s) {
+  if (!colorEnabled()) return String(s);
+  return `${ANSI.bold[0]}${String(s)}${ANSI.bold[1]}`;
+}
+
+export function dim(s) {
+  if (process.env.CIRVIX_THEME === "high-contrast") return String(s); // contrast: never dim
+  if (!colorEnabled()) return String(s);
+  return `${ANSI.dim[0]}${String(s)}${ANSI.dim[1]}`;
+}
+
+/**
+ * The semantic palette. Prefer `colors.block("…")` over importing raw
+ * helpers — call sites name the meaning, this file owns the rendering.
+ */
+export const colors = {
+  get text() { return (s) => style(s, "text"); },
+  get muted() { return (s) => style(s, "muted"); },
+  get accent() { return (s) => style(s, "accent"); },
+  get allow() { return (s) => style(s, "allow"); },
+  get sanitize() { return (s) => style(s, "sanitize"); },
+  get block() { return (s) => style(s, "block"); },
+  get hold() { return (s) => style(s, "hold"); },
+  get info() { return (s) => style(s, "info"); },
+  get warning() { return (s) => style(s, "warning"); },
+  get error() { return (s) => style(s, "error"); },
+  get border() { return (s) => style(s, "border"); },
+  get selection() { return (s) => style(s, "selection"); },
+};
+
+/** Decision → theme role. Single mapping, used by every renderer. */
+export function roleForDecision(decision) {
+  switch (String(decision ?? "").toLowerCase()) {
+    case "allow": return "allow";
+    case "sanitize": return "sanitize";
+    case "deny": return "block";
+    case "require_approval": return "hold";
+    case "audit_only": return "muted";
+    default: return "muted";
+  }
+}
+
+/** Risk → theme role. */
+export function roleForRisk(risk) {
+  switch (String(risk ?? "").toLowerCase()) {
+    case "critical": return "error";
+    case "high": return "warning";
+    case "medium": return "info";
+    case "low": return "muted";
+    default: return "muted";
+  }
+}
+
+/** Decision → icon + label. Icon is never the only signal (a11y). */
+export function badgeForDecision(decision) {
+  switch (String(decision ?? "").toLowerCase()) {
+    case "allow": return { icon: "✓", label: "ALLOWED" };
+    case "sanitize": return { icon: "◇", label: "SANITIZED" };
+    case "deny": return { icon: "✕", label: "BLOCKED" };
+    case "require_approval": return { icon: "◷", label: "HELD FOR APPROVAL" };
+    case "audit_only": return { icon: "○", label: "AUDIT ONLY" };
+    default: return { icon: "?", label: String(decision ?? "UNKNOWN").toUpperCase() };
+  }
+}
+
+export { wrapAnsi };

package/src/index.mjs

@@ -140,6 +140,48 @@ export { scan } from "./commands/scan.mjs";
 export { init, STARTER_POLICY } from "./commands/init.mjs";
 export { status } from "./commands/status.mjs";
 export { demo } from "./commands/demo.mjs";
+export { consoleCmd as console } from "./commands/console.mjs";
+export { onboard } from "./commands/onboard.mjs";
+
+/* Product UI (engine stays presentation-free; these render events) -------- */
+export {
+  THEME_NAMES,
+  THEME_NAMES as THEMES,
+  ROLES,
+  badgeForDecision,
+  colors,
+  roleForDecision,
+  roleForRisk,
+  setTheme,
+  style,
+  themeName,
+} from "./core/theme.mjs";
+export {
+  EVENT,
+  EventBus,
+  attachPipeline,
+  createEvent,
+  initialState,
+  latencyStats,
+  reduce,
+} from "./core/events.mjs";
+export {
+  blockedCard,
+  cirvixRow,
+  explainDecision,
+  frame,
+  header,
+  heldCard,
+  policyCard,
+  rule,
+  spinnerFrame,
+  toolCard,
+  userRow,
+} from "./tui/cards.mjs";
+export { statusBar } from "./tui/status.mjs";
+export { activitySummary, collapsedFeed, activityRow } from "./tui/activity.mjs";
+export { COMMANDS, filterCommands, paletteBox } from "./tui/palette.mjs";
+export { ConsoleApp, parseRequest } from "./tui/app.mjs";
 export { check as policyCheck, explain as policyExplain, list as policyList, loadPolicyFile, test as policyTest } from "./commands/policy.mjs";
 
 /* Adapters & Platform ---------------------------------------------------- */

package/src/tui/activity.mjs

@@ -0,0 +1,71 @@
+/**
+ * Collapsible activity feed — the fix for the "wall of logs".
+ *
+ * 100 tool calls never dump as 100 lines. They collapse to:
+ *
+ *   ✓ Deployment completed
+ *     14 actions  ├─ 8 allowed  ├─ 4 sanitized  └─ 2 blocked
+ *     [Enter] inspect
+ *
+ * Expanding (Enter / click / `inspect`) shows the per-call rows with the
+ * semantic badge (icon + color + WORD — never icon alone).
+ */
+
+import { style, bold, dim, badgeForDecision, roleForDecision } from "../core/theme.mjs";
+
+export function activitySummary(activity) {
+  const counts = { allow: 0, sanitize: 0, deny: 0, require_approval: 0, audit_only: 0 };
+  for (const e of activity) {
+    const d = e.decision ?? e.raw?.decision ?? "allow";
+    if (d in counts) counts[d]++;
+  }
+  return { total: activity.length, ...counts };
+}
+
+export function collapsedFeed(activity, { expanded = false, maxRows = 8 } = {}) {
+  const sum = activitySummary(activity);
+  if (sum.total === 0) return dim("No activity yet. Ask Cirvix to evaluate something.");
+
+  const head = `${style("✓", "allow")} ${bold(summaryTitle(sum))}\n\n` +
+    `  ${dim(`${sum.total} actions`)}\n` +
+    `  ${dim("├─")} ${sum.allow} allowed\n` +
+    `  ${dim("├─")} ${sum.sanitize} sanitized\n` +
+    `  ${dim("└─")} ${sum.deny + sum.require_approval} blocked/held\n\n` +
+    `  ${dim("[Enter] inspect")}`;
+
+  if (!expanded) return head;
+
+  const rows = activity.slice(-maxRows).map((e) => activityRow(e)).join("\n");
+  const more = sum.total > maxRows ? dim(`  … ${sum.total - maxRows} earlier (collapsed)`) + "\n" : "";
+  return `▼ ${bold("Activity")}\n\n${more}${rows}`;
+}
+
+function summaryTitle(sum) {
+  if (sum.deny > 0) return `Session activity — ${sum.deny} blocked`;
+  if (sum.require_approval > 0) return `Session activity — ${sum.require_approval} held`;
+  return `Session activity — all clear`;
+}
+
+export function activityRow(event) {
+  const d = event.decision ?? event.raw?.decision ?? "allow";
+  const badge = badgeForDecision(d);
+  const role = roleForDecision(d);
+  const when = clock(event.ts);
+  const tool = event.tool ?? event.raw?.tool ?? "—";
+  const target = truncate(event.resource ?? event.raw?.resource ?? "", 36);
+  const suffix = d === "deny" ? style(" → blocked", "block")
+    : d === "sanitize" ? style(" → sanitized", "sanitize")
+    : d === "require_approval" ? style(" → held", "hold")
+    : "";
+  return `  ${dim(when)}  ${style(`${badge.icon} ${tool}`, role)}${target ? dim(`  ${target}`) : ""}${suffix}`;
+}
+
+function clock(ts) {
+  const m = String(ts ?? "").match(/T(\d{2}:\d{2}:\d{2})/);
+  return m ? m[1] : "--:--:--";
+}
+
+function truncate(s, n) {
+  const v = String(s ?? "");
+  return v.length <= n ? v : `…${v.slice(-(n - 1))}`;
+}

package/src/tui/app.mjs

@@ -0,0 +1,292 @@
+/**
+ * Cirvix console — the primary interactive UX.
+ *
+ * Layout (wide terminals):
+ *   ┌ header ────────────────────────────────┐
+ *   │ CONVERSATION            │ ACTIVITY     │
+ *   │ user asks / cirvix      │ ◐ policy.eval│
+ *   │ responds / policy cards │ ✓ shell.exec │
+ *   ├ composer ──────────────────────────────┤
+ *   │ status bar                             │
+ *   └────────────────────────────────────────┘
+ *
+ * Narrow terminals (<90 cols): the activity pane collapses into the
+ * transcript automatically. No horizontal scrolling, ever.
+ *
+ * Engine separation: the app owns a Pipeline + EventBus. It emits events,
+ * reduces them to state, and renders cards from state. Policy code never
+ * touches the terminal.
+ *
+ * Non-TTY / piped usage: `runOnce(text)` evaluates one line and returns
+ * the rendered output without starting readline — used by tests, CI, and
+ * `echo "…" | cirvix console`.
+ */
+
+import { Pipeline } from "../core/pipeline.mjs";
+import { decideNow } from "../core/journal.mjs";
+import { EventBus, createEvent, initialState, reduce, attachPipeline } from "../core/events.mjs";
+import { header, policyCard, toolCard, blockedCard, heldCard, explainDecision, userRow, cirvixRow, spinnerFrame } from "./cards.mjs";
+import { statusBar } from "./status.mjs";
+import { collapsedFeed } from "./activity.mjs";
+import { paletteBox } from "./palette.mjs";
+import { setTheme, THEME_NAMES, bold, dim, style } from "../core/theme.mjs";
+import { startComposer } from "./composer.mjs";
+
+const VERSION = "0.1.0";
+
+export class ConsoleApp {
+  constructor({ cwd = process.cwd(), rules = [], mode = "enforce", agent = "local", write = (s) => process.stdout.write(s) } = {}) {
+    this.cwd = cwd;
+    this.rules = rules;
+    this.agent = agent;
+    this.write = write;
+    this.bus = new EventBus();
+    this.state = initialState();
+    this.state.status.mode = mode;
+    this.expanded = false;
+    this.overlay = null; // 'palette' | null
+
+    this.pipeline = new Pipeline({ rules, cwd, agent, mode, onEvent: () => {} });
+    attachPipeline(this.pipeline, this.bus);
+    this.bus.onAny((e) => {
+      this.state = reduce(this.state, e);
+    });
+    this.bus.emit(createEvent.sessionStarted({ agent }));
+  }
+
+  /* ---------------------------------------------------------- rendering */
+
+  renderHeader() {
+    return header({ mode: this.state.status.mode === "audit" ? "AUDIT MODE" : "PROTECTED", version: VERSION });
+  }
+
+  renderStatus() {
+    return statusBar(this.state, { version: VERSION });
+  }
+
+  renderActivity() {
+    return collapsedFeed(this.state.activity, { expanded: this.expanded });
+  }
+
+  /** Full re-render of the transcript region (used on clear / toggle). */
+  renderTranscript() {
+    const out = [this.renderHeader(), ``];
+    for (const m of this.state.messages) {
+      out.push(m.role === "user" ? userRow(m.text) : cirvixRow(m.text), ``);
+    }
+    if (this.narrow()) {
+      out.push(`▼ Activity`, this.renderActivity(), ``);
+    }
+    out.push(this.renderStatus());
+    return out.join("\n");
+  }
+
+  narrow() {
+    return (process.stdout.columns ?? 80) < 90;
+  }
+
+  /* ------------------------------------------------------------- events */
+
+  /** Animated "evaluating" line. Resolves with a stop() that clears it. */
+  animate(label) {
+    if (!process.stdout.isTTY) {
+      this.write(`${dim("◐")} ${label}...\n`);
+      return () => {};
+    }
+    let i = 0;
+    const timer = setInterval(() => {
+      process.stdout.write(`\r${dim(spinnerFrame(i++))} ${dim(label)}...`);
+    }, 90);
+    return () => {
+      clearInterval(timer);
+      process.stdout.write("\r" + " ".repeat(label.length + 6) + "\r");
+    };
+  }
+
+  /** Evaluate one free-text line through policy and render the product UI. */
+  async runOnce(input) {
+    const text = String(input ?? "").trim();
+    if (!text) return "";
+    if (text.startsWith("/")) return this.runSlash(text);
+
+    this.bus.emit(createEvent.userMessage(text));
+    const lines = [userRow(text), ``, cirvixRow(`${dim("◐ Evaluating authorization...")}`)];
+    const stop = this.animate("Evaluating policy");
+    const parsed = parseRequest(text, { agent: this.agent });
+    let decision;
+    try {
+      ({ decision } = decideNow({ ...parsed, rules: this.rules, cwd: this.cwd }));
+    } finally {
+      stop();
+    }
+    const event = {
+      decision_id: `dec_local`,
+      request_id: `req_local`,
+      agent: this.agent,
+      tool: parsed.tool,
+      resource: parsed.args.path ?? parsed.args.url ?? parsed.args.command ?? "",
+      risk: decision.risk ?? "medium",
+      decision: decision.decision ?? "deny",
+      policy: decision.rule,
+      reason: decision.reason,
+      latency_ms: 0,
+    };
+    this.bus.emit(createEvent.policyDecision(event));
+    if (event.decision === "require_approval") this.bus.emit(createEvent.approvalRequested({ tool: event.tool, resource: event.resource }));
+    this.bus.emit(createEvent.agentMessage(`Decision: ${event.decision}`));
+
+    return [...lines, ``, this.renderDecision(event, parsed), ``, this.renderStatus()].join("\n");
+  }
+
+  renderDecision(event, parsed = {}) {
+    const d = event.decision;
+    if (d === "deny") {
+      const target = event.resource || parsed.args?.command || "";
+      return [blockedCard({ tool: event.tool, target, policy: event.policy, reason: event.reason }), ``, explainDecision(event)].join("\n");
+    }
+    if (d === "require_approval") {
+      return heldCard({ tool: event.tool, target: event.resource, approvers: event.approvers ?? [], reason: event.reason });
+    }
+    return [
+      policyCard({
+        action: event.tool,
+        risk: event.risk,
+        policy: event.policy ?? "default",
+        identity: `agent:${event.agent}`,
+        reason: event.reason,
+        latencyMs: event.latency_ms,
+      }),
+      ...(d === "sanitize" ? [``, explainDecision(event)] : []),
+    ].join("\n");
+  }
+
+  /* ---------------------------------------------------------------- slash */
+
+  async runSlash(input) {
+    const [cmd, ...rest] = input.trim().split(/\s+/);
+    const arg = rest.join(" ");
+    switch (cmd.toLowerCase()) {
+      case "/help":
+        return paletteBox("/");
+      case "/quit":
+      case "/exit":
+        return "quit";
+      case "/clear":
+        return "\x1b[2J\x1b[0;0H" + this.renderTranscript();
+      case "/expand":
+        this.expanded = true;
+        return this.renderActivity();
+      case "/collapse":
+        this.expanded = false;
+        return this.renderActivity();
+      case "/theme": {
+        if (!arg) return `Usage: /theme <${THEME_NAMES.join("|")}>\nCurrent: ${bold(process.env.CIRVIX_THEME ?? "dark")}`;
+        try {
+          setTheme(arg);
+          process.env.CIRVIX_THEME = arg;
+          return `${style("✓", "allow")} Theme → ${bold(arg)}`;
+        } catch (err) {
+          return `${style("✕", "block")} ${err.message}`;
+        }
+      }
+      case "/audit":
+      case "/logs":
+        return this.renderActivity();
+      case "/policies": {
+        const names = this.rules.map((r) => `  • ${r.name ?? "(unnamed)"}  ${dim(r.effect ?? "")}`).join("\n");
+        return `${bold("Policies")} ${dim(`(${this.rules.length} rules)`)}\n${names || dim("  (no rules loaded)")}`;
+      }
+      case "/sessions":
+        return `${bold("Session")}  ${this.state.session?.id ?? "—"}  ${dim(`agent ${this.state.session?.agent ?? this.agent}`)}\n${dim(`${this.state.status.requests} requests this session`)}`;
+      case "/doctor":
+        return doctor(this.rules, this.state);
+      case "/demo":
+        return dim("Run `cirvix demo` in a fresh terminal for the full live interception demo.");
+      case "/approvals": {
+        if (!this.state.approvals.length) return dim("nothing waiting on a human");
+        return this.state.approvals.map((a) => `  ${bold(a.approval_id ?? a.id ?? "approval")}  ${a.tool ?? ""}  ${dim(a.resource ?? "")}`).join("\n");
+      }
+      case "/config":
+        return `${bold("Config")}\n  ${dim("theme")}  ${process.env.CIRVIX_THEME ?? "dark"}\n  ${dim("agent")}  ${this.agent}\n  ${dim("mode")}   ${this.state.status.mode}`;
+      default: {
+        // Prefix completion: "/pol" → show matches instead of erroring.
+        const { filterCommands } = await import("./palette.mjs");
+        const matches = filterCommands(input);
+        if (matches.length) return paletteBox(input);
+        return dim(`Unknown command "${cmd}". Type / for the palette.`);
+      }
+    }
+  }
+
+  /* ---------------------------------------------------------- interactive */
+
+  async start() {
+    this.write(this.renderTranscript() + "\n\n");
+    this.write(dim("Type / for commands. Ctrl+K palette · Ctrl+O activity · Esc close.\n"));
+    const rl = startComposer({
+      prompt: "> ",
+      onLine: async (line) => {
+        if (!line) return;
+        if (line === "/quit" || line === "/exit") return "quit";
+        const out = await this.runOnce(line);
+        if (out === "quit") return "quit";
+        this.write("\n" + out + "\n\n");
+        if (!this.narrow()) {
+          // Side-pane refresh on wide terminals: reprint compact activity.
+          this.write(dim("─ Activity ─") + "\n" + this.renderActivity() + "\n\n" + this.renderStatus() + "\n");
+        }
+      },
+      onKey: (key) => {
+        if (key === "toggle-activity") {
+          this.expanded = !this.expanded;
+          this.write("\n" + this.renderActivity() + "\n");
+        } else if (key === "palette") {
+          this.write("\n" + paletteBox("/") + "\n");
+        } else if (key === "policies") {
+          this.write("\n" + `Policies: ${this.rules.length} loaded` + "\n");
+        }
+      },
+    });
+    await new Promise((resolve) => rl.on("close", resolve));
+    this.bus.emit(createEvent.sessionEnded({}));
+    this.write("\n" + dim("Session ended. Audit chain intact.") + "\n");
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Heuristic: turn "Can the deploy bot run `rm -rf /`?" into a policy
+ * request. Deliberately conservative — unknown shapes become a low-risk
+ * workspace read that policy will judge on its merits, never an implicit
+ * permit of something dangerous.
+ */
+export function parseRequest(text, { agent = "local" } = {}) {
+  const t = String(text);
+  const url = t.match(/https?:\/\/[^\s"'`]+/i)?.[0];
+  const credPath = t.match(/(~\/\.aws\/credentials|\.env[^\s]*|\.aws[^\s]*)/i)?.[0];
+  const cmd = t.match(/`([^`]+)`/)?.[1] ?? t.match(/run\s+"([^"]+)"/i)?.[1];
+
+  if (credPath) return { tool: "read_file", server: null, args: { path: credPath }, agent };
+  if (url && /collect|attacker|exfil|send|post/i.test(t)) {
+    return { tool: "http_request", server: null, args: { url }, agent };
+  }
+  if (url) return { tool: "http_request", server: null, args: { url }, agent };
+  if (cmd) return { tool: "shell_exec", server: null, args: { command: cmd }, agent };
+  if (/deploy|production/i.test(t)) return { tool: "shell_exec", server: null, args: { command: "deploy production" }, agent };
+  if (/database|db|sql/i.test(t)) return { tool: "db_query", server: null, args: { sql: t.slice(0, 200) }, agent };
+  return { tool: "read_file", server: null, args: { path: "./" + t.slice(0, 60) }, agent };
+}
+
+function doctor(rules, state) {
+  const rows = [
+    ["Engine", style("✓ reachable", "allow")],
+    ["Rules", rules.length ? `${rules.length} loaded` : style("none — run cirvix init", "warning")],
+    ["Session", `${state.status.requests} requests`],
+    ["Blocked", state.status.blocked > 0 ? style(`${state.status.blocked} denied`, "block") : "0"],
+    ["Terminal", `${process.stdout.columns ?? 80} cols ${process.stdout.isTTY ? "(TTY)" : "(piped)"}`],
+  ];
+  return `${bold("Doctor")}\n` + rows.map(([k, v]) => `  ${dim(k.padEnd(9))} ${v}`).join("\n");
+}