@sanctuary-framework/mcp-server 1.2.10 → 1.2.12

package/dist/cli.js

@@ -17473,6 +17473,616 @@ var init_sentinel_routes = __esm({
     FINDINGS_MAX_LIMIT = 500;
   }
 });
+function makeEntryId(auditEventId) {
+  return createHash("sha256").update(auditEventId).digest("hex").slice(0, 32);
+}
+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 HANDOFF_LOG_OBSERVED_OPS, OBSERVED_OP_LIST, OPERATOR_PSEUDO_AGENT, DEFAULT_LIMIT, MAX_LIMIT, AUDIT_QUERY_LIMIT, HandoffLog, COORDINATION_VIEW_AUDIT_OPS;
+var init_handoff_log = __esm({
+  "src/coordination/handoff-log.ts"() {
+    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"
+    };
+    OBSERVED_OP_LIST = [
+      HANDOFF_LOG_OBSERVED_OPS.LOCAL_HANDOFF,
+      HANDOFF_LOG_OBSERVED_OPS.CROSS_HARNESS_APPROVAL
+    ];
+    OPERATOR_PSEUDO_AGENT = "operator";
+    DEFAULT_LIMIT = 50;
+    MAX_LIMIT = 500;
+    AUDIT_QUERY_LIMIT = 1e4;
+    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;
+      }
+    };
+    COORDINATION_VIEW_AUDIT_OPS = {
+      VIEW_OPENED: "operator_coordination_view_opened",
+      ENTRY_DRILLED: "operator_handoff_entry_drilled"
+    };
+  }
+});
+
+// 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, {
+    "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;
+  }
+}
+var COORDINATION_API_PREFIX, COORDINATION_HANDOFFS_PREFIX, COORDINATION_LIST_DEFAULT_LIMIT, COORDINATION_LIST_MAX_LIMIT, HandoffEventBridge;
+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;
+    COORDINATION_LIST_MAX_LIMIT = 500;
+    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 isDashboardViewRoute(method, path) {
   if (method !== "GET") return false;
   return path === "/" || path === "/dashboard" || path === "/v1.0" || path === "/fortress" || path === "/events";
@@ -17488,6 +18098,7 @@ var init_dashboard = __esm({
     init_dispatch();
     init_approval_aggregator_routes();
     init_sentinel_routes();
+    init_handoff_routes();
     SESSION_TTL_REMOTE_MS = 5 * 60 * 1e3;
     SESSION_TTL_LOCAL_MS = 24 * 60 * 60 * 1e3;
     MAX_SESSIONS = 1e3;
@@ -17562,6 +18173,17 @@ var init_dashboard = __esm({
        * 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;
@@ -17629,6 +18251,18 @@ var init_dashboard = __esm({
       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.
@@ -17667,6 +18301,30 @@ var init_dashboard = __esm({
           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
@@ -18066,6 +18724,18 @@ var init_dashboard = __esm({
           });
           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;
@@ -21932,15 +22602,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",
@@ -21948,7 +22655,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 {
@@ -22039,34 +22754,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);
@@ -22129,6 +22847,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,
@@ -22138,13 +22857,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 {
@@ -22421,7 +23206,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}`
       });
@@ -22435,7 +23220,7 @@ function optionalString(details, key) {
   if (typeof value !== "string" || value.length === 0) return null;
   return value;
 }
-var CROSS_AGENT_CHATTER_SENTINEL_ID, WARN_SIGMA2, ALERT_SIGMA2, BASELINE_WINDOWS2, QUERY_LIMIT2, MULTI_NEW_PARTNER_ALERT_THRESHOLD, OPERATOR_PSEUDO_AGENT, HANDOFF_OP, CROSS_HARNESS_OPS, CrossAgentChatterWatcher;
+var CROSS_AGENT_CHATTER_SENTINEL_ID, WARN_SIGMA2, ALERT_SIGMA2, BASELINE_WINDOWS2, QUERY_LIMIT2, MULTI_NEW_PARTNER_ALERT_THRESHOLD, OPERATOR_PSEUDO_AGENT2, HANDOFF_OP, CROSS_HARNESS_OPS, CrossAgentChatterWatcher;
 var init_cross_agent_chatter_watcher = __esm({
   "src/sentinel/sentinels/cross-agent-chatter-watcher.ts"() {
     init_sentinel();
@@ -22445,7 +23230,7 @@ var init_cross_agent_chatter_watcher = __esm({
     BASELINE_WINDOWS2 = 7;
     QUERY_LIMIT2 = 1e4;
     MULTI_NEW_PARTNER_ALERT_THRESHOLD = 3;
-    OPERATOR_PSEUDO_AGENT = "operator";
+    OPERATOR_PSEUDO_AGENT2 = "operator";
     HANDOFF_OP = "v1.1_local_handoff";
     CROSS_HARNESS_OPS = /* @__PURE__ */ new Set([
       "cross_harness_approval_aggregated",
@@ -25507,7 +26292,7 @@ function createBridgeCommitment(outcome, identity, identityEncryptionKey, includ
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const canonicalBytes = canonicalize2(outcome);
   const canonicalString = new TextDecoder().decode(canonicalBytes);
-  const sha25611 = createCommitment(canonicalString);
+  const sha25612 = createCommitment(canonicalString);
   let pedersenData;
   if (includePedersen && Number.isInteger(outcome.rounds) && outcome.rounds >= 0) {
     const pedersen = createPedersenCommitment(outcome.rounds);
@@ -25519,7 +26304,7 @@ function createBridgeCommitment(outcome, identity, identityEncryptionKey, includ
   const commitmentPayload = {
     bridge_commitment_id: commitmentId,
     session_id: outcome.session_id,
-    sha256_commitment: sha25611.commitment,
+    sha256_commitment: sha25612.commitment,
     terms_hash: outcome.terms_hash,
     committer_did: identity.did,
     committed_at: now,
@@ -25530,8 +26315,8 @@ function createBridgeCommitment(outcome, identity, identityEncryptionKey, includ
   return {
     bridge_commitment_id: commitmentId,
     session_id: outcome.session_id,
-    sha256_commitment: sha25611.commitment,
-    blinding_factor: sha25611.blinding_factor,
+    sha256_commitment: sha25612.commitment,
+    blinding_factor: sha25612.blinding_factor,
     committer_did: identity.did,
     signature: toBase64url(signature),
     pedersen_commitment: pedersenData,
@@ -39454,6 +40239,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;
@@ -39575,6 +40495,7 @@ var init_selector = __esm({
     init_local();
     init_venice();
     init_frontier();
+    init_header_strip();
     init_per_surface_router();
     DISABLED_CAPABILITY = {
       summarize: false,
@@ -39609,7 +40530,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();
       }
       /**
@@ -42653,6 +43588,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,
@@ -42850,6 +43798,8 @@ var init_src = __esm({
     init_sentinel_registry();
     init_sentinel_dispatcher();
     init_anomaly_pipeline();
+    init_handoff_log();
+    init_handoff_routes();
     init_sentinels();
     init_subscription_store();
     init_tools4();
@@ -44950,32 +45900,32 @@ endstream`;
         const offsets = new Array(totalObjects + 1).fill(0);
         const chunks = [];
         let bytePos = 0;
-        const write3 = (s) => {
+        const write4 = (s) => {
           const buf = Buffer.from(s, "latin1");
           chunks.push(buf);
           bytePos += buf.length;
         };
-        write3("%PDF-1.4\n%\xE2\xE3\xCF\xD3\n");
+        write4("%PDF-1.4\n%\xE2\xE3\xCF\xD3\n");
         for (let i = 1; i <= totalObjects; i++) {
           offsets[i] = bytePos;
-          write3(`${i} 0 obj
+          write4(`${i} 0 obj
 ${objectBodies[i]}
 endobj
 `);
         }
         const xrefPos = bytePos;
-        write3(`xref
+        write4(`xref
 0 ${totalObjects + 1}
 `);
-        write3("0000000000 65535 f \n");
+        write4("0000000000 65535 f \n");
         for (let i = 1; i <= totalObjects; i++) {
-          write3(`${offsets[i].toString().padStart(10, "0")} 00000 n 
+          write4(`${offsets[i].toString().padStart(10, "0")} 00000 n 
 `);
         }
-        write3(`trailer
+        write4(`trailer
 << /Size ${totalObjects + 1} /Root 1 0 R >>
 `);
-        write3(`startxref
+        write4(`startxref
 ${xrefPos}
 %%EOF
 `);
@@ -48246,6 +49196,365 @@ var init_sentinel2 = __esm({
     init_sentinels();
   }
 });
+async function issueDidWeb(opts) {
+  if (!opts.authority_host || !HOST_RE.test(opts.authority_host)) {
+    throw new Error(
+      `did-web: authority_host '${opts.authority_host}' is not a valid DNS host`
+    );
+  }
+  if (!FORTRESS_LABEL_RE.test(opts.fortress_id)) {
+    throw new Error(
+      `did-web: fortress_id '${opts.fortress_id}' is not a valid label`
+    );
+  }
+  if (opts.agent_label !== void 0 && !AGENT_LABEL_RE.test(opts.agent_label)) {
+    throw new Error(
+      `did-web: agent_label '${opts.agent_label}' is not a valid label`
+    );
+  }
+  if (opts.public_key.length !== 32) {
+    throw new Error(
+      `did-web: public_key must be exactly 32 bytes (Ed25519), got ${opts.public_key.length}`
+    );
+  }
+  const did = buildDid(opts);
+  const verificationMethodId = `${did}#key-1`;
+  const verificationMethod = {
+    id: verificationMethodId,
+    type: "JsonWebKey2020",
+    controller: did,
+    publicKeyJwk: {
+      kty: "OKP",
+      crv: "Ed25519",
+      x: toBase64url(opts.public_key)
+    }
+  };
+  const didDocument = {
+    "@context": [...DID_CONTEXT],
+    id: did,
+    verificationMethod: [verificationMethod],
+    authentication: [verificationMethodId],
+    assertionMethod: [verificationMethodId]
+  };
+  const now = (opts.now ?? (() => /* @__PURE__ */ new Date()))();
+  return {
+    did,
+    did_document: didDocument,
+    public_key: opts.public_key,
+    created_at: now.toISOString(),
+    authority_host: opts.authority_host,
+    fortress_id: opts.fortress_id,
+    ...opts.agent_label !== void 0 ? { agent_label: opts.agent_label } : {}
+  };
+}
+function publishDidWebDocument(identifier, opts = {}) {
+  const path = opts.publish_path ?? canonicalPublishPath(identifier);
+  const artifact = canonicalSerializeDidDocument(identifier.did_document);
+  const digest = sha256(stringToBytes(artifact));
+  const url = `https://${identifier.authority_host}${path}`;
+  return {
+    url,
+    publish_path: path,
+    artifact,
+    sha256: hashToString(digest)
+  };
+}
+function buildDid(opts) {
+  if (opts.agent_label === void 0) {
+    return `did:web:${opts.authority_host}`;
+  }
+  return `did:web:${opts.authority_host}:fortress:${opts.fortress_id}:agent:${opts.agent_label}`;
+}
+function canonicalPublishPath(identifier) {
+  if (identifier.agent_label === void 0) {
+    return "/.well-known/did.json";
+  }
+  return `/fortress/${identifier.fortress_id}/agent/${identifier.agent_label}/did.json`;
+}
+function canonicalSerializeDidDocument(doc) {
+  return JSON.stringify(
+    {
+      "@context": doc["@context"],
+      id: doc.id,
+      verificationMethod: doc.verificationMethod,
+      authentication: doc.authentication,
+      assertionMethod: doc.assertionMethod
+    },
+    null,
+    2
+  );
+}
+var DID_CONTEXT, HOST_RE, FORTRESS_LABEL_RE, AGENT_LABEL_RE;
+var init_did_web = __esm({
+  "src/recognition/did-web.ts"() {
+    init_encoding();
+    init_hashing();
+    DID_CONTEXT = [
+      "https://www.w3.org/ns/did/v1",
+      "https://w3id.org/security/suites/jws-2020/v1"
+    ];
+    HOST_RE = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$/i;
+    FORTRESS_LABEL_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+    AGENT_LABEL_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+  }
+});
+
+// src/cli/did-web.ts
+var did_web_exports = {};
+__export(did_web_exports, {
+  runDidWebCommand: () => runDidWebCommand
+});
+function write3(stream, text) {
+  stream.write(text);
+}
+function flagValue3(argv, name) {
+  const i = argv.indexOf(name);
+  if (i === -1) return void 0;
+  return argv[i + 1];
+}
+function hasFlag3(argv, name) {
+  return argv.includes(name);
+}
+function printUsage7(out) {
+  write3(
+    out,
+    `Usage: sanctuary did-web <command> [options]
+
+Commands:
+  issue --authority-host <host> [--agent-label <label>] [--json]
+                  Generate a did:web identifier bound to the operator's
+                  fortress Ed25519 public key. Writes the DID Document
+                  artifact to <storage>/recognition/did-web.json and
+                  prints publication instructions for the operator's
+                  HTTPS server.
+
+  show [--json]   Display the previously issued did:web identifier.
+                  Exits non-zero if none issued.
+
+Options:
+  --authority-host <host>   HTTPS host the operator controls and will
+                            serve /.well-known/did.json from.
+  --agent-label <label>     Optional agent-scoped identifier (label-safe;
+                            alphanumeric + dash + underscore, 1-64 chars).
+  --fortress <path>         Override the storage path.
+  --passphrase <val>        Passphrase for master-key derivation.
+  --json                    Output as JSON.
+  --help, -h                Show this help.
+
+Castle-walking note: did:web resolution is outbound HTTPS by design.
+This CLI never opens an outbound socket. The opt-in surface is your
+choice to run "did-web issue" with --authority-host; the resulting
+artifact is yours to publish on your own infrastructure. Sanctuary
+does not phone home.
+`
+  );
+}
+async function runDidWebCommand(args) {
+  const argv = args.argv;
+  const out = args.out ?? process.stdout;
+  const err = args.err ?? process.stderr;
+  const env = args.env ?? process.env;
+  if (argv.length === 0 || hasFlag3(argv, "--help") || hasFlag3(argv, "-h")) {
+    printUsage7(out);
+    return 0;
+  }
+  const command = argv[0];
+  if (command === "issue") {
+    return await cmdIssue(argv.slice(1), out, err, env);
+  }
+  if (command === "show") {
+    return await cmdShow3(argv.slice(1), out, err);
+  }
+  write3(err, `Unknown did-web command: ${command}
+`);
+  write3(err, `Run "sanctuary did-web --help" for usage.
+`);
+  return 2;
+}
+async function loadFortressIdentity(argv, env, err) {
+  const fortressFlag = flagValue3(argv, "--fortress");
+  if (fortressFlag) {
+    process.env.SANCTUARY_STORAGE_PATH = fortressFlag;
+  }
+  const passphrase = flagValue3(argv, "--passphrase") ?? env.SANCTUARY_PASSPHRASE;
+  const recoveryKey = env.SANCTUARY_RECOVERY_KEY;
+  if (!passphrase && !recoveryKey) {
+    write3(
+      err,
+      "Error: sanctuary did-web requires SANCTUARY_PASSPHRASE, --passphrase, or SANCTUARY_RECOVERY_KEY.\n"
+    );
+    return null;
+  }
+  const config = await loadConfig();
+  await mkdir(config.storage_path, { recursive: true, mode: 448 });
+  const stateStoragePath = join(config.storage_path, "state");
+  const storage = new FilesystemStorage(stateStoragePath);
+  let masterKey;
+  if (passphrase) {
+    let existingParams;
+    const raw = await storage.read("_meta", "key-params");
+    if (raw) {
+      existingParams = JSON.parse(bytesToString(raw));
+    }
+    const derivation = await deriveMasterKey(passphrase, existingParams);
+    masterKey = derivation.key;
+  } else if (recoveryKey) {
+    masterKey = fromBase64url(recoveryKey);
+  } else {
+    return null;
+  }
+  const identityManager = new IdentityManager(storage, masterKey);
+  const loadResult = await identityManager.load();
+  if (loadResult.loaded === 0) {
+    write3(
+      err,
+      loadResult.total > 0 ? "Error: identity files found but none could be decrypted. Wrong passphrase?\n" : "Error: no identities on this fortress yet. Run sanctuary wrap first.\n"
+    );
+    return null;
+  }
+  const primary = identityManager.getDefault();
+  if (!primary) {
+    write3(err, "Error: no primary identity on this fortress yet. Run sanctuary wrap first.\n");
+    return null;
+  }
+  return {
+    publicKey: fromBase64url(primary.public_key),
+    identityId: primary.identity_id,
+    storagePath: config.storage_path
+  };
+}
+async function cmdIssue(argv, out, err, env) {
+  const authorityHost = flagValue3(argv, "--authority-host");
+  const agentLabel = flagValue3(argv, "--agent-label");
+  const json = hasFlag3(argv, "--json");
+  if (!authorityHost) {
+    write3(err, "Error: --authority-host is required.\n");
+    write3(err, "Example: sanctuary did-web issue --authority-host alice.example.com\n");
+    return 1;
+  }
+  const snapshot = await loadFortressIdentity(argv, env, err);
+  if (!snapshot) return 1;
+  let identifier;
+  try {
+    identifier = await issueDidWeb({
+      fortress_id: snapshot.identityId,
+      authority_host: authorityHost,
+      public_key: snapshot.publicKey,
+      ...agentLabel !== void 0 ? { agent_label: agentLabel } : {}
+    });
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    write3(err, `Error: ${message}
+`);
+    return 1;
+  }
+  const artifact = publishDidWebDocument(identifier);
+  const persistDir = join(snapshot.storagePath, "recognition");
+  await mkdir(persistDir, { recursive: true, mode: 448 });
+  const persistPath = join(persistDir, "did-web.json");
+  const record = {
+    version: 1,
+    identifier: {
+      did: identifier.did,
+      created_at: identifier.created_at,
+      authority_host: identifier.authority_host,
+      fortress_id: identifier.fortress_id,
+      ...identifier.agent_label !== void 0 ? { agent_label: identifier.agent_label } : {},
+      did_document: identifier.did_document
+    },
+    artifact: {
+      url: artifact.url,
+      publish_path: artifact.publish_path,
+      sha256: artifact.sha256
+    }
+  };
+  await writeFile(persistPath, JSON.stringify(record, null, 2), {
+    mode: 384
+  });
+  if (json) {
+    write3(out, JSON.stringify(record, null, 2) + "\n");
+    return 0;
+  }
+  write3(out, `did:web identifier issued.
+`);
+  write3(out, `  DID:            ${identifier.did}
+`);
+  write3(out, `  Authority host: ${identifier.authority_host}
+`);
+  write3(out, `  Created at:     ${identifier.created_at}
+`);
+  write3(out, `  Persisted:      ${persistPath}
+`);
+  write3(out, `
+Next step: publish the DID Document to your HTTPS host.
+`);
+  write3(out, `  Target URL:  ${artifact.url}
+`);
+  write3(out, `  SHA-256:     ${artifact.sha256}
+`);
+  write3(out, `  Artifact:    ${join(persistDir, "did.json")}
+`);
+  const artifactPath = join(persistDir, "did.json");
+  await writeFile(artifactPath, artifact.artifact, { mode: 420 });
+  write3(out, `
+Castle-walking note: this CLI never opens an outbound socket.
+`);
+  write3(out, `Publishing the DID Document is your operation; serve the artifact
+`);
+  write3(out, `at the URL above from infrastructure you control.
+`);
+  return 0;
+}
+async function cmdShow3(argv, out, err, _env) {
+  const json = hasFlag3(argv, "--json");
+  const fortressFlag = flagValue3(argv, "--fortress");
+  if (fortressFlag) {
+    process.env.SANCTUARY_STORAGE_PATH = fortressFlag;
+  }
+  const config = await loadConfig();
+  const persistPath = join(config.storage_path, "recognition", "did-web.json");
+  let bytes;
+  try {
+    bytes = await readFile(persistPath);
+  } catch {
+    write3(
+      err,
+      `No did:web identifier configured on this fortress.
+Run "sanctuary did-web issue --authority-host <host>" to issue one.
+`
+    );
+    return 1;
+  }
+  if (json) {
+    write3(out, bytes.toString("utf-8"));
+    if (!bytes.toString("utf-8").endsWith("\n")) write3(out, "\n");
+    return 0;
+  }
+  const parsed = JSON.parse(bytes.toString("utf-8"));
+  write3(out, `did:web identifier on this fortress:
+`);
+  write3(out, `  DID:            ${parsed.identifier.did}
+`);
+  write3(out, `  Authority host: ${parsed.identifier.authority_host}
+`);
+  write3(out, `  Created at:     ${parsed.identifier.created_at}
+`);
+  write3(out, `  Publish URL:    ${parsed.artifact.url}
+`);
+  write3(out, `  SHA-256:        ${parsed.artifact.sha256}
+`);
+  return 0;
+}
+var init_did_web2 = __esm({
+  "src/cli/did-web.ts"() {
+    init_filesystem();
+    init_tools();
+    init_key_derivation();
+    init_encoding();
+    init_config();
+    init_did_web();
+  }
+});
 
 // src/mcp/broker-server.ts
 var broker_server_exports = {};
@@ -49111,6 +50420,11 @@ async function main() {
     const code = await runSentinelCommand2({ argv: args.slice(1) });
     process.exit(code);
   }
+  if (args[0] === "did-web") {
+    const { runDidWebCommand: runDidWebCommand2 } = await Promise.resolve().then(() => (init_did_web2(), did_web_exports));
+    const code = await runDidWebCommand2({ argv: args.slice(1) });
+    process.exit(code);
+  }
   if (args[0] === "broker-server") {
     const { openBroker: openBroker2 } = await Promise.resolve().then(() => (init_open(), open_exports));
     const { createBrokerMcpServer: createBrokerMcpServer2 } = await Promise.resolve().then(() => (init_broker_server(), broker_server_exports));