@plur-ai/mcp 0.13.0 → 0.14.0

package/README.md

@@ -52,6 +52,7 @@ Your agent gets these tools automatically:
 |------|-------------|
 | `plur_session_start` | Start a session — injects relevant engrams for your task |
 | `plur_learn` | Store a memory — correction, preference, convention, or decision |
+| `plur_learn_batch` | Store many memories in one call — same dedup + policy as `plur_learn`, with per-item failure isolation |
 | `plur_recall_hybrid` | **Best default** — BM25 + embeddings merged via RRF. Zero cost. |
 | `plur_recall` | Keyword search (BM25 only, instant) |
 | `plur_inject_hybrid` | Load relevant memories for the current task |

package/dist/index.js

@@ -5,14 +5,17 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSy
 import { join } from "path";
 import { fileURLToPath } from "url";
 import { homedir, platform } from "os";
-var VERSION = "0.13.0";
+var VERSION = "0.14.0";
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
-  plur-mcp              Start the MCP server (stdio transport)
-  plur-mcp init         Set up PLUR: storage + MCP config + hooks + CLAUDE.md
-  plur-mcp --help       Show this help message
-  plur-mcp --version    Show version
+  plur-mcp                           Start the MCP server (stdio transport)
+  plur-mcp init                      Set up PLUR: storage + MCP config + hooks + CLAUDE.md
+  plur-mcp packs install <path>      Install a knowledge pack from a local directory
+  plur-mcp packs list                List installed knowledge packs
+  plur-mcp packs uninstall <name>    Uninstall a knowledge pack by name
+  plur-mcp --help                    Show this help message
+  plur-mcp --version                 Show version
 
 Environment:
   PLUR_PATH             Storage location (default: ~/.plur/)
@@ -65,6 +68,12 @@ var PLUR_HOOKS = {
     matcher: "auto|manual",
     hooks: [{ type: "command", command: `${CLI} hook-inject --rehydrate`, timeout: 15 }]
   }],
+  // Auto-close the memory lifecycle at session end (Claude Code SessionEnd,
+  // shipped v1.0.85) — captures a closing episode and cleans up the session
+  // checkpoint even if the agent forgot to call plur_session_end (#217).
+  SessionEnd: [{
+    hooks: [{ type: "command", command: `${CLI} hook-session-end`, timeout: 5 }]
+  }],
   // --- Contextual injection ---
   PreToolUse: [
     { matcher: "EnterPlanMode", hooks: [{ type: "command", command: `${CLI} hook-inject --event plan_mode`, timeout: 10 }] },
@@ -98,7 +107,7 @@ Hooks inject engrams automatically on every first message \u2014 you do not need
 2. **Learn**: When corrected or discovering something new, call \`plur_learn\` immediately
 3. **Recall**: Before answering factual questions, call \`plur_recall_hybrid\` \u2014 check memory first
 4. **Feedback**: Rate injected engrams with \`plur_feedback\` (positive/negative) \u2014 trains relevance
-5. **End**: Call \`plur_session_end\` with summary + engram_suggestions
+5. **End**: Call \`plur_session_end\` with summary + engram_suggestions \u2014 a SessionEnd hook auto-closes the lifecycle if you forget, but calling it yourself captures higher-quality learnings
 
 Do not ask permission to use these tools \u2014 they are your memory system.
 
@@ -264,6 +273,65 @@ async function runInit() {
 `);
   }
 }
