@maxkle1nz/m1nd 0.9.0-beta.0

package/docs/IDE-INTEGRATIONS.md

@@ -0,0 +1,136 @@
+# IDE & Client Integration Matrix
+
+This page tracks where major coding clients connect MCP servers, and how `m1nd`
+fits into each one.
+
+The high-level rule is simple:
+
+- use `m1nd-mcp` for universal compatibility
+- use the native hot daemon + thin proxy/client where the host supports a faster local lane
+
+## Integration matrix
+
+| Client | Integration surface | Config location / entrypoint | What to point at |
+|---|---|---|---|
+| Claude Code | MCP config file | `.claude/mcp.json` or `claude_mcp.json` | `m1nd-mcp` |
+| Codex | MCP config in TOML | `~/.codex/config.toml` | `m1nd-mcp` |
+| Cursor | MCP config file | `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` | `m1nd-mcp` or a thin native proxy |
+| Windsurf | MCP config file | Windsurf MCP settings / config JSON | `m1nd-mcp` or a thin native proxy |
+| GitHub Copilot coding agent | Repository MCP config UI | repository settings UI for MCP servers | `m1nd-mcp` or an editor-facing native proxy command |
+| Zed | Assistant MCP config | Zed assistant MCP configuration | `m1nd-mcp` |
+| Continue | MCP / config layer | Continue MCP configuration | `m1nd-mcp` |
+| Cline / Roo Code / OpenCode | MCP-compatible command config | client-specific MCP server config | `m1nd-mcp` |
+| Antigravity | `mcp_config.json` | workspace-local `mcp_config.json` | native proxy recommended |
+
+## Why some hosts should use a proxy
+
+Most hosts are perfectly fine with:
+
+```json
+{
+  "mcpServers": {
+    "m1nd": {
+      "command": "/path/to/m1nd-mcp",
+      "env": {
+        "M1ND_GRAPH_SOURCE": "/tmp/m1nd-graph.json",
+        "M1ND_PLASTICITY_STATE": "/tmp/m1nd-plasticity.json"
+      }
+    }
+  }
+}
+```
+
+On Windows the command should point at `m1nd-mcp.exe`, for example:
+
+```json
+{
+  "mcpServers": {
+    "m1nd": {
+      "command": "C:\\Users\\you\\.m1nd\\bin\\m1nd-mcp.exe",
+      "args": ["--stdio", "--no-gui"]
+    }
+  }
+}
+```
+
+Codex uses the same idea, but in TOML:
+
+```toml
+[mcp_servers.m1nd]
+command = "/path/to/m1nd-mcp"
+args = ["--stdio", "--no-gui"]
+
+[mcp_servers.m1nd.env]
+M1ND_GRAPH_SOURCE = "/tmp/m1nd-graph.json"
+M1ND_PLASTICITY_STATE = "/tmp/m1nd-plasticity.json"
+```
+
+But some editor hosts still pay too much overhead if they cold-start a stdio MCP
+server for every interaction.
+
+For those, the better shape is:
+
+```text
+host -> thin proxy/client -> hot native daemon -> SessionState
+```
+
+That preserves host compatibility while avoiding cold process startup and graph reload
+cost on every request.
+
+## Native fast path strategy
+
+### Universal lane
+
+- `m1nd-mcp`
+- stdio or HTTP/UI
+- best for broad compatibility
+
+### Native lane
+
+- `m1nd-openclaw`
+- persistent Unix socket bridge
+- best for local runtimes that can benefit from a hot graph
+- Unix/macOS/Linux lane today; use plain `m1nd-mcp` on Windows
+
+### Thin adapters
+
+Adapters should be very small:
+
+- translate the host's command/stdio shape
+- forward to the hot native daemon
+- preserve host expectations
+
+Examples:
+
+- OpenClaw → native shell/bridge adapter
+- Antigravity → `m1nd-antigravity-proxy.py`
+- Cursor / Windsurf → project-local MCP config pointing at a native proxy if desired
+
+## Practical recommendations
+
+### Use plain MCP when:
+
+- the host already keeps the MCP server alive
+- the repo is small
+- setup simplicity matters more than absolute latency
+
+### Use the native daemon lane when:
+
+- the host repeatedly cold-starts the server
+- the graph is large
+- you want graph-first navigation to feel immediate
+
+## Current m1nd-native components
+
+- `m1nd-openclaw` — hot daemon
+- `m1nd-openclaw-client` — CLI client
+- `scripts/macos/m1nd-openclaw-bridge.sh` — daemon wrapper
+- `scripts/macos/m1nd-openclaw-call.sh` — call wrapper
+- `scripts/macos/m1nd-antigravity-proxy.py` — editor-facing stdio proxy
+
+## Notes
+
+- Antigravity integration is grounded from the local product schema that recognizes
+  `mcp_config.json`.
+- Codex, Cursor, Windsurf, Claude Code, GitHub Copilot coding agent, Zed, and Continue
+  all fit the same conceptual model: host config chooses the command, env, and working directory.

