@a-company/sentinel 3.6.0 → 3.9.0

package/dist/{dist-TYG2XME3.js → dist-TMBGF6YA.js}

@@ -5585,6 +5585,12 @@ Ze.glob = Ze;
 // ../purpose/core/dist/index.js
 var PurposeItemSchema = z.object({
   description: z.string(),
+  // Component type and hierarchy (v4)
+  type: z.string().optional(),
+  parent: z.string().optional(),
+  anchors: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  // Standard fields
   endpoints: z.array(z.string()).optional(),
   tests: z.array(z.string()).optional(),
   rules: z.record(z.unknown()).optional(),
@@ -5596,7 +5602,6 @@ var PurposeItemSchema = z.object({
   states: z.array(z.string()).optional(),
   components: z.array(z.string()).optional(),
   // Extra fields preserved
-  tags: z.array(z.string()).optional(),
   location: z.string().optional(),
   locations: z.array(z.string()).optional(),
   uses: z.array(z.string()).optional(),
@@ -6414,6 +6419,7 @@ async function aggregateFromPremise(premiseFile, rootDir) {
         purposeFiles.push(...parsed.map((p) => p.filePath));
         const features = extractFeatures(parsed);
         for (const [id, { item, filePath }] of features) {
+          const featureTags = ["feature", ...item.tags || []];
           symbols.push(createSymbolEntry({
             id: `purpose-feature-${id}`,
             symbol: `#${id}`,
@@ -6422,7 +6428,10 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             filePath,
             data: item,
             description: item.description,
-            tags: ["feature"]
+            tags: featureTags,
+            componentType: item.type,
+            parentSymbol: item.parent,
+            anchors: item.anchors?.map((a) => parseAnchorString(a))
           }));
         }
         const components = extractComponents(parsed);
@@ -6434,7 +6443,11 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             source: "purpose",
             filePath,
             data: item,
-            description: item.description
+            description: item.description,
+            tags: item.tags,
+            componentType: item.type,
+            parentSymbol: item.parent,
+            anchors: item.anchors?.map((a) => parseAnchorString(a))
           }));
         }
         const gates = extractGates(parsed);
@@ -6600,12 +6613,27 @@ async function aggregateFromPremise(premiseFile, rootDir) {
     }));
   }
   resolveReferences(symbols);
+  const symbolFileMap = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const files = symbolFileMap.get(sym.symbol) || [];
+    if (!files.includes(sym.filePath)) {
+      files.push(sym.filePath);
+    }
+    symbolFileMap.set(sym.symbol, files);
+  }
+  const duplicateSymbols = [];
+  for (const [symbol, files] of symbolFileMap) {
+    if (files.length > 1) {
+      duplicateSymbols.push({ symbol, files });
+    }
+  }
   return {
     symbols,
     purposeFiles,
     portalFiles,
     errors,
-    timestamp: Date.now()
+    timestamp: Date.now(),
+    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
   };
 }
 function createSymbolEntry(partial) {
@@ -6764,10 +6792,33 @@ function searchSymbols(index, query) {
     }
     if (entry.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
       results.push(entry);
+      continue;
+    }
+    if (entry.componentType?.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
     }
   }
   return results;
 }
