predicate-skill 1.2.0 → 1.6.0

package/hooks/codex-cli/README.md

@@ -0,0 +1,30 @@
+# Codex CLI adapter
+
+## Install MCP server
+
+Merge `config.toml.template` into `~/.codex/config.toml`, replacing
+`__PLUGIN_DIR__` with the absolute path to this package. The 8 `kg_*`
+tools will be available the next time you launch `codex`.
+
+## Hooks
+
+Codex CLI does not expose SessionStart, PreCompact, or Stop lifecycle
+events as of writing. The three scripts in this directory are provided
+so you can:
+
+1. Run `session-start.sh` manually and paste output into your initial
+   Codex prompt. Or alias:
+
+```sh
+# in ~/.zshrc or ~/.bashrc
+codex() { command codex --context "$(predicate sessionstart 2>/dev/null)" "$@"; }
+```
+
+2. Wire `pre-compact.sh` and `stop.sh` to cron for periodic maintenance:
+
+```cron
+*/30 * * * * /absolute/path/hooks/codex-cli/pre-compact.sh >/dev/null 2>&1
+```
+
+If Codex CLI adds lifecycle hooks in the future, this adapter is ready
+to wire them — script logic is unchanged.

package/hooks/codex-cli/config.toml.template

@@ -0,0 +1,10 @@
+# Merge into ~/.codex/config.toml — replace __PLUGIN_DIR__ with the
+# absolute path to packages/predicate-skill.
+
+[mcp_servers.predicate]
+command = "node"
+args = ["__PLUGIN_DIR__/server.bundle.mjs"]
+
+[mcp_servers.predicate.env]
+FUSEKI_URL = "http://localhost:3030"
+PREDICATE_DATASET = "predicate"

package/hooks/codex-cli/pre-compact.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Codex CLI pre-compact adapter: run via cron to keep the KG tidy.
+set -euo pipefail
+predicate maintain

package/hooks/codex-cli/session-start.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Codex CLI session-start adapter. Codex has no native SessionStart event;
+# run this manually before a session and paste the output as initial context,
+# or alias it to `codex` in your shell rc.
+set -euo pipefail
+predicate sessionstart 2>/dev/null || \
+  echo "Predicate: Fuseki not reachable; run \`predicate up\` first."

package/hooks/codex-cli/stop.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Codex CLI stop adapter: run manually after long sessions.
+set -euo pipefail
+predicate maintain

package/hooks/cursor/README.md

@@ -0,0 +1,46 @@
+# Cursor adapter
+
+Predicate exposes its 8 `kg_*` tools to Cursor over MCP, plus three optional
+maintenance scripts you can wire into cron.
+
+## 1. MCP server
+
+Copy `mcp.json.template` to `.cursor/mcp.json` (project-local) or
+`~/.cursor/mcp.json` (global), replacing `__PLUGIN_DIR__` with the absolute
+path to your local clone, e.g. `/Users/you/code/predicate/packages/predicate-skill`.
+
+Then in Cursor restart MCP (Cmd-Shift-P → "Reload MCP servers") and the 8
+`kg_*` tools will be available.
+
+## 2. Optional: SessionStart context
+
+Cursor has no native SessionStart event. Two options:
+
+**a. Manual:** Run `bash session-start.sh` in your terminal; paste the
+output into `.cursor/rules/predicate.md`.
+
+**b. Cron:** Refresh the rule file periodically:
+
+```cron
+*/10 * * * * bash /absolute/path/hooks/cursor/session-start.sh > /project/.cursor/rules/predicate.md
+```
+
+## 3. Optional: PreCompact maintenance
+
+Cursor has no native PreCompact event. Wire `pre-compact.sh` to cron so the
+KG stays tidy between sessions:
+
+```cron
+*/30 * * * * /absolute/path/hooks/cursor/pre-compact.sh >/dev/null 2>&1
+```
+
+## 4. Optional: Stop maintenance
+
+Run `bash stop.sh` manually after a long session, or wire it into a shell
+shutdown alias.
+
+## Notes
+
+All scripts require `predicate` on `$PATH`. Install with
+`npm install -g predicate-skill`, or use the absolute path:
+`/abs/path/to/predicate/packages/predicate-skill/cli.bundle.mjs`.

