neuralos 3.9.4 → 3.9.6

package/plugins/neuralos/neuralosEngine.mjs

@@ -1,369 +0,0 @@
-/**
- * neuralosEngine — the neuralOS runtime for the RTerm neuralos plugin.
- *
- * neuralOS instances are on-device data agents: each instance directory
- * carries a probe menu (needle_menu.json) over a real data source, the
- * 121M engine binary picks the probe that answers a question, and the
- * instance's bridge (Python) executes it against the source. Everything
- * here returns errors as data — a missing engine or instance is an
- * answer, never a thrown exception.
- *
- * Engine resolution order (first existing wins):
- *   1. settings.neuralos.engineBin/engineWeights (or NEURALOS_ENGINE_* env)
- *   2. the desktop bundle: {process.resourcesPath}/neuralos/<per-arch engine>
- *      (electron-builder extraResources; present in the packaged app only)
- *   3. the shared cache ~/.cache/neuralos/ (auto-downloaded on first use —
- *      this is what makes `npm i -g neuralos` self-provisioning: one fetch,
- *      then offline forever)
- *   4. <instancesRoot>/engine/needle (+ needle3.cact) — the fleet convention
- * If nothing exists and autoDownload is enabled, the cache is provisioned
- * from https://huggingface.co/Cactus-Compute/needle3 (public, no auth).
- */
-
-import { execFile as cpExecFile, spawn } from 'node:child_process'
-import { promises as fs, constants as fsConstants } from 'node:fs'
-import { homedir } from 'node:os'
-import path from 'node:path'
-
-export const HF_BASE = 'https://huggingface.co/Cactus-Compute/needle3/resolve/main'
-export const WEIGHTS_NAME = 'needle3.cact'
-export const MAX_RESULT_CHARS = 6000
-
-/** Per-arch bundled engine name, matching the release-workflow download. */
-export function bundledEngineName(platform, arch) {
-  const os = platform === 'darwin' ? 'macos' : platform === 'win32' ? 'windows' : 'linux'
-  if (os === 'macos') return arch === 'arm64' ? 'engine-macos-arm64' : null
-  if (os === 'linux') return arch === 'arm64' ? 'engine-linux-arm64' : arch === 'x64' ? 'engine-linux-x86_64' : null
-  return arch === 'arm64' ? 'engine-windows-arm64.exe' : arch === 'x64' ? 'engine-windows-x86_64.exe' : null
-}
-
-/** The HF platform folder for a bundled engine name. */
-export function hfFolderFor(platform, arch) {
-  const os = platform === 'darwin' ? 'macos' : platform === 'win32' ? 'windows' : 'linux'
-  if (os === 'macos') return 'macos-arm64'
-  if (os === 'linux') return arch === 'arm64' ? 'linux-arm64' : 'linux-x86_64'
-  return arch === 'arm64' ? 'windows-arm64' : 'windows-x86_64'
-}
-
-export function cacheDir(env = process.env) {
-  if (env.NEURALOS_CACHE_DIR) return env.NEURALOS_CACHE_DIR
-  return path.join(homedir(), '.cache', 'neuralos')
-}
-
-/** Settings block -> env -> default. Blank values mean unset. */
-function pick(settingsValue, envValue, fallback) {
-  const s = typeof settingsValue === 'string' ? settingsValue.trim() : ''
-  if (s) return s
-  const e = typeof envValue === 'string' ? envValue.trim() : ''
-  if (e) return e
-  return fallback
-}
-
-export function resolveConfig(ctx = {}, env = process.env) {
-  const settings = (typeof ctx.getSettings === 'function' ? ctx.getSettings() : ctx.settings) || {}
-  const block = settings.neuralos || {}
-  return {
-    instancesDir: pick(block.instancesDir, env.NEURALOS_INSTANCES_DIR, path.join(homedir(), 'neuralos-instances')),
-    pythonBin: pick(block.pythonBin, env.NEURALOS_PYTHON, 'python3'),
-    engineBin: pick(block.engineBin, env.NEURALOS_ENGINE_BIN) || null,
-    engineWeights: pick(block.engineWeights, env.NEURALOS_ENGINE_WEIGHTS) || null,
-    autoDownload: block.autoDownload !== false && env.NEURALOS_AUTO_DOWNLOAD !== '0',
-    cacheDir: pick(block.cacheDir, env.NEURALOS_CACHE_DIR, cacheDir(env)),
-    timeoutMs: Number(block.timeoutMs) > 0 ? Number(block.timeoutMs) : 120000,
-  }
-}
-
-/** Default execFile promisified; injectable for the spec. */
-export function defaultExec() {
-  return (cmd, args, opts = {}) =>
-    new Promise((resolve) => {
-      const execEnv = opts.env ? { ...process.env, ...opts.env } : process.env
-      const child = cpExecFile(cmd, args, { timeout: opts.timeoutMs ?? 120000, maxBuffer: 16 * 1024 * 1024, env: execEnv }, (err, stdout, stderr) => {
-        // err.code: 'EACCES'/'ENOENT'/'ETIMEDOUT' style codes, undefined for
-        // signal kills (e.g. our own timeout SIGTERM). Preserve the real
-        // code; a timeout must not masquerade as a generic exit 1.
-        let code = 0
-        if (err) {
-          code = typeof err.code === 'string' || typeof err.code === 'number' ? err.code : err.signal ? `killed (${err.signal})` : 1
-        }
-        resolve({ ok: !err, code, stdout: String(stdout ?? ''), stderr: String(stderr ?? '') })
-      })
-      void child
-    })
-}
-
-async function exists(p) {
-  try {
-    await fs.access(p, fsConstants.F_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * A candidate is USABLE only if the binary is actually EXECUTABLE.
- * Existence alone is not enough: electron-builder's extraResources copy and
- * curl-downloaded files routinely land with mode 0644 — spawning them dies
- * with EACCES ("engine exited EACCES:" with an empty stderr, the classic
- * symptom). We probe X_OK; where the path is OURS to manage (the shared
- * cache, the fleet-convention dir, an explicit override) we attempt a
- * one-shot chmod recovery and re-probe. The app bundle is NOT ours to
- * mutate — a 0644 bundled engine is skipped, never chmod'd, so a broken
- * bundle falls through to the next runnable engine instead of shadowing it.
- */
-async function executable(p, { recover = true } = {}) {
-  try {
-    await fs.access(p, fsConstants.X_OK)
-    return true
-  } catch {
-    if (!recover) return false
-    try {
-      await fs.chmod(p, 0o755)
-      await fs.access(p, fsConstants.X_OK)
-      return true
-    } catch {
-      return false
-    }
-  }
-}
-
-/** Download one file over HTTPS into dir with its basename (idempotent). */
-async function download(deps, url, dir) {
-  await fs.mkdir(dir, { recursive: true })
-  const target = path.join(dir, path.basename(url))
-  if (await exists(target)) return target
-  const tmp = `${target}.part`
-  if (!deps.fetchImpl) {
-    const res = await fetch(url, { redirect: 'follow' })
-    if (!res.ok) throw new Error(`download ${url} -> HTTP ${res.status}`)
-    const buf = Buffer.from(await res.arrayBuffer())
-    await fs.writeFile(tmp, buf)
-  } else {
-    await deps.fetchImpl(url, tmp)
-  }
-  await fs.rename(tmp, target)
-  return target
-}
-
-/**
- * Provision the shared cache with the weights + this platform's engine.
- * One-time (~36 MB); afterwards everything resolves offline. Injectable
- * fetch/download for the spec; the real path uses global fetch (Node >=18).
- */
-export async function ensureEngine(deps, { force = false } = {}) {
-  const engineName = bundledEngineName(deps.platform ?? process.platform, deps.arch ?? process.arch)
-  if (!engineName) return { error: `no published neuralOS engine for ${deps.platform ?? process.platform}-${deps.arch ?? process.arch}` }
-  const dir = deps.cacheDir ?? cacheDir()
-  const weightsPath = path.join(dir, WEIGHTS_NAME)
-  const enginePath = path.join(dir, engineName)
-  try {
-    if (force || !(await exists(weightsPath))) {
-      await download(deps, `${HF_BASE}/${WEIGHTS_NAME}`, dir)
-    }
-    if (force || !(await exists(enginePath))) {
-      await download(deps, `${HF_BASE}/${hfFolderFor(deps.platform ?? process.platform, deps.arch ?? process.arch)}/${engineName.startsWith('engine-windows') ? 'needle.exe' : 'needle'}`, dir)
-      // HF keeps upstream names; rename to the per-arch bundled name.
-      const raw = engineName.startsWith('engine-windows') ? 'needle.exe' : 'needle'
-      const rawPath = path.join(dir, raw)
-      if (rawPath !== enginePath && (await exists(rawPath))) await fs.rename(rawPath, enginePath)
-    }
-    await fs.chmod(enginePath, 0o755).catch(() => {})
-    return { engineBin: enginePath, engineWeights: weightsPath }
-  } catch (e) {
-    return { error: `engine auto-download failed: ${String(e?.message ?? e)}` }
-  }
-}
-
-export async function resolveEngine(cfg, deps = {}) {
-  const platform = deps.platform ?? process.platform
-  const arch = deps.arch ?? process.arch
-  const candidates = []
-  if (cfg.engineBin && cfg.engineWeights) candidates.push({ bin: cfg.engineBin, weights: cfg.engineWeights })
-  const resources = (deps.resourcesPath ?? process.resourcesPath) ?? undefined
-  const bundled = bundledEngineName(platform, arch)
-  if (resources && bundled) {
-    // the app bundle is not ours to chmod — probe, skip, never recover
-    candidates.push({ bin: path.join(resources, 'neuralos', bundled), weights: path.join(resources, 'neuralos', WEIGHTS_NAME), recover: false })
-  }
-  if (bundled) {
-    candidates.push({ bin: path.join(cfg.cacheDir, bundled), weights: path.join(cfg.cacheDir, WEIGHTS_NAME) })
-  }
-  candidates.push({ bin: path.join(cfg.instancesDir, 'engine', 'needle'), weights: path.join(cfg.instancesDir, 'engine', WEIGHTS_NAME) })
-  const skipped = []
-  for (const c of candidates) {
-    if (!(await exists(c.bin)) || !(await exists(c.weights))) continue
-    if (!(await executable(c.bin, { recover: c.recover !== false }))) {
-      // A present-but-unexecutable engine is a broken candidate, never a
-      // hard stop: record it and fall through to the next candidate.
-      skipped.push(c.bin)
-      continue
-    }
-    return { engineBin: c.bin, engineWeights: c.weights }
-  }
-  if (cfg.autoDownload) {
-    const ensured = await ensureEngine({ ...deps, cacheDir: cfg.cacheDir, platform, arch })
-    if (!ensured.error) return ensured
-    // autoDownload could not provision a usable engine either — surface
-    // BOTH failures so the operator can see why every path was exhausted.
-    return {
-      error: `neuralOS engine not usable: ${ensured.error}${skipped.length ? `; also found but not executable: ${skipped.join(', ')} (chmod +x them or set neuralos.engineBin/engineWeights)` : ''}`,
-    }
-  }
-  return {
-    error: `neuralOS engine not found or not executable${skipped.length ? ` (found but not executable: ${skipped.join(', ')} — chmod +x them or set neuralos.engineBin/engineWeights)` : ' — set neuralos.engineBin/engineWeights (settings), install the desktop bundle, or enable autoDownload'}`,
-  }
-}
-
-export function parseJsonObject(text) {
-  try {
-    return JSON.parse(text)
-  } catch {
-    const first = text.indexOf('{')
-    const last = text.lastIndexOf('}')
-    if (first === -1 || last <= first) return null
-    try {
-      return JSON.parse(text.slice(first, last + 1))
-    } catch {
-      return null
-    }
-  }
-}
-
-export async function listInstances(cfg, deps = {}) {
-  const readdir = deps.readdir ?? fs.readdir
-  const readFile = deps.readFile ?? fs.readFile
-  let entries
-  try {
-    entries = await readdir(cfg.instancesDir, { withFileTypes: true })
-  } catch {
-    return { error: `no instances directory at ${cfg.instancesDir} — set neuralos.instancesDir (settings) or NEURALOS_INSTANCES_DIR` }
-  }
-  const instances = []
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const dir = path.join(cfg.instancesDir, entry.name)
-    try {
-      const raw = await readFile(path.join(dir, 'needle_menu.json'), 'utf-8')
-      const menu = JSON.parse(raw)
-      if (!Array.isArray(menu)) continue
-      instances.push({ name: entry.name, probeCount: menu.length, probes: menu.slice(0, 40).map((t) => t.name) })
-    } catch {
-      continue
-    }
-  }
-  return instances
-}
-
-export async function instanceDirFor(cfg, instance) {
-  if (!/^[A-Za-z0-9._-]+$/.test(instance)) return { error: `invalid instance name: ${instance}` }
-  const dir = path.join(cfg.instancesDir, instance)
-  if (!(await exists(path.join(dir, 'needle_menu.json')))) {
-    return { error: `no instance named '${instance}' (see neuralos_list_instances)` }
-  }
-  return dir
-}
-
-export async function engineSelect(exec, engine, menuPath, question, opts = {}) {
-  let out
-  try {
-    out = await exec(engine.engineBin, ['--model', engine.engineWeights, '--tools', menuPath, '--prompt', question], { timeoutMs: opts.timeoutMs })
-  } catch (e) {
-    return { error: `engine execution failed: ${String(e?.message ?? e)}` }
-  }
-  if (out.code !== 0 && !out.stdout.trim()) {
-    // EACCES on spawn surfaces as code 'EACCES' with EMPTY stderr — the
-    // classic lost-exec-bit symptom. Name the fix instead of a bare code.
-    if (out.code === 'EACCES' || /EACCES|permission denied/i.test(String(out.stderr))) {
-      return {
-        error: `engine not executable (${engine.engineBin}) — restore the exec bit (chmod +x) or set neuralos.engineBin/engineWeights to a runnable binary`,
-      }
-    }
-    return { error: `engine exited ${out.code}: ${out.stderr.slice(0, 200)}` }
-  }
-  const parsed = parseJsonObject(out.stdout)
-  if (!parsed) return { error: `engine output not JSON: ${out.stdout.slice(0, 120)}` }
-  const calls = parsed.function_calls
-  if (!Array.isArray(calls) || calls.length === 0 || !calls[0]?.name) {
-    return { error: 'engine refused the question (no call selected)' }
-  }
-  return { pick: calls[0].name, args: calls[0].arguments ?? {}, confidence: typeof parsed.confidence === 'number' ? parsed.confidence : null }
-}
-
-const PROBE_RUNNER = [
-  'import json, os, sys',
-  'sys.path.insert(0, os.environ["NEURALOS_INSTANCE_DIR"])',
-  'import bridge',
-  'fn = getattr(bridge, os.environ["NEURALOS_PROBE"], None)',
-  'if fn is None:',
-  '    print(json.dumps({"error": "unknown probe", "probe": os.environ["NEURALOS_PROBE"]}))',
-  'else:',
-  '    print(json.dumps(fn(**json.loads(os.environ.get("NEURALOS_ARGS", "{}"))), default=str))',
-].join('\n')
-
-export async function executeProbe(exec, cfg, instanceDir, probe, args, opts = {}) {
-  const env = {
-    NEURALOS_INSTANCE_DIR: instanceDir,
-    NEURALOS_PROBE: probe,
-    NEURALOS_ARGS: JSON.stringify(args ?? {}),
-  }
-  let out
-  try {
-    out = await exec(cfg.pythonBin, ['-c', PROBE_RUNNER], { ...opts, env })
-  } catch (e) {
-    return { error: `probe execution failed: ${String(e?.message ?? e)}` }
-  }
-  if (out.code !== 0 && !out.stdout.trim()) return { error: `probe exited ${out.code}: ${out.stderr.slice(0, 200)}` }
-  const parsed = parseJsonObject(out.stdout)
-  if (!parsed || typeof parsed !== 'object') return { error: `probe output not JSON: ${out.stdout.slice(0, 120)}` }
-  return parsed
-}
-
-/**
- * Graph probes execute DIRECTLY by name (bypassing engine selection): probe
- * names follow the instance convention <prefix>_graph_<op>, and the 121M
- * model grounds numeric fragments poorly — direct execution is the fix.
- */
-export async function graphProbe(exec, cfg, instanceDir, input) {
-  if (!['overview', 'neighbors', 'connect'].includes(input.op)) return { error: `unknown graph op: ${input.op}` }
-  // A corrupt/unreadable menu is an answer, never a thrown exception —
-  // every other read path in this file already reports errors as data.
-  let menu
-  try {
-    const raw = await fs.readFile(path.join(instanceDir, 'needle_menu.json'), 'utf-8')
-    menu = JSON.parse(raw)
-    if (!Array.isArray(menu)) throw new Error('menu is not an array')
-  } catch (e) {
-    return { error: `instance menu unreadable: ${String(e?.message ?? e)}` }
-  }
-  const graphNames = menu.map((t) => t.name).filter((n) => n.includes('_graph_'))
-  const probe = graphNames.find((n) => n.endsWith(`_graph_${input.op}`))
-  if (!probe) return { error: `this instance has no ${input.op} graph probe`, available_graph_probes: graphNames }
-  const args = input.op === 'neighbors' ? { node: input.node ?? '' } : input.op === 'connect' ? { a: input.a ?? '', b: input.b ?? '' } : {}
-  const result = await executeProbe(exec, cfg, instanceDir, probe, args)
-  return { probe, ...result }
-}
-
-/**
- * Admin probes are write-capable bridge functions; the confirm='yes' literal
- * is the operator interlock (enforced at the tool schema) and this guard
- * keeps probe names to plain identifiers.
- */
-export async function adminProbe(exec, cfg, instanceDir, probe, args) {
-  if (!/^[A-Za-z0-9_]+$/.test(probe)) return { error: `invalid probe name: ${probe}` }
-  const result = await executeProbe(exec, cfg, instanceDir, probe, args ?? {})
-  return { probe, admin: true, result }
-}
-
-export function truncate(value, max = MAX_RESULT_CHARS) {
-  // JSON.stringify(undefined) is undefined (not a string) — a probe that
-  // returned nothing must not crash the tool; render it honestly instead.
-  const text = typeof value === 'string' ? value : JSON.stringify(value) ?? 'null'
-  if (text.length <= max) return text
-  return `${text.slice(0, max)}\n… (truncated at ${max} chars)`
-}
-
-/** Streamed engine invocation for long-running selections (unused by default). */
-export function engineSelectStreamed(engine, menuPath, question) {
-  return spawn(engine.engineBin, ['--model', engine.engineWeights, '--tools', menuPath, '--prompt', question], { stdio: ['ignore', 'pipe', 'pipe'] })
-}

package/plugins/neuralos/plugin.json

@@ -1,15 +0,0 @@
-{
-  "name": "neuralos",
-  "version": "1.0.0",
-  "description": "neuralOS instances as RTerm agent tools — on-device data agents over verified probe menus (chinook, cyberbank, aws, efraud, ...). The 121M neuralOS engine selects the probe for a plain-English question and the instance's Python bridge executes it against the real data source; the engine ships with the desktop bundle and the standalone backend auto-provisions ~/.cache/neuralos on first use. Four tools: neuralos_list_instances, neuralos_ask, neuralos_graph (relationship maps), neuralos_admin (write probes behind a confirm=\"yes\" interlock). Config in Settings (neuralos block: instancesDir, pythonBin, engineBin/engineWeights, autoDownload); instances root defaults to ~/neuralos-instances.",
-  "entry": "index.mjs",
-  "tools": [
-    "neuralos_list_instances",
-    "neuralos_ask",
-    "neuralos_graph",
-    "neuralos_admin"
-  ],
-  "permissions": [
-    "exec"
-  ]
-}

package/plugins/numbat-bridge/index.mjs

@@ -1,229 +0,0 @@
-/**
- * numbat-bridge — RTerm ↔ Numbat (endpoint AI-agent detection) integration.
- *
- * Numbat = EDR for AI agents: endpoint visibility, CEL detection, forensic
- * reconstruction. RTerm = control plane. This bridge wires them:
- *   - DEPLOY: install/manage the numbat binary + hooks on hosts (via playbooks/exec).
- *   - INGEST: accept Numbat findings (NDJSON records) delivered over HTTP or read
- *     from a local records file, normalize them, and feed RTerm triggers.
- *   - ACT: turn detections into governed actions (playbooks, MOP changes, incidents).
- *
- * Numbat detects; RTerm responds.
- *
- * Config (settings.numbat, or env):
- *   enabled        — master switch (default true)
- *   binaryPath     — path to the numbat binary (default "numbat" on PATH)
- *   recordsPath    — local NDJSON records file to tail (default ~/.numbat/records.ndjson)
- *   ingestToken    — bearer token the HTTP ingest endpoint requires (vault secretRef ok)
- *   minSeverity    — only ingest findings at/above this severity (info|low|medium|high|critical)
- */
-
-import { createRequire } from 'node:module'
-import { randomUUID } from 'node:crypto'
-
-const require = createRequire(import.meta.url)
-
-// ─── config ─────────────────────────────────────────────────────────────────
-
-export function resolveConfig(ctx = {}, env = process.env) {
-  const s = (typeof ctx.getSettings === 'function' ? ctx.getSettings() : ctx.settings) || {}
-  const b = s.numbat || {}
-  return {
-    enabled: b.enabled !== false,
-    binaryPath: b.binaryPath || env.NUMBAT_BIN || 'numbat',
-    recordsPath: b.recordsPath || env.NUMBAT_RECORDS || `${process.env.HOME}/.numbat/records.ndjson`,
-    ingestToken: b.ingestToken || undefined,
-    minSeverity: b.minSeverity || 'low',
-  }
-}
-
-const SEVERITY_ORDER = ['info', 'low', 'medium', 'high', 'critical']
-function severityAtLeast(sev, min) {
-  const i = SEVERITY_ORDER.indexOf(String(sev ?? 'info').toLowerCase())
-  const m = SEVERITY_ORDER.indexOf(String(min ?? 'low').toLowerCase())
-  return (i < 0 ? 0 : i) >= (m < 0 ? 0 : m)
-}
-
-// ─── record normalization ───────────────────────────────────────────────────
-
-/** Normalize a Numbat NDJSON record (event/finding/enforcement/indicator/scan) into
- * a compact RTerm finding. Returns null for records that shouldn't be ingested. */
-export function normalizeRecord(rec, cfg) {
-  if (!rec || typeof rec !== 'object') return null
-  const type = rec.record_type ?? rec.type ?? 'event'
-  const severity = rec.severity ?? rec.rule_severity ?? rec.level ?? 'info'
-  // Only findings + high-signal events become trigger inputs; raw events are noise.
-  const isFinding = type === 'finding' || type === 'enforcement' || type === 'indicator'
-  if (!isFinding && type === 'event' && !severityAtLeast(severity, 'high')) return null
-  if (!severityAtLeast(severity, cfg.minSeverity)) return null
-  return {
-    id: rec.id ?? rec.record_id ?? randomUUID(),
-    source: 'numbat',
-    recordType: type,
-    severity,
-    ruleId: rec.rule_id ?? rec.rule?.id ?? undefined,
-    title: rec.title ?? rec.rule_name ?? rec.rule?.name ?? type,
-    agent: rec.agent ?? rec.agent_id ?? rec.source?.agent ?? undefined,
-    host: rec.host ?? rec.hostname ?? rec.source?.host ?? undefined,
-    summary: rec.summary ?? rec.description ?? rec.content_preview ?? undefined,
-    ts: rec.ts ?? rec.timestamp ?? new Date().toISOString(),
-    raw: rec,
-  }
-}
-
-/** Parse an NDJSON blob (one JSON record per line) into normalized findings. */
-export function parseNdjson(text, cfg) {
-  const out = []
-  for (const line of String(text ?? '').split(/\r?\n/)) {
-    const t = line.trim()
-    if (!t) continue
-    try { const n = normalizeRecord(JSON.parse(t), cfg); if (n) out.push(n) } catch { /* skip malformed */ }
-  }
-  return out
-}
-
-// ─── deploy (run numbat commands on a host) ─────────────────────────────────
-
-/** Build the numbat CLI argv for a deploy action. Pure — testable. */
-export function buildDeployCommand(action, opts = {}) {
-  const agent = opts.agent || 'codex'
-  switch (action) {
-    case 'inventory': return ['agents']
-    case 'scan': return opts.agent ? ['scan', '--agent', agent] : ['scan']
-    case 'install-monitor': return ['hook', 'install', '--agent', agent, '--emit', opts.emit ?? 'all']
-    case 'install-enforce': return ['hook', 'install', '--agent', agent, '--emit', opts.emit ?? 'all', ...(opts.rulesDir ? ['--rules-dir', opts.rulesDir] : []), '--enforce']
-    case 'status': return ['hook', 'status', '--agent', agent]
-    case 'uninstall': return ['hook', 'uninstall', '--agent', agent]
-    default: throw new Error(`unknown numbat deploy action: ${action}`)
-  }
-}
-
-/** Run a numbat command via the plugin's exec capability (local or remote host). */
-async function runNumbat(ctx, cfg, argv, target) {
-  const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-  // Prefer the plugin exec/runCommand capability when available (policy-gated).
-  if (typeof ctx.runCommand === 'function') {
-    return ctx.runCommand({ command: cmdline, target })
-  }
-  if (typeof ctx.exec === 'function') {
-    return ctx.exec(cmdline, { target })
-  }
-  // Local fallback via child_process.
-  const { execFile } = require('node:child_process')
-  return new Promise((resolve) => {
-    execFile(cfg.binaryPath, argv, { timeout: 60000 }, (err, stdout, stderr) => {
-      resolve({ ok: !err, exitCode: err?.code ?? 0, stdout: String(stdout ?? ''), stderr: String(stderr ?? ''), error: err ? String(err.message) : undefined })
-    })
-  })
-}
-
-// ─── plugin registration ────────────────────────────────────────────────────
-
-async function guarded(fn, log) {
-  try { return await fn() } catch (e) {
-    const msg = e?.message ?? String(e)
-    log?.(`[numbat] ${msg}`)
-    return { error: msg, hint: 'Is numbat installed? (go install github.com/perplexityai/numbat/cmd/numbat@latest, or download a release). Configure settings.numbat.' }
-  }
-}
-
-export function register(ctx) {
-  const { registerTool, registerTrigger, registerPanel, log } = ctx
-  const cfg = resolveConfig(ctx)
-
-  registerTool({
-    name: 'numbat_health',
-    description: 'Check the numbat binary is present and report its version + the configured records path.',
-    params: {},
-    handler: async () => guarded(async () => {
-      const r = await runNumbat(ctx, cfg, ['version'])
-      return { binaryPath: cfg.binaryPath, recordsPath: cfg.recordsPath, ...r }
-    }, log),
-  })
-
-  registerTool({
-    name: 'numbat_deploy',
-    description: 'Deploy/manage numbat on a host: inventory agents, scan, install monitor-only or enforce hooks, check status, or uninstall. Runs the numbat CLI via the policy-gated exec path (local or a target host).',
-    params: {
-      action: { type: 'string', description: 'inventory | scan | install-monitor | install-enforce | status | uninstall' },
-      agent: { type: 'string', description: 'Target agent (e.g. codex)', optional: true },
-      target: { type: 'string', description: 'Host/terminal to run on (default local)', optional: true },
-      rulesDir: { type: 'string', description: 'Custom rules dir (for enforce)', optional: true },
-      emit: { type: 'string', description: 'Emit mode (default all)', optional: true },
-    },
-    handler: async (p) => guarded(async () => {
-      if (!p?.action) return { error: 'numbat_deploy needs an action' }
-      const argv = buildDeployCommand(p.action, p)
-      const r = await runNumbat(ctx, cfg, argv, p?.target)
-      return { action: p.action, argv, ...r }
-    }, log),
-  })
-
-  registerTool({
-    name: 'numbat_ingest',
-    description: 'Ingest Numbat NDJSON records (events/findings/enforcement/indicators) — normalize them into RTerm findings and fire the numbat_finding trigger for each. Pass ndjson text directly or read from the configured records file.',
-    params: {
-      ndjson: { type: 'string', description: 'NDJSON records (one JSON per line)', optional: true },
-      fromFile: { type: 'boolean', description: 'Read from recordsPath instead of inline ndjson', optional: true },
-    },
-    handler: async (p) => guarded(async () => {
-      let text = p?.ndjson
-      if (!text && (p?.fromFile || !p?.ndjson)) {
-        const fs = require('node:fs')
-        try { text = fs.readFileSync(cfg.recordsPath, 'utf8') } catch { text = '' }
-      }
-      const findings = parseNdjson(text ?? '', cfg)
-      // Fire a trigger event per finding (the trigger engine routes these).
-      if (typeof ctx.emitEvent === 'function') {
-        for (const f of findings) ctx.emitEvent({ source: 'numbat', ...f })
-      }
-      return { ingested: findings.length, findings }
-    }, log),
-  })
-
-  registerTool({
-    name: 'numbat_findings_summary',
-    description: 'Summarize Numbat findings from the records file by severity + rule + agent (quick threat picture).',
-    params: {},
-    handler: async () => guarded(async () => {
-      const fs = require('node:fs')
-      let text = ''
-      try { text = fs.readFileSync(cfg.recordsPath, 'utf8') } catch { /* none */ }
-      const findings = parseNdjson(text, { ...cfg, minSeverity: 'info' })
-      const bySeverity = {}
-      const byRule = {}
-      const byAgent = {}
-      for (const f of findings) {
-        bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1
-        if (f.ruleId) byRule[f.ruleId] = (byRule[f.ruleId] ?? 0) + 1
-        if (f.agent) byAgent[f.agent] = (byAgent[f.agent] ?? 0) + 1
-      }
-      return { total: findings.length, bySeverity, byRule, byAgent, recordsPath: cfg.recordsPath }
-    }, log),
-  })
-
-  registerTrigger({
-    name: 'numbat_finding',
-    description: 'Fires when a Numbat detection (finding/enforcement/indicator, or high-severity event) is ingested. Use to auto-remediate: isolate the host, kill the agent, open an incident, or run a playbook.',
-    match: (event) => {
-      if (event?.source !== 'numbat') return false
-      return severityAtLeast(event.severity, 'medium')
-    },
-    action: 'propose-change',
-  })
-
-  registerPanel({
-    name: 'numbat-findings',
-    title: 'Numbat Findings',
-    render: (data) => {
-      const rows = (Array.isArray(data) ? data : []).map((f) =>
-        `<tr><td>${f.severity ?? ''}</td><td>${f.title ?? ''}</td><td>${f.agent ?? ''}</td><td>${f.host ?? ''}</td></tr>`
-      ).join('')
-      return `<div class="numbat-findings"><h3>Numbat Findings</h3><p>Records: ${cfg.recordsPath}</p><table><thead><tr><th>Severity</th><th>Title</th><th>Agent</th><th>Host</th></tr></thead><tbody>${rows}</tbody></table></div>`
-    },
-  })
-
-  log(`[numbat] numbat-bridge registered: 4 tools, 1 trigger, 1 panel (bin=${cfg.binaryPath})`)
-}
-
-export default { register, resolveConfig, normalizeRecord, parseNdjson, buildDeployCommand }