diff --git a/README.md b/README.md
index 2f6c26a..987e005 100644
--- a/README.md
+++ b/README.md
@@ -148,9 +148,25 @@ binary. See the [specification](docs/opencontext/spec.md), [CLI](docs/opencontex
[SDK](docs/opencontext/sdk.md), [security model](docs/opencontext/security.md), and
[conformance guide](docs/opencontext/conformance.md).
+## One command for every LogicSRC tool
+
+`logicsrc` is the umbrella: every LogicSRC standard that has a CLI is a word after it, and the word runs the same code as the standalone command, so the two cannot drift.
+
+```bash
+logicsrc vault … # OpenCreds (also `opencreds`)
+logicsrc prd … # OpenPRD
+logicsrc ontology … # OpenOntology
+logicsrc context … # OpenContext (also `opencontext`)
+logicsrc openmcp … # OpenMCP: relays, find, call, add, probe, serve (also `openmcp`)
+logicsrc openspec … # import, export, change; any other word is OpenSpec.dev's own CLI (init, list, validate, archive, show)
+logicsrc mcp # the LogicSRC MCP server over stdio (also `logicsrc-mcp`)
+```
+
+`openmcp` is the one that lives in its own repository ([logicsrc/openmcp](https://github.com/logicsrc/openmcp)); it is a dependency here and its `main` is called with your arguments untouched. It needs Node 24 (`node:sqlite`); on an older Node that one word says so and the rest of the CLI keeps working. The standalone install, which brings its own Node 24, is `curl -fsSL https://openmcp.logicsrc.com/install.sh | sh`.
+
## MCP
-LogicSRC exposes a standards-focused MCP server as `@profullstack/logicsrc-mcp`.
+LogicSRC exposes a standards-focused MCP server as `@profullstack/logicsrc-mcp`, and `logicsrc mcp` runs it.
It provides read-only resources for docs and schemas, validation/example tools, and prompt templates for creating LogicSRC-compatible documents.
## v1.0.0 Priorities
diff --git a/apps/logicsrc-web/src/app/openmcp/page.tsx b/apps/logicsrc-web/src/app/openmcp/page.tsx
index caa5b0e..396fb96 100644
--- a/apps/logicsrc-web/src/app/openmcp/page.tsx
+++ b/apps/logicsrc-web/src/app/openmcp/page.tsx
@@ -229,7 +229,8 @@ export default function OpenMcpPage(): ReactNode {
github.com/logicsrc/openmcp : the
reference catalog and client:{" "}
- curl -fsSL https://openmcp.logicsrc.com/install.sh | sh
+ curl -fsSL https://openmcp.logicsrc.com/install.sh | sh, or{" "}
+ logicsrc openmcp from the LogicSRC CLI
{
+ return new Promise((resolve) => {
+ const child = spawn(process.execPath, [bin, ...args], { stdio: "inherit" });
+ child.on("error", (error) => {
+ console.error(`Could not start the LogicSRC MCP server at ${bin}: ${error.message}`);
+ resolve(1);
+ });
+ child.on("exit", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+ });
+}
+
+export function registerMcpCommands(program: Command, run: (args: string[]) => Promise = runLogicsrcMcp): void {
+ program
+ .command("mcp")
+ .description(
+ "Run the LogicSRC MCP server over stdio: schemas, prompts, validators, OpenOntology and OpenPRD for an " +
+ "agent client. The same server as the standalone `logicsrc-mcp` command.",
+ )
+ .argument("[args...]", "Arguments for logicsrc-mcp, exactly as the standalone command takes them")
+ .allowUnknownOption()
+ .passThroughOptions()
+ .action(async (args: string[]) => {
+ process.exitCode = await run(args);
+ });
+}
diff --git a/packages/cli/src/openmcp.ts b/packages/cli/src/openmcp.ts
new file mode 100644
index 0000000..113e1c7
--- /dev/null
+++ b/packages/cli/src/openmcp.ts
@@ -0,0 +1,63 @@
+import type { Command } from "commander";
+
+/**
+ * `logicsrc openmcp …`
+ *
+ * OpenMCP is the one LogicSRC command that lives outside this monorepo
+ * (github.com/logicsrc/openmcp, published as `@logicsrc/openmcp`), so unlike
+ * `vault`, `prd` and `context` it cannot register commander commands here.
+ * Instead every argument after `openmcp` is handed, untouched, to the same
+ * `main(argv)` the standalone `openmcp` binary runs, so `logicsrc openmcp
+ * relays` and `openmcp relays` are one contract and can never drift.
+ *
+ * The import is deferred to the action because the catalog keeps its records
+ * in `node:sqlite`, which is Node 24, while the rest of this CLI runs on 18.
+ * A box on an older Node keeps every other command and gets a plain sentence
+ * from this one instead of a stack trace about a built-in it has never heard
+ * of.
+ */
+export const OPENMCP_PACKAGE = "@logicsrc/openmcp";
+export const OPENMCP_MIN_NODE = 24;
+
+export function openmcpNodeMessage(version: string = process.version): string {
+ return [
+ `logicsrc openmcp needs Node ${OPENMCP_MIN_NODE} or newer, and this is ${version}.`,
+ " mise use -g node@lts # then re-run",
+ " curl -fsSL https://openmcp.logicsrc.com/install.sh | sh # or the standalone command, which brings its own Node 24",
+ ].join("\n");
+}
+
+/** Is this Node new enough for the catalog? */
+export function meetsOpenmcpNode(version: string = process.version): boolean {
+ return Number.parseInt(version.replace(/^v/, ""), 10) >= OPENMCP_MIN_NODE;
+}
+
+type OpenmcpMain = (argv: string[]) => Promise;
+
+/** Loaded on first use, and swapped out in tests. */
+export async function loadOpenmcpMain(): Promise {
+ const mod = (await import(`${OPENMCP_PACKAGE}/cli`)) as { main: OpenmcpMain };
+ return mod.main;
+}
+
+export function registerOpenMcpCommands(program: Command, load: () => Promise = loadOpenmcpMain): void {
+ program
+ .command("openmcp")
+ .description(
+ "OpenMCP: the open catalog of MCP relays. relays, find, call, add, probe, serve, and the rest of the " +
+ "standalone `openmcp` command, handed through as typed. `logicsrc openmcp help` lists them.",
+ )
+ .argument("[args...]", "Arguments for openmcp, exactly as the standalone command takes them")
+ .allowUnknownOption()
+ .passThroughOptions()
+ .helpOption(false)
+ .action(async (args: string[]) => {
+ if (!meetsOpenmcpNode()) {
+ console.error(openmcpNodeMessage());
+ process.exitCode = 1;
+ return;
+ }
+ const main = await load();
+ process.exitCode = await main(args.length ? args : ["help"]);
+ });
+}
diff --git a/packages/cli/src/openspec-dev.ts b/packages/cli/src/openspec-dev.ts
new file mode 100644
index 0000000..2d20500
--- /dev/null
+++ b/packages/cli/src/openspec-dev.ts
@@ -0,0 +1,60 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import type { Command } from "commander";
+
+/**
+ * `logicsrc openspec `
+ *
+ * `logicsrc openspec` owns three words of its own (`import`, `export`,
+ * `change`: the LogicSRC-shaped view of a repo's OpenSpec artifacts). Every
+ * other word is OpenSpec.dev's, and goes to OpenSpec.dev's real CLI
+ * (`@fission-ai/openspec`, the `openspec` binary) with the arguments exactly
+ * as typed: `logicsrc openspec init`, `list`, `validate`, `archive`, `show`.
+ * So a repo in compatibility mode needs one command installed, not two, and
+ * the OpenSpec.dev half is the upstream tool itself rather than a
+ * reimplementation of it that would drift.
+ *
+ * Spawned rather than imported: the package exports a library entry only, and
+ * its bin does the argv parsing, colour and prompts. Its bin is not on the
+ * exports map, so it is found from the package root instead of resolved by
+ * name.
+ */
+export const OPENSPEC_PACKAGE = "@fission-ai/openspec";
+
+/** Where OpenSpec.dev's bin lives, found from its package root. */
+export function openspecBin(resolveEntry: (id: string) => string = createRequire(import.meta.url).resolve): string {
+ // The only export is dist/index.js; bin/openspec.js sits beside dist/.
+ const entry = resolveEntry(OPENSPEC_PACKAGE);
+ return join(dirname(dirname(entry)), "bin", "openspec.js");
+}
+
+export function runOpenspec(args: string[], bin: string = openspecBin()): Promise {
+ return new Promise((resolve) => {
+ const child = spawn(process.execPath, [bin, ...args], { stdio: "inherit" });
+ child.on("error", (error) => {
+ console.error(`Could not start OpenSpec.dev's CLI at ${bin}: ${error.message}`);
+ resolve(1);
+ });
+ child.on("exit", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+ });
+}
+
+/**
+ * Attach the pass-through as the group's default subcommand, so any word
+ * commander does not know (`init`, `list`, `validate`, ...) lands here with
+ * its arguments intact, while `import`, `export` and `change` keep working.
+ */
+export function registerOpenSpecDevPassthrough(openspec: Command, run: (args: string[]) => Promise = runOpenspec): void {
+ openspec.passThroughOptions();
+ openspec
+ .command("dev", { isDefault: true, hidden: true })
+ .argument("[args...]", "Arguments for OpenSpec.dev's openspec command, exactly as it takes them")
+ .allowUnknownOption()
+ .passThroughOptions()
+ .helpOption(false)
+ .description("Any other word: OpenSpec.dev's own CLI (init, list, validate, archive, show, ...).")
+ .action(async (args: string[]) => {
+ process.exitCode = await run(args.length ? args : ["--help"]);
+ });
+}
diff --git a/packages/cli/src/umbrella.test.ts b/packages/cli/src/umbrella.test.ts
new file mode 100644
index 0000000..6c5e88e
--- /dev/null
+++ b/packages/cli/src/umbrella.test.ts
@@ -0,0 +1,87 @@
+import { Command } from "commander";
+import { describe, expect, it } from "vitest";
+import { meetsOpenmcpNode, openmcpNodeMessage, registerOpenMcpCommands } from "./openmcp.js";
+import { openspecBin, registerOpenSpecDevPassthrough } from "./openspec-dev.js";
+import { logicsrcMcpBin, registerMcpCommands } from "./mcp.js";
+
+/** A program shaped like the real one: positional options on, no process.exit. */
+function program(): Command {
+ const p = new Command();
+ p.name("logicsrc").enablePositionalOptions().exitOverride();
+ return p;
+}
+
+describe("logicsrc openmcp", () => {
+ it("hands every argument, flags included, to openmcp's own main", async () => {
+ const seen: string[][] = [];
+ const p = program();
+ registerOpenMcpCommands(p, async () => async (argv) => {
+ seen.push(argv);
+ return 0;
+ });
+ await p.parseAsync(["node", "logicsrc", "openmcp", "relays", "--online", "--catalog", "https://x.example", "--json"]);
+ expect(seen).toEqual([["relays", "--online", "--catalog", "https://x.example", "--json"]]);
+ expect(process.exitCode).toBe(0);
+ });
+
+ it("asks for help when given nothing, and passes the exit code back", async () => {
+ const seen: string[][] = [];
+ const p = program();
+ registerOpenMcpCommands(p, async () => async (argv) => {
+ seen.push(argv);
+ return 3;
+ });
+ await p.parseAsync(["node", "logicsrc", "openmcp"]);
+ expect(seen).toEqual([["help"]]);
+ expect(process.exitCode).toBe(3);
+ process.exitCode = 0;
+ });
+
+ it("knows the catalog's Node floor and offers the standalone installer below it", () => {
+ expect(meetsOpenmcpNode("v24.0.0")).toBe(true);
+ expect(meetsOpenmcpNode("v22.18.0")).toBe(false);
+ expect(openmcpNodeMessage("v22.18.0")).toContain("curl -fsSL https://openmcp.logicsrc.com/install.sh | sh");
+ });
+});
+
+describe("logicsrc openspec", () => {
+ function group(run: (args: string[]) => Promise): { p: Command; own: string[] } {
+ const p = program();
+ const own: string[] = [];
+ const openspec = p.command("openspec");
+ openspec.command("import").argument("[root]").action((root: string | undefined) => void own.push(`import ${root ?? ""}`.trim()));
+ registerOpenSpecDevPassthrough(openspec, run);
+ return { p, own };
+ }
+
+ it("keeps its own words", async () => {
+ const seen: string[][] = [];
+ const { p, own } = group(async (args) => (seen.push(args), 0));
+ await p.parseAsync(["node", "logicsrc", "openspec", "import", "specs"]);
+ expect(own).toEqual(["import specs"]);
+ expect(seen).toEqual([]);
+ });
+
+ it("sends any other word to OpenSpec.dev's CLI with its flags intact", async () => {
+ const seen: string[][] = [];
+ const { p } = group(async (args) => (seen.push(args), 0));
+ await p.parseAsync(["node", "logicsrc", "openspec", "validate", "--all", "--strict"]);
+ await p.parseAsync(["node", "logicsrc", "openspec", "init"]);
+ expect(seen).toEqual([["validate", "--all", "--strict"], ["init"]]);
+ });
+
+ it("finds the bin beside dist/ from the package's only export", () => {
+ expect(openspecBin(() => "/node_modules/@fission-ai/openspec/dist/index.js")).toBe("/node_modules/@fission-ai/openspec/bin/openspec.js");
+ });
+});
+
+describe("logicsrc mcp", () => {
+ it("runs the server entry, which is also its bin", async () => {
+ const seen: string[][] = [];
+ const p = program();
+ registerMcpCommands(p, async (args) => (seen.push(args), 0));
+ await p.parseAsync(["node", "logicsrc", "mcp"]);
+ expect(seen).toEqual([[]]);
+ expect(logicsrcMcpBin(() => "/x/dist/index.js")).toBe("/x/dist/index.js");
+ });
+});