package/hooks/cursor/mcp.json.template

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "predicate": {
+      "command": "node",
+      "args": ["__PLUGIN_DIR__/server.bundle.mjs"],
+      "env": {
+        "FUSEKI_URL": "http://localhost:3030",
+        "PREDICATE_DATASET": "predicate"
+      }
+    }
+  }
+}

package/hooks/cursor/pre-compact.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Cursor pre-compact adapter: trims low-confidence stale facts and
+# promotes any matured staged TBox proposals before context compaction.
+# Cursor has no native PreCompact event — run manually or via cron, e.g.:
+#   */30 * * * * /path/to/hooks/cursor/pre-compact.sh
+set -euo pipefail
+predicate maintain

package/hooks/cursor/session-start.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Cursor session-start adapter: emits a plain text status line.
+# Cursor reads stdout when invoked from a custom rule script;
+# can also be run manually and pasted into .cursor/rules/predicate.md.
+set -euo pipefail
+predicate sessionstart 2>/dev/null || \
+  echo "Predicate: Fuseki not reachable; run \`predicate up\` first."

package/hooks/cursor/stop.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Cursor session-end adapter: runs maintenance on session close.
+# Cursor has no native Stop event — run manually after each session.
+set -euo pipefail
+predicate maintain

package/hooks/gemini-cli/README.md

@@ -0,0 +1,29 @@
+# Gemini CLI adapter
+
+## Install
+
+Merge `settings.json.template` into `~/.gemini/settings.json`, replacing
+`__PLUGIN_DIR__` with the absolute path to this package
+(e.g. `/Users/you/code/predicate/packages/predicate-skill`).
+
+Restart Gemini CLI. The 8 `kg_*` tools will be available; the three hook
+scripts will fire on `sessionStart`, `preCompress`, and `stop`.
+
+## Hooks reference
+
+| Event | Script | What it does |
+|---|---|---|
+| `sessionStart` | `session-start.sh` | Prints KG status line; Gemini reads stdout as context. |
+| `preCompress` | `pre-compact.sh` | Runs `predicate maintain` before context compression. |
+| `stop` | `stop.sh` | Runs `predicate maintain` on session close. |
+
+## If your Gemini version doesn't expose hooks
+
+The `hooks` block is harmless if unsupported. You can still run each script
+manually or via cron — see `../cursor/README.md` for cron examples; the
+syntax is identical.
+
+## Verify wiring
+
+Run `gemini --debug` and start a fresh session; you should see Predicate's
+KG status line printed in the debug output before your first prompt.

package/hooks/gemini-cli/pre-compact.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Gemini CLI pre-compress adapter: runs maintenance before Gemini compacts
+# the chat context. Wire to the `preCompress` event in settings.json.
+set -euo pipefail
+predicate maintain

package/hooks/gemini-cli/session-start.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Gemini CLI session-start adapter. Gemini reads stdout as additional context
+# when wired via the `hooks` block in ~/.gemini/settings.json (event: "sessionStart").
+set -euo pipefail
+predicate sessionstart 2>/dev/null || \
+  echo "Predicate: Fuseki not reachable; run \`predicate up\` first."

package/hooks/gemini-cli/settings.json.template

@@ -0,0 +1,17 @@
+{
+  "mcpServers": {
+    "predicate": {
+      "command": "node",
+      "args": ["__PLUGIN_DIR__/server.bundle.mjs"],
+      "env": {
+        "FUSEKI_URL": "http://localhost:3030",
+        "PREDICATE_DATASET": "predicate"
+      }
+    }
+  },
+  "hooks": [
+    { "event": "sessionStart", "command": "bash __PLUGIN_DIR__/hooks/gemini-cli/session-start.sh" },
+    { "event": "preCompress",  "command": "bash __PLUGIN_DIR__/hooks/gemini-cli/pre-compact.sh" },
+    { "event": "stop",         "command": "bash __PLUGIN_DIR__/hooks/gemini-cli/stop.sh" }
+  ]
+}

