predicate-skill 1.2.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,24 @@
+{
+  "name": "predicate",
+  "version": "1.0.0",
+  "description": "Local reasoning knowledge graph (RDF/OWL) for AI agents.",
+  "author": {
+    "name": "MX Research"
+  },
+  "homepage": "https://github.com/mxresearch/predicate#readme",
+  "repository": "https://github.com/mxresearch/predicate",
+  "license": "Apache-2.0",
+  "keywords": ["mcp", "knowledge-graph", "rdf", "owl", "sparql", "reasoning"],
+  "mcpServers": {
+    "predicate": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/server.bundle.mjs"],
+      "env": {
+        "FUSEKI_URL": "http://localhost:3030",
+        "PREDICATE_DATASET": "predicate"
+      }
+    }
+  },
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json"
+}

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,47 @@
+# predicate-skill
+
+Claude Code plugin packaging the Predicate MCP server + SKILL.md + SessionStart
+hook + operator skills. This is the install target for the marketplace path.
+
+## Install (via marketplace)
+
+```
+/plugin marketplace add mxresearch/predicate
+/plugin install predicate@predicate
+```
+
+After install, bring Fuseki up:
+
+```bash
+predicate up
+predicate doctor
+```
+
+## What's in this directory
+
+- `.claude-plugin/plugin.json` — MCP server + skills + hooks registration.
+- `server.bundle.mjs` — bundled MCP server (no `node_modules` required).
+- `cli.bundle.mjs` — bundled `predicate` CLI, surfaced via the package's `bin`.
+- `skills/predicate/SKILL.md` — host-agent contract: triggers, workflow,
+  HARD-GATE anti-patterns, four worked examples.
+- `skills/predicate-doctor/SKILL.md`, `skills/predicate-stats/SKILL.md` —
+  operator skills.
+- `hooks/hooks.json` + `hooks/session-start.sh` — SessionStart hook that
+  surfaces current goal/class counts.
+- `compose/docker-compose.yml`, `compose/fuseki/config.ttl` — Fuseki config
+  the CLI launches.
+
+## Rebuilding the bundles
+
+Bundles are committed so the marketplace install path works without
+`pnpm install`. To rebuild after a source change:
+
+```bash
+pnpm --filter predicate-skill bundle
+```
+
+Or rebuild everything:
+
+```bash
+pnpm build
+```

