@a-company/paradigm 3.5.0 → 3.6.0

package/dist/index.js

@@ -521,76 +521,76 @@ hooksCmd.action(async () => {
 });
 var triageCmd = program.command("triage").description("Semantic error triage - incident management and pattern matching");
 triageCmd.command("list").alias("ls").description("List recent incidents with matched patterns").option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status: open, investigating, resolved, wont-fix, all").option("--symbol <symbol>", "Filter by symbol (e.g., @checkout, ^auth)").option("-e, --env <environment>", "Filter by environment").option("--search <text>", "Search in error messages").option("--from <date>", "Filter from date (ISO format)").option("--to <date>", "Filter to date (ISO format)").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageListCommand } = await import("./triage-B5W6GZLT.js");
   await triageListCommand(options);
 });
 triageCmd.command("show <id>").description("Show full incident details").option("--timeline", "Include flow timeline").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triageShowCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageShowCommand } = await import("./triage-B5W6GZLT.js");
   await triageShowCommand(id, options);
 });
 triageCmd.command("resolve <id>").description("Mark incident as resolved").option("-p, --pattern <patternId>", "Pattern that led to resolution").option("-c, --commit <hash>", "Git commit hash of fix").option("--pr <url>", "Pull request URL").option("-n, --notes <text>", "Resolution notes").option("--wont-fix", "Mark as will not fix").action(async (id, options) => {
-  const { triageResolveCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageResolveCommand } = await import("./triage-B5W6GZLT.js");
   await triageResolveCommand(id, options);
 });
 triageCmd.command("note <id> <note>").description("Add a note to an incident").action(async (id, note) => {
-  const { triageNoteCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageNoteCommand } = await import("./triage-B5W6GZLT.js");
   await triageNoteCommand(id, note);
 });
 triageCmd.command("link <id1> <id2>").description("Link two related incidents").action(async (id1, id2) => {
-  const { triageLinkCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageLinkCommand } = await import("./triage-B5W6GZLT.js");
   await triageLinkCommand(id1, id2);
 });
 var triagePatternsCmd = triageCmd.command("patterns").description("Manage failure patterns");
 triagePatternsCmd.command("list").alias("ls").description("List all patterns").option("--source <source>", "Filter by source: manual, suggested, imported, community").option("--min-confidence <score>", "Minimum confidence score").option("--json", "Output as JSON").action(async (options) => {
-  const { triagePatternsListCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsListCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsListCommand(options);
 });
 triagePatternsCmd.command("show <id>").description("Show pattern details").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsShowCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsShowCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsShowCommand(id, options);
 });
 triagePatternsCmd.command("add").description("Create a new pattern").requiredOption("--id <id>", "Pattern ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").option("--description <text>", "Pattern description").option("--symbols <pairs>", 'Symbol criteria (e.g., "feature:@checkout,gate:^auth")').option("--error-contains <keywords>", "Error keywords (comma-separated)").option("--missing-signals <signals>", "Expected missing signals (comma-separated)").option("--strategy <strategy>", "Resolution strategy: retry, fallback, fix-data, fix-code, ignore, escalate", "fix-code").option("--priority <priority>", "Priority: low, medium, high, critical", "medium").option("--code-hint <text>", "Code hint for resolution").option("--tags <tags>", "Tags (comma-separated)").option("--from-incident <id>", "Generate suggestion from incident").action(async (options) => {
-  const { triagePatternsAddCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsAddCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsAddCommand(options);
 });
 triagePatternsCmd.command("delete <id>").alias("rm").description("Delete a pattern").action(async (id) => {
-  const { triagePatternsDeleteCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsDeleteCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsDeleteCommand(id);
 });
 triagePatternsCmd.command("test <id>").description("Test pattern against historical incidents").option("-l, --limit <number>", "Max incidents to test against", "100").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsTestCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsTestCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsTestCommand(id, options);
 });
 triagePatternsCmd.command("seed").description("Load built-in seed patterns").action(async () => {
-  const { triagePatternsSeedCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsSeedCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsSeedCommand();
 });
 triagePatternsCmd.action(async () => {
-  const { triagePatternsListCommand } = await import("./triage-PXMU3RWV.js");
+  const { triagePatternsListCommand } = await import("./triage-B5W6GZLT.js");
   await triagePatternsListCommand({});
 });
 triageCmd.command("export <type>").description("Export patterns or full backup (type: patterns, backup)").option("-o, --output <path>", "Output file path").option("--include-private", "Include private patterns").action(async (type, options) => {
-  const { triageExportCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageExportCommand } = await import("./triage-B5W6GZLT.js");
   await triageExportCommand(type, options);
 });
 triageCmd.command("import <file>").description("Import patterns from JSON file").option("--overwrite", "Overwrite existing patterns").action(async (file, options) => {
-  const { triageImportCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageImportCommand } = await import("./triage-B5W6GZLT.js");
   await triageImportCommand(file, options);
 });
 triageCmd.command("restore <file>").description("Restore from full backup").action(async (file) => {
-  const { triageRestoreCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageRestoreCommand } = await import("./triage-B5W6GZLT.js");
   await triageRestoreCommand(file);
 });
 triageCmd.command("stats").description("Show statistics dashboard").option("-p, --period <period>", "Time period: 1d, 7d, 30d, 90d", "7d").option("--symbol <symbol>", "Show health for specific symbol").option("--json", "Output as JSON").action(async (options) => {
-  const { triageStatsCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageStatsCommand } = await import("./triage-B5W6GZLT.js");
   await triageStatsCommand(options);
 });
 triageCmd.command("record").description("Manually record an incident").requiredOption("--error <message>", "Error message").requiredOption("-e, --env <environment>", "Environment").option("--feature <symbol>", "Feature symbol (@...)").option("--component <symbol>", "Component symbol (#...)").option("--flow <symbol>", "Flow symbol ($...)").option("--gate <symbol>", "Gate symbol (^...)").option("--signal <symbol>", "Signal symbol (!...)").option("--state <symbol>", "State symbol (%...)").option("--integration <symbol>", "Integration symbol (&...)").option("--service <name>", "Service name").option("--version <version>", "App version").option("--stack <trace>", "Stack trace").option("--json", "Output as JSON").action(async (options) => {
-  const { triageRecordCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageRecordCommand } = await import("./triage-B5W6GZLT.js");
   await triageRecordCommand(options);
 });
 triageCmd.option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-PXMU3RWV.js");
+  const { triageListCommand } = await import("./triage-B5W6GZLT.js");
   await triageListCommand(options);
 });
 var loreCmd = program.command("lore").description("Project lore - timeline of everything that happened to this project");
