@sanctuary-framework/mcp-server 1.2.9 → 1.2.11

package/dist/index.cjs

@@ -16565,6 +16565,306 @@ async function handleSentinelRoute(deps, req, res) {
     return true;
   }
 }
+var HANDOFF_LOG_OBSERVED_OPS = {
+  /** Tau-3 in-process coordination handoff. */
+  LOCAL_HANDOFF: "v1.1_local_handoff",
+  /** Upsilon-1 cross-harness approval (wrapped-agent -> operator). */
+  CROSS_HARNESS_APPROVAL: "cross_harness_approval_aggregated"
+};
+var OBSERVED_OP_LIST = [
+  HANDOFF_LOG_OBSERVED_OPS.LOCAL_HANDOFF,
+  HANDOFF_LOG_OBSERVED_OPS.CROSS_HARNESS_APPROVAL
+];
+var OPERATOR_PSEUDO_AGENT = "operator";
+function makeEntryId(auditEventId) {
+  return crypto.createHash("sha256").update(auditEventId).digest("hex").slice(0, 32);
+}
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 500;
+var AUDIT_QUERY_LIMIT = 1e4;
+var HandoffLog = class {
+  auditLog;
+  fortressId;
+  constructor(opts) {
+    this.auditLog = opts.auditLog;
+    this.fortressId = opts.fortressId;
+  }
+  /** Stable fortress id this HandoffLog reads. */
+  getFortressId() {
+    return this.fortressId;
+  }
+  /**
+   * Query handoffs in chronological-newest-first order. Filters
+   * applied after normalization so the per-event-class shape
+   * differences (sender field name, recipient inference) are handled
+   * once.
+   */
+  async query(opts) {
+    const limit = Math.min(opts.limit ?? DEFAULT_LIMIT, MAX_LIMIT);
+    const queryResult = await this.auditLog.query({
+      ...opts.since !== void 0 ? { since: opts.since } : {},
+      layer: "l2",
+      limit: AUDIT_QUERY_LIMIT
+    });
+    const normalized = [];
+    for (const entry of queryResult.entries) {
+      if (!OBSERVED_OP_LIST.includes(entry.operation)) continue;
+      const handoff = this.normalize(entry);
+      if (!handoff) continue;
+      if (opts.until && handoff.observed_at > opts.until) continue;
+      if (opts.since && handoff.observed_at < opts.since) continue;
+      if (opts.agent_id) {
+        if (handoff.source_agent_id !== opts.agent_id && handoff.target_agent_id !== opts.agent_id) {
+          continue;
+        }
+      }
+      normalized.push(handoff);
+    }
+    normalized.sort((a, b) => a.observed_at < b.observed_at ? 1 : -1);
+    return normalized.slice(0, limit);
+  }
+  /**
+   * Look up a single entry by id. Returns the normalized entry +
+   * the source audit payload for operator-facing detail rendering.
+   * Returns null when no audit entry maps to the given id.
+   */
+  async getEntry(entryId) {
+    const queryResult = await this.auditLog.query({
+      layer: "l2",
+      limit: AUDIT_QUERY_LIMIT
+    });
+    for (const audit of queryResult.entries) {
+      if (!OBSERVED_OP_LIST.includes(audit.operation)) continue;
+      const handoff = this.normalize(audit);
+      if (!handoff) continue;
+      if (handoff.entry_id === entryId) {
+        return { entry: handoff, source_audit_entry: audit };
+      }
+    }
+    return null;
+  }
+  normalize(audit) {
+    const details = audit.details;
+    if (audit.operation === HANDOFF_LOG_OBSERVED_OPS.LOCAL_HANDOFF) {
+      const sender = optString(details, "sender_agent_id");
+      const recipient = optString(details, "recipient_agent_id");
+      if (!sender || !recipient || sender === recipient) return null;
+      const auditEventId = optString(details, "event_id") ?? auditEventIdFallback(audit);
+      return {
+        entry_id: makeEntryId(auditEventId),
+        audit_event_id: auditEventId,
+        source_agent_id: sender,
+        target_agent_id: recipient,
+        observed_at: audit.timestamp,
+        event_class: audit.operation,
+        context_transfer_summary: localHandoffSummary(details, sender, recipient),
+        workflow_link: null
+      };
+    }
+    if (audit.operation === HANDOFF_LOG_OBSERVED_OPS.CROSS_HARNESS_APPROVAL) {
+      const sender = optString(details, "source_harness") ?? optString(details, "source_agent_id");
+      if (!sender) return null;
+      const auditEventId = optString(details, "aggregator_id") ?? auditEventIdFallback(audit);
+      return {
+        entry_id: makeEntryId(auditEventId),
+        audit_event_id: auditEventId,
+        source_agent_id: sender,
+        target_agent_id: OPERATOR_PSEUDO_AGENT,
+        observed_at: audit.timestamp,
+        event_class: audit.operation,
+        context_transfer_summary: crossHarnessSummary(details, sender),
+        workflow_link: null
+      };
+    }
+    return null;
+  }
+};
+function optString(details, key) {
+  if (!details) return null;
+  const value = details[key];
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value;
+}
+function auditEventIdFallback(audit) {
+  return `${audit.timestamp}:${audit.operation}`;
+}
+function localHandoffSummary(details, sender, recipient) {
+  const taskScope = optString(details, "task_scope");
+  const reasonClass = optString(details, "reason_class");
+  if (taskScope) {
+    return `${sender} -> ${recipient} handoff: ${taskScope}`;
+  }
+  if (reasonClass) {
+    return `${sender} -> ${recipient} handoff (${reasonClass})`;
+  }
+  return `${sender} -> ${recipient} handoff`;
+}
+function crossHarnessSummary(details, sender) {
+  const policyRule = optString(details, "policy_rule_id");
+  if (policyRule) {
+    return `${sender} -> operator approval (${policyRule})`;
+  }
+  return `${sender} -> operator approval`;
+}
+var COORDINATION_VIEW_AUDIT_OPS = {
+  VIEW_OPENED: "operator_coordination_view_opened",
+  ENTRY_DRILLED: "operator_handoff_entry_drilled"
+};
+
+// src/coordination/handoff-routes.ts
+var COORDINATION_API_PREFIX = "/api/coordination";
+var COORDINATION_HANDOFFS_PREFIX = "/api/coordination/handoffs";
+var COORDINATION_LIST_DEFAULT_LIMIT = 50;
+var COORDINATION_LIST_MAX_LIMIT = 500;
+var HandoffEventBridge = class {
+  listeners = /* @__PURE__ */ new Set();
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(entry) {
+    for (const listener of this.listeners) {
+      try {
+        listener(entry);
+      } catch {
+      }
+    }
+  }
+};
+function writeJSON6(res, status, payload) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store"
+  });
+  res.end(JSON.stringify(payload));
+}
+function parseLimit4(raw, defaultValue, max) {
+  if (raw === null || raw === "") return defaultValue;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed < 0) return defaultValue;
+  return Math.min(parsed, max);
+}
+function matchEntryRoute2(path) {
+  const prefix = `${COORDINATION_HANDOFFS_PREFIX}/`;
+  if (!path.startsWith(prefix)) return null;
+  const rest = path.slice(prefix.length);
+  if (rest.length === 0 || rest === "stream") return null;
+  if (rest.includes("/")) return null;
+  return { entryId: decodeURIComponent(rest) };
+}
+async function handleStream3(deps, res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  const snapshot = await deps.handoffLog.query({ limit: 50 });
+  res.write(
+    `event: handoff_snapshot
+data: ${JSON.stringify({ entries: snapshot })}
+
+`
+  );
+  const unsubscribe = deps.events.subscribe((entry) => {
+    try {
+      res.write(
+        `event: handoff_added
+data: ${JSON.stringify(entry)}
+
+`
+      );
+    } catch {
+    }
+  });
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(": keepalive\n\n");
+    } catch {
+    }
+  }, 25e3);
+  const cleanup = () => {
+    clearInterval(keepAlive);
+    unsubscribe();
+  };
+  res.on("close", cleanup);
+  res.on("error", cleanup);
+}
+async function handleCoordinationRoute(deps, req, res) {
+  const host = req.headers.host || "localhost";
+  const url = new URL(req.url ?? "/", `http://${host}`);
+  const method = (req.method ?? "GET").toUpperCase();
+  const path = url.pathname;
+  if (path !== COORDINATION_API_PREFIX && !path.startsWith(`${COORDINATION_API_PREFIX}/`)) {
+    return false;
+  }
+  const checkAuth = authMiddleware(deps.authConfig);
+  if (!checkAuth(req, res, url)) return true;
+  try {
+    if (method === "GET" && path === `${COORDINATION_HANDOFFS_PREFIX}/stream`) {
+      await handleStream3(deps, res);
+      return true;
+    }
+    if (method === "GET" && path === COORDINATION_HANDOFFS_PREFIX) {
+      const limit = parseLimit4(
+        url.searchParams.get("limit"),
+        COORDINATION_LIST_DEFAULT_LIMIT,
+        COORDINATION_LIST_MAX_LIMIT
+      );
+      const since = url.searchParams.get("since") ?? void 0;
+      const until = url.searchParams.get("until") ?? void 0;
+      const agentId = url.searchParams.get("agent_id") ?? void 0;
+      const entries = await deps.handoffLog.query({
+        limit,
+        ...since !== void 0 ? { since } : {},
+        ...until !== void 0 ? { until } : {},
+        ...agentId !== void 0 ? { agent_id: agentId } : {}
+      });
+      deps.auditLog.append(
+        "l2",
+        COORDINATION_VIEW_AUDIT_OPS.VIEW_OPENED,
+        deps.operatorId,
+        {
+          fortress_id: deps.handoffLog.getFortressId(),
+          result_count: entries.length,
+          ...since !== void 0 ? { since } : {},
+          ...until !== void 0 ? { until } : {},
+          ...agentId !== void 0 ? { agent_id: agentId } : {}
+        }
+      );
+      writeJSON6(res, 200, { ok: true, data: { entries } });
+      return true;
+    }
+    const entryMatch = matchEntryRoute2(path);
+    if (method === "GET" && entryMatch) {
+      const detail = await deps.handoffLog.getEntry(entryMatch.entryId);
+      if (!detail) {
+        writeJSON6(res, 404, { ok: false, error: "not_found" });
+        return true;
+      }
+      deps.auditLog.append(
+        "l2",
+        COORDINATION_VIEW_AUDIT_OPS.ENTRY_DRILLED,
+        deps.operatorId,
+        {
+          fortress_id: deps.handoffLog.getFortressId(),
+          entry_id: detail.entry.entry_id,
+          event_class: detail.entry.event_class,
+          source_agent_id: detail.entry.source_agent_id,
+          target_agent_id: detail.entry.target_agent_id
+        }
+      );
+      writeJSON6(res, 200, { ok: true, data: detail });
+      return true;
+    }
+    writeJSON6(res, 404, { ok: false, error: "not_found", path });
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeJSON6(res, 500, { ok: false, error: "internal", detail: msg });
+    return true;
+  }
+}
 
 // src/principal-policy/dashboard.ts
 var SESSION_TTL_REMOTE_MS = 5 * 60 * 1e3;