package/cli.bundle.mjs

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+
+// ../predicate-cli/src/docker.ts
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+function findComposeDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    process.env.PREDICATE_COMPOSE_DIR,
+    resolve(here, "compose"),
+    resolve(here, "..", "compose"),
+    resolve(here, "..", "..", "predicate-skill", "compose"),
+    resolve(here, "..", "..", "..", "predicate-skill", "compose"),
+    resolve(here, "..", "..", "..", "predicate-server")
+  ].filter((p) => Boolean(p));
+  for (const c of candidates) {
+    if (c && existsSync(resolve(c, "docker-compose.yml"))) return c;
+  }
+  throw new Error(
+    `Could not locate docker-compose.yml. Set PREDICATE_COMPOSE_DIR to the directory containing it, or run from the predicate repo root. Searched: ${candidates.join(", ")}`
+  );
+}
+function dockerAvailable() {
+  try {
+    execSync("docker version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function compose(args, cwd) {
+  const r = spawnSync("docker", ["compose", ...args], { cwd, stdio: "inherit" });
+  return r.status ?? 1;
+}
+
+// ../predicate-cli/src/commands/up.ts
+async function up() {
+  if (!dockerAvailable()) {
+    console.error("Docker not found. Install Docker Desktop or Docker Engine first.");
+    return 2;
+  }
+  const dir = findComposeDir();
+  console.log(`bringing Fuseki up from ${dir}`);
+  return compose(["up", "-d"], dir);
+}
+
+// ../predicate-cli/src/commands/down.ts
+async function down() {
+  if (!dockerAvailable()) {
+    console.error("Docker not found.");
+    return 2;
+  }
+  const dir = findComposeDir();
+  return compose(["down"], dir);
+}
+
+// ../predicate-mcp/src/sparql/client.ts
+function err(status, body) {
+  const e = new Error(`SPARQL error ${status}: ${body}`);
+  e.status = status;
+  e.body = body;
+  return e;
+}
+function authHeader() {
+  const user = process.env.PREDICATE_ADMIN_USER ?? "admin";
+  const pass = process.env.PREDICATE_ADMIN_PASSWORD ?? "changeme";
+  return "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
+}
+var SparqlClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  async select(query) {
+    const res = await fetch(this.cfg.queryEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/sparql-query",
+        "Accept": "application/sparql-results+json",
+        "Authorization": authHeader()
+      },
+      body: query
+    });
+    if (!res.ok) throw err(res.status, await res.text());
+    return await res.json();
+  }
+  async ask(query) {
+    const res = await fetch(this.cfg.queryEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/sparql-query",
+        "Accept": "application/sparql-results+json",
+        "Authorization": authHeader()
+      },
+      body: query
+    });
+    if (!res.ok) throw err(res.status, await res.text());
+    const json = await res.json();
+    return json.boolean;
+  }
+  async update(query) {
+    const res = await fetch(this.cfg.updateEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/sparql-update",
+        "Authorization": authHeader()
+      },
+      body: query
+    });
+    if (!res.ok) throw err(res.status, await res.text());
+  }
+  async knownGraphs() {
+    const r = await this.select(
+      'SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } FILTER(STRSTARTS(STR(?g), "kg:")) }'
+    );
+    return r.results.bindings.map((b) => b.g.value);
+  }
+};
+
+// ../predicate-mcp/src/config.ts
+function loadConfig() {
+  const raw = process.env.FUSEKI_URL ?? "http://localhost:3030";
+  const fusekiUrl = raw.replace(/\/+$/, "");
+  const dataset = process.env.PREDICATE_DATASET ?? "predicate";
+  return {
+    fusekiUrl,
+    dataset,
+    queryEndpoint: `${fusekiUrl}/${dataset}/query`,
+    updateEndpoint: `${fusekiUrl}/${dataset}/update`,
+    dataEndpoint: `${fusekiUrl}/${dataset}/data`
+  };
+}
+
+// ../predicate-cli/src/commands/doctor.ts
+async function doctor() {
+  const cfg = loadConfig();
+  const checks = [];
+  checks.push({
+    name: "docker installed",
+    ok: dockerAvailable(),
+    detail: dockerAvailable() ? "" : "install Docker Desktop"
+  });
+  const ping = await fetch(`${cfg.fusekiUrl}/$/ping`).catch(() => null);
+  checks.push({
+    name: "fuseki reachable",
+    ok: Boolean(ping?.ok),
+    detail: ping?.ok ? cfg.fusekiUrl : `not reachable at ${cfg.fusekiUrl} \u2014 try 'predicate up'`
+  });
+  if (ping?.ok) {
+    const client = new SparqlClient(cfg);
+    const tboxOk = await client.ask(`
+      PREFIX owl: <http://www.w3.org/2002/07/owl#>
+      ASK { GRAPH <kg:tbox> { ?c a owl:Class } }
+    `).catch(() => false);
+    checks.push({
+      name: "kg:tbox loaded",
+      ok: tboxOk,
+      detail: tboxOk ? "" : "no classes found \u2014 try 'predicate up' (re-runs bootstrap)"
+    });
+  }
+  const width = Math.max(...checks.map((c) => c.name.length));
+  for (const c of checks) {
+    const mark = c.ok ? "[x]" : "[ ]";
+    const name = c.name.padEnd(width);
+    const detail = c.detail ? `  \u2014 ${c.detail}` : "";
+    console.log(`${mark} ${name}${detail}`);
+  }
+  return checks.every((c) => c.ok) ? 0 : 1;
+}
+
+// ../predicate-mcp/src/tools/kg-stats.ts
+async function countGraph(client, graph) {
+  const r = await client.select(
+    `SELECT (COUNT(*) AS ?n) WHERE { GRAPH <${graph}> { ?s ?p ?o } }`
+  );
+  return parseInt(r.results.bindings[0].n.value, 10);
+}
+async function countClasses(client) {
+  const r = await client.select(`
+    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+    SELECT (COUNT(DISTINCT ?c) AS ?n) WHERE {
+      GRAPH <kg:tbox> { ?c a owl:Class }
+    }
+  `);
+  return parseInt(r.results.bindings[0].n.value, 10);
+}
+async function unusedConceptRatio(client, classCount) {
+  if (classCount === 0) return 0;
+  const r = await client.select(`
+    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+    PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    SELECT (COUNT(DISTINCT ?c) AS ?n) WHERE {
+      GRAPH <kg:tbox> { ?c a owl:Class }
+      FILTER NOT EXISTS {
+        { GRAPH <kg:abox>     { ?x rdf:type ?c } }
+        UNION
+        { GRAPH <kg:inferred> { ?x rdf:type ?c } }
+      }
+    }
+  `);
+  const unused = parseInt(r.results.bindings[0].n.value, 10);
+  return unused / classCount;
+}
+async function materializationLatencyP95(client) {
+  const r = await client.select(`
+    PREFIX pred: <https://predicate.dev/meta#>
+    SELECT ?payload WHERE {
+      GRAPH <kg:meta> {
+        ?e a pred:MaterializationCompleted ;
+           pred:payload ?payload .
+      }
+    }
+  `);
+  const values = r.results.bindings.map((b) => {
+    const raw = b.payload?.value ?? "";
+    const m = raw.match(/"elapsedMs"\s*:\s*(\d+)/);
+    return m ? parseInt(m[1], 10) : 0;
+  }).filter((n) => Number.isFinite(n) && n > 0);
+  if (values.length === 0) return 0;
+  values.sort((a, b) => a - b);
+  const idx = Math.min(values.length - 1, Math.ceil(values.length * 0.95) - 1);
+  return values[Math.max(idx, 0)];
+}
+async function kgStats(client) {
+  const [abox, inferred, tbox] = await Promise.all([
+    countGraph(client, "kg:abox"),
+    countGraph(client, "kg:inferred"),
+    countGraph(client, "kg:tbox")
+  ]);
+  const classes = await countClasses(client);
+  const triples = abox + inferred + tbox;
+  const denom = abox + inferred;
+  const inferredRatio = denom === 0 ? 0 : inferred / denom;
+  const unused = await unusedConceptRatio(client, classes);
+  const p95 = await materializationLatencyP95(client);
+  return {
+    triples,
+    abox,
+    inferred,
+    tbox,
+    classes,
+    inferredRatio,
+    unusedConceptRatio: unused,
+    materializationLatencyMsP95: p95
+  };
+}
+
+// ../predicate-cli/src/commands/stats.ts
+async function stats() {
+  const client = new SparqlClient(loadConfig());
+  const s = await kgStats(client);
+  const rows = [
+    ["triples", s.triples],
+    ["abox", s.abox],
+    ["inferred", s.inferred],
+    ["tbox", s.tbox],
+    ["classes", s.classes],
+    ["inferredRatio", s.inferredRatio.toFixed(3)],
+    ["unusedConceptRatio", s.unusedConceptRatio.toFixed(3)],
+    ["materializationLatencyMsP95", s.materializationLatencyMsP95]
+  ];
+  const width = Math.max(...rows.map(([k]) => k.length));
+  for (const [k, v] of rows) {
+    console.log(`${k.padEnd(width)}  ${v}`);
+  }
+  return 0;
+}
+
+// ../predicate-cli/src/index.ts
+var VERSION = "1.0.0";
+function help() {
+  console.log(`predicate <command>
+
+Commands:
+  up           Bring Fuseki up (docker compose up -d) and load the seed TBox.
+  down         Stop Fuseki, preserve the data volume.
+  doctor       Health checks: docker, fuseki, tbox.
+  stats        Print kg_stats output for the live graph.
+  --version    Print the predicate version.
+  --help       This message.
+
+Env:
+  FUSEKI_URL                http://localhost:3030 (default)
+  PREDICATE_DATASET         predicate (default)
+  PREDICATE_ADMIN_USER      admin (default)
+  PREDICATE_ADMIN_PASSWORD  changeme (default)
+  PREDICATE_COMPOSE_DIR     override docker-compose.yml location
+`);
+}
+async function main() {
+  const cmd = process.argv[2];
+  switch (cmd) {
+    case "up":
+      return up();
+    case "down":
+      return down();
+    case "doctor":
+      return doctor();
+    case "stats":
+      return stats();
+    case "--version":
+    case "version":
+      console.log(VERSION);
+      return 0;
+    case void 0:
+    case "--help":
+    case "help":
+      help();
+      return 0;
+    default:
+      console.error(`unknown command: ${cmd}`);
+      help();
+      return 2;
+  }
+}
+main().then((code) => process.exit(code)).catch((err2) => {
+  console.error(err2);
+  process.exit(1);
+});