package/docs/MCP-HOST-REFRESH.md

@@ -0,0 +1,123 @@
+# MCP Host Refresh
+
+Use this when the repo-local `m1nd-mcp` binary works, but a client such as
+Codex, Claude, Cursor, Windsurf, Cline, or another MCP host still exposes an
+older or partial tool surface.
+
+The most common symptom is simple:
+
+- local smoke sees `trust_selftest`, `ingest`, `seek`, `help`, `recovery_playbook`, and `doctor`
+- the host session only sees some of those tools
+- retrieval looks blocked or stale even after ingest
+
+## 1. Prove The Local Binary First
+
+From the repo root:
+
+```bash
+cargo build -p m1nd-mcp
+python3 scripts/m1nd_agent_demo.py --repo . --transport stdio --json
+python3 scripts/m1nd_agent_demo.py --repo . --transport http --json
+```
+
+Both outputs should report:
+
+- `schema=m1nd-agent-first-demo-v0`
+- `trust.verdict=full_trust`
+- `checks.trust_selftest_full_trust=true`
+- `checks.seek_scanned_ingested_graph=true`
+- `checks.negative_trust_selftest_validated=true`
+
+If these fail, fix the local binary or repo ingest path first. Do not blame the
+host binding yet.
+
+## 2. Compare The Host Tool Surface
+
+In the client, inspect its `tools/list` result. A safe host surface should expose
+at least:
+
+```text
+health
+trust_selftest
+session_handshake
+recovery_playbook
+doctor
+ingest
+seek
+help
+```
+
+If `trust_selftest` is visible, call it first:
+
+```json
+{"agent_id":"dev"}
+```
+
+If it returns `full_trust`, continue with m1nd-first work. If it returns any
+other verdict, follow the embedded `recovery_playbook` or call
+`recovery_playbook` with the same evidence.
+
+## 3. When Only `health` Is Visible
+
+Some hosts can still expose `health` while hiding newly added tools. In that
+case, call `health` and inspect:
+
+- `tool_surface_contract.required_host_visible_tools`
+- `host_binding_alignment`
+- `binding_fingerprint`
+
+If the contract requires tools the host does not list, treat the session as
+`degraded_host_tool_surface`. Use the local demo output as runtime truth and
+verify final answers against files until the client refreshes its MCP binding.
+
+## 4. Refresh The Client Binding
+
+Recommended order:
+
+1. Rebuild `m1nd-mcp`.
+2. Confirm the MCP config points at the rebuilt binary.
+3. Restart the MCP server process if the host manages it separately.
+4. Reload or restart the client window/session.
+5. Re-run `tools/list`.
+6. Call `trust_selftest`.
+
+For hosts that cache tool schemas per conversation or workspace, start a new
+conversation/session after rebuilding the binary. The old conversation may keep
+the previous tool registry even though the local binary is correct.
+
+## 5. Recovery Payload For Agents
+
+When a host surface is suspicious, pass the host evidence into `trust_selftest`
+or `recovery_playbook`:
+
+```json
+{
+  "agent_id": "dev",
+  "observed_tool": "tools/list",
+  "observed_proof_state": "blocked",
+  "observed_tool_count": 3,
+  "available_tools": ["health", "seek", "doctor"],
+  "missing_tools": ["trust_selftest", "ingest", "recovery_playbook"]
+}
+```
+
+For blocked retrieval after a populated ingest:
+
+```json
+{
+  "agent_id": "dev",
+  "observed_tool": "seek",
+  "observed_proof_state": "blocked",
+  "observed_candidates": 0
+}
+```
+
+The important rule is to compare binding fingerprints before falling back to
+manual search. If the local stdio/HTTP demo and the host session disagree, the
+problem is likely host binding freshness, not the graph model itself.
+
+## Limits
+
+This guide does not force any client to reload its MCP registry. It gives the
+agent a deterministic way to classify the session, preserve evidence, and avoid
+treating a stale host surface as a failed graph.