+async function runPacks() {
+  const sub = process.argv[3];
+  const plurPath = process.env.PLUR_PATH ?? join(homedir(), ".plur");
+  const { Plur } = await import("@plur-ai/core");
+  const plur = new Plur({ path: plurPath });
+  if (sub === "install") {
+    const source = process.argv[4];
+    if (!source) {
+      process.stderr.write("Usage: plur-mcp packs install <path>\n");
+      process.exit(1);
+    }
+    try {
+      const result = plur.installPack(source);
+      process.stdout.write(`Installed pack '${result.name}' (${result.installed} engrams)
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  } else if (sub === "list") {
+    const packs = plur.listPacks();
+    if (packs.length === 0) {
+      process.stdout.write("No packs installed.\n");
+    } else {
+      for (const pack of packs) {
+        const version = pack.manifest?.version ? ` v${pack.manifest.version}` : "";
+        process.stdout.write(`${pack.name}${version} (${pack.engram_count} engrams)
+`);
+      }
+    }
+  } else if (sub === "uninstall") {
+    const name = process.argv[4];
+    if (!name) {
+      process.stderr.write("Usage: plur-mcp packs uninstall <name>\n");
+      process.exit(1);
+    }
+    try {
+      const result = plur.uninstallPack(name);
+      if (result.removed) {
+        process.stdout.write(`Uninstalled pack '${result.name}' (${result.engram_count} engrams removed)
+`);
+      } else {
+        process.stderr.write(`Pack '${name}' not found.
+`);
+        process.exit(1);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  } else {
+    process.stderr.write(`Unknown packs subcommand: ${sub ?? "(none)"}
+Available: install, list, uninstall
+`);
+    process.exit(1);
+  }
+}
 var arg = process.argv[2];
 if (arg === "--help" || arg === "-h") {
   process.stdout.write(HELP);
@@ -278,8 +346,12 @@ if (arg === "init") {
   await runInit();
   process.exit(0);
 }
+if (arg === "packs") {
+  await runPacks();
+  process.exit(0);
+}
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-B6OJN4ZX.js");
+  const { runStdio } = await import("./server-LAXRBVKA.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);

package/dist/{server-B6OJN4ZX.js → server-LAXRBVKA.js}

@@ -11,6 +11,9 @@ import {
   ErrorCode,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 import { Plur as Plur2, checkForUpdate } from "@plur-ai/core";
 
 // src/tools.ts
@@ -31,7 +34,7 @@ function recordTelemetry(event) {
 }
 
 // src/version.ts
-var VERSION = "0.13.0";
+var VERSION = "0.14.0";
 
 // src/tools.ts
 import { z } from "zod";
@@ -179,6 +182,24 @@ mcpCanary.expect({
   description: "Learning from corrections",
   fix: "Call plur_learn when corrected. If using hooks, verify they are installed."
 });
+var _sessionTelemetry = /* @__PURE__ */ new Map();
+var SESSION_TTL_MS = 8 * 60 * 60 * 1e3;
+function _cleanExpiredSessions() {
+  const cutoff = Date.now() - SESSION_TTL_MS;
+  for (const [id, state] of _sessionTelemetry) {
+    if (new Date(state.started_at).getTime() < cutoff) _sessionTelemetry.delete(id);
+  }
+}
+var _activeSessionId;
+function _recordInjectionTelemetry(session_id, injected_packs) {
+  if (!session_id || !injected_packs) return;
+  const state = _sessionTelemetry.get(session_id);
+  if (!state) return;
+  state.injection_calls++;
+  for (const [pack, count] of Object.entries(injected_packs)) {
+    state.pack_counts[pack] = (state.pack_counts[pack] ?? 0) + count;
+  }
+}
 var CURSOR_CORE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "plur_session_start",
   "plur_session_end",
@@ -347,6 +368,87 @@ function getAllToolDefinitions() {
         }
       }
     },
+    {
+      name: "plur_learn_batch",
+      description: "Create many engrams in one call \u2014 the batch form of plur_learn. Accepts an array of engram objects and writes them sequentially through the SAME dedup + policy pipeline as plur_learn (content-hash NOOP \u2192 semantic recall \u2192 LLM ADD/UPDATE/MERGE decision). Dedup also applies WITHIN the batch: a statement duplicating an earlier item in the same array resolves to NOOP against it. Returns `ids` aligned 1:1 with the input array (ids[i] is the engram id for input i, or null if input i failed), the per-item decisions (each carrying its input_index), aggregate stats, and any per-item failures (each with its input index) \u2014 a single bad item does not abort the batch. Use this when an orchestration fans out and wants to persist consolidated findings without N separate calls. LLM dedup calls are capped (default 50, override with max_llm_calls) to bound bulk-import cost. Note: unlike plur_learn, batch items take the LOCAL learn path \u2014 remote-scope auto-routing (learnRouted) is not applied per item, so for shared/remote-store writes prefer plur_learn or pass an explicit local scope. See plur-ai/plur#281.",
+      annotations: { title: "Learn (batch)", destructiveHint: false, idempotentHint: false },
+      inputSchema: {
+        type: "object",
+        properties: {
+          engrams: {
+            type: "array",
+            description: "Engram objects to persist. Each requires `statement`; the other fields mirror plur_learn.",
+            items: {
+              type: "object",
+              properties: {
+                statement: { type: "string", description: "The knowledge assertion to store" },
+                type: { type: "string", enum: ["behavioral", "terminological", "procedural", "architectural"], description: "Category of the engram" },
+                scope: { type: "string", description: "Namespace, e.g. global, project:myapp" },
+                domain: { type: "string", description: "Domain tag, e.g. software.deployment" },
+                tags: { type: "array", items: { type: "string" }, description: "Searchable keyword tags \u2014 contribute to BM25/embedding recall" },
+                rationale: { type: "string", description: "Why this knowledge matters \u2014 also enters the search corpus" },
+                source: { type: "string", description: "Origin of this knowledge (URL, conversation ref, etc.)" },
+                pinned: { type: "boolean", description: "Always-load flag. Use sparingly: meta-rules, safety conventions, core principles." },
+                commitment: { type: "string", enum: ["exploring", "leaning", "decided", "locked"], description: "How firmly the user has committed (default: leaning)" },
+                valid_from: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge becomes valid" },
+                valid_until: { type: "string", description: "ISO date (YYYY-MM-DD) the knowledge expires" }
+              },
+              required: ["statement"]
+            }
+          },
+          max_llm_calls: { type: "number", description: "Max LLM dedup calls across the whole batch (default 50). Once spent, remaining items use the cheap hash/cosine path. Pass a large number to opt out." }
+        },
+        required: ["engrams"]
+      },
+      handler: async (args, plur) => {
+        const llm = getLlmFunction();
+        const raw = Array.isArray(args.engrams) ? args.engrams : [];
+        if (raw.length === 0) {
+          return { ids: [], results: [], stats: { added: 0, updated: 0, merged: 0, noops: 0, failed: 0 }, failures: [], warning: "No engrams provided \u2014 pass a non-empty `engrams` array." };
+        }
+        const items = raw.map((e) => ({
+          statement: sanitizeStatement(e.statement),
+          context: {
+            type: e.type,
+            scope: e.scope,
+            domain: e.domain,
+            source: e.source,
+            tags: e.tags,
+            rationale: e.rationale,
+            commitment: e.commitment,
+            pinned: e.pinned,
+            valid_from: e.valid_from,
+            valid_until: e.valid_until
+          }
+        }));
+        const maxLlmCalls = typeof args.max_llm_calls === "number" ? args.max_llm_calls : void 0;
+        const { results, stats, failures } = await plur.learnBatch(
+          items,
+          llm,
+          maxLlmCalls !== void 0 ? { maxLlmCalls } : void 0
+        );
+        mcpCanary.signal("learn_activity");
+        recordTelemetry("learn");
+        const ids = raw.map(() => null);
+        for (const r of results) {
+          if (r.input_index !== void 0) ids[r.input_index] = r.engram.id;
+        }
+        return {
+          ids,
+          results: results.map((r) => ({
+            input_index: r.input_index,
+            id: r.engram.id,
+            statement: r.engram.statement,
+            scope: r.engram.scope,
+            type: r.engram.type,
+            decision: r.decision,
+            ...r.existing_id ? { existing_id: r.existing_id } : {}
+          })),
+          stats,
+          ...failures.length > 0 ? { failures, warning: `${failures.length} of ${raw.length} engram(s) failed to persist; the rest were written.` } : {}
+        };
+      }
+    },
     {
       name: "plur_recall",
       description: "Query engrams by BM25 keyword matching \u2014 use plur_recall_hybrid for semantic similarity. Note: a project-scope filter also returns personal-family engrams (local, global, user:*, agent:*); an explicit scope=global recall returns ALL personal-family engrams \u2014 wider than scope=global INJECT, which is targeted to the global namespace only.",
@@ -370,14 +472,18 @@ function getAllToolDefinitions() {
           limit: args.limit
         });
         return {
-          results: results.map((e) => ({
-            id: e.id,
-            statement: e.statement,
-            type: e.type,
-            scope: e.scope,
-            domain: e.domain,
-            retrieval_strength: e.activation.retrieval_strength
-          })),
+          results: results.map((e) => {
+            const supersededBy = e.relations?.superseded_by;
+            const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
+            return {
+              id: e.id,
+              statement: e.statement + annotation,
+              type: e.type,
+              scope: e.scope,
+              domain: e.domain,
+              retrieval_strength: e.activation.retrieval_strength
+            };
+          }),
           count: results.length
         };
       }
@@ -433,9 +539,11 @@ function getAllToolDefinitions() {
         const response = {
           results: boundedResults.map((e) => {
             const raw = e;
+            const supersededBy = e.relations?.superseded_by;
+            const annotation = supersededBy?.length ? ` [superseded by ${supersededBy.join(", ")}]` : "";
             const base = {
               id: e.id,
-              statement: e.statement,
+              statement: e.statement + annotation,
               type: e.type,
               scope: e.scope,
               domain: e.domain,
@@ -483,6 +591,7 @@ function getAllToolDefinitions() {
           budget: args.budget,
           scope: args.scope
         });
+        _recordInjectionTelemetry(_activeSessionId, result.injected_packs);
         return {
           directives: result.directives,
           consider: result.consider,
@@ -512,6 +621,7 @@ function getAllToolDefinitions() {
           budget: args.budget,
           scope: args.scope
         });
+        _recordInjectionTelemetry(_activeSessionId, result.injected_packs);
         return {
           directives: result.directives,
           consider: result.consider,
@@ -1050,14 +1160,20 @@ function getAllToolDefinitions() {
     },
     {
       name: "plur_status",
-      description: "Return system health \u2014 running version, engram count, episode count, pack count, storage root",
+      description: "Return system health \u2014 running version, engram count, episode count, pack count, storage root. Optionally filter engram counts by domain prefix and/or creation date.",
       annotations: { title: "Status", readOnlyHint: true, idempotentHint: true },
       inputSchema: {
         type: "object",
-        properties: {}
+        properties: {
+          domain: { type: "string", description: 'Only count engrams whose domain starts with this prefix (e.g. "meridian")' },
+          created_after: { type: "string", description: "ISO-8601 date (YYYY-MM-DD). Only count engrams learned on or after this date." }
+        }
       },
-      handler: async (_args, plur) => {
-        const status = plur.status();
+      handler: async (args, plur) => {
+        const status = plur.status({
+          domain: args.domain,
+          created_after: args.created_after
+        });
         const versionCheck = getCachedUpdateCheck("@plur-ai/mcp");
         return {
           version: VERSION,
@@ -1184,6 +1300,23 @@ function getAllToolDefinitions() {
             }
           }
           checks.push({ check: "reranker available", ok: rerankerOk, detail: rerankerDetail });
+          if (rerankerOk) {
+            try {
+              const fitResult = await plur.checkRerankerFit({ rerankerName });
+              const sep = fitResult.separability.toFixed(3);
+              checks.push({
+                check: "reranker domain fit",
+                ok: fitResult.fit,
+                detail: fitResult.n_pairs === 0 ? "Not enough engrams to evaluate fit (< 2) \u2014 assuming fit" : fitResult.fit ? `Good fit \u2014 separability ${sep} on ${fitResult.n_pairs} pairs (threshold \u2265 0.05)` : `Poor fit \u2014 separability ${sep} on ${fitResult.n_pairs} pairs (threshold \u2265 0.05). Reranker may be net-negative on this store's domain mix.`
+              });
+              if (!fitResult.fit && fitResult.n_pairs > 0) {
+                remediation.push(
+                  `Reranker "${rerankerName}" shows poor separability (${sep}) on this store's engrams \u2014 it may be scoring irrelevant pairs higher than relevant ones. Consider unsetting PLUR_RERANKER or switching to a different tier. The fit check compares same-domain vs cross-domain pair scores; low separability means the model lacks signal on your content.`
+                );
+              }
+            } catch {
+            }
+          }
           try {
             let evalStatus;
             let freshlyRun = false;
@@ -1286,6 +1419,13 @@ function getAllToolDefinitions() {
         const session_id = crypto.randomUUID();
         const task = args.task;
         const tags = args.tags;
+        _cleanExpiredSessions();
+        _activeSessionId = session_id;
+        _sessionTelemetry.set(session_id, {
+          pack_counts: {},
+          injection_calls: 0,
+          started_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
         let outbox_result;
         try {
           outbox_result = await plur.flushOutbox();
@@ -1319,6 +1459,7 @@ function getAllToolDefinitions() {
             session_id
             // stamped on the co_injection provenance event (#452)
           });
+          _recordInjectionTelemetry(session_id, result.injected_packs);
           if (result.count > 0) {
             const lines = [];
             if (result.directives) lines.push("## DIRECTIVES\n", result.directives);
@@ -1331,6 +1472,7 @@ function getAllToolDefinitions() {
             scope: tags?.length ? `tags:${tags.join(",")}` : void 0,
             session_id
           });
+          _recordInjectionTelemetry(session_id, result.injected_packs);
           if (result.count > 0) {
             const lines = [];
             if (result.directives) lines.push("## DIRECTIVES\n", result.directives);
@@ -1516,6 +1658,16 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
           session_id,
           channel: "mcp"
         });
+        const telemetry = session_id ? _sessionTelemetry.get(session_id) : void 0;
+        const injection_summary = telemetry && telemetry.injection_calls > 0 ? {
+          pack_counts: { ...telemetry.pack_counts },
+          total_injections: telemetry.injection_calls,
+          session_duration_ms: Date.now() - new Date(telemetry.started_at).getTime()
+        } : void 0;
+        if (session_id) {
+          _sessionTelemetry.delete(session_id);
+          if (_activeSessionId === session_id) _activeSessionId = void 0;
+        }
         try {
           const plurDir = process.env.PLUR_PATH ?? join(homedir(), ".plur");
           const sessionsDir = join(plurDir, "sessions");
@@ -1534,6 +1686,7 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
           engrams_created,
           episode_id: episode.id,
           total_engrams: status.engram_count,
+          ...injection_summary ? { injection_summary } : {},
           hint: engrams_created === 0 ? "No engrams captured this session. If any corrections, preferences, or patterns came up, consider calling plur_learn before ending." : void 0
         };
       }
@@ -1638,11 +1791,27 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         if (discoveries.length === 0) {
           return { discovered: [], note: "No remote stores configured. Register one scope first with plur_stores_add, then discover the rest." };
         }
+        const enrich = (d) => {
+          if (!d.ok) return d;
+          const byScope = new Map(d.metadata.map((m) => [m.scope, m]));
+          const registeredSet = new Set(d.registered);
+          const scopes = d.authorized.map((scope) => {
+            const m = byScope.get(scope);
+            return {
+              scope,
+              registered: registeredSet.has(scope),
+              ...m?.description ? { description: m.description } : {},
+              ...m && m.covers.length ? { covers: m.covers } : {}
+            };
+          });
+          return { ...d, scopes };
+        };
+        const discovered = discoveries.map(enrich);
         if (!register) {
-          return { discovered: discoveries };
+          return { discovered };
         }
         const registered = await plur.registerDiscoveredScopes({ url });
-        return { discovered: discoveries, registered };
+        return { discovered, registered };
       }
     },
     {
@@ -1953,9 +2122,9 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         if (filterType) {
           engrams = engrams.filter((e) => e.type === filterType);
         }
-        const { homedir: homedir2 } = await import("os");
-        const { join: join2 } = await import("path");
-        const outputDir = args.output_dir || join2(homedir2(), "plur-packs", name);
+        const { homedir: homedir3 } = await import("os");
+        const { join: join3 } = await import("path");
+        const outputDir = args.output_dir || join3(homedir3(), "plur-packs", name);
         const result = plur.exportPack(engrams, outputDir, {
           name,
           version: "1.0.0",
@@ -2005,23 +2174,6 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
         };
       }
     },