package/hooks/gemini-cli/stop.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Gemini CLI stop adapter: runs maintenance on session close.
+# Wire to the `stop` event in settings.json.
+set -euo pipefail
+predicate maintain

package/hooks/hooks.json

@@ -4,6 +4,21 @@
       "event": "SessionStart",
       "matcher": "startup|clear|compact",
       "command": "bash ${PLUGIN_DIR}/hooks/session-start.sh"
+    },
+    {
+      "event": "PreToolUse",
+      "matcher": "*",
+      "command": "bash ${PLUGIN_DIR}/hooks/pre-tool-use.sh"
+    },
+    {
+      "event": "PostToolUse",
+      "matcher": "*",
+      "command": "bash ${PLUGIN_DIR}/hooks/post-tool-use.sh"
+    },
+    {
+      "event": "Stop",
+      "matcher": "*",
+      "command": "bash ${PLUGIN_DIR}/hooks/stop.sh"
     }
   ]
 }

package/hooks/opencode/README.md

@@ -0,0 +1,31 @@
+# OpenCode adapter
+
+## Install
+
+Merge `opencode.json.template` into `~/.config/opencode/opencode.json`
+(or your project-local `opencode.json`), replacing `__PLUGIN_DIR__` with
+the absolute path to this package.
+
+Restart OpenCode. The 8 `kg_*` tools will be available, and the three
+hook scripts will fire on `session.started`, `session.compacted`, and
+`session.stopped`.
+
+## Hooks reference
+
+| Event | Script | What it does |
+|---|---|---|
+| `session.started` | `session-start.sh` | Prints KG status line; OpenCode reads stdout as context. |
+| `session.compacted` | `pre-compact.sh` | Runs `predicate maintain` before context compression. |
+| `session.stopped` | `stop.sh` | Runs `predicate maintain` on session close. |
+
+## Verify wiring
+
+Start an OpenCode session and check the debug log; you should see
+Predicate's KG status line in the initial context, and `predicate maintain`
+output when the session compacts or stops.
+
+## If event names changed in your OpenCode version
+
+Consult `opencode --help events` (or the OpenCode docs) for the current
+event names. The scripts are event-agnostic — only the template's `on:`
+keys need to match.

package/hooks/opencode/opencode.json.template

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "predicate": {
+      "type": "local",
+      "command": ["node", "__PLUGIN_DIR__/server.bundle.mjs"],
+      "environment": {
+        "FUSEKI_URL": "http://localhost:3030",
+        "PREDICATE_DATASET": "predicate"
+      }
+    }
+  },
+  "events": [
+    { "on": "session.started",   "run": "bash __PLUGIN_DIR__/hooks/opencode/session-start.sh" },
+    { "on": "session.compacted", "run": "bash __PLUGIN_DIR__/hooks/opencode/pre-compact.sh" },
+    { "on": "session.stopped",   "run": "bash __PLUGIN_DIR__/hooks/opencode/stop.sh" }
+  ]
+}

package/hooks/opencode/pre-compact.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# OpenCode pre-compact adapter. Wire to the session.compacted event
+# (fires immediately before OpenCode compresses chat history).
+set -euo pipefail
+predicate maintain

package/hooks/opencode/session-start.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# OpenCode session-start adapter. OpenCode reads stdout as additional context
+# when wired to the session.started event.
+set -euo pipefail
+predicate sessionstart 2>/dev/null || \
+  echo "Predicate: Fuseki not reachable; run \`predicate up\` first."

package/hooks/opencode/stop.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# OpenCode stop adapter. Wire to the session.stopped event.
+set -euo pipefail
+predicate maintain