package/commands/ask.md

@@ -0,0 +1,18 @@
+---
+name: ask
+description: Ask the knowledge graph a structural question. Composes kg_explore_schema → kg_ask → kg_explain.
+---
+
+# /predicate:ask <question>
+
+Treat the arguments as the user's question. Follow the SKILL.md workflow:
+
+1. Call `kg_explore_schema(concept)` for the main subject in the question.
+2. Draft fresh SPARQL against `kg:abox ∪ kg:inferred` using predicates from
+   the schema slice.
+3. Call `kg_ask` to execute.
+4. Call `kg_explain` for each load-bearing claim in the answer, with cited
+   provenance.
+
+Do NOT invent predicates — use only what `kg_explore_schema` returned. If a
+predicate is missing, call `kg_propose_schema` instead of fabricating.

package/commands/doctor.md

@@ -0,0 +1,14 @@
+---
+name: doctor
+description: Run health checks on the Predicate stack — Docker + Fuseki + TBox.
+---
+
+# /predicate:doctor
+
+Run the shell command `predicate doctor` for the user. Fallback to
+`node ${CLAUDE_PLUGIN_ROOT}/cli.bundle.mjs doctor` if not on PATH.
+
+Read the output. For each `[ ]` (failed) check, give the user the
+one-line fix from the doctor's `— ...` detail field.
+
+Then call `kg_stats` via MCP to sanity-check that tools actually respond.