+function getComponentsByType(index, componentType) {
+  const components = getSymbolsByType(index, "component");
+  return components.filter((c) => c.componentType === componentType);
+}
+function getAllComponentTypes(index) {
+  const types = /* @__PURE__ */ new Set();
+  const components = getSymbolsByType(index, "component");
+  for (const comp of components) {
+    if (comp.componentType) {
+      types.add(comp.componentType);
+    }
+  }
+  return Array.from(types).sort();
+}
+function getChildComponents(index, parentSymbol) {
+  const components = getSymbolsByType(index, "component");
+  return components.filter((c) => c.parentSymbol === parentSymbol);
+}
 function getReferencesTo(index, symbol) {
   const entry = getSymbol(index, symbol);
   if (!entry) return [];
@@ -6851,9 +6902,12 @@ export {
   createSnapshot,
   createSymbolIndex,
   createSymbolString,
+  getAllComponentTypes,
   getAllSymbols,
   getAllTags,
   getAutocompleteSuggestions,
+  getChildComponents,
+  getComponentsByType,
   getDefaultPremiseContent,
   getReferencesFrom,
   getReferencesTo,

package/dist/index.d.ts

@@ -1,60 +1,11 @@
-export { F as FlowTracker, P as PatternMatcher, S as Sentinel } from './sdk-CzFDYYST.js';
-export { S as SentinelClient, a as SentinelClientOptions, b as SentinelTransport, c as SpanContext, d as createSentinelClient, e as createSentinelTransport, f as enableSentinel } from './transport-DqamniUy.js';
-import { S as SentinelServerConfig, a as SymbolicIncidentRecord, I as IncidentGroup, F as FlowTimeline, b as SentinelStats, c as SymbolHealth, E as EnrichedIncident, d as SymbolEnrichment, e as FailurePattern, P as PatternCandidate, f as PatternExport } from './types-BmVoO1iF.js';
-export { A as AppState, g as AuthConfig, h as AuthPermission, i as AuthToken, B as BackupExport, C as ComponentContext, j as CorsConfig, k as CreateGroupInput, l as CreateIncidentInput, m as CreatePatternInput, D as DEFAULT_AUTH_CONFIG, n as DEFAULT_RATE_LIMIT_CONFIG, o as DEFAULT_SERVER_CONFIG, p as DayCount, q as Environment, r as ErrorDetails, s as FlowEvent, t as FlowEventType, u as FlowPosition, H as HistogramBucket, v as IncidentNote, w as IncidentQueryOptions, x as IncidentStatus, L as LogEntry, y as LogEntryInput, z as LogLevel, G as LogQueryOptions, J as LogSymbolType, M as MatchedCriteria, K as MatcherConfig, N as MetricAggregation, O as MetricEntry, Q as MetricInput, R as MetricQueryOptions, T as MetricType, U as PatternConfidence, V as PatternCriteria, W as PatternEffectiveness, X as PatternMatch, Y as PatternPriority, Z as PatternQueryOptions, _ as PatternRecurrence, $ as PatternResolution, a0 as PatternSource, a1 as PatternSymbolCriteria, a2 as PatternTestResult, a3 as PracticeCategory, a4 as PracticeEvent, a5 as PracticeEventInput, a6 as PracticeEventQuery, a7 as PracticeResult, a8 as RateLimitConfig, a9 as RateLimitRule, aa as Resolution, ab as ResolutionQueryOptions, ac as ResolutionRecord, ad as ResolutionStrategy, ae as SentinelConfig, af as ServiceInfo, ag as ServiceRegistration, ah as SymbolHotspot, ai as SymbolIncidentCount, aj as SymbolResolutionTime, ak as SymbolValidationResult, al as SymbolicContext, am as TraceSpan, an as TraceSpanInput, ao as TraceView } from './types-BmVoO1iF.js';
-import { S as SentinelStorage, E as EventSchemaDeclaration } from './storage-BKyt7aPJ.js';
-export { C as CausalityDeclaration, a as EventFieldDeclaration, b as EventTypeDeclaration, G as GenericEvent, c as GenericEventInput, d as GenericEventQuery, e as ScopeDeclaration, f as ScopeSummary, g as StoredSchema, V as VisualizationHints } from './storage-BKyt7aPJ.js';
-
-/**
- * Sentinel Configuration
- *
- * Loads and writes .sentinel.yaml config files.
- * Provides project-level configuration for the Sentinel SDK and CLI.
- */
-
-interface SentinelYamlConfig {
-    version: string;
-    project: string;
-    environment?: string;
-    symbols?: {
-        components?: string[];
-        gates?: string[];
-        flows?: string[];
-        signals?: string[];
-    };
-    routes?: Record<string, string>;
-    scrub?: {
-        headers?: string[];
-        fields?: string[];
-    };
-    server?: {
-        port?: number;
-        maxLogs?: number;
-        maxBatchSize?: number;
-        wsMaxSubscribers?: number;
-        pruneIntervalInserts?: number;
-        logRetentionDays?: number;
-    };
-}
-/**
- * Load .sentinel.yaml from a project directory.
- *
- * @param projectDir - Project root directory
- * @returns Parsed config or null if not found
- */
-declare function loadConfig(projectDir: string): SentinelYamlConfig | null;
-/**
- * Write .sentinel.yaml to a project directory.
- *
- * @param projectDir - Project root directory
- * @param config - Config to write
- */
-declare function writeConfig(projectDir: string, config: SentinelYamlConfig): void;
-/**
- * Load server configuration with resolution order:
- * env vars → local .sentinel.yaml → global ~/.paradigm/sentinel.yaml → defaults
- */
-declare function loadServerConfig(projectDir?: string): SentinelServerConfig;
+export { F as FlowTracker, P as PatternMatcher, S as Sentinel } from './sdk-faJTgu-S.js';
+export { S as SentinelClient, a as SentinelClientOptions, b as SentinelTransport, c as SpanContext, d as createSentinelClient, e as createSentinelTransport, f as enableSentinel } from './transport-Biz9YfoQ.js';
+import { S as SymbolicIncidentRecord, I as IncidentGroup, F as FlowTimeline, a as SentinelStats, b as SymbolHealth, E as EnrichedIncident, c as SymbolEnrichment, d as FailurePattern, P as PatternCandidate, e as PatternExport } from './types-CPU5sxLq.js';
+export { A as AppState, f as AuthConfig, g as AuthPermission, h as AuthToken, B as BackupExport, C as ComponentContext, i as CorsConfig, j as CreateGroupInput, k as CreateIncidentInput, l as CreatePatternInput, D as DEFAULT_AUTH_CONFIG, m as DEFAULT_RATE_LIMIT_CONFIG, n as DEFAULT_SERVER_CONFIG, o as DayCount, p as Environment, q as ErrorDetails, r as FlowEvent, s as FlowEventType, t as FlowPosition, H as HistogramBucket, u as IncidentNote, v as IncidentQueryOptions, w as IncidentStatus, L as LogEntry, x as LogEntryInput, y as LogLevel, z as LogQueryOptions, G as LogSymbolType, M as MatchedCriteria, J as MatcherConfig, K as MetricAggregation, N as MetricEntry, O as MetricInput, Q as MetricQueryOptions, R as MetricType, T as PatternConfidence, U as PatternCriteria, V as PatternEffectiveness, W as PatternMatch, X as PatternPriority, Y as PatternQueryOptions, Z as PatternRecurrence, _ as PatternResolution, $ as PatternSource, a0 as PatternSymbolCriteria, a1 as PatternTestResult, a2 as PracticeCategory, a3 as PracticeEvent, a4 as PracticeEventInput, a5 as PracticeEventQuery, a6 as PracticeResult, a7 as RateLimitConfig, a8 as RateLimitRule, a9 as Resolution, aa as ResolutionQueryOptions, ab as ResolutionRecord, ac as ResolutionStrategy, ad as SentinelConfig, ae as SentinelServerConfig, af as ServiceInfo, ag as ServiceRegistration, ah as SymbolHotspot, ai as SymbolIncidentCount, aj as SymbolResolutionTime, ak as SymbolValidationResult, al as SymbolicContext, am as TraceSpan, an as TraceSpanInput, ao as TraceView } from './types-CPU5sxLq.js';
+import { S as SentinelYamlConfig } from './builtin-symphony-qZiFR8hQ.js';
+export { P as PARADIGM_SCHEMA, a as SYMPHONY_SCHEMA, l as loadConfig, b as loadServerConfig, w as writeConfig } from './builtin-symphony-qZiFR8hQ.js';
+import { S as SentinelStorage } from './storage-8SPPsAJb.js';
+export { C as CausalityDeclaration, E as EventFieldDeclaration, a as EventSchemaDeclaration, b as EventTypeDeclaration, G as GenericEvent, c as GenericEventInput, d as GenericEventQuery, e as ScopeDeclaration, f as ScopeSummary, g as StoredSchema, V as VisualizationHints } from './storage-8SPPsAJb.js';
 
 /**
  * Sentinel Auto-Symbol Detector
@@ -474,13 +425,4 @@ declare function loadParadigmPatterns(): PatternExport;
  */
 declare function loadAllSeedPatterns(): PatternExport;
 
-/**
- * Built-in Paradigm Schema Declaration
- *
- * Registers Paradigm's existing log/metric/trace types as an event schema.
- * This is informational — existing tables remain untouched.
- */
-
-declare const PARADIGM_SCHEMA: EventSchemaDeclaration;
-
-export { ContextEnricher, EnrichedIncident, EventSchemaDeclaration, FailurePattern, FlowTimeline, IncidentGroup, IncidentGrouper, PARADIGM_SCHEMA, PatternCandidate, PatternExport, PatternImporter, PatternSuggester, SentinelServerConfig, SentinelStats, SentinelStorage, type SentinelYamlConfig, StatsCalculator, SymbolEnrichment, SymbolHealth, SymbolicIncidentRecord, TimelineBuilder, detectSymbols, generateConfig, loadAllSeedPatterns, loadConfig, loadParadigmPatterns, loadServerConfig, loadUniversalPatterns, writeConfig };
+export { ContextEnricher, EnrichedIncident, FailurePattern, FlowTimeline, IncidentGroup, IncidentGrouper, PatternCandidate, PatternExport, PatternImporter, PatternSuggester, SentinelStats, SentinelStorage, SentinelYamlConfig, StatsCalculator, SymbolEnrichment, SymbolHealth, SymbolicIncidentRecord, TimelineBuilder, detectSymbols, generateConfig, loadAllSeedPatterns, loadParadigmPatterns, loadUniversalPatterns };

package/dist/index.js

@@ -9,11 +9,13 @@ import {
   DEFAULT_AUTH_CONFIG,
   DEFAULT_RATE_LIMIT_CONFIG,
   DEFAULT_SERVER_CONFIG,
+  PARADIGM_SCHEMA,
+  SYMPHONY_SCHEMA,
   SentinelStorage,
   loadConfig,
   loadServerConfig,
   writeConfig
-} from "./chunk-NTX74ZPM.js";
+} from "./chunk-OKYYIAML.js";
 
 // src/matcher.ts
 var DEFAULT_CONFIG = {
@@ -2195,152 +2197,6 @@ var PatternImporter = class {
     };
   }
 };