package/docs/README.md

@@ -0,0 +1,36 @@
+# Docs guide
+
+This repo keeps the public docs surface intentionally small.
+
+## Start here
+- `../README.md` — primary project overview and quick start
+- `AGENT-FIRST-DEMO.md` — shortest real agent-first demo transcript path
+- `AGENT-PACKS.md` — installable m1nd-first skills and portable agent packs
+- `MCP-HOST-REFRESH.md` — diagnose stale or partial MCP host tool surfaces
+- `deployment.md` — persistent runtime and production setup
+- `IDE-INTEGRATIONS.md` — client and integration notes
+- `use-cases.md` — audience-oriented product workflows
+- `benchmarks/README.md` — benchmark scenarios, runs, and methodology
+- `wiki/` — canonical mdBook source for the public docs site
+
+## Maintainer-facing docs
+- `internal/` — design notes, visual reviews, hardening reports, and workflow docs
+- `AGENT-TASKNOTES.md` — running capture of real agent friction worth turning into improvements
+
+## Public docs policy
+If a doc is primarily:
+- user-facing
+- setup-facing
+- benchmark-facing
+- or canonical product reference
+
+it should stay in the public docs surface.
+
+If it is primarily:
+- exploratory
+- historical
+- design-internal
+- release-process-specific
+- or maintainer-only
+
+it should live under `docs/internal/`.

package/npm/bin/m1nd.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+
+const { main } = require("../lib/cli");
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`m1nd: ${error.message}`);
+  process.exitCode = 1;
+});

package/npm/lib/cli.js