@@ -16645,6 +16945,17 @@ var DashboardApprovalChannel = class {
    * dispatcher's audited paths.
    */
   sentinelDispatcher = null;
+  /**
+   * v1.3 WP-V1.3-3 Omega-1 Coordination Handoff Visualization.
+   * Mounted additively at `/api/coordination/*` when set. Read-only
+   * against the audit log; the only writes are operator-action audit
+   * events (operator_coordination_view_opened,
+   * operator_handoff_entry_drilled).
+   */
+  handoffLog = null;
+  handoffEventBridge = null;
+  handoffAuditLog = null;
+  handoffOperatorId = null;
   constructor(config) {
     this.config = config;
     this.authToken = config.auth_token;
@@ -16712,6 +17023,18 @@ var DashboardApprovalChannel = class {
   setSentinelDispatcher(dispatcher) {
     this.sentinelDispatcher = dispatcher;
   }
+  /**
+   * v1.3 WP-V1.3-3 Omega-1: bind the Coordination handoff log +
+   * event bridge + audit log + operator id. Once set, requests to
+   * `/api/coordination/*` route through `handleCoordinationRoute`.
+   * Pass `null` for any field to detach.
+   */
+  setHandoffLog(opts) {
+    this.handoffLog = opts.handoffLog;
+    this.handoffEventBridge = opts.eventBridge ?? null;
+    this.handoffAuditLog = opts.auditLog ?? null;
+    this.handoffOperatorId = opts.operatorId ?? null;
+  }
   /**
    * v1.3 WP-V1.3-10 dispatch entry point. Called from `handleRequest`
    * before the legacy approval route table. Returns true when served.
@@ -16750,6 +17073,30 @@ var DashboardApprovalChannel = class {
       res
     );
   }
+  /**
+   * v1.3 WP-V1.3-3 Omega-1 dispatch entry point. Routes
+   * `/api/coordination/*` requests through the coordination router
+   * when a HandoffLog has been bound. Returns true when served.
+   */
+  async dispatchCoordination(req, res) {
+    if (!this.handoffLog || !this.handoffEventBridge || !this.handoffAuditLog) {
+      return false;
+    }
+    return handleCoordinationRoute(
+      {
+        authConfig: {
+          loopbackAutoAuth: this._autoAuthLocalhost,
+          ...this.authToken !== void 0 ? { authToken: this.authToken } : {}
+        },
+        handoffLog: this.handoffLog,
+        auditLog: this.handoffAuditLog,
+        operatorId: this.handoffOperatorId ?? this.identityManager?.getPrimaryIdentityId() ?? "operator_dashboard",
+        events: this.handoffEventBridge
+      },
+      req,
+      res
+    );
+  }
   /**
    * v1.1 dispatch entry point. Called from `handleRequest` before the
    * legacy route table. Returns true when the request was served by v1.1
@@ -17149,6 +17496,18 @@ var DashboardApprovalChannel = class {
       });
       return;
     }
+    if (this.handoffLog && url.pathname.startsWith(COORDINATION_API_PREFIX)) {
+      this.dispatchCoordination(req, res).then((handled) => {
+        if (handled) return;
+        this.handleLegacyRequest(req, res, url, method);
+      }).catch(() => {
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      });
+      return;
+    }
     if (this.v11Bindings) {
       this.dispatchV11(req, res, url, method).then((handled) => {
         if (handled) return;
@@ -20809,6 +21168,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);
@@ -20947,6 +21311,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 || 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 = class {
@@ -21127,7 +21703,7 @@ var ALERT_SIGMA2 = 6;
 var BASELINE_WINDOWS2 = 7;
 var QUERY_LIMIT2 = 1e4;
 var MULTI_NEW_PARTNER_ALERT_THRESHOLD = 3;
-var OPERATOR_PSEUDO_AGENT = "operator";
+var OPERATOR_PSEUDO_AGENT2 = "operator";
 var HANDOFF_OP = "v1.1_local_handoff";
 var CROSS_HARNESS_OPS = /* @__PURE__ */ new Set([
   "cross_harness_approval_aggregated",
@@ -21360,7 +21936,7 @@ function extractInterAgentEvents(entries) {
       if (!sender) continue;
       out.push({
         sender,
-        recipient: OPERATOR_PSEUDO_AGENT,
+        recipient: OPERATOR_PSEUDO_AGENT2,
         timestampMs: Date.parse(entry.timestamp),
         auditId: `${entry.timestamp}:${entry.operation}`
       });
@@ -22087,6 +22663,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 = [
   {
@@ -22108,6 +22901,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;
@@ -40640,6 +41438,28 @@ ${err.message}
   if (dashboard) {
     dashboard.setSentinelDispatcher(sentinelDispatcher);
   }
+  const anomalyDispatcher = new AnomalyPipelineDispatcher({
+    findingStore: sentinelFindingStore,
+    auditLog,
+    storage,
+    masterKey,
+    fortressId: fortressIdForAggregator,
+    identityId: aggregatorIdentityId
+  });
+  anomalyDispatcher.start();
+  const handoffLog = new HandoffLog({
+    auditLog,
+    fortressId: fortressIdForAggregator
+  });
+  const handoffEventBridge = new HandoffEventBridge();
+  if (dashboard) {
+    dashboard.setHandoffLog({
+      handoffLog,
+      eventBridge: handoffEventBridge,
+      auditLog,
+      operatorId: aggregatorIdentityId
+    });
+  }
   const policyTools = createPrincipalPolicyTools(policy, baseline, auditLog);
   const { tools: sanctuaryMetaTools } = createSanctuaryTools({
     config,