-    {
-      name: "plur_batch_decay",
-      description: "Apply ACT-R decay to all local engrams. Run weekly. Only decays engrams in the local YAML store \u2014 remote-store engrams are not decayed client-side. Returns status transitions only.",
-      annotations: { title: "Batch decay", destructiveHint: false, idempotentHint: false },
-      inputSchema: {
-        type: "object",
-        properties: {
-          context_scope: { type: "string", description: "Scope to skip during decay (engrams in active scope are not decayed)" }
-        }
-      },
-      handler: async (args, plur) => {
-        const result = plur.batchDecay({
-          contextScope: args.context_scope
-        });
-        return result;
-      }
-    },
     {
       name: "plur_profile",
       description: "Generate or retrieve a cognitive profile \u2014 a narrative summary synthesized from stored engrams. Cached for 24h.",
@@ -2059,6 +2211,28 @@ Include at least one engram_suggestion if ANYTHING was learned. An empty suggest
 }
 
 // src/server.ts
+function serverPidPath(baseDir) {
+  return join2(baseDir ?? join2(homedir2(), ".plur"), "server.pid");
+}
+function readEnterpriseToken(baseDir) {
+  const configPath = join2(baseDir ?? join2(homedir2(), ".plur"), "config.json");
+  if (!existsSync2(configPath)) return void 0;
+  try {
+    const cfg = JSON.parse(readFileSync(configPath, "utf8"));
+    const ent = cfg?.enterprise;
+    if (!ent || typeof ent.url !== "string" || typeof ent.token !== "string") return void 0;
+    return { url: ent.url, token: ent.token, username: ent.username };
+  } catch {
+    return void 0;
+  }
+}
+var _pendingReload = false;
+function isPendingReload() {
+  return _pendingReload;
+}
+function clearPendingReload() {
+  _pendingReload = false;
+}
 var INSTRUCTIONS = `PLUR is your persistent memory. Corrections, preferences, and conventions persist across sessions as engrams.
 
 PLUR is a GLOBAL tool \u2014 one MCP server, one engram store (~/.plur/), available in every project. Multi-project scoping uses domain/scope fields on engrams, not separate installations.
@@ -2363,11 +2537,24 @@ async function runStdio() {
   const profile = process.env.PLUR_TOOL_PROFILE === "cursor" ? "cursor" : "full";
   const server = await createServer(void 0, { profile });
   registerFlushOnExit({});
+  try {
+    writeFileSync(serverPidPath(), String(process.pid));
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    process.on("SIGUSR1", () => {
+      _pendingReload = true;
+    });
+  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 export {
   INSTRUCTIONS,
+  clearPendingReload,
   createServer,
-  runStdio
+  isPendingReload,
+  readEnterpriseToken,
+  runStdio,
+  serverPidPath
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plur-ai/mcp",
   "mcpName": "io.github.plur-ai/plur",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "bin": {
     "plur-mcp": "dist/index.js"
@@ -14,7 +14,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.23.0",
-    "@plur-ai/core": "0.13.0"
+    "@plur-ai/core": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0"