@@ -0,0 +1,346 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+const SKILLS_ROOT = path.join(PACKAGE_ROOT, "skills");
+const UNIVERSAL_PACK = path.join(SKILLS_ROOT, "m1nd-universal-agent-pack.md");
+
+const HOSTS = new Set(["codex", "claude", "gemini", "antigravity", "generic", "all"]);
+
+function usage() {
+  return `m1nd installer
+
+Usage:
+  m1nd init [--host codex|claude|gemini|antigravity|generic|all] [--project <dir>]
+  m1nd install-skills <host> [--project <dir>]
+  m1nd mcp-config <host> [--binary <path>]
+  m1nd doctor [--json]
+  m1nd demo [--repo <dir>] [--transport stdio|http] [--json]
+  m1nd smoke [--repo <dir>] [--transport stdio|http] [--json]
+  m1nd pack-check [--json]
+
+This npm package installs the universal agent doctrine and host adapters. The
+native runtime is still m1nd-mcp; doctor tells you whether it is visible.`;
+}
+
+function parseArgs(args) {
+  const parsed = { _: [] };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith("--")) {
+      parsed._.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    if (["help", "json", "yes"].includes(key)) {
+      parsed[key] = true;
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw new Error(`missing value for --${key}`);
+    }
+    parsed[key] = value;
+    index += 1;
+  }
+  return parsed;
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function copyFile(source, target) {
+  ensureDir(path.dirname(target));
+  fs.copyFileSync(source, target);
+}
+
+function copyDir(source, target) {
+  ensureDir(target);
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(sourcePath, targetPath);
+    } else if (entry.isFile()) {
+      copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+function which(binary) {
+  const paths = (process.env.PATH || "").split(path.delimiter);
+  const extensions = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of paths) {
+    for (const extension of extensions) {
+      const candidate = path.join(dir, `${binary}${extension}`);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+
+function runtimeBinaryName(platform = process.platform) {
+  return platform === "win32" ? "m1nd-mcp.exe" : "m1nd-mcp";
+}
+
+function defaultRuntimePath(platform = process.platform, homeDir = os.homedir()) {
+  const pathModule = platform === "win32" ? path.win32 : path;
+  return pathModule.join(homeDir, ".m1nd", "bin", runtimeBinaryName(platform));
+}
+
+function findRuntimeBinary() {
+  return process.env.M1ND_MCP_BINARY || which("m1nd-mcp") || (fs.existsSync(defaultRuntimePath()) ? defaultRuntimePath() : null);
+}
+
+function readPackageVersion() {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+  return packageJson.version;
+}
+
+function assertPackShape() {
+  const required = [
+    path.join(SKILLS_ROOT, "m1nd-first", "SKILL.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "SKILL.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "references", "routing-playbooks.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "references", "tool-families.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "references", "runtime-and-refresh.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "references", "l1ght-and-docs.md"),
+    path.join(SKILLS_ROOT, "m1nd-operator", "scripts", "probe_m1nd.py"),
+    UNIVERSAL_PACK,
+  ];
+  const missing = required.filter((file) => !fs.existsSync(file));
+  return { ok: missing.length === 0, missing, required };
+}
+
+function installCodex() {
+  const targetRoot = path.join(os.homedir(), ".codex", "skills");
+  copyDir(path.join(SKILLS_ROOT, "m1nd-first"), path.join(targetRoot, "m1nd-first"));
+  copyDir(path.join(SKILLS_ROOT, "m1nd-operator"), path.join(targetRoot, "m1nd-operator"));
+  return {
+    host: "codex",
+    installed: [
+      path.join(targetRoot, "m1nd-first"),
+      path.join(targetRoot, "m1nd-operator"),
+    ],
+  };
+}
+
+function hostRuleFilename(host) {
+  switch (host) {
+    case "claude":
+      return "CLAUDE.md";
+    case "gemini":
+      return "GEMINI.md";
+    case "antigravity":
+      return "AGENTS.md";
+    default:
+      return "m1nd-agent-rules.md";
+  }
+}
+
+function installPortable(host, projectDir) {
+  const targetRoot = path.join(projectDir, ".m1nd", "agent-pack");
+  copyDir(SKILLS_ROOT, path.join(targetRoot, "skills"));
+  const ruleFile = path.join(targetRoot, hostRuleFilename(host));
+  copyFile(UNIVERSAL_PACK, ruleFile);
+  return {
+    host,
+    installed: [targetRoot, ruleFile],
+    note: "Point your agent host at the rule file or paste it into the host custom-instructions surface.",
+  };
+}
+
+function installSkills(host, projectDir) {
+  if (!HOSTS.has(host)) {
+    throw new Error(`unsupported host '${host}'. Supported hosts: ${Array.from(HOSTS).join(", ")}`);
+  }
+  if (host === "all") {
+    return [
+      installCodex(),
+      installPortable("claude", projectDir),
+      installPortable("gemini", projectDir),
+      installPortable("antigravity", projectDir),
+      installPortable("generic", projectDir),
+    ];
+  }
+  if (host === "codex") {
+    return [installCodex()];
+  }
+  return [installPortable(host, projectDir)];
+}
+
+function mcpConfig(host, binary) {
+  const command = binary || findRuntimeBinary() || defaultRuntimePath();
+  if (host === "codex") {
+    const escapedCommand = command.replace(/\\/g, "\\\\");
+    return `[mcp_servers.m1nd]
+command = "${escapedCommand}"
+args = ["--stdio", "--no-gui"]
+`;
+  }
+  return JSON.stringify(
+    {
+      mcpServers: {
+        m1nd: {
+          command,
+          args: ["--stdio", "--no-gui"],
+        },
+      },
+    },
+    null,
+    2
+  );
+}
+
+function doctor() {
+  const pack = assertPackShape();
+  const binary = findRuntimeBinary();
+  const codexSkillRoot = path.join(os.homedir(), ".codex", "skills");
+  const codexSkillsInstalled =
+    fs.existsSync(path.join(codexSkillRoot, "m1nd-first", "SKILL.md")) &&
+    fs.existsSync(path.join(codexSkillRoot, "m1nd-operator", "SKILL.md"));
+
+  const result = {
+    schema: "m1nd-npm-doctor-v0",
+    package_version: readPackageVersion(),
+    package_root: PACKAGE_ROOT,
+    pack_ok: pack.ok,
+    missing_pack_files: pack.missing,
+    runtime: {
+      platform: process.platform,
+      arch: process.arch,
+      binary: binary || null,
+      default_install_path: defaultRuntimePath(),
+      visible_on_path_or_env: Boolean(binary),
+      hint: binary
+        ? "m1nd-mcp is visible. Use m1nd smoke from a repo checkout for a live MCP smoke."
+        : "m1nd-mcp is not visible. Build from source or install the native runtime before wiring MCP hosts.",
+    },
+    codex: {
+      skill_root: codexSkillRoot,
+      skills_installed: codexSkillsInstalled,
+    },
+    next_actions: [],
+  };
+
+  if (!pack.ok) {
+    result.next_actions.push("Reinstall or rebuild the npm package; required agent-pack files are missing.");
+  }
+  if (!binary) {
+    result.next_actions.push(`From a source checkout: cargo build --release -p m1nd-mcp, then copy ${runtimeBinaryName()} to ${defaultRuntimePath()}`);
+  }
+  if (!codexSkillsInstalled) {
+    result.next_actions.push("For Codex: m1nd install-skills codex");
+  }
+  if (result.next_actions.length === 0) {
+    result.next_actions.push("Run trust_selftest in your MCP host, then ingest your repo.");
+  }
+  return result;
+}
+
+function runDemo(args) {
+  const repo = path.resolve(args.repo || process.cwd());
+  const script = path.join(repo, "scripts", "m1nd_agent_demo.py");
+  if (!fs.existsSync(script)) {
+    throw new Error(`demo script not found at ${script}; run this from a m1nd source checkout`);
+  }
+  const python = process.env.PYTHON || "python3";
+  const commandArgs = [script, "--repo", repo, "--transport", args.transport || "stdio"];
+  if (args.json) commandArgs.push("--json");
+  const result = spawnSync(python, commandArgs, { stdio: "inherit" });
+  if (result.error) {
+    throw result.error;
+  }
+  process.exitCode = result.status || 0;
+}
+
+function print(value, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      console.log(`${item.host}:`);
+      for (const installed of item.installed) {
+        console.log(`  installed ${installed}`);
+      }
+      if (item.note) console.log(`  ${item.note}`);
+    }
+    return;
+  }
+  if (value.schema === "m1nd-npm-doctor-v0") {
+    console.log(`m1nd npm package ${value.package_version}`);
+    console.log(`pack: ${value.pack_ok ? "ok" : "missing files"}`);
+    console.log(`runtime: ${value.runtime.binary || "not found"}`);
+    console.log(`codex skills: ${value.codex.skills_installed ? "installed" : "not installed"}`);
+    console.log("next:");
+    for (const action of value.next_actions) console.log(`  - ${action}`);
+    return;
+  }
+  console.log(String(value));
+}
+
+async function main(rawArgs) {
+  const args = parseArgs(rawArgs);
+  const command = args._[0] || "help";
+
+  if (args.help || ["help", "-h", "--help"].includes(command)) {
+    console.log(usage());
+    return;
+  }
+
+  if (["init", "install-skills"].includes(command)) {
+    const host = args._[1] || args.host || "generic";
+    const projectDir = path.resolve(args.project || process.cwd());
+    print(installSkills(host, projectDir), args.json);
+    return;
+  }
+
+  if (command === "mcp-config") {
+    const host = args._[1] || args.host || "generic";
+    console.log(mcpConfig(host, args.binary));
+    return;
+  }
+
+  if (command === "doctor") {
+    print(doctor(), args.json);
+    return;
+  }
+
+  if (command === "pack-check") {
+    const result = assertPackShape();
+    if (args.json) {
+      console.log(JSON.stringify({ schema: "m1nd-agent-pack-check-v0", ...result }, null, 2));
+    } else {
+      console.log(result.ok ? "m1nd agent pack ok" : `m1nd agent pack missing: ${result.missing.join(", ")}`);
+    }
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (["demo", "smoke"].includes(command)) {
+    runDemo(args);
+    return;
+  }
+
+  throw new Error(`unknown command '${command}'\n\n${usage()}`);
+}
+
+module.exports = {
+  main,
+  assertPackShape,
+  defaultRuntimePath,
+  doctor,
+  findRuntimeBinary,
+  installSkills,
+  mcpConfig,
+  runtimeBinaryName,
+};

package/npm/test/cli.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const assert = require("assert");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const {
+  defaultRuntimePath,
+  mcpConfig,
+  runtimeBinaryName,
+} = require("../lib/cli");
+
+const cli = path.resolve(__dirname, "../bin/m1nd.js");
+
+assert.strictEqual(runtimeBinaryName("win32"), "m1nd-mcp.exe");
+assert.strictEqual(runtimeBinaryName("darwin"), "m1nd-mcp");
+assert.strictEqual(runtimeBinaryName("linux"), "m1nd-mcp");
+
+assert.strictEqual(
+  defaultRuntimePath("win32", "C:\\Users\\you"),
+  "C:\\Users\\you\\.m1nd\\bin\\m1nd-mcp.exe"
+);
+
+const codexWindowsConfig = mcpConfig(
+  "codex",
+  "C:\\Users\\you\\.m1nd\\bin\\m1nd-mcp.exe"
+);
+assert(codexWindowsConfig.includes('command = "C:\\\\Users\\\\you\\\\.m1nd\\\\bin\\\\m1nd-mcp.exe"'));
+assert(codexWindowsConfig.includes('args = ["--stdio", "--no-gui"]'));
+
+const genericWindowsConfig = JSON.parse(
+  mcpConfig("generic", "C:\\Users\\you\\.m1nd\\bin\\m1nd-mcp.exe")
+);
+assert.strictEqual(
+  genericWindowsConfig.mcpServers.m1nd.command,
+  "C:\\Users\\you\\.m1nd\\bin\\m1nd-mcp.exe"
+);
+assert.deepStrictEqual(genericWindowsConfig.mcpServers.m1nd.args, ["--stdio", "--no-gui"]);
+
+const help = spawnSync(process.execPath, [cli, "--help"], { encoding: "utf8" });
+assert.strictEqual(help.status, 0, help.stderr);
+assert(help.stdout.includes("m1nd installer"));
+assert(help.stdout.includes("m1nd smoke"));
+
+const packCheck = spawnSync(process.execPath, [cli, "pack-check", "--json"], { encoding: "utf8" });
+assert.strictEqual(packCheck.status, 0, packCheck.stderr);
+assert.strictEqual(JSON.parse(packCheck.stdout).schema, "m1nd-agent-pack-check-v0");
+
+console.log("npm cli tests ok");