@bridge_gpt/mcp-server 0.1.17 → 0.2.0

package/build/agent-capabilities/cli.js

@@ -0,0 +1,152 @@
+/**
+ * CLI entry for the `agent-capabilities` subcommand:
+ *
+ *   npx -y @bridge_gpt/mcp-server agent-capabilities [--agent <name|all>] [--only <ids>] [--json]
+ *
+ * Mirrors `doctor`'s shape: strict arg parsing → non-throwing collection →
+ * format → exit code. Exit 0 when every applicable/non-filtered probe is
+ * pass/skip/not-applicable; nonzero on any FAIL or HANG.
+ */
+import { DEFAULT_AGENT_NAME, formatValidAgentNames, isAgentName, listAgentNames, } from "../agent-registry.js";
+import { createDefaultAgentCapabilitiesDeps } from "./default-deps.js";
+import { formatCapabilityJson, formatCapabilityReport } from "./reporter.js";
+import { collectCapabilityResults, hasFailureOrHang } from "./runner.js";
+import { listProbeIds } from "./probes.js";
+export function getAgentCapabilitiesUsage() {
+    return [
+        "Usage:",
+        "  npx -y @bridge_gpt/mcp-server agent-capabilities [--agent <name|all>] [--only <ids>] [--json]",
+        "",
+        "Empirically validates what an agent CLI can do (binary resolution, headless",
+        "print mode + exit, .claude/commands resolution, preamble drift-check, output",
+        "formats). Runs disposable probes in temp projects; never writes to your repo.",
+        "",
+        "Flags:",
+        `  --agent <name|all>   Agent(s) to probe: ${formatValidAgentNames()}, or 'all' (default: ${DEFAULT_AGENT_NAME})`,
+        `  --only <ids>         Comma-separated probe ids to run (default: all). Valid ids:`,
+        `                       ${listProbeIds().join(", ")}`,
+        "  --json               Emit JSON instead of the human report",
+        "  -h, --help           Show this help",
+        "",
+        "Auth: cursor-agent probes that spawn the agent require CURSOR_API_KEY (read from",
+        "the environment, never printed); they SKIP when it is unset. claude uses",
+        "keychain/OAuth, which cannot be verified from the environment.",
+        "",
+        "Exit code: 0 when every probe is pass/skip/n-a; nonzero when any probe FAILs or HANGs.",
+    ].join("\n");
+}
+function parseListFlag(raw) {
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+export function parseAgentCapabilitiesArgs(argv) {
+    if (argv.includes("-h") || argv.includes("--help")) {
+        return { status: "help", usage: getAgentCapabilitiesUsage() };
+    }
+    let agentSelector = DEFAULT_AGENT_NAME;
+    let only;
+    let json = false;
+    let timeoutMs;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--agent" || arg.startsWith("--agent=")) {
+            let value;
+            if (arg.startsWith("--agent=")) {
+                value = arg.slice("--agent=".length);
+            }
+            else {
+                if (i + 1 >= argv.length) {
+                    return { status: "error", message: "--agent requires a value (an agent name or 'all')." };
+                }
+                value = argv[++i];
+            }
+            if (value !== "all" && !isAgentName(value)) {
+                return {
+                    status: "error",
+                    message: `Invalid --agent value: '${value}' (allowed: ${formatValidAgentNames()}, all).`,
+                };
+            }
+            agentSelector = value;
+            continue;
+        }
+        if (arg === "--only" || arg.startsWith("--only=")) {
+            let value;
+            if (arg.startsWith("--only=")) {
+                value = arg.slice("--only=".length);
+            }
+            else {
+                if (i + 1 >= argv.length) {
+                    return { status: "error", message: "--only requires a value (comma-separated probe ids)." };
+                }
+                value = argv[++i];
+            }
+            const ids = parseListFlag(value);
+            const valid = new Set(listProbeIds());
+            const unknown = ids.filter((id) => !valid.has(id));
+            if (unknown.length > 0) {
+                return {
+                    status: "error",
+                    message: `Unknown probe id(s): ${unknown.join(", ")} (valid: ${listProbeIds().join(", ")}).`,
+                };
+            }
+            only = ids;
+            continue;
+        }
+        if (arg === "--timeout-ms" || arg.startsWith("--timeout-ms=")) {
+            let value;
+            if (arg.startsWith("--timeout-ms=")) {
+                value = arg.slice("--timeout-ms=".length);
+            }
+            else {
+                if (i + 1 >= argv.length) {
+                    return { status: "error", message: "--timeout-ms requires a numeric value." };
+                }
+                value = argv[++i];
+            }
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed) || parsed <= 0) {
+                return { status: "error", message: `Invalid --timeout-ms value: '${value}'.` };
+            }
+            timeoutMs = parsed;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { status: "error", message: `Unknown flag: ${arg}` };
+        }
+        return {
+            status: "error",
+            message: `Unexpected positional argument: '${arg}'. agent-capabilities takes only flags.`,
+        };
+    }
+    return { status: "ok", options: { agentSelector, only, json, timeoutMs } };
+}
+export async function runAgentCapabilitiesCli(argv, overrides = {}) {
+    const log = overrides.log ?? ((m) => console.log(m));
+    const errorLog = overrides.errorLog ?? ((m) => console.error(m));
+    const parsed = parseAgentCapabilitiesArgs(argv);
+    if (parsed.status === "help") {
+        log(parsed.usage);
+        return 0;
+    }
+    if (parsed.status === "error") {
+        errorLog(`Error: ${parsed.message}`);
+        errorLog("");
+        errorLog(getAgentCapabilitiesUsage());
+        return 1;
+    }
+    const deps = overrides.deps ?? createDefaultAgentCapabilitiesDeps();
+    const agents = parsed.options.agentSelector === "all" ? listAgentNames() : [parsed.options.agentSelector];
+    const collection = await collectCapabilityResults(deps, {
+        agents,
+        only: parsed.options.only,
+        timeoutMs: parsed.options.timeoutMs,
+    });
+    log(parsed.options.json ? formatCapabilityJson(collection) : formatCapabilityReport(collection));
+    return hasFailureOrHang(collection) ? 1 : 0;
+}

