@sanctuary-framework/mcp-server 1.2.10 → 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;
@@ -22421,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}`
       });
@@ -22435,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();
@@ -22445,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",
@@ -25507,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);
@@ -25519,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,
@@ -25530,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,
@@ -42653,6 +43025,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 +43235,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 +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
 `);
@@ -48246,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 = {};
@@ -49111,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));