@sanctuary-framework/mcp-server 1.2.8 → 1.2.10

package/dist/index.js

@@ -20802,6 +20802,11 @@ var SentinelDispatcher = class {
       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);
@@ -20940,6 +20945,218 @@ var SentinelDispatcher = class {
     }
   }
 };
+var 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"
+};
+var DEFAULT_TICK_INTERVAL_MS2 = 6e4;
+var 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 || 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 = class {
@@ -22080,6 +22297,223 @@ function truncateSummary2(s) {
   return s.length > 240 ? s.slice(0, 237) + "..." : s;
 }
 
+// src/sentinel/sentinels/anomaly-trigger.ts
+var ANOMALY_TRIGGER_SENTINEL_ID = "anomaly-trigger";
+var WARN_SIGMA5 = 3;
+var ALERT_SIGMA5 = 6;
+var BASELINE_WINDOWS5 = 7;
+var QUERY_LIMIT5 = 5e3;
+var WINDOW_MS = 24 * 60 * 60 * 1e3;
+var COMPOUND_TRIGGER_MIN_SENTINELS = 2;
+var 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;
+  }
+};
+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("|");
+}
+
 // src/sentinel/sentinels/index.ts
 var PHI1_BASELINE_CATALOG = [
   {
@@ -22101,6 +22535,11 @@ var PHI1_BASELINE_CATALOG = [
     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()
   }
 ];
 var FILE_VERSION = 1;
@@ -40633,6 +41072,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,