@@ -628,47 +628,47 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
 });
 var habitsCmd = program.command("habits").description("Behavioral habits - practice tracking and compliance");
 habitsCmd.command("list").alias("ls").description("List all configured habits").option("--trigger <trigger>", "Filter by trigger: preflight, postflight, on-stop, on-commit").option("--category <category>", "Filter by category: discovery, verification, testing, documentation, collaboration, security").option("--json", "Output as JSON").action(async (options) => {
-  const { habitsListCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsListCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsListCommand(options);
 });
 habitsCmd.command("status").description("Show practice profile with compliance rates").option("-p, --period <period>", "Time period: 7d, 30d, 90d, all", "30d").option("--json", "Output as JSON").action(async (options) => {
-  const { habitsStatusCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsStatusCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsStatusCommand(options);
 });
 habitsCmd.command("init").description("Initialize habits.yaml with seed habits").option("-f, --force", "Overwrite existing file").action(async (options) => {
-  const { habitsInitCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsInitCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsInitCommand(options);
 });
 habitsCmd.command("check").description("Evaluate habit compliance for a trigger point").requiredOption("-t, --trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--record", "Record practice events to Sentinel").option("--json", "Output as JSON").option("--files <files>", "Comma-separated files modified (default: git diff)").option("--symbols <symbols>", "Comma-separated symbols touched").action(async (options) => {
-  const { habitsCheckCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsCheckCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsCheckCommand(options);
 });
 habitsCmd.command("add").description("Add a custom habit").requiredOption("--id <id>", "Habit ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").requiredOption("--description <desc>", "What this habit enforces").requiredOption("--category <category>", "Category: discovery, verification, testing, documentation, collaboration, security").requiredOption("--trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--severity <severity>", "Severity: advisory, warn, block", "advisory").option("--tools <tools>", "Comma-separated tools to check (for tool-called check type)").option("--check-type <type>", "Check type: tool-called, file-exists, file-modified, lore-recorded, symbols-registered, gates-declared, tests-exist, git-clean", "tool-called").option("--patterns <patterns>", "Comma-separated patterns (for file-exists, file-modified, tests-exist check types)").action(async (options) => {
-  const { habitsAddCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsAddCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsAddCommand({ ...options, checkType: options.checkType });
 });
 habitsCmd.command("edit <id>").description("Edit a habit (seed habits: only severity/enabled; custom: all fields)").option("--name <name>", "New name").option("--description <desc>", "New description").option("--category <category>", "New category").option("--trigger <trigger>", "New trigger").option("--severity <severity>", "New severity: advisory, warn, block").option("--enabled <bool>", "Enable or disable: true, false").option("--check-type <type>", "New check type").option("--patterns <patterns>", "Comma-separated patterns").option("--tools <tools>", "Comma-separated tools").action(async (id, options) => {
-  const { habitsEditCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsEditCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsEditCommand(id, { ...options, checkType: options.checkType });
 });
 habitsCmd.command("remove <id>").description("Remove a custom habit (seed habits cannot be removed, only disabled)").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
-  const { habitsRemoveCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsRemoveCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsRemoveCommand(id, options);
 });
 habitsCmd.command("enable <id>").description("Enable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsToggleCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsToggleCommand(id, "enable");
 });
 habitsCmd.command("disable <id>").description("Disable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsToggleCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsToggleCommand(id, "disable");
 });
 habitsCmd.action(async () => {
-  const { habitsListCommand } = await import("./habits-CHP4EW5H.js");
+  const { habitsListCommand } = await import("./habits-ZJBAL4HD.js");
   await habitsListCommand({});
 });
 program.command("sentinel [path]").description("Launch the Sentinel UI - unified codebase intelligence visualizer").option("-p, --port <port>", "Port to run on", "3838").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
-  const { sentinelCommand } = await import("./sentinel-ZTL224IG.js");
+  const { sentinelCommand } = await import("./sentinel-KDIGZWKT.js");
   await sentinelCommand(path2, options);
 });
 program.command("university").description("Launch Paradigm University - interactive learning platform & PLSAT certification").option("-p, --port <port>", "Port to run on", "3839").option("--no-open", "Don't open browser automatically").action(async (options) => {

package/dist/mcp.js

@@ -7,9 +7,9 @@ import {
   schedulePluginUpdateCheck
 } from "./chunk-4G54C4VM.js";
 
-// ../../node_modules/sql.js/dist/sql-wasm.js
+// ../paradigm-mcp/node_modules/.pnpm/sql.js@1.14.0/node_modules/sql.js/dist/sql-wasm.js
 var require_sql_wasm = __commonJS({
-  "../../node_modules/sql.js/dist/sql-wasm.js"(exports, module) {
+  "../paradigm-mcp/node_modules/.pnpm/sql.js@1.14.0/node_modules/sql.js/dist/sql-wasm.js"(exports, module) {
     "use strict";
     var initSqlJsPromise = void 0;
     var initSqlJs3 = function(moduleConfig) {
@@ -2131,12 +2131,12 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import * as fs6 from "fs";
 import * as path7 from "path";
 
-// ../premise/core/dist/index.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
 import * as yaml3 from "js-yaml";
 import { z as z2 } from "zod";
 import * as path3 from "path";
 
-// ../purpose/core/dist/index.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+purpose-core@3.5.0_typescript@5.9.3/node_modules/@a-company/purpose-core/dist/index.js
 import * as fs from "fs";
 import * as yaml from "js-yaml";
 import { z } from "zod";
@@ -2743,7 +2743,7 @@ function validatePurposeItem(id, item, itemType, prefix, issues) {
   }
 }
 
-// ../portal/core/dist/index.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+portal-core@0.1.0/node_modules/@a-company/portal-core/dist/index.js
 import * as fs2 from "fs";
 import * as path2 from "path";
 import * as yaml2 from "js-yaml";
@@ -2887,7 +2887,7 @@ async function findGateFiles(rootDir) {
   return files;
 }
 
-// ../premise/core/dist/index.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
 var PositionSchema = z2.object({
   x: z2.number(),
   y: z2.number()
@@ -3052,9 +3052,7 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             data: item,
             description: item.description,
             anchors: item.anchors?.map((a) => parseAnchorString(a)),
-            appliesTo: item["applies-to"],
-            tags: item.tags,
-            enforcement: item.enforcement
+            appliesTo: item["applies-to"]
           }));
         }
         const symbolRefs = extractSymbolReferences(parsed);
@@ -7414,7 +7412,7 @@ function generateMinimalNavigator(ctx) {
   };
 }
 
-// ../sentinel/node_modules/uuid/dist/esm-node/rng.js
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js
 import crypto3 from "crypto";
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
@@ -7426,7 +7424,7 @@ function rng() {
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
 
-// ../sentinel/node_modules/uuid/dist/esm-node/stringify.js
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/stringify.js
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -7435,13 +7433,13 @@ function unsafeStringify(arr, offset = 0) {
   return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
 }
 
-// ../sentinel/node_modules/uuid/dist/esm-node/native.js
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/native.js
 import crypto4 from "crypto";
 var native_default = {
   randomUUID: crypto4.randomUUID
 };
 
-// ../sentinel/node_modules/uuid/dist/esm-node/v4.js
+// ../paradigm-mcp/node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/v4.js
 function v4(options, buf, offset) {
   if (native_default.randomUUID && !buf && !options) {
     return native_default.randomUUID();
@@ -7461,7 +7459,7 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// ../sentinel/dist/chunk-FOF7CPJ6.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+sentinel@3.5.0/node_modules/@a-company/sentinel/dist/chunk-FOF7CPJ6.js
 var import_sql = __toESM(require_sql_wasm(), 1);
 import * as path14 from "path";
 import * as fs12 from "fs";
@@ -9493,7 +9491,7 @@ var SentinelStorage = class {
   }
 };
 
-// ../sentinel/dist/index.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+sentinel@3.5.0/node_modules/@a-company/sentinel/dist/index.js
 import * as path15 from "path";
 import * as fs13 from "fs";
 import { fileURLToPath } from "url";
@@ -10913,6 +10911,51 @@ function getSentinelToolsList() {
         }
       },
       annotations: { readOnlyHint: true, destructiveHint: false }
+    },
+    // ─── Schema-Driven Observability ──────────────────────────────
+    {
+      name: "paradigm_sentinel_schemas",
+      description: "List or get registered event schemas. Schemas define event types, scopes, causality, and visualization for application-agnostic observability. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Get a specific schema by ID. Omit to list all." }
+        }
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false }
+    },
+    {
+      name: "paradigm_sentinel_events",
+      description: "Query generic events from any registered schema. Filters by schema, event type, category, scope, service, severity, time range. ~200-400 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          schemaId: { type: "string", description: 'Filter by schema ID (e.g., "pretend-engine")' },
+          eventType: { type: "string", description: 'Filter by event type (e.g., "rule:fire")' },
+          category: { type: "string", description: 'Filter by category (e.g., "rules")' },
+          service: { type: "string", description: "Filter by service name" },
+          scopeValue: { type: "string", description: "Filter by scope value (e.g., frame number)" },
+          severity: { type: "string", enum: ["debug", "info", "warn", "error"], description: "Filter by severity" },
+          since: { type: "string", description: "ISO timestamp \u2014 events after this time" },
+          search: { type: "string", description: "Full-text search in event data" },
+          limit: { type: "number", description: "Max results (default: 50)" }
+        }
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false }
+    },
+    {
+      name: "paradigm_sentinel_scopes",
+      description: "Get scope summaries for a schema \u2014 e.g., frame list with event counts, request list with category breakdown. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          schemaId: { type: "string", description: "Schema ID (required)" },
+          sessionId: { type: "string", description: "Filter by session ID" },
+          limit: { type: "number", description: "Max scopes (default: 50)" }
+        },
+        required: ["schemaId"]
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false }
     }
   ];
 }