package/build/agent-capabilities/default-deps.js

@@ -0,0 +1,45 @@
+/**
+ * Production deps for the `agent-capabilities` toolkit: real subprocesses, temp
+ * dirs, and clock. Subprocess execution uses `execFile` (list-based, never
+ * `shell: true`) and forwards an `AbortSignal` with `killSignal: "SIGKILL"` so the
+ * timeout guard in `probe-context.ts` can actually kill a hung agent (the
+ * version-sensitive `cursor-agent -p` non-exit bug) instead of leaking it.
+ *
+ * Mirrors `createDefaultScheduleRunDeps()` in `schedule-run.ts`, adding the temp-dir
+ * filesystem ops and a unique-suffix source the probes need.
+ */
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import { randomBytes } from "node:crypto";
+export function createDefaultAgentCapabilitiesDeps() {
+    const runCommand = (file, args, options) => new Promise((resolve) => {
+        execFile(file, args, {
+            cwd: options?.cwd,
+            env: options?.env ?? process.env,
+            signal: options?.signal,
+            killSignal: "SIGKILL",
+            maxBuffer: 64 * 1024 * 1024,
+            encoding: "utf-8",
+        }, (error, stdout, stderr) => {
+            const exitCode = error && typeof error.code === "number"
+                ? error.code
+                : error
+                    ? 1
+                    : 0;
+            resolve({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
+        });
+    });
+    return {
+        platform: process.platform,
+        env: process.env,
+        runCommand,
+        tmpRoot: os.tmpdir(),
+        mkdtemp: (prefix) => mkdtemp(prefix),
+        rm: (target, opts) => rm(target, opts),
+        writeFile: (target, data) => writeFile(target, data, "utf-8"),
+        mkdir: (target, opts) => mkdir(target, opts).then(() => undefined),
+        now: () => Date.now(),
+        uniqueSuffix: () => randomBytes(3).toString("hex").toUpperCase(),
+    };
+}

package/build/agent-capabilities/probe-context.js

@@ -0,0 +1,111 @@
+/**
+ * Per-agent probe context: resolves the agent binary once, mints marker tokens,
+ * creates auto-cleaned temp projects, and runs the agent headless behind a hard
+ * timeout guard.
+ *
+ * The timeout guard is the whole point of HANG handling: it starts a timer and an
+ * AbortController; whichever resolves first wins. If the timer fires we abort the
+ * child (SIGKILL via the deps runner) and report `{ kind: "hang" }` distinctly —
+ * so the version-sensitive `cursor-agent -p` non-exit bug surfaces as HANG rather
+ * than wedging the toolkit forever. This replaces the bash spike's `perl -e 'alarm'`.
+ */
+import { join } from "node:path";
+import { resolveCommandOnPath } from "../agent-launchers/claude.js";
+import { DEFAULT_PROBE_TIMEOUT_MS, } from "./types.js";
+/**
+ * Build the exact argv for a headless (`-p`) invocation, per agent. Argv arrays
+ * only — never a shell string. Exported for direct unit assertion.
+ *
+ * - cursor-agent: `-p --output-format <fmt> --trust --workspace <cwd> <prompt>`.
+ *   `--trust` is MANDATORY headless or the workspace-trust prompt hangs; cursor has
+ *   its own `--workspace` cwd flag.
+ * - claude: `-p [--output-format json] <prompt>`. Claude has NO working-dir flag —
+ *   cwd is set via the spawn options, never an argument.
+ */
+export function buildHeadlessArgs(agentName, opts) {
+    const fmt = opts.outputFormat ?? "text";
+    if (agentName === "cursor-agent") {
+        return ["-p", "--output-format", fmt, "--trust", "--workspace", opts.cwd, opts.prompt];
+    }
+    // claude (and any positional-prompt agent without a cwd flag)
+    const args = ["-p"];
+    if (fmt === "json")
+        args.push("--output-format", "json");
+    args.push(opts.prompt);
+    return args;
+}
+/** Create a probe context for one agent plus a `cleanup()` that removes its temp dirs. */
+export async function createProbeContext(deps, agent, defaultTimeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+    const launcherDeps = {
+        platform: deps.platform,
+        env: deps.env,
+        runCommand: (file, args, options) => deps.runCommand(file, args, options),
+    };
+    const resolvedBinary = await resolveCommandOnPath(agent.command, deps.env.PATH ?? "", launcherDeps);
+    const createdDirs = [];
+    let counter = 0;
+    const ctx = {
+        agent,
+        deps,
+        resolvedBinary,
+        marker(name) {
+            return `${name}_${deps.uniqueSuffix()}_${counter++}`;
+        },
+        async makeTempProject(seed) {
+            const dir = await deps.mkdtemp(join(deps.tmpRoot, "agent-cap-"));
+            createdDirs.push(dir);
+            if (seed)
+                await seed(dir);
+            return dir;
+        },
+        async runHeadless(opts) {
+            const exe = resolvedBinary ?? agent.command;
+            const args = buildHeadlessArgs(agent.name, opts);
+            const timeoutMs = opts.timeoutMs ?? defaultTimeoutMs;
+            const controller = new AbortController();
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, timeoutMs);
+            const start = deps.now();
+            try {
+                const result = await deps.runCommand(exe, args, {
+                    cwd: opts.cwd,
+                    env: deps.env,
+                    signal: controller.signal,
+                });
+                const elapsedMs = deps.now() - start;
+                if (timedOut)
+                    return { kind: "hang", elapsedMs, partialStdout: result.stdout ?? "" };
+                return {
+                    kind: "exited",
+                    exitCode: result.exitCode,
+                    stdout: result.stdout ?? "",
+                    stderr: result.stderr ?? "",
+                    elapsedMs,
+                };
+            }
+            catch (err) {
+                const elapsedMs = deps.now() - start;
+                if (timedOut)
+                    return { kind: "hang", elapsedMs, partialStdout: "" };
+                return { kind: "spawn-error", message: err instanceof Error ? err.message : String(err) };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+    const cleanup = async () => {
+        for (const dir of createdDirs.splice(0)) {
+            try {
+                await deps.rm(dir, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup; a leaked temp dir must not fail the run
+            }
+        }
+    };
+    return { ctx, cleanup };
+}

package/build/agent-capabilities/probes.js

@@ -0,0 +1,278 @@
+/**
+ * The structural/cheap capability probe set. Each probe is small, isolated, and
+ * marker-based: it seeds a disposable temp project, runs the agent headless, and
+ * asserts a token that only the seeded command/prompt could have produced — so a
+ * pass means the capability genuinely worked, not that the model guessed.
+ *
+ * Reuses the validated approach from the cursor-agent spike (baseline, the
+ * `.claude/commands` resolution check, and the preamble-then-command drift-check
+ * pattern that the schedulable-automations design depends on).
+ */
+import { join } from "node:path";
+import { buildHeadlessArgs } from "./probe-context.js";
+const EVIDENCE_MAX = 200;
+function truncate(text) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > EVIDENCE_MAX ? `${flat.slice(0, EVIDENCE_MAX)}…` : flat;
+}
+/** Verbatim body of the disposable `.claude/commands/echo-test.md` probe command. */
+function echoCommandBody(marker) {
+    return [
+        "---",
+        "description: Disposable no-op probe command that emits a marker token.",
+        "---",
+        "This is an agent-capability probe. Do not use any tools.",
+        `As part of your output, include the token ${marker} on its own line.`,
+        "You may also include other content from earlier steps.",
+        "",
+    ].join("\n");
+}
+/** Seed `<dir>/.claude/commands/echo-test.md` with a marker-emitting command. */
+async function seedEchoCommand(ctx, dir, marker) {
+    const cmdDir = join(dir, ".claude", "commands");
+    await ctx.deps.mkdir(cmdDir, { recursive: true });
+    await ctx.deps.writeFile(join(cmdDir, "echo-test.md"), echoCommandBody(marker));
+}
+/** Map a non-exited guarded run to a probe result; returns null when it exited cleanly. */
+function nonExitedResult(run) {
+    if (run.kind === "hang") {
+        return {
+            status: "hang",
+            detail: `agent did not exit within the timeout (${run.elapsedMs}ms) — likely the version-sensitive -p hang`,
+            elapsedMs: run.elapsedMs,
+            evidence: run.partialStdout ? truncate(run.partialStdout) : undefined,
+        };
+    }
+    if (run.kind === "spawn-error") {
+        return { status: "fail", detail: `could not spawn agent: ${run.message}` };
+    }
+    return null;
+}
+/** Assert exit code 0 and that every expected marker appears in stdout. */
+function assertMarkers(run, markers, failHint) {
+    const nonExited = nonExitedResult(run);
+    if (nonExited)
+        return nonExited;
+    // run.kind === "exited"
+    const { exitCode, stdout, elapsedMs } = run;
+    if (exitCode !== 0) {
+        return {
+            status: "fail",
+            detail: `agent exited ${exitCode} (${failHint})`,
+            elapsedMs,
+            evidence: truncate(stdout),
+        };
+    }
+    const missing = markers.filter((m) => !stdout.includes(m));
+    if (missing.length > 0) {
+        return {
+            status: "fail",
+            detail: `${failHint}; missing marker(s): ${missing.join(", ")}`,
+            elapsedMs,
+            evidence: truncate(stdout),
+        };
+    }
+    return { status: "pass", detail: `markers present, clean exit`, elapsedMs };
+}
+const binaryResolves = {
+    id: "binary-resolves",
+    title: "Binary resolves on PATH",
+    description: "The agent command resolves to an absolute path on PATH.",
+    tier: "structural",
+    appliesTo: ["claude", "cursor-agent"],
+    spawnsAgent: false,
+    async run(ctx) {
+        if (ctx.resolvedBinary) {
+            return { status: "pass", detail: `resolved at ${ctx.resolvedBinary}` };
+        }
+        const hint = ctx.deps.platform === "darwin" || ctx.deps.platform === "linux" || ctx.deps.platform === "win32"
+            ? ctx.agent.installHint[ctx.deps.platform]
+            : "see the agent's install docs";
+        return { status: "fail", detail: `'${ctx.agent.command}' not found on PATH. Install: ${hint}` };
+    },
+};
+const authEnvPresent = {
+    id: "auth-env-present",
+    title: "Headless auth credential present",
+    description: "The agent's headless auth env var (CURSOR_API_KEY) is set — presence only, value never read into output.",
+    tier: "structural",
+    appliesTo: ["cursor-agent"],
+    spawnsAgent: false,
+    async run(ctx) {
+        const value = ctx.deps.env.CURSOR_API_KEY;
+        if (value && value.length > 0) {
+            return { status: "pass", detail: "CURSOR_API_KEY is set" };
+        }
+        return {
+            status: "skip",
+            detail: "CURSOR_API_KEY not set — export it to enable headless cursor-agent probes",
+        };
+    },
+};
+const headlessPrintMode = {
+    id: "headless-print-mode",
+    title: "Headless print mode runs and exits",
+    description: "`-p` print mode produces output and exits cleanly (a hang is reported distinctly).",
+    tier: "structural",
+    appliesTo: ["claude", "cursor-agent"],
+    spawnsAgent: true,
+    async run(ctx) {
+        const marker = ctx.marker("BASE_OK");
+        const dir = await ctx.makeTempProject();
+        const run = await ctx.runHeadless({
+            prompt: `Do not use any tools. Output exactly the token ${marker} on its own line.`,
+            cwd: dir,
+        });
+        return assertMarkers(run, [marker], "headless print mode did not emit the marker");
+    },
+};
+const claudeCommandsResolve = {
+    id: "claude-commands-resolve",
+    title: "Resolves .claude/commands slash commands",
+    description: "A `/echo-test` command seeded in `.claude/commands/` is expanded and its instructions run.",
+    tier: "structural",
+    appliesTo: ["claude", "cursor-agent"],
+    spawnsAgent: true,
+    async run(ctx) {
+        const marker = ctx.marker("ECHO_CMD_RAN");
+        const dir = await ctx.makeTempProject((d) => seedEchoCommand(ctx, d, marker));
+        const run = await ctx.runHeadless({ prompt: "/echo-test", cwd: dir });
+        return assertMarkers(run, [marker], "agent did not expand the .claude/commands/ slash command");
+    },
+};
+/** How many times the (inherently probabilistic) preamble probe samples the behavior. */
+const PREAMBLE_ATTEMPTS = 3;
+const preambleMidPrompt = {
+    id: "preamble-mid-prompt",
+    title: "Runs a preamble then a mid-prompt command",
+    description: "A preamble step followed by a mid-prompt `/echo-test` runs BOTH (the drift-check gate pattern). " +
+        "This behavior is probabilistic — slash-command expansion can suppress the preceding text — so it is " +
+        "sampled several times and reported as a ratio (majority passes).",
+    tier: "structural",
+    appliesTo: ["claude", "cursor-agent"],
+    spawnsAgent: true,
+    async run(ctx) {
+        const pre = ctx.marker("PREAMBLE_OK");
+        const echo = ctx.marker("ECHO_CMD_RAN");
+        const dir = await ctx.makeTempProject((d) => seedEchoCommand(ctx, d, echo));
+        let honored = 0;
+        let totalMs = 0;
+        let lastNonExited = null;
+        for (let attempt = 0; attempt < PREAMBLE_ATTEMPTS; attempt++) {
+            const run = await ctx.runHeadless({
+                prompt: `You must produce two things in your final output. First, output the token ${pre} on its own line. ` +
+                    `Then run the /echo-test command. Your output must contain BOTH ${pre} and the echo-test command's token.`,
+                cwd: dir,
+            });
+            if (run.kind === "hang")
+                return nonExitedResult(run); // a hang is decisive — stop sampling
+            const nonExited = nonExitedResult(run);
+            if (nonExited) {
+                lastNonExited = nonExited;
+                continue;
+            }
+            const exited = run;
+            totalMs += exited.elapsedMs;
+            if (exited.exitCode === 0 && exited.stdout.includes(pre) && exited.stdout.includes(echo)) {
+                honored += 1;
+            }
+        }
+        if (honored === 0 && lastNonExited)
+            return lastNonExited;
+        const pass = honored * 2 >= PREAMBLE_ATTEMPTS; // majority
+        return {
+            status: pass ? "pass" : "fail",
+            detail: `${honored}/${PREAMBLE_ATTEMPTS} runs honored preamble + mid-prompt command` +
+                (pass ? "" : " — preamble is unreliable when a slash command follows it"),
+            elapsedMs: totalMs,
+        };
+    },
+};
+const outputFormat = {
+    id: "output-format",
+    title: "Honors --output-format text and json",
+    description: "Text mode emits the plain marker; json mode emits a parseable JSON envelope.",
+    tier: "structural",
+    appliesTo: ["claude", "cursor-agent"],
+    spawnsAgent: true,
+    async run(ctx) {
+        const marker = ctx.marker("FMT_OK");
+        const dir = await ctx.makeTempProject();
+        const textRun = await ctx.runHeadless({
+            prompt: `Do not use any tools. Output exactly the token ${marker} on its own line.`,
+            cwd: dir,
+            outputFormat: "text",
+        });
+        const textResult = assertMarkers(textRun, [marker], "text output-format did not emit the marker");
+        if (textResult.status !== "pass")
+            return textResult;
+        const jsonRun = await ctx.runHeadless({
+            prompt: `Do not use any tools. Output exactly the token ${marker}.`,
+            cwd: dir,
+            outputFormat: "json",
+        });
+        const nonExited = nonExitedResult(jsonRun);
+        if (nonExited)
+            return nonExited;
+        const { exitCode, stdout, elapsedMs } = jsonRun;
+        if (exitCode !== 0) {
+            return { status: "fail", detail: `json output-format exited ${exitCode}`, elapsedMs, evidence: truncate(stdout) };
+        }
+        try {
+            JSON.parse(stdout.trim());
+        }
+        catch {
+            return { status: "fail", detail: "json output-format did not emit parseable JSON", elapsedMs, evidence: truncate(stdout) };
+        }
+        return { status: "pass", detail: "text marker present and json parseable", elapsedMs };
+    },
+};
+const workspaceFlag = {
+    id: "workspace-flag",
+    title: "Accepts the --workspace working-dir flag",
+    description: "cursor-agent accepts `--workspace <dir>` headless and exits cleanly.",
+    tier: "structural",
+    appliesTo: ["cursor-agent"],
+    spawnsAgent: true,
+    async run(ctx) {
+        const marker = ctx.marker("WS_OK");
+        const dir = await ctx.makeTempProject();
+        // buildHeadlessArgs always adds --workspace <dir> for cursor-agent.
+        const run = await ctx.runHeadless({
+            prompt: `Do not use any tools. Output exactly the token ${marker} on its own line.`,
+            cwd: dir,
+        });
+        return assertMarkers(run, [marker], "--workspace run did not complete cleanly");
+    },
+};
+const noCwdFlag = {
+    id: "no-cwd-flag",
+    title: "Has no working-dir flag (cwd via spawn)",
+    description: "Claude takes no working-dir flag; cwd is set via the spawn options, not an argument.",
+    tier: "structural",
+    appliesTo: ["claude"],
+    spawnsAgent: false,
+    async run(ctx) {
+        const args = buildHeadlessArgs(ctx.agent.name, { prompt: "noop", cwd: "/tmp/x" });
+        const offenders = args.filter((a) => a === "--workspace" || a === "--cwd" || a === "-C");
+        if (offenders.length === 0) {
+            return { status: "pass", detail: "no working-dir flag emitted; cwd set via spawn options" };
+        }
+        return { status: "fail", detail: `unexpected cwd flag(s) in argv: ${offenders.join(", ")}` };
+    },
+};
+/** All probes in deterministic report order. */
+export const ALL_PROBES = [
+    binaryResolves,
+    authEnvPresent,
+    headlessPrintMode,
+    claudeCommandsResolve,
+    preambleMidPrompt,
+    outputFormat,
+    workspaceFlag,
+    noCwdFlag,
+];
+/** Stable set of valid probe ids for `--only` validation. */
+export function listProbeIds() {
+    return ALL_PROBES.map((p) => p.id);
+}

package/build/agent-capabilities/reporter.js

@@ -0,0 +1,50 @@
+const LABEL = {
+    pass: "PASS",
+    fail: "FAIL",
+    skip: "SKIP",
+    hang: "HANG",
+    "not-applicable": "N/A ",
+};
+export function formatCapabilityReport(collection) {
+    const lines = ["agent-capabilities report", ""];
+    const agents = [];
+    for (const rec of collection.records) {
+        if (!agents.includes(rec.agent))
+            agents.push(rec.agent);
+    }
+    const totals = {
+        pass: 0,
+        fail: 0,
+        skip: 0,
+        hang: 0,
+        "not-applicable": 0,
+    };
+    for (const agent of agents) {
+        lines.push(`Agent: ${agent}`);
+        for (const rec of collection.records.filter((r) => r.agent === agent)) {
+            totals[rec.result.status] += 1;
+            const ms = rec.result.elapsedMs !== undefined ? ` (${rec.result.elapsedMs}ms)` : "";
+            lines.push(`  [${LABEL[rec.result.status]}] ${rec.probeId.padEnd(24)} ${rec.result.detail}${ms}`);
+            if (rec.result.evidence) {
+                lines.push(`           evidence: ${rec.result.evidence}`);
+            }
+        }
+        lines.push("");
+    }
+    const na = totals["not-applicable"] ? `, ${totals["not-applicable"]} n/a` : "";
+    lines.push(`Summary: ${totals.pass} pass, ${totals.fail} fail, ${totals.skip} skip, ${totals.hang} hang${na}`);
+    return lines.join("\n");
+}
+export function formatCapabilityJson(collection) {
+    return JSON.stringify({
+        records: collection.records.map((r) => ({
+            agent: r.agent,
+            probe: r.probeId,
+            title: r.title,
+            status: r.result.status,
+            detail: r.result.detail,
+            elapsedMs: r.result.elapsedMs ?? null,
+            evidence: r.result.evidence ?? null,
+        })),
+    }, null, 2);
+}