dsh-ensp 0.1.9 → 0.2.0

package/src/core/doctor.mjs

@@ -0,0 +1,350 @@
+/**
+ * Environment self-check.
+ *
+ * Every failure this project has hit in the field was an environment problem
+ * masquerading as a code problem: a missing device image made eNSP quit after
+ * rendering, a window covered by another application swallowed every click, and
+ * a non-interactive session accepted `SendInput` while never delivering it. All
+ * three look identical from the outside — "nothing happened".
+ *
+ * `doctor()` turns those into explicit, checkable facts before a lab starts, and
+ * every failing check carries the fix in the same object. It never starts eNSP.
+ *
+ * @module dsh-ensp/doctor
+ */
+
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { checkTopologySupport, probeDevice } from './compat.mjs'
+import { DEFAULT_ANCHORS, calibrateAnchors } from './calibrate.mjs'
+import { enspPid, locateWindow } from './launcher.mjs'
+
+export const DEFAULT_ENSP_EXE = 'E:\\Huawei\\eNSP\\eNSP_Client.exe'
+export const DEFAULT_VBOX = 'E:\\VirtualBox\\VBoxManage.exe'
+
+const MIN_FREE_MEMORY_MB = 1024
+
+/** PowerShell helper that answers "does synthetic input reach this session?". */
+const INPUT_PROBE = String.raw`
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public class EnspInputProbe {
+  [StructLayout(LayoutKind.Sequential)] public struct LASTINPUTINFO { public uint cbSize; public uint dwTime; }
+  [StructLayout(LayoutKind.Sequential)] public struct MOUSEINPUT { public int dx; public int dy; public uint mouseData; public uint dwFlags; public uint time; public IntPtr dwExtraInfo; }
+  [StructLayout(LayoutKind.Sequential)] public struct KEYBDINPUT { public ushort wVk; public ushort wScan; public uint dwFlags; public uint time; public IntPtr dwExtraInfo; }
+  [StructLayout(LayoutKind.Explicit)] public struct INPUTUNION { [FieldOffset(0)] public MOUSEINPUT mi; [FieldOffset(0)] public KEYBDINPUT ki; }
+  [StructLayout(LayoutKind.Sequential)] public struct INPUT { public uint type; public INPUTUNION u; }
+  [DllImport("user32.dll")] public static extern bool GetLastInputInfo(ref LASTINPUTINFO p);
+  [DllImport("user32.dll", SetLastError=true)] public static extern uint SendInput(uint n, INPUT[] inputs, int cb);
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("kernel32.dll")] public static extern uint WTSGetActiveConsoleSessionId();
+  [DllImport("kernel32.dll")] public static extern bool ProcessIdToSessionId(uint pid, out uint sid);
+
+  public static uint Tick() {
+    var l = new LASTINPUTINFO(); l.cbSize = 8;
+    if (!GetLastInputInfo(ref l)) return 0;
+    return l.dwTime;
+  }
+
+  public static string Run() {
+    uint before = Tick();
+    var moves = new INPUT[2];
+    moves[0].type = 0; moves[0].u.mi.dx = 1;  moves[0].u.mi.dy = 0; moves[0].u.mi.dwFlags = 0x0001;
+    moves[1].type = 0; moves[1].u.mi.dx = -1; moves[1].u.mi.dy = 0; moves[1].u.mi.dwFlags = 0x0001;
+    uint sent = SendInput(2, moves, Marshal.SizeOf(typeof(INPUT)));
+    int err = Marshal.GetLastWin32Error();
+    System.Threading.Thread.Sleep(120);
+    uint after = Tick();
+    uint myPid = (uint)System.Diagnostics.Process.GetCurrentProcess().Id;
+    uint mySession;
+    ProcessIdToSessionId(myPid, out mySession);
+    return string.Format("sent={0};err={1};tickBefore={2};tickAfter={3};changed={4};session={5};consoleSession={6};foreground={7}",
+      sent, err, before, after, (before != 0 && before != after) ? "true" : "false",
+      mySession, WTSGetActiveConsoleSessionId(), GetForegroundWindow());
+  }
+}
+'@
+[EnspInputProbe]::Run()
+`
+
+/**
+ * Can this process deliver synthetic mouse/keyboard input to the session?
+ *
+ * The probe sends two opposing 1-pixel mouse moves (net cursor movement zero)
+ * and compares the session's last-input tick before and after. `SendInput`
+ * returning a non-zero count only means the API accepted the call; the tick is
+ * what proves it reached the input queue.
+ */
+export function probeInputInjection({ timeoutMs = 30000 } = {}) {
+  const r = spawnSync('powershell', ['-NoProfile', '-Command', INPUT_PROBE], {
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: timeoutMs,
+  })
+  if (r.error) {
+    return { ok: false, reason: 'probe-failed', detail: String(r.error.message || r.error) }
+  }
+  if (r.status !== 0) {
+    return { ok: false, reason: 'probe-failed', detail: (r.stderr || r.stdout || '').trim().slice(0, 400) }
+  }
+  const line = (r.stdout || '').split('\n').map((s) => s.trim()).filter(Boolean).pop() || ''
+  const field = (k) => {
+    const m = line.match(new RegExp(k + '=([^;]*)'))
+    return m ? m[1] : ''
+  }
+  const changed = field('changed') === 'true'
+  return {
+    ok: changed,
+    sent: Number(field('sent') || 0),
+    tickChanged: changed,
+    session: field('session'),
+    consoleSession: field('consoleSession'),
+    foreground: field('foreground'),
+    raw: line,
+  }
+}
+
+/** Free physical memory in MB, or null when it cannot be read. */
+export function freeMemoryMb() {
+  const r = spawnSync(
+    'powershell',
+    [
+      '-NoProfile',
+      '-Command',
+      "Get-CimInstance Win32_OperatingSystem | ForEach-Object { [int]($_.FreePhysicalMemory / 1024) }",
+    ],
+    { encoding: 'utf8', windowsHide: true, timeout: 20000 },
+  )
+  if (r.status !== 0) return null
+  const n = Number((r.stdout || '').trim())
+  return Number.isFinite(n) && n > 0 ? n : null
+}
+
+/** Ports in eNSP's console range that are already listening. */
+export function busyConsolePorts() {
+  const r = spawnSync(
+    'powershell',
+    [
+      '-NoProfile',
+      '-Command',
+      "Get-NetTCPConnection -State Listen -ErrorAction SilentlyContinue | " +
+        'Where-Object { $_.LocalPort -ge 2000 -and $_.LocalPort -le 2100 } | ' +
+        'ForEach-Object { $_.LocalPort } | Sort-Object -Unique',
+    ],
+    { encoding: 'utf8', windowsHide: true, timeout: 20000 },
+  )
+  if (r.status !== 0) return []
+  return (r.stdout || '')
+    .split(/\s+/)
+    .map(Number)
+    .filter((n) => Number.isInteger(n) && n >= 2000 && n <= 2100)
+}
+
+function check(id, status, detail, fix) {
+  return fix ? { id, status, detail, fix } : { id, status, detail }
+}
+
+/**
+ * Run every environment check.
+ *
+ * @param {object} [options]
+ * @param {string} [options.exe]     eNSP client path
+ * @param {string} [options.vbox]    VBoxManage path
+ * @param {string} [options.root]    eNSP installation root (defaults to exe dir)
+ * @param {string[]} [options.models] device models the run needs
+ * @param {boolean} [options.deep]   also run the input probe (slow: ~2 s)
+ */
+export function doctor(options = {}) {
+  const exe = options.exe || DEFAULT_ENSP_EXE
+  const vbox = options.vbox || DEFAULT_VBOX
+  const root = options.root || path.dirname(exe)
+  const deep = options.deep !== false
+  const checks = []
+
+  // 1. eNSP client present
+  const exeOk = fs.existsSync(exe)
+  checks.push(
+    check(
+      'ensp-installed',
+      exeOk ? 'pass' : 'fail',
+      exeOk ? exe : `not found: ${exe}`,
+      exeOk
+        ? undefined
+        : 'Install eNSP, or pass --exe with the real path to eNSP_Client.exe.',
+    ),
+  )
+
+  // 2. VirtualBox present (eNSP cannot boot a single device without it)
+  const vboxOk = fs.existsSync(vbox)
+  checks.push(
+    check(
+      'virtualbox',
+      vboxOk ? 'pass' : 'fail',
+      vboxOk ? vbox : `not found: ${vbox}`,
+      vboxOk ? undefined : 'Install VirtualBox 5.2.x, which ships with eNSP.',
+    ),
+  )
+
+  // 3. Device images for the models this scenario needs
+  if (options.models && options.models.length) {
+    const missing = []
+    for (const model of [...new Set(options.models)]) {
+      const p = probeDevice(model, { root })
+      if (!p.available) missing.push(`${model}: ${p.reason}`)
+    }
+    checks.push(
+      check(
+        'device-images',
+        missing.length === 0 ? 'pass' : 'fail',
+        missing.length === 0 ? `${[...new Set(options.models)].join(', ')} all present` : missing.join('; '),
+        missing.length === 0
+          ? undefined
+          : 'Reinstall eNSP with the missing device component selected, or remove those devices from the topology.',
+      ),
+    )
+  }
+
+  // 4. Console port range has room
+  const busy = busyConsolePorts()
+  checks.push(
+    check(
+      'console-ports',
+      busy.length === 0 ? 'pass' : 'warn',
+      busy.length === 0 ? '2000-2100 free' : `already listening: ${busy.join(', ')}`,
+      busy.length === 0
+        ? undefined
+        : 'Another eNSP instance is holding these ports. Stop it first, or the new topology will bind elsewhere and consoles will time out.',
+    ),
+  )
+
+  // 5. Synthetic input reaches the session (the decisive check)
+  if (deep) {
+    const input = probeInputInjection()
+    checks.push(
+      check(
+        'input-injection',
+        input.ok ? 'pass' : 'fail',
+        input.ok
+          ? 'synthetic mouse input reached the input queue'
+          : input.reason === 'probe-failed'
+            ? `probe failed: ${input.detail}`
+            : `SendInput accepted ${input.sent} event(s) but the session last-input tick did not change (session ${input.session}, console session ${input.consoleSession})`,
+        input.ok
+          ? undefined
+          : 'This session cannot deliver mouse input, so the eNSP toolbar button can never be pressed. Run the tool from an interactive desktop session (a normal logged-in terminal), not from a service, a scheduled task, an SSH shell, or an agent sandbox.',
+      ),
+    )
+  }
+
+  // 6. Memory headroom: each AR_Base needs 256 MB, WLAN images 530-650 MB
+  const free = freeMemoryMb()
+  if (free === null) {
+    checks.push(check('memory', 'warn', 'could not read free physical memory'))
+  } else {
+    const okMem = free >= MIN_FREE_MEMORY_MB
+    checks.push(
+      check(
+        'memory',
+        okMem ? 'pass' : 'warn',
+        `${free} MB free (each router needs ~256 MB)`,
+        okMem ? undefined : 'Close some applications; devices may boot very slowly or fail to start.',
+      ),
+    )
+  }
+
+  // 7. Calibration anchors. The static defaults are only a fallback for a window we
+  // could not photograph, so comparing them to each other proves nothing. When eNSP
+  // is open, measure the live window instead and say which method produced it.
+  const hwnd = options.hwnd ?? (options.live === false ? null : safeWindow())
+  if (hwnd) {
+    try {
+      const anchors = calibrateAnchors(hwnd, { refresh: true })
+      const measured = anchors.method === 'measured'
+      checks.push(
+        check(
+          'anchors',
+          measured ? 'pass' : 'warn',
+          `${anchors.method}: start (${anchors.start.x},${anchors.start.y}) stop (${anchors.stop.x},${anchors.stop.y})`,
+          measured
+            ? undefined
+            : 'The toolbar could not be located by colour, so the cached fallback is in use. ' +
+              'Bring eNSP to the front and run `ensp probe`.',
+        ),
+      )
+    } catch (error) {
+      checks.push(check('anchors', 'warn', `not measured: ${error.message}`, 'Run `ensp probe` with eNSP visible.'))
+    }
+  } else {
+    const a = DEFAULT_ANCHORS.start
+    const b = DEFAULT_ANCHORS.stop
+    checks.push(
+      check(
+        'anchors',
+        b.x > a.x ? 'pass' : 'fail',
+        `fallback start (${a.x},${a.y}) stop (${b.x},${b.y}); eNSP not open, nothing measured`,
+        b.x > a.x ? undefined : 'Fallback anchors are inconsistent; run `ensp probe`.',
+      ),
+    )
+  }
+
+  const failed = checks.filter((c) => c.status === 'fail')
+  const warned = checks.filter((c) => c.status === 'warn')
+  return {
+    ok: failed.length === 0,
+    checks,
+    failed: failed.map((c) => c.id),
+    warned: warned.map((c) => c.id),
+  }
+}
+
+/**
+ * The eNSP window, if one is open. Best effort: doctor must still work when eNSP is
+ * not installed, not running, or running as a zombie without threads.
+ */
+function safeWindow() {
+  try {
+    return locateWindow(enspPid()) ?? null
+  } catch {
+    return null
+  }
+}
+
+/** Render a doctor report for a terminal. */
+export function formatDoctor(report) {
+  const mark = { pass: 'ok  ', warn: 'warn', fail: 'FAIL' }
+  const lines = []
+  for (const c of report.checks) {
+    lines.push(`[${mark[c.status] || c.status}] ${c.id}: ${c.detail}`)
+    if (c.fix) lines.push(`         fix: ${c.fix}`)
+  }
+  lines.push('')
+  lines.push(
+    report.ok
+      ? `environment ok${report.warned.length ? ` (${report.warned.length} warning(s))` : ''}`
+      : `environment is not ready: ${report.failed.join(', ')}`,
+  )
+  return lines.join('\n')
+}
+
+/** Convenience wrapper used by the CLI, MCP server and plugin. */
+export function checkEnvironment(options = {}) {
+  const report = doctor(options)
+  return { ...report, text: formatDoctor(report) }
+}
+
+/**
+ * Models a topology needs, so `doctor()` can check the right images.
+ * Accepts a parsed topology (from `readTopology`).
+ */
+export function modelsOf(topology) {
+  const devices = topology?.devices ?? []
+  return [...new Set(devices.map((d) => d.model))].sort()
+}
+
+/** Free-memory constant, exported so tests can assert against it. */
+export { MIN_FREE_MEMORY_MB }