package/commands/down.md

@@ -0,0 +1,11 @@
+---
+name: down
+description: Stop Fuseki via `predicate down` (preserves the data volume).
+---
+
+# /predicate:down
+
+Run the shell command `predicate down` for the user. Fallback to
+`node ${CLAUDE_PLUGIN_ROOT}/cli.bundle.mjs down` if not on PATH.
+
+Report the exit code.

package/commands/stats.md

@@ -0,0 +1,22 @@
+---
+name: stats
+description: Show current Predicate graph metrics via `kg_stats`.
+---
+
+# /predicate:stats
+
+Call the `kg_stats` MCP tool. Format the result as a compact table:
+
+```
+triples              N
+abox                 N
+inferred             N
+tbox                 N
+classes              N
+inferredRatio        N.NNN
+unusedConceptRatio   N.NNN
+materializationLatencyMsP95   N
+```
+
+Flag if `unusedConceptRatio > 0.15` (PRD §16 bounded-growth target) — suggest
+`/predicate:maintain` (or `kg_maintain` MCP call) to reclaim space.

package/commands/up.md

@@ -0,0 +1,13 @@
+---
+name: up
+description: Bring Fuseki up via `predicate up` (Docker Compose + bootstrap graphs + load seed TBox).
+---
+
+# /predicate:up
+
+Run the shell command `predicate up` for the user.
+
+If `predicate` is not on PATH, fall back to:
+`node ${CLAUDE_PLUGIN_ROOT}/cli.bundle.mjs up`
+
+Report the exit code. If non-zero, run `predicate doctor` and report what's failing.