@sanctuary-framework/mcp-server 1.2.9 → 1.2.10

package/dist/cli.cjs

@@ -21794,6 +21794,11 @@ var init_sentinel_dispatcher = __esm({
           fortressId: this.fortressId,
           auditLog: this.auditLog,
           now: this.now,
+          // Phi-5 meta-sentinel reads the per-fortress finding store to
+          // detect patterns across other sentinels' findings. First-order
+          // sentinels ignore the field; the dispatcher always attaches it
+          // because the store is already in scope here.
+          findingStore: this.findingStore,
           ...contextOverrides ?? {}
         };
         const sentinel = await this.registry.subscribe(sentinelId, context);
@@ -21935,6 +21940,230 @@ var init_sentinel_dispatcher = __esm({
   }
 });
 
+// src/anomaly-detection/types.ts
+var init_types4 = __esm({
+  "src/anomaly-detection/types.ts"() {
+  }
+});
+var ANOMALY_AUDIT_OPS, DEFAULT_TICK_INTERVAL_MS2, AnomalyPipelineDispatcher;
+var init_anomaly_pipeline = __esm({
+  "src/anomaly-detection/anomaly-pipeline.ts"() {
+    init_types4();
+    ANOMALY_AUDIT_OPS = {
+      DETECTOR_REGISTERED: "anomaly_detector_registered",
+      DETECTOR_UNREGISTERED: "anomaly_detector_unregistered",
+      FINDING_EMITTED: "anomaly_finding_emitted",
+      EVALUATION_FAILED: "anomaly_evaluation_failed",
+      TRAINING_COMPLETED: "anomaly_training_completed",
+      TRAINING_FAILED: "anomaly_training_failed"
+    };
+    DEFAULT_TICK_INTERVAL_MS2 = 6e4;
+    AnomalyPipelineDispatcher = class {
+      findingStore;
+      auditLog;
+      storage;
+      masterKey;
+      fortressId;
+      identityId;
+      now;
+      tickIntervalMs;
+      detectors = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      tickTimer = null;
+      tickInFlight = false;
+      constructor(deps) {
+        this.findingStore = deps.findingStore;
+        this.auditLog = deps.auditLog;
+        this.storage = deps.storage;
+        this.masterKey = deps.masterKey;
+        this.fortressId = deps.fortressId;
+        this.identityId = deps.identityId;
+        this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+        this.tickIntervalMs = deps.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS2;
+      }
+      onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      /**
+       * Register + subscribe a detector to this fortress. Idempotent: a
+       * second call with the same detectorId returns the already-
+       * registered instance without re-subscribing.
+       */
+      async registerDetector(detector) {
+        const existing = this.detectors.get(detector.detectorId);
+        if (existing) return existing;
+        const context = {
+          fortressId: this.fortressId,
+          auditLog: this.auditLog,
+          storage: this.storage,
+          masterKey: this.masterKey,
+          now: this.now
+        };
+        await detector.subscribe(context);
+        this.detectors.set(detector.detectorId, detector);
+        this.auditLog.append(
+          "l2",
+          ANOMALY_AUDIT_OPS.DETECTOR_REGISTERED,
+          this.identityId,
+          { detector_id: detector.detectorId, fortress_id: this.fortressId }
+        );
+        return detector;
+      }
+      /**
+       * Unregister + tear down a detector. Idempotent. Returns true when
+       * an active registration was removed.
+       */
+      async unregisterDetector(detectorId) {
+        const detector = this.detectors.get(detectorId);
+        if (!detector) return false;
+        try {
+          await detector.unsubscribe();
+        } finally {
+          this.detectors.delete(detectorId);
+        }
+        this.auditLog.append(
+          "l2",
+          ANOMALY_AUDIT_OPS.DETECTOR_UNREGISTERED,
+          this.identityId,
+          { detector_id: detectorId, fortress_id: this.fortressId }
+        );
+        return true;
+      }
+      listDetectors() {
+        return [...this.detectors.keys()];
+      }
+      /** Run one evaluation pass over every registered detector. */
+      async tick() {
+        if (this.tickInFlight) return [];
+        this.tickInFlight = true;
+        try {
+          const findings = [];
+          for (const [detectorId, detector] of this.detectors.entries()) {
+            try {
+              const detectorFindings = await detector.evaluate();
+              for (const raw of detectorFindings) {
+                const stamped = await this.routeFinding(detectorId, raw);
+                findings.push(stamped);
+              }
+              try {
+                const trainingResult = await detector.classifier.train();
+                this.auditLog.append(
+                  "l2",
+                  ANOMALY_AUDIT_OPS.TRAINING_COMPLETED,
+                  this.identityId,
+                  {
+                    detector_id: detectorId,
+                    classifier_id: detector.classifier.classifierId,
+                    trained_at: trainingResult.trained_at,
+                    sample_count: trainingResult.sample_count,
+                    agent_count: trainingResult.agent_count,
+                    fortress_id: this.fortressId
+                  }
+                );
+              } catch (trainErr) {
+                const message = trainErr instanceof Error ? trainErr.message : String(trainErr);
+                this.auditLog.append(
+                  "l2",
+                  ANOMALY_AUDIT_OPS.TRAINING_FAILED,
+                  this.identityId,
+                  {
+                    detector_id: detectorId,
+                    error_message: message,
+                    fortress_id: this.fortressId
+                  },
+                  "failure"
+                );
+              }
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              const observedAt = this.now().toISOString();
+              this.auditLog.append(
+                "l2",
+                ANOMALY_AUDIT_OPS.EVALUATION_FAILED,
+                this.identityId,
+                {
+                  detector_id: detectorId,
+                  error_message: message,
+                  fortress_id: this.fortressId
+                },
+                "failure"
+              );
+              this.emit({
+                type: "evaluation_failed",
+                detector_id: detectorId,
+                error_message: message,
+                observed_at: observedAt
+              });
+            }
+          }
+          return findings;
+        } finally {
+          this.tickInFlight = false;
+        }
+      }
+      start() {
+        if (this.tickTimer !== null) return;
+        if (this.tickIntervalMs <= 0) return;
+        this.tickTimer = setInterval(() => {
+          void this.tick();
+        }, this.tickIntervalMs);
+        if (typeof this.tickTimer.unref === "function") {
+          this.tickTimer.unref();
+        }
+      }
+      stop() {
+        if (this.tickTimer === null) return;
+        clearInterval(this.tickTimer);
+        this.tickTimer = null;
+      }
+      async dispose() {
+        this.stop();
+        const ids = [...this.detectors.keys()];
+        for (const id of ids) {
+          try {
+            await this.unregisterDetector(id);
+          } catch {
+          }
+        }
+        this.listeners.clear();
+      }
+      async routeFinding(detectorId, raw) {
+        const stamped = {
+          ...raw,
+          finding_id: raw.finding_id || crypto.randomUUID(),
+          fortress_id: this.fortressId,
+          observed_at: raw.observed_at || this.now().toISOString()
+        };
+        await this.findingStore.saveFinding(stamped);
+        this.auditLog.append(
+          "l2",
+          ANOMALY_AUDIT_OPS.FINDING_EMITTED,
+          this.identityId,
+          {
+            detector_id: detectorId,
+            finding_id: stamped.finding_id,
+            severity: stamped.severity,
+            anomaly_score: stamped.details["anomaly_score"] ?? null,
+            ...stamped.agent_id !== void 0 ? { agent_id: stamped.agent_id } : {},
+            fortress_id: this.fortressId
+          }
+        );
+        this.emit({ type: "finding", finding: stamped });
+        return stamped;
+      }
+      emit(event) {
+        for (const listener of this.listeners) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/sentinel/sentinel.ts
 var Sentinel;
 var init_sentinel = __esm({
@@ -23104,6 +23333,229 @@ var init_suspicious_tool_call_detector = __esm({
   }
 });
 
+// src/sentinel/sentinels/anomaly-trigger.ts
+function computeCompoundFindings(windowZero, now) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const f of windowZero) {
+    if (!f.agent_id) continue;
+    if (!isWarnOrAlert(f.severity)) continue;
+    let bucket = byAgent.get(f.agent_id);
+    if (!bucket) {
+      bucket = [];
+      byAgent.set(f.agent_id, bucket);
+    }
+    bucket.push(f);
+  }
+  const out = [];
+  for (const [agentId, group] of byAgent.entries()) {
+    const distinctSentinels = new Set(group.map((f) => f.sentinel_id));
+    if (distinctSentinels.size < COMPOUND_TRIGGER_MIN_SENTINELS) continue;
+    const contributingSentinels = [...distinctSentinels].sort();
+    const evidence = group.map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+    const summary = `${agentId} agent triggered ${distinctSentinels.size} distinct sentinels in the last 24h: ${contributingSentinels.join(", ")}. Compound suspicious behavior; review the contributing findings.`;
+    out.push({
+      finding_id: "",
+      sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+      severity: "alert",
+      agent_id: agentId,
+      summary,
+      details: {
+        trigger: "compound",
+        agent_id: agentId,
+        contributing_sentinels: contributingSentinels,
+        contributing_finding_count: group.length
+      },
+      observed_at: now.toISOString(),
+      evidence_audit_ids: evidence,
+      fortress_id: ""
+    });
+  }
+  return out;
+}
+function computeCountSpikeFinding(windowed, now) {
+  const currentCount = (windowed[0] ?? []).length;
+  const baselineCounts = [];
+  for (let i = 1; i <= BASELINE_WINDOWS5; i += 1) {
+    baselineCounts.push((windowed[i] ?? []).length);
+  }
+  const populated = baselineCounts.filter((c) => c > 0).length;
+  if (populated < BASELINE_WINDOWS5) {
+    return null;
+  }
+  const mean = baselineCounts.reduce((sum, c) => sum + c, 0) / baselineCounts.length;
+  const variance = baselineCounts.reduce((sum, c) => sum + (c - mean) ** 2, 0) / baselineCounts.length;
+  const stddev = Math.sqrt(variance);
+  const warnThreshold = mean + WARN_SIGMA5 * stddev;
+  const alertThreshold = mean + ALERT_SIGMA5 * stddev;
+  if (currentCount > alertThreshold) {
+    return buildCountFinding(
+      currentCount,
+      mean,
+      stddev,
+      ALERT_SIGMA5,
+      "alert",
+      windowed[0] ?? [],
+      now
+    );
+  }
+  if (currentCount > warnThreshold) {
+    return buildCountFinding(
+      currentCount,
+      mean,
+      stddev,
+      WARN_SIGMA5,
+      "warn",
+      windowed[0] ?? [],
+      now
+    );
+  }
+  return null;
+}
+function buildCountFinding(currentCount, mean, stddev, sigma, severity, windowZero, now) {
+  const ratio = mean === 0 ? Number.POSITIVE_INFINITY : currentCount / mean;
+  const ratioStr = Number.isFinite(ratio) ? `${ratio.toFixed(1)}x normal` : "no prior baseline";
+  const summary = `Fortress finding count is ${ratioStr}: ${currentCount} findings in last 24h, baseline ${mean.toFixed(1)} +/- ${stddev.toFixed(1)}. Crossed +${sigma} sigma threshold across all sentinels.`;
+  const evidence = windowZero.map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+  return {
+    finding_id: "",
+    sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+    severity,
+    summary,
+    details: {
+      trigger: "count_spike",
+      current_count: currentCount,
+      baseline_mean: mean,
+      baseline_stddev: stddev,
+      sigma_threshold: sigma,
+      ratio: Number.isFinite(ratio) ? ratio : null
+    },
+    observed_at: now.toISOString(),
+    evidence_audit_ids: evidence,
+    fortress_id: ""
+  };
+}
+function computeNovelComboFinding(windowed, now) {
+  const distinctByWindow = [];
+  for (let i = 0; i <= BASELINE_WINDOWS5; i += 1) {
+    const set = /* @__PURE__ */ new Set();
+    for (const f of windowed[i] ?? []) {
+      set.add(f.sentinel_id);
+    }
+    distinctByWindow.push(set);
+  }
+  const populatedBaselineWindows = distinctByWindow.slice(1).filter((s) => s.size > 0).length;
+  if (populatedBaselineWindows < BASELINE_WINDOWS5) {
+    return null;
+  }
+  const currentCombo = distinctByWindow[0];
+  if (currentCombo.size < 2) return null;
+  const currentKey = comboKey(currentCombo);
+  for (let i = 1; i <= BASELINE_WINDOWS5; i += 1) {
+    if (comboKey(distinctByWindow[i]) === currentKey) {
+      return null;
+    }
+  }
+  const sentinelIds = [...currentCombo].sort();
+  const summary = `Novel sentinel-ID combination this 24h window: ${sentinelIds.join(" + ")}. This co-occurrence pattern has not appeared in the prior ${BASELINE_WINDOWS5} baseline windows.`;
+  const evidence = (windowed[0] ?? []).map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+  return {
+    finding_id: "",
+    sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+    severity: "info",
+    summary,
+    details: {
+      trigger: "novel_combo",
+      sentinel_ids: sentinelIds,
+      baseline_window_count: BASELINE_WINDOWS5
+    },
+    observed_at: now.toISOString(),
+    evidence_audit_ids: evidence,
+    fortress_id: ""
+  };
+}
+function isWarnOrAlert(s) {
+  return s === "warn" || s === "alert";
+}
+function bucketByWindow(findings, nowMs) {
+  const buckets = Array.from(
+    { length: BASELINE_WINDOWS5 + 1 },
+    () => []
+  );
+  for (const f of findings) {
+    const ts = Date.parse(f.observed_at);
+    if (!Number.isFinite(ts)) continue;
+    const age = nowMs - ts;
+    if (age < 0) continue;
+    const idx = Math.floor(age / WINDOW_MS);
+    if (idx > BASELINE_WINDOWS5) continue;
+    buckets[idx].push(f);
+  }
+  return buckets;
+}
+function comboKey(set) {
+  return [...set].sort().join("|");
+}
+var ANOMALY_TRIGGER_SENTINEL_ID, WARN_SIGMA5, ALERT_SIGMA5, BASELINE_WINDOWS5, QUERY_LIMIT5, WINDOW_MS, COMPOUND_TRIGGER_MIN_SENTINELS, AnomalyTriggerWatcher;
+var init_anomaly_trigger = __esm({
+  "src/sentinel/sentinels/anomaly-trigger.ts"() {
+    init_sentinel();
+    ANOMALY_TRIGGER_SENTINEL_ID = "anomaly-trigger";
+    WARN_SIGMA5 = 3;
+    ALERT_SIGMA5 = 6;
+    BASELINE_WINDOWS5 = 7;
+    QUERY_LIMIT5 = 5e3;
+    WINDOW_MS = 24 * 60 * 60 * 1e3;
+    COMPOUND_TRIGGER_MIN_SENTINELS = 2;
+    AnomalyTriggerWatcher = class extends Sentinel {
+      sentinelId = ANOMALY_TRIGGER_SENTINEL_ID;
+      description = "Meta-sentinel. Watches for patterns ACROSS other sentinels' findings: compound suspicious behavior on one agent, fortress-wide finding-count spikes, and novel cross-sentinel combinations. Closes WP-V1.3-1 Sentinel Baseline Pack.";
+      async subscribe(context) {
+        if (!context.findingStore) {
+          throw new Error(
+            `${ANOMALY_TRIGGER_SENTINEL_ID}: findingStore missing from SentinelContext; this meta-sentinel requires the Phi-1 finding store`
+          );
+        }
+        await super.subscribe(context);
+      }
+      async evaluate() {
+        const ctx = this.requireContext();
+        const findingStore = ctx.findingStore;
+        if (!findingStore) {
+          return [];
+        }
+        const now = ctx.now();
+        const nowMs = now.getTime();
+        const windowSpanMs = (BASELINE_WINDOWS5 + 1) * WINDOW_MS;
+        const sinceIso = new Date(nowMs - windowSpanMs).toISOString();
+        let findings;
+        try {
+          findings = await findingStore.listFindings({
+            since: sinceIso,
+            limit: QUERY_LIMIT5
+          });
+        } catch {
+          return [];
+        }
+        const firstOrderFindings = findings.filter(
+          (f) => f.sentinel_id !== ANOMALY_TRIGGER_SENTINEL_ID
+        );
+        const windowed = bucketByWindow(firstOrderFindings, nowMs);
+        const out = [];
+        const compoundFindings = computeCompoundFindings(
+          windowed[0] ?? [],
+          now
+        );
+        out.push(...compoundFindings);
+        const countSpikeFinding = computeCountSpikeFinding(windowed, now);
+        if (countSpikeFinding) out.push(countSpikeFinding);
+        const novelComboFinding = computeNovelComboFinding(windowed, now);
+        if (novelComboFinding) out.push(novelComboFinding);
+        return out;
+      }
+    };
+  }
+});
+
 // src/sentinel/sentinels/index.ts
 var PHI1_BASELINE_CATALOG;
 var init_sentinels = __esm({
@@ -23112,6 +23564,7 @@ var init_sentinels = __esm({
     init_cross_agent_chatter_watcher();
     init_credential_usage_watcher();
     init_suspicious_tool_call_detector();
+    init_anomaly_trigger();
     PHI1_BASELINE_CATALOG = [
       {
         sentinelId: EGRESS_VOLUME_SENTINEL_ID,
@@ -23132,6 +23585,11 @@ var init_sentinels = __esm({
         sentinelId: SUSPICIOUS_TOOL_CALL_SENTINEL_ID,
         description: "Surfaces tool calls whose argument shape, call frequency, or permission combination looks unusual for the fortress's recent history.",
         factory: () => new SuspiciousToolCallDetector()
+      },
+      {
+        sentinelId: ANOMALY_TRIGGER_SENTINEL_ID,
+        description: "Meta-sentinel. Watches for patterns ACROSS other sentinels' findings: compound suspicious behavior on one agent, fortress-wide finding-count spikes, and novel cross-sentinel combinations. Closes WP-V1.3-1 Sentinel Baseline Pack.",
+        factory: () => new AnomalyTriggerWatcher()
       }
     ];
   }
@@ -34650,7 +35108,7 @@ var init_recovery_key_disclosure = __esm({
 });
 
 // src/hub/types.ts
-var init_types4 = __esm({
+var init_types5 = __esm({
   "src/hub/types.ts"() {
   }
 });
@@ -35689,7 +36147,7 @@ var init_hub = __esm({
   "src/hub/index.ts"() {
     init_constants3();
     init_errors4();
-    init_types4();
+    init_types5();
     init_agent_registry();
     init_inbox_store();
     init_inbox_aggregator();
@@ -42193,6 +42651,15 @@ ${err.message}
   if (dashboard) {
     dashboard.setSentinelDispatcher(sentinelDispatcher);
   }
+  const anomalyDispatcher = new AnomalyPipelineDispatcher({
+    findingStore: sentinelFindingStore,
+    auditLog,
+    storage,
+    masterKey,
+    fortressId: fortressIdForAggregator,
+    identityId: aggregatorIdentityId
+  });
+  anomalyDispatcher.start();
   const policyTools = createPrincipalPolicyTools(policy, baseline, auditLog);
   const { tools: sanctuaryMetaTools } = createSanctuaryTools({
     config,
@@ -42389,6 +42856,7 @@ var init_src = __esm({
     init_sentinel_finding_store();
     init_sentinel_registry();
     init_sentinel_dispatcher();
+    init_anomaly_pipeline();
     init_sentinels();
     init_subscription_store();
     init_tools4();