@sanctuary-framework/mcp-server 1.2.10 → 1.2.12

package/dist/index.js

@@ -16558,6 +16558,598 @@ 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 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/context-transfer-extractor.ts
+var SUMMARY_MAX_CHARS = 240;
+var CATEGORY_VALUES = [
+  "memory",
+  "credentials",
+  "plans",
+  "outputs",
+  "audit-refs",
+  "other"
+];
+async function extractContextTransferBreakdown(detail, deps = {}) {
+  const pathA = tryStructuredPath(detail);
+  if (pathA) return pathA;
+  const pathB = tryCompositionPath(detail);
+  if (pathB) return pathB;
+  const pathC = tryHeuristicPath(detail);
+  if (pathC.confidence >= 0.5 || !deps.substrateSelector) {
+    return pathC;
+  }
+  const assist = await tryLlmAssistPath(detail, deps.substrateSelector);
+  return assist ?? pathC;
+}
+function tryStructuredPath(detail) {
+  const details = sourceDetails(detail.source_audit_entry);
+  if (!details) return null;
+  const transferredRaw = details["transferred"];
+  const withheldRaw = details["withheld"];
+  if (transferredRaw === void 0 && withheldRaw === void 0) return null;
+  const transferred = parseExplicitContextItems(transferredRaw);
+  const withheld = parseExplicitContextItems(withheldRaw);
+  return {
+    handoff_entry_id: detail.entry.entry_id,
+    transferred,
+    withheld,
+    source: "structured",
+    confidence: 1
+  };
+}
+function tryCompositionPath(detail) {
+  const op = detail.source_audit_entry.operation;
+  if (!op.startsWith("composition_completed")) return null;
+  const details = sourceDetails(detail.source_audit_entry);
+  if (!details) return null;
+  const receiptRaw = details["receipt"];
+  const sourceStateRaw = details["source_state_snapshot"];
+  if (receiptRaw === void 0) return null;
+  const transferred = parseExplicitContextItems(receiptRaw);
+  const withheld = [];
+  if (Array.isArray(sourceStateRaw)) {
+    const transferredKeys = new Set(
+      transferred.map((t) => `${t.category}:${t.summary}`)
+    );
+    for (const item of parseExplicitContextItems(sourceStateRaw)) {
+      const key = `${item.category}:${item.summary}`;
+      if (!transferredKeys.has(key)) withheld.push(item);
+    }
+  }
+  return {
+    handoff_entry_id: detail.entry.entry_id,
+    transferred,
+    withheld,
+    source: "composition",
+    confidence: 0.9
+  };
+}
+function tryHeuristicPath(detail) {
+  const entry = detail.entry;
+  const audit = detail.source_audit_entry;
+  const details = sourceDetails(audit);
+  if (audit.operation === "cross_harness_approval_aggregated") {
+    const ruleId = optString2(details, "policy_rule_id");
+    if (ruleId) {
+      const category = categoryFromPolicyRuleId(ruleId);
+      const summary = `${ruleId} (${entry.source_agent_id} -> operator)`;
+      return {
+        handoff_entry_id: entry.entry_id,
+        transferred: [
+          {
+            category,
+            summary: truncate(summary, SUMMARY_MAX_CHARS),
+            size_hint: "minimal"
+          }
+        ],
+        withheld: [],
+        source: "heuristic",
+        confidence: 0.5
+      };
+    }
+  }
+  if (audit.operation === "v1.1_local_handoff") {
+    const reasonClass = optString2(details, "reason_class");
+    const newStatus = optString2(details, "new_status");
+    const previousStatus = optString2(details, "previous_status");
+    const transferred = [];
+    const withheld = [];
+    if (newStatus === "denied" || newStatus === "failed") {
+      withheld.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${newStatus}${reasonClass ? ` (${reasonClass})` : ""}: ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      });
+    } else if (newStatus === "accepted" || newStatus === "completed") {
+      transferred.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${newStatus}${previousStatus ? ` (from ${previousStatus})` : ""}: ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "small"
+      });
+    } else {
+      transferred.push({
+        category: "other",
+        summary: truncate(
+          `handoff ${entry.source_agent_id} -> ${entry.target_agent_id}${newStatus ? ` (${newStatus})` : ""}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      });
+    }
+    return {
+      handoff_entry_id: entry.entry_id,
+      transferred,
+      withheld,
+      source: "heuristic",
+      confidence: reasonClass || newStatus ? 0.5 : 0.3
+    };
+  }
+  return {
+    handoff_entry_id: entry.entry_id,
+    transferred: [
+      {
+        category: "other",
+        summary: truncate(
+          `handoff ${entry.source_agent_id} -> ${entry.target_agent_id}`,
+          SUMMARY_MAX_CHARS
+        ),
+        size_hint: "minimal"
+      }
+    ],
+    withheld: [],
+    source: "heuristic",
+    confidence: 0.3
+  };
+}
+async function tryLlmAssistPath(detail, selector) {
+  const entry = detail.entry;
+  const audit = detail.source_audit_entry;
+  const probe = `event=${audit.operation} sender=${entry.source_agent_id} target=${entry.target_agent_id} summary=${entry.context_transfer_summary}`;
+  try {
+    const response = await selector.invokeClassify("sentinel-scoring", {
+      kind: "classify",
+      items: [probe],
+      categories: [...CATEGORY_VALUES]
+    });
+    if (response.body.kind !== "classify") return null;
+    const top = response.body.results[0];
+    if (!top || !isCategory(top.category) || top.confidence < 0.4) {
+      return null;
+    }
+    return {
+      handoff_entry_id: entry.entry_id,
+      transferred: [
+        {
+          category: top.category,
+          summary: truncate(
+            `LLM-classified handoff ${entry.source_agent_id} -> ${entry.target_agent_id}: ${top.category} (confidence ${top.confidence.toFixed(2)})`,
+            SUMMARY_MAX_CHARS
+          ),
+          size_hint: "minimal"
+        }
+      ],
+      withheld: [],
+      source: "llm-assist",
+      confidence: 0.6
+    };
+  } catch {
+    return null;
+  }
+}
+function sourceDetails(audit) {
+  return audit.details;
+}
+function optString2(details, key) {
+  if (!details) return null;
+  const value = details[key];
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value;
+}
+function isCategory(value) {
+  return CATEGORY_VALUES.includes(value);
+}
+function truncate(s, cap) {
+  return s.length <= cap ? s : `${s.slice(0, cap - 3)}...`;
+}
+function parseExplicitContextItems(raw) {
+  if (raw === null || raw === void 0) return [];
+  if (Array.isArray(raw)) {
+    const out = [];
+    for (const entry of raw) {
+      if (typeof entry === "string") {
+        out.push({
+          category: "other",
+          summary: truncate(entry, SUMMARY_MAX_CHARS),
+          size_hint: "minimal"
+        });
+        continue;
+      }
+      if (entry && typeof entry === "object") {
+        const obj = entry;
+        const category = isCategoryValue(obj["category"]) ? obj["category"] : "other";
+        const summary = typeof obj["summary"] === "string" ? truncate(obj["summary"], SUMMARY_MAX_CHARS) : "(unspecified)";
+        const sizeHint = isSizeHintValue(obj["size_hint"]) ? obj["size_hint"] : "minimal";
+        out.push({ category, summary, size_hint: sizeHint });
+      }
+    }
+    return out;
+  }
+  if (typeof raw === "object" && raw !== null) {
+    const out = [];
+    for (const [k, v] of Object.entries(raw)) {
+      const category = isCategoryValue(k) ? k : "other";
+      if (Array.isArray(v)) {
+        for (const item of v) {
+          if (typeof item === "string") {
+            out.push({
+              category,
+              summary: truncate(item, SUMMARY_MAX_CHARS),
+              size_hint: "minimal"
+            });
+          }
+        }
+      }
+    }
+    return out;
+  }
+  return [];
+}
+function isCategoryValue(v) {
+  return typeof v === "string" && CATEGORY_VALUES.includes(v);
+}
+function isSizeHintValue(v) {
+  return typeof v === "string" && (v === "minimal" || v === "small" || v === "medium" || v === "large");
+}
+function categoryFromPolicyRuleId(ruleId) {
+  const lower = ruleId.toLowerCase();
+  if (lower.includes("credential") || lower.includes("broker_secret")) {
+    return "credentials";
+  }
+  if (lower.includes("memory") || lower.includes("state_read")) {
+    return "memory";
+  }
+  if (lower.includes("plan")) {
+    return "plans";
+  }
+  if (lower.includes("export") || lower.includes("output")) {
+    return "outputs";
+  }
+  if (lower.includes("audit")) {
+    return "audit-refs";
+  }
+  return "other";
+}
+var CONTEXT_TRANSFER_AUDIT_OPS = {
+  DECODED: "operator_handoff_context_transfer_decoded"
+};
+
+// 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
+        }
+      );
+      let breakdown = null;
+      try {
+        breakdown = await extractContextTransferBreakdown(
+          detail,
+          deps.contextTransfer ?? {}
+        );
+        deps.auditLog.append(
+          "l2",
+          CONTEXT_TRANSFER_AUDIT_OPS.DECODED,
+          deps.operatorId,
+          {
+            fortress_id: deps.handoffLog.getFortressId(),
+            entry_id: detail.entry.entry_id,
+            extractor_path: breakdown.source,
+            confidence: breakdown.confidence,
+            transferred_count: breakdown.transferred.length,
+            withheld_count: breakdown.withheld.length
+          }
+        );
+      } catch {
+      }
+      const responseData = breakdown !== null ? { ...detail, context_transfer_breakdown: breakdown } : detail;
+      writeJSON6(res, 200, { ok: true, data: responseData });
+      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;
@@ -16638,6 +17230,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;
@@ -16705,6 +17308,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.
@@ -16743,6 +17358,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
@@ -17142,6 +17781,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;
@@ -20945,13 +21596,33 @@ var SentinelDispatcher = class {
     }
   }
 };
+
+// src/anomaly-detection/classifier-state-store.ts
+init_encryption();
+init_encoding();
+
+// src/anomaly-detection/classifiers/cusum.ts
+var CUSUM_CLASSIFIER_ID = "cusum";
+
+// src/anomaly-detection/classifiers/psi.ts
+var PSI_CLASSIFIER_ID = "psi";
+
+// src/anomaly-detection/anomaly-pipeline.ts
 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"
+  TRAINING_FAILED: "anomaly_training_failed",
+  /** Chi-2: a classifier was attached to an existing detector. */
+  CLASSIFIER_SUBSCRIBED: "anomaly_classifier_subscribed",
+  /** Chi-2: a classifier was detached from an existing detector. */
+  CLASSIFIER_UNSUBSCRIBED: "anomaly_classifier_unsubscribed",
+  /** Chi-2: CUSUM-flagged mean-shift drift on a per-agent feature. */
+  CUSUM_DRIFT_DETECTED: "anomaly_cusum_drift_detected",
+  /** Chi-2: PSI-flagged distribution shift on a per-agent feature. */
+  PSI_DISTRIBUTION_SHIFT_DETECTED: "anomaly_psi_distribution_shift_detected"
 };
 var DEFAULT_TICK_INTERVAL_MS2 = 6e4;
 var AnomalyPipelineDispatcher = class {
@@ -21042,34 +21713,37 @@ var AnomalyPipelineDispatcher = class {
             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"
-            );
+          for (const classifier of detector.getAllClassifiers()) {
+            try {
+              const trainingResult = await classifier.train();
+              this.auditLog.append(
+                "l2",
+                ANOMALY_AUDIT_OPS.TRAINING_COMPLETED,
+                this.identityId,
+                {
+                  detector_id: detectorId,
+                  classifier_id: 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,
+                  classifier_id: classifier.classifierId,
+                  error_message: message,
+                  fortress_id: this.fortressId
+                },
+                "failure"
+              );
+            }
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -21132,6 +21806,7 @@ var AnomalyPipelineDispatcher = class {
       observed_at: raw.observed_at || this.now().toISOString()
     };
     await this.findingStore.saveFinding(stamped);
+    const classifierId = stamped.details["classifier_id"] ?? null;
     this.auditLog.append(
       "l2",
       ANOMALY_AUDIT_OPS.FINDING_EMITTED,
@@ -21141,13 +21816,79 @@ var AnomalyPipelineDispatcher = class {
         finding_id: stamped.finding_id,
         severity: stamped.severity,
         anomaly_score: stamped.details["anomaly_score"] ?? null,
+        ...classifierId !== null ? { classifier_id: classifierId } : {},
         ...stamped.agent_id !== void 0 ? { agent_id: stamped.agent_id } : {},
         fortress_id: this.fortressId
       }
     );
+    const specificOp = classifierSpecificAuditOp(classifierId);
+    if (specificOp !== null) {
+      this.auditLog.append("l2", specificOp, 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;
   }
+  /**
+   * Chi-2: attach an additional classifier to an already-registered
+   * detector. Emits ANOMALY_CLASSIFIER_SUBSCRIBED on success. The
+   * factory is called with the fortress AnomalyContext so the
+   * classifier can build its own state-store binding. Idempotent: a
+   * second call with the same classifierId returns false.
+   */
+  async addClassifierToDetector(detectorId, factory) {
+    const detector = this.detectors.get(detectorId);
+    if (!detector) return false;
+    const context = {
+      fortressId: this.fortressId,
+      auditLog: this.auditLog,
+      storage: this.storage,
+      masterKey: this.masterKey,
+      now: this.now
+    };
+    const classifier = factory(context);
+    const added = detector.addClassifier(classifier);
+    if (!added) return false;
+    this.auditLog.append(
+      "l2",
+      ANOMALY_AUDIT_OPS.CLASSIFIER_SUBSCRIBED,
+      this.identityId,
+      {
+        detector_id: detectorId,
+        classifier_id: classifier.classifierId,
+        fortress_id: this.fortressId
+      }
+    );
+    return true;
+  }
+  /**
+   * Chi-2: detach an additional classifier from an already-registered
+   * detector. Emits ANOMALY_CLASSIFIER_UNSUBSCRIBED on success. The
+   * primary classifier cannot be detached (returns false).
+   */
+  async removeClassifierFromDetector(detectorId, classifierId) {
+    const detector = this.detectors.get(detectorId);
+    if (!detector) return false;
+    const removed = detector.removeClassifier(classifierId);
+    if (!removed) return false;
+    this.auditLog.append(
+      "l2",
+      ANOMALY_AUDIT_OPS.CLASSIFIER_UNSUBSCRIBED,
+      this.identityId,
+      {
+        detector_id: detectorId,
+        classifier_id: classifierId,
+        fortress_id: this.fortressId
+      }
+    );
+    return true;
+  }
   emit(event) {
     for (const listener of this.listeners) {
       try {
@@ -21157,6 +21898,16 @@ var AnomalyPipelineDispatcher = class {
     }
   }
 };
+function classifierSpecificAuditOp(classifierId) {
+  if (classifierId === null) return null;
+  if (classifierId === CUSUM_CLASSIFIER_ID) {
+    return ANOMALY_AUDIT_OPS.CUSUM_DRIFT_DETECTED;
+  }
+  if (classifierId === PSI_CLASSIFIER_ID) {
+    return ANOMALY_AUDIT_OPS.PSI_DISTRIBUTION_SHIFT_DETECTED;
+  }
+  return null;
+}
 
 // src/sentinel/sentinel.ts
 var Sentinel = class {
@@ -21337,7 +22088,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",
@@ -21570,7 +22321,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}`
       });
@@ -37836,6 +38587,136 @@ function tryParseClassification3(text) {
   }
 }
 
+// src/query-anonymity/header-strip.ts
+var QUERY_ANONYMITY_AUDIT_OPS = {
+  HEADERS_STRIPPED: "query_anonymity_headers_stripped"
+};
+var CANONICAL_STRIP_LIST = [
+  // Browser / runtime fingerprinting.
+  { name: "user-agent", reason: "user-agent" },
+  { name: "sec-ch-ua", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-mobile", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-platform", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-platform-version", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-arch", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-bitness", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-model", reason: "fingerprintable-extension" },
+  { name: "sec-ch-ua-full-version-list", reason: "fingerprintable-extension" },
+  // Locale fingerprint.
+  { name: "accept-language", reason: "locale-fingerprint" },
+  // Request-origin leak.
+  { name: "referer", reason: "leaking-network-info" },
+  { name: "referrer-policy", reason: "leaking-network-info" },
+  { name: "origin", reason: "leaking-network-info" },
+  // Forwarded-by / IP-derived network info.
+  { name: "via", reason: "leaking-network-info" },
+  { name: "forwarded", reason: "leaking-network-info" },
+  { name: "x-forwarded-for", reason: "leaking-network-info" },
+  { name: "x-real-ip", reason: "leaking-network-info" },
+  { name: "x-client-ip", reason: "leaking-network-info" },
+  // DNT / GPC are technically anti-tracking signals but they
+  // themselves form a fingerprint (operators who set DNT=1 are a
+  // smaller subset). Strip to keep the substrate ignorant of
+  // operator preferences.
+  { name: "dnt", reason: "unnecessary-metadata" },
+  { name: "sec-gpc", reason: "unnecessary-metadata" }
+];
+var REQUIRED_HEADERS = [
+  "authorization",
+  "content-type",
+  "content-length",
+  "host",
+  "accept",
+  "x-api-key",
+  // Anthropic API auth
+  "anthropic-version",
+  // Anthropic API contract version
+  "anthropic-beta",
+  // optional Anthropic beta opt-in
+  "openai-organization",
+  // optional OpenAI org id
+  "x-stainless-package-version",
+  // allowed for Anthropic + OpenAI SDK contract compat
+  "x-goog-api-key",
+  // Google AI Studio
+  "x-goog-user-project"
+  // Google AI Studio
+];
+var REQUIRED_HEADER_SET = new Set(
+  REQUIRED_HEADERS.map((h) => h.toLowerCase())
+);
+var STRIP_REASON_BY_NAME = new Map(
+  CANONICAL_STRIP_LIST.map((h) => [h.name.toLowerCase(), h.reason])
+);
+function stripHeaders(headers) {
+  const stripped = {};
+  const removed = [];
+  for (const [name, value] of Object.entries(headers)) {
+    const lower = name.toLowerCase();
+    if (REQUIRED_HEADER_SET.has(lower)) {
+      stripped[name] = value;
+      continue;
+    }
+    const reason = STRIP_REASON_BY_NAME.get(lower);
+    if (reason !== void 0) {
+      removed.push({ name, reason });
+      continue;
+    }
+    stripped[name] = value;
+  }
+  return { stripped, removed };
+}
+function defeatUndiciDefaultsInto(headers) {
+  if (headers["user-agent"] === void 0 && headers["User-Agent"] === void 0) {
+    headers["User-Agent"] = "";
+  }
+  if (headers["accept-language"] === void 0 && headers["Accept-Language"] === void 0) {
+    headers["Accept-Language"] = "";
+  }
+  return headers;
+}
+function createAnonymizedFetch(baseFetch, onAudit) {
+  const wrapped = async (input, init) => {
+    const headers = normalizeHeadersInit(init?.headers);
+    const result = stripHeaders(headers);
+    defeatUndiciDefaultsInto(result.stripped);
+    const preservedRequired = Object.keys(result.stripped).filter(
+      (k) => REQUIRED_HEADER_SET.has(k.toLowerCase())
+    );
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    if (onAudit) {
+      onAudit({
+        url,
+        method,
+        stripped_count: result.removed.length,
+        removed: result.removed,
+        required_preserved: preservedRequired
+      });
+    }
+    return baseFetch(input, { ...init, headers: result.stripped });
+  };
+  return wrapped;
+}
+function normalizeHeadersInit(raw) {
+  if (raw === void 0) return {};
+  if (typeof Headers !== "undefined" && raw instanceof Headers) {
+    const out = {};
+    raw.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+  if (Array.isArray(raw)) {
+    const out = {};
+    for (const [k, v] of raw) {
+      if (k !== void 0 && v !== void 0) out[k] = v;
+    }
+    return out;
+  }
+  return { ...raw };
+}
+
 // src/intelligence/substrates/hybrid/per-surface-router.ts
 function resolveHybridChoice(rules, surface) {
   if (!rules) return null;
@@ -37896,7 +38777,21 @@ var SubstrateSelector = class {
     this.auditLog = cfg.auditLog;
     this.identityId = cfg.identityId;
     this.redactor = cfg.redactor ?? IDENTITY_REDACTOR;
-    this.fetchImpl = cfg.fetchImpl;
+    const baseFetch = cfg.fetchImpl ?? globalThis.fetch;
+    this.fetchImpl = createAnonymizedFetch(baseFetch, (event) => {
+      this.auditLog.append(
+        "l2",
+        QUERY_ANONYMITY_AUDIT_OPS.HEADERS_STRIPPED,
+        this.identityId,
+        {
+          url: event.url,
+          method: event.method,
+          stripped_count: event.stripped_count,
+          removed: event.removed,
+          required_preserved: event.required_preserved
+        }
+      );
+    });
     this.config = buildDefaultConfig();
   }
   /**
@@ -41081,6 +41976,19 @@ ${err.message}
     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,