package/src/core/index.mjs

@@ -59,6 +59,29 @@ export {
   rootFromExe,
 } from './compat.mjs'
 
+export {
+  doctor,
+  formatDoctor,
+  checkEnvironment,
+  probeInputInjection,
+  freeMemoryMb,
+  busyConsolePorts,
+  modelsOf,
+  DEFAULT_ENSP_EXE,
+  DEFAULT_VBOX,
+  MIN_FREE_MEMORY_MB,
+} from './doctor.mjs'
+
+export {
+  EXPECTATIONS,
+  evaluateAssertion,
+  planFor,
+  hasChecks,
+  consolePorts,
+  runAcceptance,
+  formatAcceptance,
+} from './acceptance.mjs'
+
 export { ConsoleSession, openConsole, probeConsole, viewOf, hostnameOf } from './console.mjs'
 
 export {

package/src/core/launcher.mjs

@@ -100,6 +100,7 @@ public class EnspWin {
   [DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r);
   [DllImport("user32.dll")] public static extern bool IsWindow(IntPtr h);
   [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr h);
+  [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr h);
   [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr h, int c);
   [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);
   [DllImport("user32.dll")] public static extern bool BringWindowToTop(IntPtr h);
@@ -111,6 +112,8 @@ public class EnspWin {
   [DllImport("user32.dll")] public static extern IntPtr WindowFromPoint(POINT p);
   [DllImport("user32.dll")] public static extern IntPtr GetAncestor(IntPtr h, uint flags);
 
+  [DllImport("user32.dll")] public static extern IntPtr SendMessage(IntPtr h, uint msg, IntPtr wp, IntPtr lp);
+
   [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; }
   [StructLayout(LayoutKind.Sequential)] public struct POINT { public int X, Y; }
 
@@ -162,13 +165,31 @@ public class EnspWin {
     return found != IntPtr.Zero ? found : fallback;
   }
 
+  private const uint WM_SYSCOMMAND = 0x0112;
+  private const int SC_RESTORE = 0xF120;
+
+  /**
+   * Bring a minimised window back to its normal size.
+   *
+   * ShowWindow(h, SW_RESTORE) reports failure on this MFC frame and leaves the
+   * window at its icon size (measured: 237x39 at -32000,-32000), so every later
+   * screenshot is taken on the icon and calibration finds no toolbar. The
+   * WM_SYSCOMMAND/SC_RESTORE path is what the system menu itself uses and it does
+   * restore the frame to 1280x800.
+   */
+  public static void RestoreWindow(IntPtr h) {
+    if (!IsIconic(h)) return;
+    ShowWindow(h, 9);                                   // best effort, may report false
+    SendMessage(h, WM_SYSCOMMAND, (IntPtr)SC_RESTORE, IntPtr.Zero);
+  }
+
   public static bool FocusWindow(IntPtr h) {
+    RestoreWindow(h);
     IntPtr fg = GetForegroundWindow();
     uint dummy;
     uint fgt = GetWindowThreadProcessId(fg, out dummy);
     uint myt = GetCurrentThreadId();
     AttachThreadInput(myt, fgt, true);
-    ShowWindow(h, 9);            // SW_RESTORE
     BringWindowToTop(h);
     bool ok = SetForegroundWindow(h);
     AttachThreadInput(myt, fgt, false);

package/src/dsh/index.mjs

@@ -46,6 +46,8 @@ import {
 import { calibrateAnchors, inspectAnchors } from '../core/calibrate.mjs'
 import { pushConfig, pushConfigMany, queryDevice } from '../core/provision.mjs'
 import { SCENARIOS, SCENARIO_IDS, renderScenario, searchScenarios, byLevel } from '../core/presets.mjs'
+import { doctor, modelsOf } from '../core/doctor.mjs'
+import { runAcceptance, hasChecks } from '../core/acceptance.mjs'
 import { VERSION } from '../core/version.mjs'
 
 /** Declared hard dependency: the tool registry. */
@@ -550,7 +552,14 @@ export function apply(ctx) {
       const brief = hasLab(id)
         ? renderScenario(id) + `\n\n可生成拓扑: ensp_build_topology { path: "${id}.topo", scenario: "${id}" }`
         : renderScenario(id)
-      return { id, brief }
+      return {
+        id,
+        brief:
+          brief +
+          (hasChecks(id)
+            ? `\n\n验收: ensp_verify { scenario: "${id}", topology: "${id}.topo" }`
+            : '\n\n验收: 无专门断言，ensp_verify 会逐条跑场景里的验证命令'),
+      }
     },
   })
 
@@ -615,6 +624,101 @@ export function apply(ctx) {
       }
     },
   })
