@sanctuary-framework/mcp-server 1.2.11 → 1.2.12

package/dist/cli.cjs

@@ -17631,6 +17631,281 @@ var init_handoff_log = __esm({
   }
 });
 
+// src/coordination/context-transfer-extractor.ts
+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 SUMMARY_MAX_CHARS, CATEGORY_VALUES, CONTEXT_TRANSFER_AUDIT_OPS;
+var init_context_transfer_extractor = __esm({
+  "src/coordination/context-transfer-extractor.ts"() {
+    SUMMARY_MAX_CHARS = 240;
+    CATEGORY_VALUES = [
+      "memory",
+      "credentials",
+      "plans",
+      "outputs",
+      "audit-refs",
+      "other"
+    ];
+    CONTEXT_TRANSFER_AUDIT_OPS = {
+      DECODED: "operator_handoff_context_transfer_decoded"
+    };
+  }
+});
+
 // src/coordination/handoff-routes.ts
 function writeJSON6(res, status, payload) {
   res.writeHead(status, {
@@ -17755,7 +18030,29 @@ async function handleCoordinationRoute(deps, req, res) {
           target_agent_id: detail.entry.target_agent_id
         }
       );
-      writeJSON6(res, 200, { ok: true, data: detail });
+      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 });
@@ -17771,6 +18068,7 @@ var init_handoff_routes = __esm({
   "src/coordination/handoff-routes.ts"() {
     init_auth_middleware();
     init_handoff_log();
+    init_context_transfer_extractor();
     COORDINATION_API_PREFIX = "/api/coordination";
     COORDINATION_HANDOFFS_PREFIX = "/api/coordination/handoffs";
     COORDINATION_LIST_DEFAULT_LIMIT = 50;
@@ -22311,15 +22609,52 @@ var init_sentinel_dispatcher = __esm({
     };
   }
 });
+var init_classifier_state_store = __esm({
+  "src/anomaly-detection/classifier-state-store.ts"() {
+    init_encryption();
+    init_key_derivation();
+    init_encoding();
+  }
+});
+
+// src/anomaly-detection/classifiers/cusum.ts
+var CUSUM_CLASSIFIER_ID;
+var init_cusum = __esm({
+  "src/anomaly-detection/classifiers/cusum.ts"() {
+    init_classifier_state_store();
+    CUSUM_CLASSIFIER_ID = "cusum";
+  }
+});
+
+// src/anomaly-detection/classifiers/psi.ts
+var PSI_CLASSIFIER_ID;
+var init_psi = __esm({
+  "src/anomaly-detection/classifiers/psi.ts"() {
+    init_classifier_state_store();
+    PSI_CLASSIFIER_ID = "psi";
+  }
+});
 
 // src/anomaly-detection/types.ts
 var init_types4 = __esm({
   "src/anomaly-detection/types.ts"() {
   }
 });
+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;
+}
 var ANOMALY_AUDIT_OPS, DEFAULT_TICK_INTERVAL_MS2, AnomalyPipelineDispatcher;
 var init_anomaly_pipeline = __esm({
   "src/anomaly-detection/anomaly-pipeline.ts"() {
+    init_cusum();
+    init_psi();
     init_types4();
     ANOMALY_AUDIT_OPS = {
       DETECTOR_REGISTERED: "anomaly_detector_registered",
@@ -22327,7 +22662,15 @@ var init_anomaly_pipeline = __esm({
       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"
     };
     DEFAULT_TICK_INTERVAL_MS2 = 6e4;
     AnomalyPipelineDispatcher = class {
@@ -22418,34 +22761,37 @@ var init_anomaly_pipeline = __esm({
                 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);
@@ -22508,6 +22854,7 @@ var init_anomaly_pipeline = __esm({
           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,
@@ -22517,13 +22864,79 @@ var init_anomaly_pipeline = __esm({
             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 {
@@ -39833,6 +40246,141 @@ ${redactedItems.map((r) => `- ${r.redacted}`).join("\n")}`,
   }
 });
 
+// src/query-anonymity/header-strip.ts
+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 };
+}
+var QUERY_ANONYMITY_AUDIT_OPS, CANONICAL_STRIP_LIST, REQUIRED_HEADERS, REQUIRED_HEADER_SET, STRIP_REASON_BY_NAME;
+var init_header_strip = __esm({
+  "src/query-anonymity/header-strip.ts"() {
+    QUERY_ANONYMITY_AUDIT_OPS = {
+      HEADERS_STRIPPED: "query_anonymity_headers_stripped"
+    };
+    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" }
+    ];
+    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
+    ];
+    REQUIRED_HEADER_SET = new Set(
+      REQUIRED_HEADERS.map((h) => h.toLowerCase())
+    );
+    STRIP_REASON_BY_NAME = new Map(
+      CANONICAL_STRIP_LIST.map((h) => [h.name.toLowerCase(), h.reason])
+    );
+  }
+});
+
 // src/intelligence/substrates/hybrid/per-surface-router.ts
 function resolveHybridChoice(rules, surface) {
   if (!rules) return null;
@@ -39954,6 +40502,7 @@ var init_selector = __esm({
     init_local();
     init_venice();
     init_frontier();
+    init_header_strip();
     init_per_surface_router();
     DISABLED_CAPABILITY = {
       summarize: false,
@@ -39988,7 +40537,21 @@ var init_selector = __esm({
         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();
       }
       /**