package/hooks/post-tool-use.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Claude Code PostToolUse hook: records {toolName, input, output, sessionId,
+# phase:"post"} in kg:usage. Reads Claude Code's hook payload JSON from stdin
+# and delegates to `predicate capture --from-stdin`. Fails open.
+set -uo pipefail
+
+if command -v predicate >/dev/null 2>&1; then
+  predicate capture --from-stdin --phase post >/dev/null 2>&1 || true
+fi
+exit 0

package/hooks/pre-tool-use.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Claude Code PreToolUse hook: records {toolName, input, sessionId, phase:"pre"}
+# in kg:usage. Reads Claude Code's hook payload JSON from stdin and delegates
+# to `predicate capture --from-stdin`. Fails open: any error returns exit 0
+# so the user's tool invocation is never blocked by capture logic.
+set -uo pipefail
+
+if command -v predicate >/dev/null 2>&1; then
+  predicate capture --from-stdin --phase pre >/dev/null 2>&1 || true
+fi
+exit 0

package/hooks/session-start.sh

@@ -1,25 +1,13 @@
 #!/usr/bin/env bash
-# SessionStart hook: emits a short context block telling the agent
-# how many open goals and active concepts Predicate is tracking.
+# SessionStart hook for Claude Code: emits a short context block telling
+# the agent what's in the KG. Delegates to `predicate sessionstart` so the
+# message format stays in one place.
 set -euo pipefail
-FUSEKI="${FUSEKI_URL:-http://localhost:3030}"
-DS="${PREDICATE_DATASET:-predicate}"
 
-if ! curl -fsS "$FUSEKI/$/ping" >/dev/null 2>&1; then
-  jq -n '{ additional_context: "Predicate: Fuseki not reachable; KG tools may fail. Start it with `pnpm fuseki:up`." }'
-  exit 0
+if MSG="$(predicate sessionstart 2>/dev/null)"; then
+  :
+else
+  MSG="Predicate: Fuseki not reachable; KG tools may fail. Start it with \`predicate up\`."
 fi
 
-GOALS=$(curl -fsS "$FUSEKI/$DS/query" \
-  --data-urlencode "query=PREFIX pred: <https://predicate.dev/meta#>
-  SELECT (COUNT(*) AS ?n) WHERE { GRAPH <kg:goals> { ?g pred:status \"active\" } }" \
-  --header "Accept: application/sparql-results+json" \
-  | jq -r '.results.bindings[0].n.value // "0"')
-
-CONCEPTS=$(curl -fsS "$FUSEKI/$DS/query" \
-  --data-urlencode "query=SELECT (COUNT(DISTINCT ?c) AS ?n) WHERE { GRAPH <kg:tbox> { ?c a <http://www.w3.org/2002/07/owl#Class> } }" \
-  --header "Accept: application/sparql-results+json" \
-  | jq -r '.results.bindings[0].n.value // "0"')
-
-MSG="Predicate ready: ${GOALS} active goals, ${CONCEPTS} TBox classes. Use kg_explore_schema before drafting SPARQL."
 jq -n --arg m "$MSG" '{ additional_context: $m }'

package/hooks/stop.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Claude Code Stop hook: reads the Stop-hook JSON payload from stdin,
+# runs structured turn extraction (predicate extract), then a
+# maintenance sweep. Fail-open: any error returns exit 0 so capture
+# never blocks the user's next prompt.
+set -uo pipefail
+
+if ! command -v predicate >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Buffer stdin so we can tee it into extract.
+payload="$(cat || true)"
+
+if [ -n "$payload" ]; then
+  printf '%s' "$payload" | predicate extract --from-stdin >/dev/null 2>&1 || true
+fi
+
+predicate maintain >/dev/null 2>&1 || true
+exit 0

package/hooks/vscode-copilot/README.md

@@ -0,0 +1,43 @@
+# VS Code Copilot adapter
+
+## Install MCP server
+
+Merge `settings.json.template` into your VS Code `settings.json`
+(User or Workspace), replacing `__PLUGIN_DIR__` with the absolute path
+to this package. Restart VS Code. The 8 `kg_*` tools will be available
+to Copilot Chat.
+
+## Hooks
+
+VS Code Copilot does not expose SessionStart, PreCompact, or Stop
+lifecycle events as of writing. The three scripts in this directory
+are provided so you can:
+
+1. Run `session-start.sh` manually before opening Copilot Chat and
+   paste the output into a prompt as initial context.
+
+2. Wire `pre-compact.sh` and `stop.sh` to cron for periodic KG
+   maintenance — see `../cursor/README.md` for cron examples.
+
+3. Use them in VS Code tasks (`.vscode/tasks.json`):
+
+```json
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "predicate: session start",
+      "type": "shell",
+      "command": "bash ${workspaceFolder}/packages/predicate-skill/hooks/vscode-copilot/session-start.sh"
+    },
+    {
+      "label": "predicate: maintain",
+      "type": "shell",
+      "command": "bash ${workspaceFolder}/packages/predicate-skill/hooks/vscode-copilot/pre-compact.sh"
+    }
+  ]
+}
+```
+
+If VS Code adds lifecycle hooks for Copilot Chat in the future, this
+adapter is ready to wire them — script logic is unchanged.

package/hooks/vscode-copilot/pre-compact.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# VS Code Copilot pre-compact adapter. Run via cron or a VS Code task.
+set -euo pipefail
+predicate maintain

package/hooks/vscode-copilot/session-start.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# VS Code Copilot session-start adapter. VS Code has no native SessionStart
+# hook today — run this manually before invoking Copilot Chat, or wire it
+# to a VS Code task in tasks.json.
+set -euo pipefail
+predicate sessionstart 2>/dev/null || \
+  echo "Predicate: Fuseki not reachable; run \`predicate up\` first."

package/hooks/vscode-copilot/settings.json.template

@@ -0,0 +1,12 @@
+{
+  "github.copilot.chat.mcp.servers": {
+    "predicate": {
+      "command": "node",
+      "args": ["__PLUGIN_DIR__/server.bundle.mjs"],
+      "env": {
+        "FUSEKI_URL": "http://localhost:3030",
+        "PREDICATE_DATASET": "predicate"
+      }
+    }
+  }
+}

package/hooks/vscode-copilot/stop.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# VS Code Copilot stop adapter. Run manually after a long chat session
+# or wire to a VS Code task that runs on workspace close.
+set -euo pipefail
+predicate maintain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "predicate-skill",
-  "version": "1.2.0",
+  "version": "1.6.0",
   "description": "Local reasoning knowledge graph (RDF/OWL) for AI agents — Claude Code plugin + MCP server + predicate CLI.",
   "author": {
     "name": "Nordic Agents Research",

package/server.bundle.mjs

@@ -3643,7 +3643,7 @@ var require_fast_uri = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse3(serialize(uri, options), options);
+        parse3(serialize2(uri, options), options);
       }
       return uri;
     }
@@ -3651,13 +3651,13 @@ var require_fast_uri = __commonJS({
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved, schemelessOptions);
+      return serialize2(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse3(serialize(base, options), options);
-        relative = parse3(serialize(relative, options), options);
+        base = parse3(serialize2(base, options), options);
+        relative = parse3(serialize2(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -3711,7 +3711,7 @@ var require_fast_uri = __commonJS({
       const normalizedB = normalizeComparableURI(uriB, options);
       return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
-    function serialize(cmpts, opts) {
+    function serialize2(cmpts, opts) {
       const component = {
         host: cmpts.host,
         scheme: cmpts.scheme,
@@ -3889,7 +3889,7 @@ var require_fast_uri = __commonJS({
     function normalizeStringWithStatus(uri, opts) {
       const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        normalized: malformedAuthorityOrPort ? uri : serialize2(parsed, opts),
         malformedAuthorityOrPort
       };
     }
@@ -3899,7 +3899,7 @@ var require_fast_uri = __commonJS({
         return malformedAuthorityOrPort ? void 0 : normalized;
       }
       if (typeof uri === "object") {
-        return serialize(uri, opts);
+        return serialize2(uri, opts);
       }
     }
     var fastUri = {
@@ -3908,7 +3908,7 @@ var require_fast_uri = __commonJS({
       resolve: resolve2,
       resolveComponent,
       equal,
-      serialize,
+      serialize: serialize2,
       parse: parse3
     };
     module.exports = fastUri;
@@ -30990,9 +30990,9 @@ async function kgAsk(client, input) {
 async function logUsage(client, question, sparql, rowCount, elapsedMs) {
   const usage = escapeIRI(GRAPH.usage);
   const id = `urn:predicate:usage:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const META6 = "https://predicate.dev/meta#";
+  const META7 = "https://predicate.dev/meta#";
   await client.update(`
-    PREFIX pred: <${META6}>
+    PREFIX pred: <${META7}>
     PREFIX xsd:  <http://www.w3.org/2001/XMLSchema#>
     INSERT DATA { GRAPH ${usage} {
       <${id}> a pred:Query ;
@@ -37832,6 +37832,51 @@ async function kgStats(client) {
   };
 }
 
+// ../predicate-mcp/src/tools/kg-capture.ts
+var META6 = "https://predicate.dev/meta#";
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  const extra = s.length - max;
+  return `${s.slice(0, max)} \u2026 [truncated, ${extra} more chars]`;
+}
+function serialize(value, max) {
+  let s;
+  if (value === void 0 || value === null) s = "";
+  else if (typeof value === "string") s = value;
+  else {
+    try {
+      s = JSON.stringify(value);
+    } catch {
+      s = String(value);
+    }
+  }
+  return truncate(s, max);
+}
+async function kgCapture(client, input) {
+  const t0 = Date.now();
+  const maxChars = parseInt(process.env["PREDICATE_CAPTURE_TRUNCATE"] ?? "500", 10);
+  const captureId = `urn:predicate:capture:${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const inputStr = serialize(input.input, maxChars);
+  const hasOutput = input.output !== void 0 && input.output !== null;
+  const outputStr = hasOutput ? serialize(input.output, maxChars) : "";
+  const lines = [
+    `${escapeIRI(captureId)} a <${META6}ToolCall> ;`,
+    `  <${META6}toolName>  ${escapeLiteral(input.toolName)} ;`,
+    `  <${META6}phase>     ${escapeLiteral(input.phase)} ;`,
+    `  <${META6}at>        "${(/* @__PURE__ */ new Date()).toISOString()}"^^<http://www.w3.org/2001/XMLSchema#dateTime>`
+  ];
+  if (inputStr.length > 0) lines.push(`  ; <${META6}toolInput>  ${escapeLiteral(inputStr)}`);
+  if (hasOutput) lines.push(`  ; <${META6}toolOutput> ${escapeLiteral(outputStr)}`);
+  if (input.sessionId) lines.push(`  ; <${META6}sessionId>  ${escapeLiteral(input.sessionId)}`);
+  lines.push("  .");
+  await client.update(`
+    INSERT DATA { GRAPH ${escapeIRI(GRAPH.usage)} {
+      ${lines.join("\n      ")}
+    } }
+  `);
+  return { captureId, elapsedMs: Date.now() - t0 };
+}
+
 // ../predicate-mcp/src/tools/registry.ts
 var deltaQuadSchema = external_exports.object({
   s: external_exports.string(),
@@ -37996,6 +38041,27 @@ function buildTools(client) {
       inputSchema: external_exports.object({}),
       handler: async () => kgStats(client)
     },
+    {
+      name: "kg_capture",
+      description: "Record a tool invocation (toolName, input, output, sessionId, phase) into kg:usage. Used by per-platform PreToolUse/PostToolUse hooks; safe to call directly. Returns {captureId, elapsedMs}.",
+      inputSchema: external_exports.object({
+        toolName: external_exports.string().min(1),
+        input: external_exports.unknown().optional(),
+        output: external_exports.unknown().optional(),
+        sessionId: external_exports.string().optional(),
+        phase: external_exports.enum(["pre", "post"])
+      }),
+      handler: async (raw) => {
+        const args = external_exports.object({
+          toolName: external_exports.string().min(1),
+          input: external_exports.unknown().optional(),
+          output: external_exports.unknown().optional(),
+          sessionId: external_exports.string().optional(),
+          phase: external_exports.enum(["pre", "post"])
+        }).parse(raw);
+        return kgCapture(client, args);
+      }
+    },
     ...stubs()
   ];
 }