+
+  /* ----------------------------------------------------------------- doctor */
+
+  add(tools, {
+    name: 'ensp_doctor',
+    description:
+      'Check whether this machine can actually run a lab before starting anything: eNSP and '
+      + 'VirtualBox presence, missing device images, console ports already in use, free memory, and '
+      + 'whether synthetic mouse input reaches this session at all. Every failing check comes with a '
+      + 'fix. Never starts eNSP, so it is safe to run first.',
+    parameters: {
+      topology: str('optional .topo path, so the device images it needs can be checked'),
+      deep: bool('run the slow input-injection probe (default true)'),
+    },
+    output: {
+      schema: obj({
+        ok: req(bool()),
+        failed: req(str()),
+        warned: req(str()),
+        checks: req(str()),
+        error: req(str()),
+      }),
+      render(args, value) {
+        if (value.error) return text(value.error)
+        return text(value.checks + '\n\n' + (value.ok ? 'environment ok' : 'environment NOT ready'))
+      },
+    },
+    async execute({ topology, deep }) {
+      let models
+      if (topology) models = modelsOf(await readTopology(path.resolve(topology)))
+      const report = doctor({ models, deep: deep !== false })
+      const lines = report.checks.map((c) => {
+        const tag = c.status === 'pass' ? '[ok  ]' : c.status === 'warn' ? '[warn]' : '[FAIL]'
+        return `${tag} ${c.id}: ${c.detail}` + (c.fix ? `\n       fix: ${c.fix}` : '')
+      })
+      return {
+        ok: report.ok,
+        failed: report.failed.join(', ') || '(none)',
+        warned: report.warned.join(', ') || '(none)',
+        checks: lines.join('\n'),
+      }
+    },
+  })
+
+  /* ----------------------------------------------------------------- verify */
+
+  add(tools, {
+    name: 'ensp_verify',
+    description:
+      'Run a scenario\'s acceptance checks against a lab that is already running. Curated scenarios '
+      + 'assert on what each device reports (OSPF Full, BGP Established, VRRP Master); the rest '
+      + 'smoke-test every verification command in the scenario. Use this to decide whether the lab '
+      + 'works, rather than whether configuration was merely sent.',
+    parameters: {
+      scenario: str('scenario id, e.g. "ospf-single"'),
+      topology: str('the .topo file that is running, used for console ports'),
+      timeout: num('per-command timeout in ms (default 25000)'),
+      wait: num('how long a failing assertion may keep being retried, in ms (default 60000)'),
+    },
+    output: {
+      schema: obj({
+        scenario: req(str()),
+        ok: req(bool()),
+        summary: req(str()),
+        detail: req(str()),
+        error: req(str()),
+      }),
+      render(args, value) {
+        if (value.error) return text(value.error)
+        return text(`${value.scenario} · ${value.summary}\n\n${value.detail}`)
+      },
+    },
+    async execute({ scenario, topology, timeout, wait }) {
+      if (!scenario) throw new Error('scenario is required')
+      if (!topology) throw new Error('topology is required: pass the .topo file that is running')
+      const report = await runAcceptance({
+        id: scenario,
+        topology: path.resolve(topology),
+        timeoutMs: timeout,
+        waitMs: wait,
+      })
+      const detail = report.results
+        .map((r) => {
+          const waited = r.pass && r.waitedMs ? ` (converged after ${Math.round(r.waitedMs / 1000)}s)` : ''
+          return `${r.pass ? 'PASS' : 'FAIL'} ${r.device} · ${r.id}${waited} — ${r.why}`
+        })
+        .join('\n')
+      return {
+        scenario: report.scenario,
+        ok: report.ok,
+        summary: `${report.passed}/${report.total} checks passed (${report.source})`,
+        detail,
+      }
+    },
+  })
 }
 
 /** Model metadata for the plugin row. */