-
-// src/schema/builtin-paradigm.ts
-var PARADIGM_SCHEMA = {
-  id: "paradigm-logger",
-  version: "1.0.0",
-  name: "Paradigm Logger",
-  description: "Structured logs from @a-company/paradigm-logger with symbolic context",
-  scope: {
-    field: "correlationId",
-    type: "string",
-    label: "Correlation",
-    ordering: "independent",
-    sessionField: "sessionId"
-  },
-  eventTypes: [
-    {
-      type: "log:debug",
-      category: "logs",
-      label: "Debug Log",
-      severity: "debug",
-      frequency: "high",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true },
-        { name: "durationMs", type: "number", display: true }
-      ]
-    },
-    {
-      type: "log:info",
-      category: "logs",
-      label: "Info Log",
-      severity: "info",
-      frequency: "high",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true },
-        { name: "durationMs", type: "number", display: true }
-      ]
-    },
-    {
-      type: "log:warn",
-      category: "logs",
-      label: "Warning Log",
-      severity: "warn",
-      frequency: "medium",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true }
-      ]
-    },
-    {
-      type: "log:error",
-      category: "logs",
-      label: "Error Log",
-      severity: "error",
-      frequency: "low",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true }
-      ]
-    },
-    {
-      type: "metric:counter",
-      category: "metrics",
-      label: "Counter Metric",
-      severity: "info",
-      frequency: "high",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "metric:gauge",
-      category: "metrics",
-      label: "Gauge Metric",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "metric:histogram",
-      category: "metrics",
-      label: "Histogram Metric",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "trace:span",
-      category: "traces",
-      label: "Trace Span",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "traceId", type: "string", indexed: true, display: true },
-        { name: "spanId", type: "string", indexed: true },
-        { name: "operation", type: "string", display: true },
-        { name: "durationMs", type: "number", display: true },
-        { name: "status", type: "string", display: true }
-      ]
-    },
-    {
-      type: "incident:recorded",
-      category: "incidents",
-      label: "Incident Recorded",
-      severity: "error",
-      frequency: "low",
-      fields: [
-        { name: "incidentId", type: "string", indexed: true, display: true },
-        { name: "errorMessage", type: "string", display: true },
-        { name: "symbols", type: "object" },
-        { name: "environment", type: "string", display: true }
-      ]
-    }
-  ],
-  visualization: {
-    defaultView: "table",
-    categoryColors: {
-      logs: "#3b82f6",
-      metrics: "#22c55e",
-      traces: "#a855f7",
-      incidents: "#ef4444"
-    },
-    summaryFields: ["symbol", "message", "service"],
-    defaultExcluded: ["log:debug"]
-  },
-  tags: ["builtin", "paradigm"]
-};
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,
@@ -2352,6 +2208,7 @@ export {
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
+  SYMPHONY_SCHEMA,
   Sentinel,
   SentinelClient,
   SentinelStorage,

package/dist/mcp.js

@@ -604,6 +604,19 @@ var SentinelStorage = class {
     );
     this.save();
   }