@@ -11403,6 +11446,122 @@ async function handleSentinelTool(name, args, ctx) {
         }, null, 2)
       };
     }
+    // ─── Schema-Driven Observability ──────────────────────────────
+    // Note: cast to any for new v3.6 methods until types are rebuilt
+    case "paradigm_sentinel_schemas": {
+      const { id: schemaId } = args;
+      if (schemaId) {
+        const schema = store.getSchema(schemaId);
+        if (!schema) {
+          return { handled: true, text: JSON.stringify({ error: `Schema "${schemaId}" not found` }) };
+        }
+        return { handled: true, text: JSON.stringify(schema, null, 2) };
+      }
+      const schemas = store.listSchemas();
+      if (schemas.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            schemas: [],
+            tip: "No event schemas registered yet. Applications register schemas via POST /api/schemas or SentinelWebClient.registerSchema()."
+          }, null, 2)
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          count: schemas.length,
+          schemas: schemas.map((s) => ({
+            id: s.id,
+            version: s.version,
+            name: s.name,
+            description: s.description,
+            eventTypeCount: s.eventTypes.length,
+            scope: s.scope.label,
+            tags: s.tags,
+            registeredAt: s.registeredAt
+          }))
+        }, null, 2)
+      };
+    }
+    case "paradigm_sentinel_events": {
+      const {
+        schemaId: evSchemaId,
+        eventType: evType,
+        category: evCategory,
+        service: evService,
+        scopeValue: evScope,
+        severity: evSeverity,
+        since: evSince,
+        search: evSearch,
+        limit: evLimit
+      } = args;
+      const events = store.queryEvents({
+        schemaId: evSchemaId,
+        eventType: evType,
+        category: evCategory,
+        service: evService,
+        scopeValue: evScope,
+        severity: evSeverity,
+        since: evSince,
+        search: evSearch,
+        limit: Math.min(evLimit || 50, 100)
+      });
+      if (events.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            events: [],
+            tip: "No events found. Events are ingested via POST /api/events or SentinelWebClient.emit()."
+          }, null, 2)
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          count: events.length,
+          events: events.map((e) => ({
+            id: e.id,
+            schemaId: e.schemaId,
+            eventType: e.eventType,
+            category: e.category,
+            timestamp: e.timestamp,
+            scopeValue: e.scopeValue,
+            service: e.service,
+            severity: e.severity,
+            data: e.data,
+            parentEventId: e.parentEventId,
+            depth: e.depth
+          }))
+        }, null, 2)
+      };
+    }
+    case "paradigm_sentinel_scopes": {
+      const { schemaId: scopeSchemaId, sessionId: scopeSession, limit: scopeLimit } = args;
+      const scopes = store.getEventScopes(scopeSchemaId, {
+        limit: Math.min(scopeLimit || 50, 200),
+        sessionId: scopeSession
+      });
+      if (scopes.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            scopes: [],
+            tip: `No scopes found for schema "${scopeSchemaId}". Events with scope values are required.`
+          }, null, 2)
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          count: scopes.length,
+          scopes
+        }, null, 2)
+      };
+    }
     default:
       return { handled: false, text: "" };
   }
@@ -15434,7 +15593,7 @@ import * as fs26 from "fs";
 import * as path29 from "path";
 import * as yaml15 from "js-yaml";
 
-// ../probe/core/dist/generator.js
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+probe-core@3.5.0/node_modules/@a-company/probe-core/dist/generator.js
 var PARADIGM_VERSION = "0.1.0";
 var SCHEMA_VERSION2 = "1.0.0";
 function generateScanIndex(input, options) {

package/dist/{sentinel-ZTL224IG.js → sentinel-KDIGZWKT.js}

@@ -9,7 +9,7 @@ async function sentinelCommand(path, options) {
   const shouldOpen = options.open !== false;
   console.log(chalk.cyan("\nStarting Sentinel...\n"));
   try {
-    const { startServer } = await import("./server-MZBYDXJY.js");
+    const { startServer } = await import("./server-NN7WDAZJ.js");
     console.log(chalk.gray(`Project: ${projectDir}`));
     console.log(chalk.gray(`Port: ${port}`));
     console.log();