@sanctuary-framework/mcp-server 1.2.9 → 1.2.11

package/dist/cli.js

@@ -17473,6 +17473,318 @@ 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/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
+        }
+      );
+      writeJSON6(res, 200, { ok: true, data: detail });
+      return true;
+    }
+    writeJSON6(res, 404, { ok: false, error: "not_found", path });
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeJSON6(res, 500, { ok: false, error: "internal", detail: msg });
+    return true;
+  }
+}
+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();
+    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 +17800,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 +17875,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 +17953,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 +18003,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 +18426,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;
@@ -21787,6 +22159,11 @@ var init_sentinel_dispatcher = __esm({
           fortressId: this.fortressId,
           auditLog: this.auditLog,
           now: this.now,
+          // Phi-5 meta-sentinel reads the per-fortress finding store to
+          // detect patterns across other sentinels' findings. First-order
+          // sentinels ignore the field; the dispatcher always attaches it
+          // because the store is already in scope here.
+          findingStore: this.findingStore,
           ...contextOverrides ?? {}
         };
         const sentinel = await this.registry.subscribe(sentinelId, context);
@@ -21888,28 +22265,252 @@ var init_sentinel_dispatcher = __esm({
        */
       async dispose() {
         this.stop();
-        await this.registry.unsubscribeAll();
+        await this.registry.unsubscribeAll();
+        this.listeners.clear();
+      }
+      async routeFinding(sentinelId, raw) {
+        const stamped = {
+          ...raw,
+          finding_id: raw.finding_id || randomUUID(),
+          sentinel_id: sentinelId,
+          fortress_id: this.fortressId,
+          observed_at: raw.observed_at || this.now().toISOString()
+        };
+        await this.findingStore.saveFinding(stamped);
+        this.auditLog.append(
+          "l2",
+          SENTINEL_AUDIT_OPS.FINDING_EMITTED,
+          this.identityId,
+          {
+            sentinel_id: sentinelId,
+            finding_id: stamped.finding_id,
+            severity: stamped.severity,
+            ...stamped.agent_id !== void 0 ? { agent_id: stamped.agent_id } : {},
+            evidence_audit_ids: stamped.evidence_audit_ids,
+            fortress_id: this.fortressId
+          }
+        );
+        this.emit({ type: "finding", finding: stamped });
+        return stamped;
+      }
+      emit(event) {
+        for (const listener of this.listeners) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/anomaly-detection/types.ts
+var init_types4 = __esm({
+  "src/anomaly-detection/types.ts"() {
+  }
+});
+var ANOMALY_AUDIT_OPS, DEFAULT_TICK_INTERVAL_MS2, AnomalyPipelineDispatcher;
+var init_anomaly_pipeline = __esm({
+  "src/anomaly-detection/anomaly-pipeline.ts"() {
+    init_types4();
+    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"
+    };
+    DEFAULT_TICK_INTERVAL_MS2 = 6e4;
+    AnomalyPipelineDispatcher = class {
+      findingStore;
+      auditLog;
+      storage;
+      masterKey;
+      fortressId;
+      identityId;
+      now;
+      tickIntervalMs;
+      detectors = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      tickTimer = null;
+      tickInFlight = false;
+      constructor(deps) {
+        this.findingStore = deps.findingStore;
+        this.auditLog = deps.auditLog;
+        this.storage = deps.storage;
+        this.masterKey = deps.masterKey;
+        this.fortressId = deps.fortressId;
+        this.identityId = deps.identityId;
+        this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+        this.tickIntervalMs = deps.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS2;
+      }
+      onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      /**
+       * Register + subscribe a detector to this fortress. Idempotent: a
+       * second call with the same detectorId returns the already-
+       * registered instance without re-subscribing.
+       */
+      async registerDetector(detector) {
+        const existing = this.detectors.get(detector.detectorId);
+        if (existing) return existing;
+        const context = {
+          fortressId: this.fortressId,
+          auditLog: this.auditLog,
+          storage: this.storage,
+          masterKey: this.masterKey,
+          now: this.now
+        };
+        await detector.subscribe(context);
+        this.detectors.set(detector.detectorId, detector);
+        this.auditLog.append(
+          "l2",
+          ANOMALY_AUDIT_OPS.DETECTOR_REGISTERED,
+          this.identityId,
+          { detector_id: detector.detectorId, fortress_id: this.fortressId }
+        );
+        return detector;
+      }
+      /**
+       * Unregister + tear down a detector. Idempotent. Returns true when
+       * an active registration was removed.
+       */
+      async unregisterDetector(detectorId) {
+        const detector = this.detectors.get(detectorId);
+        if (!detector) return false;
+        try {
+          await detector.unsubscribe();
+        } finally {
+          this.detectors.delete(detectorId);
+        }
+        this.auditLog.append(
+          "l2",
+          ANOMALY_AUDIT_OPS.DETECTOR_UNREGISTERED,
+          this.identityId,
+          { detector_id: detectorId, fortress_id: this.fortressId }
+        );
+        return true;
+      }
+      listDetectors() {
+        return [...this.detectors.keys()];
+      }
+      /** Run one evaluation pass over every registered detector. */
+      async tick() {
+        if (this.tickInFlight) return [];
+        this.tickInFlight = true;
+        try {
+          const findings = [];
+          for (const [detectorId, detector] of this.detectors.entries()) {
+            try {
+              const detectorFindings = await detector.evaluate();
+              for (const raw of detectorFindings) {
+                const stamped = await this.routeFinding(detectorId, raw);
+                findings.push(stamped);
+              }
+              try {
+                const trainingResult = await detector.classifier.train();
+                this.auditLog.append(
+                  "l2",
+                  ANOMALY_AUDIT_OPS.TRAINING_COMPLETED,
+                  this.identityId,
+                  {
+                    detector_id: detectorId,
+                    classifier_id: detector.classifier.classifierId,
+                    trained_at: trainingResult.trained_at,
+                    sample_count: trainingResult.sample_count,
+                    agent_count: trainingResult.agent_count,
+                    fortress_id: this.fortressId
+                  }
+                );
+              } catch (trainErr) {
+                const message = trainErr instanceof Error ? trainErr.message : String(trainErr);
+                this.auditLog.append(
+                  "l2",
+                  ANOMALY_AUDIT_OPS.TRAINING_FAILED,
+                  this.identityId,
+                  {
+                    detector_id: detectorId,
+                    error_message: message,
+                    fortress_id: this.fortressId
+                  },
+                  "failure"
+                );
+              }
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              const observedAt = this.now().toISOString();
+              this.auditLog.append(
+                "l2",
+                ANOMALY_AUDIT_OPS.EVALUATION_FAILED,
+                this.identityId,
+                {
+                  detector_id: detectorId,
+                  error_message: message,
+                  fortress_id: this.fortressId
+                },
+                "failure"
+              );
+              this.emit({
+                type: "evaluation_failed",
+                detector_id: detectorId,
+                error_message: message,
+                observed_at: observedAt
+              });
+            }
+          }
+          return findings;
+        } finally {
+          this.tickInFlight = false;
+        }
+      }
+      start() {
+        if (this.tickTimer !== null) return;
+        if (this.tickIntervalMs <= 0) return;
+        this.tickTimer = setInterval(() => {
+          void this.tick();
+        }, this.tickIntervalMs);
+        if (typeof this.tickTimer.unref === "function") {
+          this.tickTimer.unref();
+        }
+      }
+      stop() {
+        if (this.tickTimer === null) return;
+        clearInterval(this.tickTimer);
+        this.tickTimer = null;
+      }
+      async dispose() {
+        this.stop();
+        const ids = [...this.detectors.keys()];
+        for (const id of ids) {
+          try {
+            await this.unregisterDetector(id);
+          } catch {
+          }
+        }
         this.listeners.clear();
       }
-      async routeFinding(sentinelId, raw) {
+      async routeFinding(detectorId, raw) {
         const stamped = {
           ...raw,
           finding_id: raw.finding_id || randomUUID(),
-          sentinel_id: sentinelId,
           fortress_id: this.fortressId,
           observed_at: raw.observed_at || this.now().toISOString()
         };
         await this.findingStore.saveFinding(stamped);
         this.auditLog.append(
           "l2",
-          SENTINEL_AUDIT_OPS.FINDING_EMITTED,
+          ANOMALY_AUDIT_OPS.FINDING_EMITTED,
           this.identityId,
           {
-            sentinel_id: sentinelId,
+            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 } : {},
-            evidence_audit_ids: stamped.evidence_audit_ids,
             fortress_id: this.fortressId
           }
         );
@@ -22192,7 +22793,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}`
       });
@@ -22206,7 +22807,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();
@@ -22216,7 +22817,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",
@@ -23097,6 +23698,229 @@ var init_suspicious_tool_call_detector = __esm({
   }
 });
 
+// src/sentinel/sentinels/anomaly-trigger.ts
+function computeCompoundFindings(windowZero, now) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const f of windowZero) {
+    if (!f.agent_id) continue;
+    if (!isWarnOrAlert(f.severity)) continue;
+    let bucket = byAgent.get(f.agent_id);
+    if (!bucket) {
+      bucket = [];
+      byAgent.set(f.agent_id, bucket);
+    }
+    bucket.push(f);
+  }
+  const out = [];
+  for (const [agentId, group] of byAgent.entries()) {
+    const distinctSentinels = new Set(group.map((f) => f.sentinel_id));
+    if (distinctSentinels.size < COMPOUND_TRIGGER_MIN_SENTINELS) continue;
+    const contributingSentinels = [...distinctSentinels].sort();
+    const evidence = group.map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+    const summary = `${agentId} agent triggered ${distinctSentinels.size} distinct sentinels in the last 24h: ${contributingSentinels.join(", ")}. Compound suspicious behavior; review the contributing findings.`;
+    out.push({
+      finding_id: "",
+      sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+      severity: "alert",
+      agent_id: agentId,
+      summary,
+      details: {
+        trigger: "compound",
+        agent_id: agentId,
+        contributing_sentinels: contributingSentinels,
+        contributing_finding_count: group.length
+      },
+      observed_at: now.toISOString(),
+      evidence_audit_ids: evidence,
+      fortress_id: ""
+    });
+  }
+  return out;
+}
+function computeCountSpikeFinding(windowed, now) {
+  const currentCount = (windowed[0] ?? []).length;
+  const baselineCounts = [];
+  for (let i = 1; i <= BASELINE_WINDOWS5; i += 1) {
+    baselineCounts.push((windowed[i] ?? []).length);
+  }
+  const populated = baselineCounts.filter((c) => c > 0).length;
+  if (populated < BASELINE_WINDOWS5) {
+    return null;
+  }
+  const mean = baselineCounts.reduce((sum, c) => sum + c, 0) / baselineCounts.length;
+  const variance = baselineCounts.reduce((sum, c) => sum + (c - mean) ** 2, 0) / baselineCounts.length;
+  const stddev = Math.sqrt(variance);
+  const warnThreshold = mean + WARN_SIGMA5 * stddev;
+  const alertThreshold = mean + ALERT_SIGMA5 * stddev;
+  if (currentCount > alertThreshold) {
+    return buildCountFinding(
+      currentCount,
+      mean,
+      stddev,
+      ALERT_SIGMA5,
+      "alert",
+      windowed[0] ?? [],
+      now
+    );
+  }
+  if (currentCount > warnThreshold) {
+    return buildCountFinding(
+      currentCount,
+      mean,
+      stddev,
+      WARN_SIGMA5,
+      "warn",
+      windowed[0] ?? [],
+      now
+    );
+  }
+  return null;
+}
+function buildCountFinding(currentCount, mean, stddev, sigma, severity, windowZero, now) {
+  const ratio = mean === 0 ? Number.POSITIVE_INFINITY : currentCount / mean;
+  const ratioStr = Number.isFinite(ratio) ? `${ratio.toFixed(1)}x normal` : "no prior baseline";
+  const summary = `Fortress finding count is ${ratioStr}: ${currentCount} findings in last 24h, baseline ${mean.toFixed(1)} +/- ${stddev.toFixed(1)}. Crossed +${sigma} sigma threshold across all sentinels.`;
+  const evidence = windowZero.map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+  return {
+    finding_id: "",
+    sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+    severity,
+    summary,
+    details: {
+      trigger: "count_spike",
+      current_count: currentCount,
+      baseline_mean: mean,
+      baseline_stddev: stddev,
+      sigma_threshold: sigma,
+      ratio: Number.isFinite(ratio) ? ratio : null
+    },
+    observed_at: now.toISOString(),
+    evidence_audit_ids: evidence,
+    fortress_id: ""
+  };
+}
+function computeNovelComboFinding(windowed, now) {
+  const distinctByWindow = [];
+  for (let i = 0; i <= BASELINE_WINDOWS5; i += 1) {
+    const set = /* @__PURE__ */ new Set();
+    for (const f of windowed[i] ?? []) {
+      set.add(f.sentinel_id);
+    }
+    distinctByWindow.push(set);
+  }
+  const populatedBaselineWindows = distinctByWindow.slice(1).filter((s) => s.size > 0).length;
+  if (populatedBaselineWindows < BASELINE_WINDOWS5) {
+    return null;
+  }
+  const currentCombo = distinctByWindow[0];
+  if (currentCombo.size < 2) return null;
+  const currentKey = comboKey(currentCombo);
+  for (let i = 1; i <= BASELINE_WINDOWS5; i += 1) {
+    if (comboKey(distinctByWindow[i]) === currentKey) {
+      return null;
+    }
+  }
+  const sentinelIds = [...currentCombo].sort();
+  const summary = `Novel sentinel-ID combination this 24h window: ${sentinelIds.join(" + ")}. This co-occurrence pattern has not appeared in the prior ${BASELINE_WINDOWS5} baseline windows.`;
+  const evidence = (windowed[0] ?? []).map((f) => f.finding_id).filter((id) => id.length > 0).slice(0, 50);
+  return {
+    finding_id: "",
+    sentinel_id: ANOMALY_TRIGGER_SENTINEL_ID,
+    severity: "info",
+    summary,
+    details: {
+      trigger: "novel_combo",
+      sentinel_ids: sentinelIds,
+      baseline_window_count: BASELINE_WINDOWS5
+    },
+    observed_at: now.toISOString(),
+    evidence_audit_ids: evidence,
+    fortress_id: ""
+  };
+}
+function isWarnOrAlert(s) {
+  return s === "warn" || s === "alert";
+}
+function bucketByWindow(findings, nowMs) {
+  const buckets = Array.from(
+    { length: BASELINE_WINDOWS5 + 1 },
+    () => []
+  );
+  for (const f of findings) {
+    const ts = Date.parse(f.observed_at);
+    if (!Number.isFinite(ts)) continue;
+    const age = nowMs - ts;
+    if (age < 0) continue;
+    const idx = Math.floor(age / WINDOW_MS);
+    if (idx > BASELINE_WINDOWS5) continue;
+    buckets[idx].push(f);
+  }
+  return buckets;
+}
+function comboKey(set) {
+  return [...set].sort().join("|");
+}
+var ANOMALY_TRIGGER_SENTINEL_ID, WARN_SIGMA5, ALERT_SIGMA5, BASELINE_WINDOWS5, QUERY_LIMIT5, WINDOW_MS, COMPOUND_TRIGGER_MIN_SENTINELS, AnomalyTriggerWatcher;
+var init_anomaly_trigger = __esm({
+  "src/sentinel/sentinels/anomaly-trigger.ts"() {
+    init_sentinel();
+    ANOMALY_TRIGGER_SENTINEL_ID = "anomaly-trigger";
+    WARN_SIGMA5 = 3;
+    ALERT_SIGMA5 = 6;
+    BASELINE_WINDOWS5 = 7;
+    QUERY_LIMIT5 = 5e3;
+    WINDOW_MS = 24 * 60 * 60 * 1e3;
+    COMPOUND_TRIGGER_MIN_SENTINELS = 2;
+    AnomalyTriggerWatcher = class extends Sentinel {
+      sentinelId = ANOMALY_TRIGGER_SENTINEL_ID;
+      description = "Meta-sentinel. Watches for patterns ACROSS other sentinels' findings: compound suspicious behavior on one agent, fortress-wide finding-count spikes, and novel cross-sentinel combinations. Closes WP-V1.3-1 Sentinel Baseline Pack.";
+      async subscribe(context) {
+        if (!context.findingStore) {
+          throw new Error(
+            `${ANOMALY_TRIGGER_SENTINEL_ID}: findingStore missing from SentinelContext; this meta-sentinel requires the Phi-1 finding store`
+          );
+        }
+        await super.subscribe(context);
+      }
+      async evaluate() {
+        const ctx = this.requireContext();
+        const findingStore = ctx.findingStore;
+        if (!findingStore) {
+          return [];
+        }
+        const now = ctx.now();
+        const nowMs = now.getTime();
+        const windowSpanMs = (BASELINE_WINDOWS5 + 1) * WINDOW_MS;
+        const sinceIso = new Date(nowMs - windowSpanMs).toISOString();
+        let findings;
+        try {
+          findings = await findingStore.listFindings({
+            since: sinceIso,
+            limit: QUERY_LIMIT5
+          });
+        } catch {
+          return [];
+        }
+        const firstOrderFindings = findings.filter(
+          (f) => f.sentinel_id !== ANOMALY_TRIGGER_SENTINEL_ID
+        );
+        const windowed = bucketByWindow(firstOrderFindings, nowMs);
+        const out = [];
+        const compoundFindings = computeCompoundFindings(
+          windowed[0] ?? [],
+          now
+        );
+        out.push(...compoundFindings);
+        const countSpikeFinding = computeCountSpikeFinding(windowed, now);
+        if (countSpikeFinding) out.push(countSpikeFinding);
+        const novelComboFinding = computeNovelComboFinding(windowed, now);
+        if (novelComboFinding) out.push(novelComboFinding);
+        return out;
+      }
+    };
+  }
+});
+
 // src/sentinel/sentinels/index.ts
 var PHI1_BASELINE_CATALOG;
 var init_sentinels = __esm({
@@ -23105,6 +23929,7 @@ var init_sentinels = __esm({
     init_cross_agent_chatter_watcher();
     init_credential_usage_watcher();
     init_suspicious_tool_call_detector();
+    init_anomaly_trigger();
     PHI1_BASELINE_CATALOG = [
       {
         sentinelId: EGRESS_VOLUME_SENTINEL_ID,
@@ -23125,6 +23950,11 @@ var init_sentinels = __esm({
         sentinelId: SUSPICIOUS_TOOL_CALL_SENTINEL_ID,
         description: "Surfaces tool calls whose argument shape, call frequency, or permission combination looks unusual for the fortress's recent history.",
         factory: () => new SuspiciousToolCallDetector()
+      },
+      {
+        sentinelId: ANOMALY_TRIGGER_SENTINEL_ID,
+        description: "Meta-sentinel. Watches for patterns ACROSS other sentinels' findings: compound suspicious behavior on one agent, fortress-wide finding-count spikes, and novel cross-sentinel combinations. Closes WP-V1.3-1 Sentinel Baseline Pack.",
+        factory: () => new AnomalyTriggerWatcher()
       }
     ];
   }
@@ -25049,7 +25879,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);
@@ -25061,7 +25891,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,
@@ -25072,8 +25902,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,
@@ -34643,7 +35473,7 @@ var init_recovery_key_disclosure = __esm({
 });
 
 // src/hub/types.ts
-var init_types4 = __esm({
+var init_types5 = __esm({
   "src/hub/types.ts"() {
   }
 });
@@ -35682,7 +36512,7 @@ var init_hub = __esm({
   "src/hub/index.ts"() {
     init_constants3();
     init_errors4();
-    init_types4();
+    init_types5();
     init_agent_registry();
     init_inbox_store();
     init_inbox_aggregator();
@@ -42186,6 +43016,28 @@ ${err.message}
   if (dashboard) {
     dashboard.setSentinelDispatcher(sentinelDispatcher);
   }
+  const anomalyDispatcher = new AnomalyPipelineDispatcher({
+    findingStore: sentinelFindingStore,
+    auditLog,
+    storage,
+    masterKey,
+    fortressId: fortressIdForAggregator,
+    identityId: aggregatorIdentityId
+  });
+  anomalyDispatcher.start();
+  const handoffLog = new HandoffLog({
+    auditLog,
+    fortressId: fortressIdForAggregator
+  });
+  const handoffEventBridge = new HandoffEventBridge();
+  if (dashboard) {
+    dashboard.setHandoffLog({
+      handoffLog,
+      eventBridge: handoffEventBridge,
+      auditLog,
+      operatorId: aggregatorIdentityId
+    });
+  }
   const policyTools = createPrincipalPolicyTools(policy, baseline, auditLog);
   const { tools: sanctuaryMetaTools } = createSanctuaryTools({
     config,
@@ -42382,6 +43234,9 @@ var init_src = __esm({
     init_sentinel_finding_store();
     init_sentinel_registry();
     init_sentinel_dispatcher();
+    init_anomaly_pipeline();
+    init_handoff_log();
+    init_handoff_routes();
     init_sentinels();
     init_subscription_store();
     init_tools4();
@@ -44482,32 +45337,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
 `);
@@ -47778,6 +48633,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 = {};
@@ -48643,6 +49857,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));