package/src/mcp/server.mjs

@@ -38,6 +38,8 @@ import {
   waitForConsole,
 } from '../core/launcher.mjs'
 import { calibrateAnchors, inspectAnchors, DEFAULT_ANCHORS } from '../core/calibrate.mjs'
+import { doctor, modelsOf } from '../core/doctor.mjs'
+import { runAcceptance, hasChecks, EXPECTATIONS } from '../core/acceptance.mjs'
 import { pushConfig, pushConfigMany, queryDevice } from '../core/provision.mjs'
 import { SCENARIOS, SCENARIO_IDS, byLevel, renderScenario, searchScenarios } from '../core/presets.mjs'
 import { PACKAGE_NAME, VERSION } from '../core/version.mjs'
@@ -327,10 +329,50 @@ const TOOLS = [
         brief: renderScenario(id),
         data: SCENARIOS[id],
         hasTopology: hasLab(id),
+        hasCuratedChecks: hasChecks(id),
         ...(hasLab(id) ? { devices: labDevices(id), addressing: labAddressing(id) } : {}),
       }
     },
   },
+  {
+    name: 'ensp_doctor',
+    description:
+      'Check whether this machine can actually run a lab, before starting anything. ' +
+      'Reports eNSP and VirtualBox presence, missing device images, console ports already in ' +
+      'use, free memory, and — most importantly — whether synthetic mouse input reaches this ' +
+      'session at all. Every failing check comes with the fix. Never starts eNSP.',
+    inputSchema: obj({
+      topology: { type: 'string', description: 'optional .topo path, so device images can be checked' },
+      deep: { type: 'boolean', description: 'run the slow input-injection probe (default true)' },
+    }),
+    async run({ topology, deep }) {
+      let models
+      if (topology) models = modelsOf(await readTopology(topology))
+      return doctor({ models, deep: deep !== false })
+    },
+  },
+  {
+    name: 'ensp_verify',
+    description:
+      'Run a scenario\'s acceptance checks against a lab that is already running. Curated ' +
+      'scenarios assert on what each device reports (OSPF Full, BGP Established, VRRP Master); ' +
+      'the rest smoke-test every verification command from the scenario. Use this to decide ' +
+      'whether the lab works, not just whether configuration was sent.',
+    inputSchema: obj({
+      scenario: { type: 'string', description: 'scenario id, e.g. "ospf-single"' },
+      topology: { type: 'string', description: 'the .topo file that is running (for console ports)' },
+      timeout: { type: 'number', description: 'per-command timeout in ms (default 25000)' },
+      wait: {
+        type: 'number',
+        description: 'how long a failing assertion may keep being retried, in ms (default 60000)',
+      },
+    }),
+    async run({ scenario, topology, timeout, wait }) {
+      if (!scenario) throw new Error('scenario is required')
+      if (!topology) throw new Error('topology is required: pass the .topo file that is running')
+      return runAcceptance({ id: scenario, topology, timeoutMs: timeout, waitMs: wait })
+    },
+  },
   {
     name: 'ensp_preset_config',
     description: 'Return the configuration that makes the built-in two-PC lab pass traffic.',