+  resolveIncident(id, options) {
+    this.updateIncident(id, {
+      status: "resolved",
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (options?.notes) {
+      this.addIncidentNote(id, {
+        author: "system",
+        content: options.notes,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
   addIncidentNote(incidentId, note) {
     this.initializeSync();
     const incident = this.getIncident(incidentId);

package/dist/{sdk-CzFDYYST.d.ts → sdk-faJTgu-S.d.ts}

@@ -1,5 +1,5 @@
-import { S as SentinelStorage } from './storage-BKyt7aPJ.js';
-import { a as SymbolicIncidentRecord, K as MatcherConfig, X as PatternMatch, e as FailurePattern, a2 as PatternTestResult, ae as SentinelConfig, C as ComponentContext, al as SymbolicContext, u as FlowPosition } from './types-BmVoO1iF.js';
+import { S as SentinelStorage } from './storage-8SPPsAJb.js';
+import { S as SymbolicIncidentRecord, J as MatcherConfig, W as PatternMatch, d as FailurePattern, a1 as PatternTestResult, ad as SentinelConfig, C as ComponentContext, al as SymbolicContext, t as FlowPosition } from './types-CPU5sxLq.js';
 
 /**
  * Paradigm Sentinel - Pattern Matching Engine

package/dist/server/index.d.ts

@@ -1,6 +1,7 @@
-import { Express } from 'express';
-import { S as SentinelStorage, G as GenericEvent } from '../storage-BKyt7aPJ.js';
-import { S as SentinelServerConfig, L as LogEntry } from '../types-BmVoO1iF.js';
+import { Router, Request, Response, NextFunction, Express } from 'express';
+import { S as SentinelStorage, G as GenericEvent } from '../storage-8SPPsAJb.js';
+import { ae as SentinelServerConfig, L as LogEntry, f as AuthConfig, g as AuthPermission, a7 as RateLimitConfig } from '../types-CPU5sxLq.js';
+export { P as PARADIGM_SCHEMA, a as SYMPHONY_SCHEMA, b as loadServerConfig } from '../builtin-symphony-qZiFR8hQ.js';
 
 /**
  * Symbol index loader for the server
@@ -63,6 +64,154 @@ declare function loadGitHistory(projectDir: string, options?: {
  */
 declare function getSymbolsAtCommit(projectDir: string, commitHash: string): Promise<string[]>;
 
+/**
+ * Structured Logs API route
+ *
+ * POST /api/logs  — Accept single entry or batch {entries: [...]}
+ * GET  /api/logs  — Query with filters
+ */
+
+interface LogsRouterOptions {
+    storage: SentinelStorage;
+    serverConfig: SentinelServerConfig;
+    onLogReceived?: (entry: LogEntry, validation?: {
+        known: boolean;
+        suggestion?: string;
+    }) => void;
+    symbolIndex?: Array<{
+        symbol: string;
+        type: string;
+        filePath: string;
+    }>;
+}
+declare function createLogsRouter(options: LogsRouterOptions): Router;
+
+/**
+ * Services & State API routes
+ *
+ * POST /api/services      — Register a service
+ * GET  /api/services      — List registered services
+ * POST /api/state         — Push app state snapshot
+ * GET  /api/state         — Get all live app states
+ * GET  /api/state/:service — Get state for specific service
+ */
+
+interface ServicesRouterOptions {
+    storage: SentinelStorage;
+}
+declare function createServicesRouter(options: ServicesRouterOptions): Router;
+declare function createStateRouter(options: ServicesRouterOptions): Router;
+
+/**
+ * Metrics API route
+ *
+ * POST /api/metrics  — Accept single metric or batch {entries: [...]}
+ * GET  /api/metrics  — Query with filters
+ * GET  /api/metrics/aggregate/:name — Get aggregation for a metric
+ */
+
+interface MetricsRouterOptions {
+    storage: SentinelStorage;
+    serverConfig: SentinelServerConfig;
+}
+declare function createMetricsRouter(options: MetricsRouterOptions): Router;
+
+/**
+ * Distributed Tracing API route
+ *
+ * POST /api/traces   — Submit a trace span
+ * GET  /api/traces   — Query traces
+ * GET  /api/traces/:traceId — Get full trace view
+ */
+
+interface TracesRouterOptions {
+    storage: SentinelStorage;
+}
+declare function createTracesRouter(options: TracesRouterOptions): Router;
+
+/**
+ * Schema Registry API routes
+ *
+ * POST /api/schemas       — Register/update schema (upsert by id)
+ * GET  /api/schemas       — List all registered schemas
+ * GET  /api/schemas/:id   — Get specific schema
+ */
+
+interface SchemasRouterOptions {
+    storage: SentinelStorage;
+}
+declare function createSchemasRouter(options: SchemasRouterOptions): Router;
+
+/**
+ * Generic Events API routes
+ *
+ * POST /api/events              — Ingest event batch { schemaId, service, events: [...] }
+ * GET  /api/events              — Query events with filters
+ * GET  /api/events/scopes       — Scope summaries (frames with counts, etc.)
+ * GET  /api/events/scope/:value — All events within a single scope value
+ */
+
+interface EventsRouterOptions {
+    storage: SentinelStorage;
+    serverConfig: SentinelServerConfig;
+    onEventReceived?: (event: GenericEvent) => void;
+}
+declare function createEventsRouter(options: EventsRouterOptions): Router;
+
+/**
+ * Symbols API route
+ */
+
+declare function createSymbolsRouter(projectDir: string): Router;
+
+/**
+ * Project info API route
+ */
+
+declare function createInfoRouter(projectDir: string): Router;
+
+/**
+ * Commits API route - Git history
+ */
+
+declare function createCommitsRouter(projectDir: string): Router;
+
+/**
+ * Incidents API route
+ */
+
+declare function createIncidentsRouter(_projectDir: string): Router;
+
+/**
+ * Patterns API route
+ */
+
+declare function createPatternsRouter(_projectDir: string): Router;
+
+/**
+ * Authentication middleware for Sentinel server
+ *
+ * Bearer token authentication with permission levels.
+ * When auth is disabled, all requests pass through.
+ */
+
+/**
+ * Create auth middleware that checks bearer tokens
+ */
+declare function createAuthMiddleware(config: AuthConfig): (requiredPermission: AuthPermission) => (req: Request, res: Response, next: NextFunction) => void;
+
+/**
+ * Rate limiting middleware for Sentinel server
+ *
+ * Per-service and global rate limiting with configurable sampling.
+ * Uses in-memory sliding window counters.
+ */
+
+/**
+ * Create rate limiting middleware
+ */
+declare function createRateLimiter(config: RateLimitConfig): (req: Request, res: Response, next: NextFunction) => void;
+
 /**
  * Sentinel Server - Express server with WebSocket for real-time log streaming
  */
@@ -96,4 +245,4 @@ declare function createApp(options: ServerOptions & {
  */
 declare function startServer(options: ServerOptions): Promise<void>;
 
-export { type CommitInfo, type ParadigmConfig, type ServerOptions, type SymbolEntry, createApp, getSymbolCount, getSymbolsAtCommit, loadGitHistory, loadParadigmConfig, loadSymbolIndex, startServer };
+export { type CommitInfo, type EventsRouterOptions, GenericEvent, LogEntry, type LogsRouterOptions, type MetricsRouterOptions, type ParadigmConfig, type SchemasRouterOptions, SentinelServerConfig, SentinelStorage, type ServerOptions, type ServicesRouterOptions, type SymbolEntry, type TracesRouterOptions, createApp, createAuthMiddleware, createCommitsRouter, createEventsRouter, createIncidentsRouter, createInfoRouter, createLogsRouter, createMetricsRouter, createPatternsRouter, createRateLimiter, createSchemasRouter, createServicesRouter, createStateRouter, createSymbolsRouter, createTracesRouter, getSymbolCount, getSymbolsAtCommit, loadGitHistory, loadParadigmConfig, loadSymbolIndex, startServer };

package/dist/server/index.js

@@ -1,7 +1,9 @@
 import {
+  PARADIGM_SCHEMA,
+  SYMPHONY_SCHEMA,
   SentinelStorage,
   loadServerConfig
-} from "../chunk-NTX74ZPM.js";
+} from "../chunk-OKYYIAML.js";
 
 // src/server/index.ts
 import express from "express";
@@ -107,7 +109,7 @@ async function loadParadigmConfig(projectDir) {
 }
 async function loadWithPremiseCore(projectDir) {
   try {
-    const { aggregateFromDirectory } = await import("../dist-AG5JNIZU.js");
+    const { aggregateFromDirectory } = await import("../dist-5QE2BB2B.js");
     log.flow("load-symbols").info("Using premise-core aggregator", { path: projectDir });
     const result = await aggregateFromDirectory(projectDir);
     const counts = {};
@@ -1494,8 +1496,16 @@ function createApp(options) {
   app.get("/api/health", (_req, res) => {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
-  const uiDistPath = path3.join(__dirname, "..", "..", "ui", "dist");
-  if (fs2.existsSync(uiDistPath)) {
+  const uiCandidates = [
+    path3.join(__dirname, "sentinel-ui"),
+    // bundled: paradigm/dist/sentinel-ui/ (copied during build)
+    path3.join(__dirname, "..", "..", "ui", "dist"),
+    // standalone: sentinel/dist/server/ → sentinel/ui/dist
+    path3.join(__dirname, "..", "ui", "dist")
+    // standalone flat: sentinel/dist/ → sentinel/ui/dist
+  ];
+  const uiDistPath = uiCandidates.find((p) => fs2.existsSync(p));
+  if (uiDistPath) {
     app.use(express.static(uiDistPath));
     app.get("{*path}", (req, res) => {
       if (!req.path.startsWith("/api")) {
@@ -1512,6 +1522,9 @@ async function startServer(options) {
   }
   const storage = new SentinelStorage(options.dbPath);
   await storage.ensureReady();
+  storage.registerSchema(PARADIGM_SCHEMA);
+  storage.registerSchema(SYMPHONY_SCHEMA);
+  log3.component("sentinel-server").info("Registered builtin schemas", { schemas: "paradigm-logger, paradigm-symphony" });
   let symbolIndex = [];
   try {
     symbolIndex = await loadSymbolIndex(options.projectDir);
@@ -1640,11 +1653,29 @@ async function startServer(options) {
   });
 }
 export {
+  PARADIGM_SCHEMA,
+  SYMPHONY_SCHEMA,
+  SentinelStorage,
   createApp,
+  createAuthMiddleware,
+  createCommitsRouter,
+  createEventsRouter,
+  createIncidentsRouter,
+  createInfoRouter,
+  createLogsRouter,
+  createMetricsRouter,
+  createPatternsRouter,
+  createRateLimiter,
+  createSchemasRouter,
+  createServicesRouter,
+  createStateRouter,
+  createSymbolsRouter,
+  createTracesRouter,
   getSymbolCount,
   getSymbolsAtCommit,
   loadGitHistory,
   loadParadigmConfig,
+  loadServerConfig,
   loadSymbolIndex,
   startServer
 };