@sanctuary-framework/mcp-server 1.2.5 → 1.2.7

package/dist/cli.js

@@ -5037,7 +5037,8 @@ var init_constants = __esm({
     RESERVED_EVENT_TYPE_PREFIXES = [
       "EXTENSION_",
       "cross_fortress_",
-      "multi_master_"
+      "multi_master_",
+      "cross_harness_approval_"
     ];
     RESERVED_EXTENSION_ENVELOPE_KEYS = [
       "cross_fortress_read_grant",
@@ -9229,9 +9230,9 @@ function fingerprintDID(did) {
   return `${raw.slice(0, 6)}\u2026${raw.slice(-6)}`;
 }
 function countInjectionsToday(audit) {
-  const startOfDay = /* @__PURE__ */ new Date();
-  startOfDay.setHours(0, 0, 0, 0);
-  const cutoff = startOfDay.getTime();
+  const startOfDay2 = /* @__PURE__ */ new Date();
+  startOfDay2.setHours(0, 0, 0, 0);
+  const cutoff = startOfDay2.getTime();
   return audit.filter((e) => {
     const ts = new Date(e.timestamp).getTime();
     if (isNaN(ts) || ts < cutoff) return false;
@@ -9240,9 +9241,9 @@ function countInjectionsToday(audit) {
   }).length;
 }
 function countProofsToday(audit) {
-  const startOfDay = /* @__PURE__ */ new Date();
-  startOfDay.setHours(0, 0, 0, 0);
-  const cutoff = startOfDay.getTime();
+  const startOfDay2 = /* @__PURE__ */ new Date();
+  startOfDay2.setHours(0, 0, 0, 0);
+  const cutoff = startOfDay2.getTime();
   return audit.filter((e) => {
     if (e.layer !== "l3") return false;
     if (!PROOF_CREATION_OPS.has(e.operation)) return false;
@@ -17211,6 +17212,45 @@ async function handleApprovalInboxRoute(deps, req, res) {
       await handleStream2(deps, res);
       return true;
     }
+    if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/revision`) {
+      const revision = await deps.aggregator.getRevision();
+      writeJSON4(res, 200, { ok: true, data: { revision } });
+      return true;
+    }
+    if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/sync`) {
+      const sinceRaw = url.searchParams.get("since_revision");
+      const sinceParsed = sinceRaw === null ? 0 : Number.parseInt(sinceRaw, 10);
+      const sinceRevision = Number.isFinite(sinceParsed) && sinceParsed >= 0 ? sinceParsed : 0;
+      const limit = parseLimit2(
+        url.searchParams.get("limit"),
+        APPROVAL_INBOX_DEFAULT_LIMIT,
+        APPROVAL_INBOX_MAX_LIMIT
+      );
+      const delta = await deps.aggregator.getSync({ sinceRevision, limit });
+      writeJSON4(res, 200, { ok: true, data: delta });
+      return true;
+    }
+    if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/history`) {
+      const limit = parseLimit2(
+        url.searchParams.get("limit"),
+        APPROVAL_INBOX_DEFAULT_LIMIT,
+        APPROVAL_INBOX_MAX_LIMIT
+      );
+      const statusRaw = url.searchParams.get("status");
+      const sinceTs = url.searchParams.get("since") ?? void 0;
+      const operatorId = deps.operatorId ?? APPROVAL_INBOX_OPERATOR_DEFAULT;
+      const filterStatus = statusRaw && isStatusFilter(statusRaw) && statusRaw !== "pending" ? statusRaw : void 0;
+      const entries = await deps.aggregator.getHistory(
+        {
+          limit,
+          ...filterStatus !== void 0 ? { status: filterStatus } : {},
+          ...sinceTs !== void 0 ? { sinceTs } : {}
+        },
+        operatorId
+      );
+      writeJSON4(res, 200, { ok: true, data: { entries } });
+      return true;
+    }
     if (method === "GET" && path === APPROVAL_INBOX_API_PREFIX) {
       const limit = parseLimit2(
         url.searchParams.get("limit"),
@@ -17233,11 +17273,39 @@ async function handleApprovalInboxRoute(deps, req, res) {
       writeJSON4(res, 404, { ok: false, error: "not_found", path });
       return true;
     }
-    if (method === "GET" && entryMatch.action === null) {
-      const entries = await deps.aggregator.list({ limit: APPROVAL_INBOX_MAX_LIMIT });
-      const entry = entries.find(
-        (e) => e.aggregator_id === entryMatch.aggregatorId
+    if (method === "GET" && entryMatch.action === "audit-trail") {
+      const entry = await deps.aggregator.getEntry(entryMatch.aggregatorId);
+      if (!entry) {
+        writeJSON4(res, 404, { ok: false, error: "not_found" });
+        return true;
+      }
+      const operatorId = deps.operatorId ?? APPROVAL_INBOX_OPERATOR_DEFAULT;
+      const trail = await deps.aggregator.getAuditTrail(
+        entryMatch.aggregatorId,
+        operatorId
       );
+      writeJSON4(res, 200, { ok: true, data: { entry, audit_trail: trail } });
+      return true;
+    }
+    if (method === "GET" && entryMatch.action === "payload") {
+      const entry = await deps.aggregator.getEntry(entryMatch.aggregatorId);
+      if (!entry) {
+        writeJSON4(res, 404, { ok: false, error: "not_found" });
+        return true;
+      }
+      const operatorId = deps.operatorId ?? APPROVAL_INBOX_OPERATOR_DEFAULT;
+      const payload = await deps.aggregator.getFullPayloadWithAudit(
+        entryMatch.aggregatorId,
+        operatorId
+      );
+      writeJSON4(res, 200, {
+        ok: true,
+        data: { entry, request_payload: payload }
+      });
+      return true;
+    }
+    if (method === "GET" && entryMatch.action === null) {
+      const entry = await deps.aggregator.getEntry(entryMatch.aggregatorId);
       if (!entry) {
         writeJSON4(res, 404, { ok: false, error: "not_found" });
         return true;
@@ -20271,7 +20339,10 @@ var init_approval_aggregator = __esm({
     APPROVAL_AGGREGATOR_AUDIT_OPS = {
       AGGREGATED: "cross_harness_approval_aggregated",
       RESOLVED: "cross_harness_approval_resolved",
-      DEDUPED: "cross_harness_approval_deduped"
+      DEDUPED: "cross_harness_approval_deduped",
+      PAYLOAD_DECRYPTED: "cross_harness_approval_payload_decrypted",
+      AUDIT_TRAIL_VIEWED: "cross_harness_approval_audit_trail_viewed",
+      REPLAYED: "cross_harness_approval_replayed"
     };
     DEFAULT_PENDING_TTL_MS = 5 * 60 * 1e3;
     DEFAULT_MAX_LIST_LIMIT = 200;
@@ -20287,6 +20358,8 @@ var init_approval_aggregator = __esm({
       now;
       resolveSourceContext;
       resolveHubInboxItemId;
+      payloadStore;
+      resolveEnforcementChain;
       /** Cached entries by `aggregator_id`. */
       entries = /* @__PURE__ */ new Map();
       /** Dedup index: `${harness}|${agent}|${audit_id}` -> aggregator_id. */
@@ -20299,6 +20372,20 @@ var init_approval_aggregator = __esm({
       hydrated = false;
       /** Active SSE listeners. */
       listeners = /* @__PURE__ */ new Set();
+      /**
+       * Monotonic revision counter, bumped on every mutation (ingest of new
+       * entry, resolve, expire, delete). Hydrated from max(last_modified_revision)
+       * across persisted entries on first read; in-memory after that. v1.3
+       * Upsilon-4.
+       */
+      currentRevision = 0;
+      /**
+       * Removal tombstones: aggregator_id -> revision at removal. Used by the
+       * sync API to surface "removed" entries to mobile consumers between
+       * polls. In-memory only; server restart clears tombstones (mobile
+       * bootstraps via `list()` on reconnect). v1.3 Upsilon-4.
+       */
+      removedTombstones = /* @__PURE__ */ new Map();
       constructor(deps) {
         this.storage = deps.storage;
         this.encryptionKey = derivePurposeKey(
@@ -20316,6 +20403,14 @@ var init_approval_aggregator = __esm({
           source_agent_id: this.fortressId
         }));
         this.resolveHubInboxItemId = deps.resolveHubInboxItemId ?? ((_event) => void 0);
+        this.payloadStore = deps.payloadStore ?? null;
+        this.resolveEnforcementChain = deps.resolveEnforcementChain ?? ((event) => [
+          {
+            layer: "l2",
+            event: `approval_required:${event.operation}`,
+            timestamp: event.request_timestamp
+          }
+        ]);
       }
       /**
        * Subscribe an event listener. Returns an unsubscribe fn. SSE handlers
@@ -20325,6 +20420,113 @@ var init_approval_aggregator = __esm({
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
       }
+      /**
+       * Current aggregator revision. v1.3 Upsilon-4. Mobile companions
+       * poll the lightweight `/revision` route to detect that something
+       * changed before fetching a full sync delta.
+       */
+      async getRevision() {
+        await this.hydrate();
+        return this.currentRevision;
+      }
+      /**
+       * Compute a delta since `sinceRevision`. v1.3 Upsilon-4. Mobile
+       * clients poll this for cheap state-sync. Behavior:
+       *  - `added`: entries whose `created_at_revision > sinceRevision`.
+       *  - `changed`: entries that existed at `sinceRevision` but had a
+       *    status transition (resolve, expire) since.
+       *  - `removed`: aggregator_ids deleted after `sinceRevision`.
+       *  - `revision`: current aggregator revision; pass this back as
+       *    `sinceRevision` on the next call.
+       *
+       * `limit` caps the total count returned across all three lists,
+       * prioritized as added -> changed -> removed (newer-state first).
+       * When more changes exist than fit, the next call with the returned
+       * revision will pick up the rest because each entry's
+       * last_modified_revision is unchanged by truncation.
+       */
+      async getSync(opts) {
+        await this.hydrate();
+        await this.expireStale();
+        const sinceRevision = opts?.sinceRevision ?? 0;
+        const cap = Math.min(
+          opts?.limit ?? DEFAULT_LIST_PAGE_SIZE,
+          this.maxListLimit
+        );
+        const added = [];
+        const changed = [];
+        for (const entry of this.entries.values()) {
+          const lastMod = entry.last_modified_revision ?? 0;
+          if (lastMod <= sinceRevision) continue;
+          const createdRev = entry.created_at_revision ?? 0;
+          if (createdRev > sinceRevision) {
+            added.push(entry);
+          } else {
+            changed.push(entry);
+          }
+        }
+        const removed = [];
+        for (const [id, rev] of this.removedTombstones) {
+          if (rev > sinceRevision) removed.push(id);
+        }
+        added.sort(
+          (a, b) => (a.last_modified_revision ?? 0) - (b.last_modified_revision ?? 0)
+        );
+        changed.sort(
+          (a, b) => (a.last_modified_revision ?? 0) - (b.last_modified_revision ?? 0)
+        );
+        let remaining = cap;
+        const addedOut = added.slice(0, Math.max(0, remaining));
+        remaining -= addedOut.length;
+        const changedOut = changed.slice(0, Math.max(0, remaining));
+        remaining -= changedOut.length;
+        const removedOut = removed.slice(0, Math.max(0, remaining));
+        return {
+          revision: this.currentRevision,
+          added: addedOut,
+          changed: changedOut,
+          removed: removedOut
+        };
+      }
+      /**
+       * Delete an entry. Drops the in-memory record, the persisted bundle,
+       * and the at-rest payload (if a payload store is wired). Records a
+       * tombstone with the new revision so sync-API consumers see a
+       * `removed` delta. Returns true when an entry was deleted, false on
+       * unknown id. v1.3 Upsilon-4. Reserved for v1.4+ retention housekeeping;
+       * Upsilon-4 ships the surface so mobile sync-API tests can exercise the
+       * removal path.
+       */
+      async deleteEntry(aggregatorId) {
+        await this.hydrate();
+        const entry = this.entries.get(aggregatorId);
+        if (!entry) return false;
+        const dedupKey = `${entry.source_harness}|${entry.source_agent_id}|${entry.audit_log_entry_id}`;
+        this.entries.delete(aggregatorId);
+        this.dedupIndex.delete(dedupKey);
+        this.fullPayloads.delete(aggregatorId);
+        for (const [corr, id] of this.correlationIndex) {
+          if (id === aggregatorId) this.correlationIndex.delete(corr);
+        }
+        try {
+          await this.storage.delete(APPROVAL_AGGREGATOR_NAMESPACE, aggregatorId);
+        } catch {
+        }
+        if (this.payloadStore) {
+          try {
+            await this.payloadStore.deletePayload(aggregatorId);
+          } catch {
+          }
+        }
+        const revision = this.nextRevision();
+        this.removedTombstones.set(aggregatorId, revision);
+        this.emit({ type: "removed", entry: { ...entry } });
+        return true;
+      }
+      nextRevision() {
+        this.currentRevision += 1;
+        return this.currentRevision;
+      }
       /**
        * Ingest a gate event. Returns the aggregator entry on first sight,
        * `null` when deduped. Resolution events update the existing record;
@@ -20366,13 +20568,152 @@ var init_approval_aggregator = __esm({
       }
       /**
        * Return the original (unhashed) request payload for the entry. Returns
-       * `null` when the entry is unknown or the payload was evicted (e.g. the
-       * process restarted; payloads are in-memory only at v1.3 Upsilon-1).
+       * `null` when the entry is unknown. When the in-memory payload map has
+       * been evicted (e.g. after a server restart) and a `payloadStore` was
+       * provided, the at-rest bundle is decrypted and the in-memory map is
+       * refilled. Audit emission lives on the `*WithAudit` variant; this base
+       * accessor is silent so internal callers can read without polluting the
+       * audit trail.
        */
       async getFullPayload(aggregatorId) {
         await this.hydrate();
         if (!this.entries.has(aggregatorId)) return null;
-        return this.fullPayloads.get(aggregatorId) ?? null;
+        const cached = this.fullPayloads.get(aggregatorId);
+        if (cached !== void 0) return cached;
+        if (this.payloadStore) {
+          try {
+            const restored = await this.payloadStore.loadPayload(aggregatorId);
+            if (restored !== null) {
+              this.fullPayloads.set(aggregatorId, restored);
+              return restored;
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      /**
+       * Return the entry record for the given id, or null when unknown.
+       * Idempotent. v1.3 Upsilon-3.
+       */
+      async getEntry(aggregatorId) {
+        await this.hydrate();
+        return this.entries.get(aggregatorId) ?? null;
+      }
+      /**
+       * Audited variant of `getFullPayload`. Emits the
+       * `cross_harness_approval_payload_decrypted` audit event before
+       * returning. Used by the operator-facing /payload replay route.
+       * v1.3 Upsilon-3.
+       */
+      async getFullPayloadWithAudit(aggregatorId, operatorId) {
+        const payload = await this.getFullPayload(aggregatorId);
+        if (payload === null) return null;
+        const entry = this.entries.get(aggregatorId);
+        this.auditLog.append(
+          "l2",
+          APPROVAL_AGGREGATOR_AUDIT_OPS.PAYLOAD_DECRYPTED,
+          operatorId,
+          {
+            aggregator_id: aggregatorId,
+            ...entry ? {
+              source_harness: entry.source_harness,
+              source_agent_id: entry.source_agent_id,
+              entry_status: entry.status
+            } : {}
+          }
+        );
+        return payload;
+      }
+      /**
+       * Return the audit-log entries that led to and surround this approval.
+       * Best-effort matching: aggregator-side emissions (AGGREGATED, RESOLVED,
+       * DEDUPED, replay events) all carry `details.aggregator_id` and link
+       * directly. Gate-side emissions (`gate_*:operation`) do not carry the
+       * aggregator id at v1.3, so they are matched via timestamp window
+       * (entry.created_at to entry.resolved_at + 1s, or expires_at + 1s while
+       * pending) and operation suffix. Emits AUDIT_TRAIL_VIEWED on call.
+       * v1.3 Upsilon-3.
+       */
+      async getAuditTrail(aggregatorId, operatorId) {
+        await this.hydrate();
+        const entry = this.entries.get(aggregatorId);
+        if (!entry) {
+          return [];
+        }
+        const sinceMs = Date.parse(entry.created_at) - 1e3;
+        const sinceIso = new Date(sinceMs).toISOString();
+        const queried = await this.auditLog.query({ since: sinceIso, limit: 1e3 });
+        const operationPart = entry.policy_rule_id.includes(":") ? entry.policy_rule_id.slice(entry.policy_rule_id.indexOf(":") + 1) : entry.policy_rule_id;
+        const lifetimeStart = sinceMs;
+        const lifetimeEnd = entry.resolved_at ? Date.parse(entry.resolved_at) + 1e3 : Date.parse(entry.expires_at) + 1e3;
+        const matches = [];
+        for (const audit of queried.entries) {
+          const detailsId = audit.details !== void 0 ? audit.details["aggregator_id"] : void 0;
+          if (detailsId === aggregatorId) {
+            matches.push(audit);
+            continue;
+          }
+          const auditMs = Date.parse(audit.timestamp);
+          if (auditMs < lifetimeStart || auditMs > lifetimeEnd) continue;
+          if (audit.operation.endsWith(`:${operationPart}`)) {
+            matches.push(audit);
+          }
+        }
+        matches.sort(
+          (a, b) => a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0
+        );
+        this.auditLog.append(
+          "l2",
+          APPROVAL_AGGREGATOR_AUDIT_OPS.AUDIT_TRAIL_VIEWED,
+          operatorId,
+          {
+            aggregator_id: aggregatorId,
+            entry_status: entry.status,
+            match_count: matches.length
+          }
+        );
+        return matches;
+      }
+      /**
+       * List historical (resolved) approvals. Excludes pending entries by
+       * design: `list()` is the pending-inbox surface and `getHistory()` is
+       * the resolved-replay surface. Emits REPLAYED on each call. v1.3
+       * Upsilon-3.
+       */
+      async getHistory(opts, operatorId) {
+        await this.hydrate();
+        await this.expireStale();
+        const limit = Math.min(
+          opts?.limit ?? DEFAULT_LIST_PAGE_SIZE,
+          this.maxListLimit
+        );
+        const sinceMs = opts?.sinceTs ? Date.parse(opts.sinceTs) : Number.NEGATIVE_INFINITY;
+        const matching = [];
+        for (const entry of this.entries.values()) {
+          if (entry.status === "pending") continue;
+          if (opts?.status && entry.status !== opts.status) continue;
+          const stamp = Date.parse(entry.resolved_at ?? entry.created_at);
+          if (stamp < sinceMs) continue;
+          matching.push(entry);
+        }
+        matching.sort((a, b) => {
+          const aStamp = a.resolved_at ?? a.created_at;
+          const bStamp = b.resolved_at ?? b.created_at;
+          return bStamp.localeCompare(aStamp);
+        });
+        const sliced = matching.slice(0, limit);
+        this.auditLog.append(
+          "l2",
+          APPROVAL_AGGREGATOR_AUDIT_OPS.REPLAYED,
+          operatorId,
+          {
+            result_count: sliced.length,
+            ...opts?.status !== void 0 ? { status_filter: opts.status } : {},
+            ...opts?.sinceTs !== void 0 ? { since: opts.sinceTs } : {}
+          }
+        );
+        return sliced;
       }
       /**
        * Resolve an entry. Used by both:
@@ -20396,6 +20737,7 @@ var init_approval_aggregator = __esm({
         entry.status = decision;
         entry.resolved_at = this.now().toISOString();
         entry.resolved_by = operatorId;
+        entry.last_modified_revision = this.nextRevision();
         await this.persist(entry);
         this.auditLog.append(
           "l2",
@@ -20446,6 +20788,8 @@ var init_approval_aggregator = __esm({
         const now = this.now();
         const expires = new Date(now.getTime() + this.pendingTtlMs);
         const hubInboxId = this.resolveHubInboxItemId(event);
+        const enforcementChain = this.resolveEnforcementChain(event);
+        const revision = this.nextRevision();
         const entry = {
           aggregator_id: id,
           source_harness: ctx.source_harness,
@@ -20457,13 +20801,22 @@ var init_approval_aggregator = __esm({
           status: "pending",
           created_at: now.toISOString(),
           expires_at: expires.toISOString(),
-          ...hubInboxId !== void 0 ? { hub_inbox_item_id: hubInboxId } : {}
+          created_at_revision: revision,
+          last_modified_revision: revision,
+          ...hubInboxId !== void 0 ? { hub_inbox_item_id: hubInboxId } : {},
+          ...enforcementChain.length > 0 ? { enforcement_chain: enforcementChain } : {}
         };
         this.entries.set(id, entry);
         this.dedupIndex.set(dedupKey, id);
         this.correlationIndex.set(event.correlation_id, id);
         this.fullPayloads.set(id, event.context);
         await this.persist(entry);
+        if (this.payloadStore) {
+          try {
+            await this.payloadStore.savePayload(id, event.context);
+          } catch {
+          }
+        }
         this.auditLog.append(
           "l2",
           APPROVAL_AGGREGATOR_AUDIT_OPS.AGGREGATED,
@@ -20492,6 +20845,7 @@ var init_approval_aggregator = __esm({
         entry.status = status;
         entry.resolved_at = event.resolution.decided_at;
         entry.resolved_by = event.resolution.decided_by;
+        entry.last_modified_revision = this.nextRevision();
         await this.persist(entry);
         this.auditLog.append(
           "l2",
@@ -20554,6 +20908,7 @@ var init_approval_aggregator = __esm({
           entry.status = "expired";
           entry.resolved_at = this.now().toISOString();
           entry.resolved_by = "system_ttl";
+          entry.last_modified_revision = this.nextRevision();
           await this.persist(entry);
           this.auditLog.append(
             "l2",
@@ -20600,6 +20955,10 @@ var init_approval_aggregator = __esm({
               this.entries.set(entry.aggregator_id, entry);
               const dedupKey = `${entry.source_harness}|${entry.source_agent_id}|${entry.audit_log_entry_id}`;
               this.dedupIndex.set(dedupKey, entry.aggregator_id);
+              const lastMod = entry.last_modified_revision ?? 0;
+              if (lastMod > this.currentRevision) {
+                this.currentRevision = lastMod;
+              }
             } catch {
             }
           }
@@ -20779,6 +21138,149 @@ var init_aggregator_backed_channel = __esm({
   }
 });
 
+// src/principal-policy/aggregator-store.ts
+function payloadKey(aggregatorId) {
+  return `${AGGREGATOR_PAYLOAD_KEY_PREFIX}${aggregatorId}`;
+}
+function stripKeyPrefix(key) {
+  if (!key.startsWith(AGGREGATOR_PAYLOAD_KEY_PREFIX)) return null;
+  return key.slice(AGGREGATOR_PAYLOAD_KEY_PREFIX.length);
+}
+var AGGREGATOR_PAYLOAD_NAMESPACE, AGGREGATOR_PAYLOAD_KEY_PREFIX, HKDF_INFO, DEFAULT_AGGREGATOR_PAYLOAD_RETENTION_DAYS, MAX_BUNDLE_BYTES2, AggregatorPayloadStore;
+var init_aggregator_store = __esm({
+  "src/principal-policy/aggregator-store.ts"() {
+    init_encryption();
+    init_key_derivation();
+    init_encoding();
+    AGGREGATOR_PAYLOAD_NAMESPACE = "_approval_aggregator_payloads";
+    AGGREGATOR_PAYLOAD_KEY_PREFIX = "payload.";
+    HKDF_INFO = "l2-approval-aggregator-payload-v1";
+    DEFAULT_AGGREGATOR_PAYLOAD_RETENTION_DAYS = 30;
+    MAX_BUNDLE_BYTES2 = 4 * 1024 * 1024;
+    AggregatorPayloadStore = class {
+      storage;
+      encryptionKey;
+      fortressId;
+      retentionDays;
+      constructor(opts) {
+        this.storage = opts.storage;
+        this.encryptionKey = derivePurposeKey(opts.masterKey, HKDF_INFO);
+        this.fortressId = opts.fortressId;
+        this.retentionDays = opts.retentionDays !== void 0 && opts.retentionDays > 0 ? opts.retentionDays : DEFAULT_AGGREGATOR_PAYLOAD_RETENTION_DAYS;
+      }
+      /**
+       * Persist `payload` under the given aggregator_id. Idempotent; calling
+       * twice with the same id rewrites the bundle (retention_until is
+       * recomputed). Returns the bundle's retention_until ISO-8601 timestamp
+       * so callers can log it.
+       */
+      async savePayload(aggregatorId, payload) {
+        const now = /* @__PURE__ */ new Date();
+        const retentionMs = this.retentionDays * 24 * 60 * 60 * 1e3;
+        const retentionUntil = new Date(now.getTime() + retentionMs);
+        const bundle = {
+          version: 1,
+          aggregator_id: aggregatorId,
+          fortress_id: this.fortressId,
+          created_at: now.toISOString(),
+          retention_until: retentionUntil.toISOString(),
+          payload
+        };
+        const aad = stringToBytes(aggregatorId);
+        const plaintext = stringToBytes(JSON.stringify(bundle));
+        const envelope = encrypt(plaintext, this.encryptionKey, aad);
+        await this.storage.write(
+          AGGREGATOR_PAYLOAD_NAMESPACE,
+          payloadKey(aggregatorId),
+          stringToBytes(JSON.stringify(envelope))
+        );
+        return bundle.retention_until;
+      }
+      /**
+       * Read the persisted payload for the aggregator_id. Returns null if no
+       * bundle exists, the bundle is corrupted, or AAD binding fails.
+       */
+      async loadPayload(aggregatorId) {
+        const key = payloadKey(aggregatorId);
+        let raw;
+        try {
+          raw = await this.storage.read(AGGREGATOR_PAYLOAD_NAMESPACE, key);
+        } catch {
+          return null;
+        }
+        if (!raw) return null;
+        if (raw.length > MAX_BUNDLE_BYTES2) return null;
+        try {
+          const envelope = JSON.parse(bytesToString(raw));
+          const aad = stringToBytes(aggregatorId);
+          const plaintext = decrypt(envelope, this.encryptionKey, aad);
+          const parsed = JSON.parse(
+            bytesToString(plaintext)
+          );
+          if (parsed.version !== 1) return null;
+          if (parsed.aggregator_id !== aggregatorId) return null;
+          return parsed.payload;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Delete the persisted payload. Returns true when a bundle was removed,
+       * false when none existed.
+       */
+      async deletePayload(aggregatorId) {
+        const key = payloadKey(aggregatorId);
+        const existed = await this.storage.exists(
+          AGGREGATOR_PAYLOAD_NAMESPACE,
+          key
+        );
+        if (!existed) return false;
+        try {
+          await this.storage.delete(AGGREGATOR_PAYLOAD_NAMESPACE, key);
+        } catch {
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Drop expired payload bundles. Returns the count of bundles pruned.
+       * Caller wires this into the cocoon-unlock initialization path.
+       */
+      async pruneExpired(now) {
+        const cutoff = (now ?? /* @__PURE__ */ new Date()).toISOString();
+        const entries = await this.storage.list(
+          AGGREGATOR_PAYLOAD_NAMESPACE,
+          AGGREGATOR_PAYLOAD_KEY_PREFIX
+        );
+        let pruned = 0;
+        for (const meta of entries) {
+          const aggregatorId = stripKeyPrefix(meta.key);
+          if (aggregatorId === null) continue;
+          const raw = await this.storage.read(
+            AGGREGATOR_PAYLOAD_NAMESPACE,
+            meta.key
+          );
+          if (!raw) continue;
+          try {
+            const envelope = JSON.parse(bytesToString(raw));
+            const aad = stringToBytes(aggregatorId);
+            const plaintext = decrypt(envelope, this.encryptionKey, aad);
+            const parsed = JSON.parse(
+              bytesToString(plaintext)
+            );
+            if (parsed.retention_until <= cutoff) {
+              await this.storage.delete(AGGREGATOR_PAYLOAD_NAMESPACE, meta.key);
+              pruned += 1;
+            }
+          } catch {
+          }
+        }
+        return { pruned };
+      }
+    };
+  }
+});
+
 // src/principal-policy/tools.ts
 function createPrincipalPolicyTools(policy, baseline, auditLog) {
   return [
@@ -33397,7 +33899,14 @@ var init_operator_chat_audit_events = __esm({
        * turns; the concierge degrades to single-turn after emitting. Body
        * carries thread_id + a stable failure_reason enum.
        */
-      CONCIERGE_MEMORY_READ_FAILED: "operator_concierge_memory_read_failed"
+      CONCIERGE_MEMORY_READ_FAILED: "operator_concierge_memory_read_failed",
+      /**
+       * Concierge dynamic-context fetcher failed (WP-V1.3-9 Tau-3). Emitted
+       * when a category fetcher throws while assembling the dynamic context
+       * fold. The concierge omits that category and continues; the user-
+       * facing query is never broken. Body carries category + failure_reason.
+       */
+      CONCIERGE_CONTEXT_FETCHER_FAILED: "operator_concierge_context_fetcher_failed"
     };
   }
 });
@@ -33410,12 +33919,844 @@ var init_operator_chat_types = __esm({
     CONCIERGE_THREAD_KEY = "_fortress";
   }
 });
+
+// src/chat/concierge-context-router.ts
+function phrasePattern(phrase) {
+  const escaped = phrase.toLowerCase().split(/\s+/).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+  return { source: `\\b${escaped}\\b`, phrase };
+}
+function extractAgentNameHint(query) {
+  const agentPattern = /\bagent\s+["']?([A-Za-z][\w-]{0,40})["']?/i;
+  const m = query.match(agentPattern);
+  if (m && m[1]) return m[1];
+  const quoted = query.match(/["']([A-Za-z][\w-]{0,40})["']/);
+  if (quoted && quoted[1]) return quoted[1];
+  return null;
+}
+function isTrivialQuery(query) {
+  const norm = query.trim().toLowerCase();
+  if (norm.length === 0) return true;
+  if (norm.length < 8) return true;
+  return TRIVIAL_GREETINGS.has(norm);
+}
+function classifyQuery(query, parsedGrammar) {
+  const normalized = query.toLowerCase();
+  const matches = [];
+  const grammarAgent = parsedGrammar && parsedGrammar.agent_names.length > 0 ? parsedGrammar.agent_names[0] ?? null : null;
+  for (const spec of CATEGORY_KEYWORDS) {
+    const matchedPhrases = [];
+    for (const pattern of spec.patterns) {
+      if (matchedPhrases.includes(pattern.phrase)) continue;
+      const re = new RegExp(pattern.source, "i");
+      if (re.test(normalized)) {
+        matchedPhrases.push(pattern.phrase);
+      }
+    }
+    if (matchedPhrases.length === 0) continue;
+    const confidence = Math.min(1, 0.4 + 0.3 * matchedPhrases.length);
+    const wantsAgentHint = spec.category === "agent_state" || spec.category === "agent_activity";
+    const agent_name_hint = wantsAgentHint ? grammarAgent ?? extractAgentNameHint(query) : null;
+    matches.push({
+      category: spec.category,
+      confidence,
+      matched_keywords: matchedPhrases,
+      agent_name_hint,
+      ...parsedGrammar !== void 0 ? { query_grammar: parsedGrammar } : {}
+    });
+  }
+  matches.sort((a, b) => {
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    return CONTEXT_CATEGORIES.indexOf(a.category) - CONTEXT_CATEGORIES.indexOf(b.category);
+  });
+  return matches;
+}
+function fetcherHintsFromGrammar(parsed) {
+  if (!parsed) return void 0;
+  const hasTime = parsed.time_range !== null;
+  const hasAgents = parsed.agent_names.length > 0;
+  const hasEvents = parsed.event_types.length > 0;
+  if (!hasTime && !hasAgents && !hasEvents) return void 0;
+  const hints = {};
+  if (parsed.time_range) {
+    const range = parsed.time_range;
+    hints.time_range = {
+      start: range.start,
+      end: range.end,
+      ...range.relative_label !== void 0 ? { relative_label: range.relative_label } : {}
+    };
+  }
+  if (hasAgents) hints.agent_names = parsed.agent_names;
+  if (hasEvents) hints.event_types = parsed.event_types;
+  return hints;
+}
 function approxTokenLen(text) {
+  return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
+}
+async function runFetcher(match, fetchers, hints) {
+  switch (match.category) {
+    case "templates":
+      return fetchers.templates(hints);
+    case "agent_state":
+      return fetchers.agent_state(match.agent_name_hint, hints);
+    case "agent_activity":
+      return fetchers.agent_activity(match.agent_name_hint, hints);
+    case "audit_log":
+      return fetchers.audit_log(hints);
+    case "sentinel_findings":
+      return fetchers.sentinel_findings(hints);
+    case "anomaly_alerts":
+      return fetchers.anomaly_alerts(hints);
+    case "recent_receipts":
+      return fetchers.recent_receipts(hints);
+    case "verascore_deltas":
+      return fetchers.verascore_deltas(hints);
+  }
+}
+function trivialMatch(category, parsedGrammar) {
+  return {
+    category,
+    confidence: 0.5,
+    matched_keywords: ["llm-assist"],
+    agent_name_hint: parsedGrammar && parsedGrammar.agent_names.length > 0 ? parsedGrammar.agent_names[0] ?? null : null,
+    ...parsedGrammar !== void 0 ? { query_grammar: parsedGrammar } : {}
+  };
+}
+async function foldContext(query, fetchers, opts) {
+  const budget = opts?.maxTokens ?? DEFAULT_DYNAMIC_CONTEXT_TOKEN_BUDGET;
+  const parsed = opts?.parsed ?? null;
+  const hints = fetcherHintsFromGrammar(parsed);
+  let matches = classifyQuery(query, parsed);
+  if (matches.length === 0 && !isTrivialQuery(query) && opts?.llmAssistClassify) {
+    try {
+      const picked = await opts.llmAssistClassify(query, CONTEXT_CATEGORIES);
+      if (picked !== "none" && CONTEXT_CATEGORIES.includes(picked)) {
+        matches = [trivialMatch(picked, parsed)];
+      }
+    } catch {
+    }
+  }
+  if (matches.length === 0) {
+    return { section: "", categoriesIncluded: [] };
+  }
+  const attempts = [];
+  for (const match of matches) {
+    try {
+      const text = await runFetcher(match, fetchers, hints);
+      const trimmed = text.trim();
+      if (trimmed.length > 0) {
+        attempts.push({ category: match.category, text: trimmed });
+      }
+    } catch (err) {
+      opts?.onFetcherFailure?.(match.category, err);
+    }
+  }
+  if (attempts.length === 0) {
+    return { section: "", categoriesIncluded: [] };
+  }
+  const headerTokens = approxTokenLen(`${DYNAMIC_CONTEXT_SECTION_HEADER}
+`);
+  const sepTokens = approxTokenLen("\n\n");
+  let runningTokens = headerTokens;
+  const kept = [];
+  for (const attempt of attempts) {
+    const block = `### ${CATEGORY_LABELS[attempt.category]}
+${attempt.text}`;
+    const tokens = approxTokenLen(block) + (kept.length > 0 ? sepTokens : 0);
+    if (kept.length === 0) {
+      kept.push(attempt);
+      runningTokens += tokens;
+      continue;
+    }
+    if (runningTokens + tokens > budget) break;
+    kept.push(attempt);
+    runningTokens += tokens;
+  }
+  const blocks = kept.map(
+    (k) => `### ${CATEGORY_LABELS[k.category]}
+${k.text}`
+  );
+  const section = `${DYNAMIC_CONTEXT_SECTION_HEADER}
+${blocks.join("\n\n")}`;
+  return {
+    section,
+    categoriesIncluded: kept.map((k) => k.category)
+  };
+}
+var APPROX_CHARS_PER_TOKEN, DEFAULT_DYNAMIC_CONTEXT_TOKEN_BUDGET, DYNAMIC_CONTEXT_SECTION_HEADER, CONTEXT_CATEGORIES, CATEGORY_KEYWORDS, TRIVIAL_GREETINGS, CATEGORY_LABELS;
+var init_concierge_context_router = __esm({
+  "src/chat/concierge-context-router.ts"() {
+    APPROX_CHARS_PER_TOKEN = 4;
+    DEFAULT_DYNAMIC_CONTEXT_TOKEN_BUDGET = 2e3;
+    DYNAMIC_CONTEXT_SECTION_HEADER = "## Live fortress context";
+    CONTEXT_CATEGORIES = [
+      "templates",
+      "agent_state",
+      "agent_activity",
+      "audit_log",
+      "sentinel_findings",
+      "anomaly_alerts",
+      "recent_receipts",
+      "verascore_deltas"
+    ];
+    CATEGORY_KEYWORDS = [
+      {
+        category: "templates",
+        patterns: [
+          "templates",
+          "template",
+          "channel templates",
+          "channel template",
+          "list templates",
+          "available templates",
+          "what templates"
+        ].map(phrasePattern)
+      },
+      {
+        category: "agent_state",
+        patterns: [
+          "state",
+          "status",
+          "agent state",
+          "agent status",
+          "status of agent",
+          "status of agents",
+          "state of",
+          "doing"
+        ].map(phrasePattern)
+      },
+      {
+        category: "agent_activity",
+        patterns: [
+          "activity",
+          "agent activity",
+          "what did",
+          "recent activity"
+        ].map(phrasePattern)
+      },
+      {
+        category: "audit_log",
+        patterns: [
+          "audit log",
+          "audit",
+          "log entry",
+          "log entries",
+          "what happened",
+          "show me events",
+          "event class"
+        ].map(phrasePattern)
+      },
+      {
+        category: "sentinel_findings",
+        patterns: [
+          "sentinel",
+          "sentinels",
+          "warning",
+          "warnings",
+          "alert",
+          "alerts",
+          "whats wrong",
+          "what's wrong",
+          "findings"
+        ].map(phrasePattern)
+      },
+      {
+        category: "anomaly_alerts",
+        patterns: [
+          "anomaly",
+          "anomalies",
+          "spike",
+          "unusual",
+          "outlier"
+        ].map(phrasePattern)
+      },
+      {
+        category: "recent_receipts",
+        patterns: [
+          "receipt",
+          "receipts",
+          "concordia",
+          "commitment",
+          "commitments",
+          "chain",
+          "chains"
+        ].map(phrasePattern)
+      },
+      {
+        category: "verascore_deltas",
+        patterns: [
+          "verascore",
+          "vera score",
+          "trust score",
+          "reputation"
+        ].map(phrasePattern)
+      }
+    ];
+    TRIVIAL_GREETINGS = /* @__PURE__ */ new Set([
+      "hi",
+      "hello",
+      "hey",
+      "yo",
+      "ok",
+      "thanks",
+      "thx",
+      "thank you"
+    ]);
+    CATEGORY_LABELS = {
+      templates: "Templates",
+      agent_state: "Agent state",
+      agent_activity: "Agent activity",
+      audit_log: "Audit log",
+      sentinel_findings: "Sentinel findings",
+      anomaly_alerts: "Anomaly alerts",
+      recent_receipts: "Recent receipts",
+      verascore_deltas: "Verascore deltas"
+    };
+  }
+});
+
+// src/composition/constants.ts
+var COMPOSITION_EVENT_TYPES;
+var init_constants4 = __esm({
+  "src/composition/constants.ts"() {
+    init_constants();
+    COMPOSITION_EVENT_TYPES = [
+      "composition_receipt_packed",
+      "composition_receipt_verified",
+      "composition_mandate_verified",
+      "composition_verascore_published",
+      "composition_sidecar_spawned",
+      "composition_sidecar_crashed",
+      "composition_sidecar_recovered",
+      "composition_degraded",
+      "composition_recovered"
+    ];
+  }
+});
+
+// src/chat/concierge-query-grammar.ts
+function resolveTimeRange(query, now) {
+  const normalized = query.trim();
+  const lower = normalized.toLowerCase();
+  const fromTo = lower.match(
+    /\b(?:from|between)\s+(.+?)\s+(?:to|and|-|until)\s+([\w:.\-+t /]+)/i
+  );
+  if (fromTo) {
+    const aSlice = fromTo[1];
+    const bSlice = fromTo[2];
+    if (aSlice !== void 0 && bSlice !== void 0) {
+      const a = parseInstant(aSlice, now);
+      const b = parseInstant(bSlice, now);
+      if (a && b) {
+        const start = a.getTime() <= b.getTime() ? a : b;
+        const end = a.getTime() <= b.getTime() ? b : a;
+        return {
+          range: { start, end },
+          matchedSubstring: fromTo[0]
+        };
+      }
+    }
+  }
+  const sinceMatch = lower.match(/\bsince\s+([\w:.\-+t /]+)/i);
+  if (sinceMatch) {
+    const slice = sinceMatch[1];
+    if (slice !== void 0) {
+      const start = parseInstant(slice, now);
+      if (start) {
+        return {
+          range: { start, end: now },
+          matchedSubstring: sinceMatch[0]
+        };
+      }
+    }
+  }
+  if (/\byesterday\b/.test(lower)) {
+    const startOfToday = startOfDay(now);
+    const start = new Date(startOfToday.getTime() - MS_PER_DAY);
+    const end = new Date(startOfToday.getTime() - 1);
+    return {
+      range: { start, end, relative_label: "yesterday" },
+      matchedSubstring: "yesterday"
+    };
+  }
+  if (/\btoday\b/.test(lower)) {
+    return {
+      range: {
+        start: startOfDay(now),
+        end: now,
+        relative_label: "today"
+      },
+      matchedSubstring: "today"
+    };
+  }
+  const compactHours = lower.match(/\blast\s+(\d+)\s*h\b/i);
+  if (compactHours) {
+    const tok = compactHours[1];
+    if (tok !== void 0) {
+      const n = Number.parseInt(tok, 10);
+      if (Number.isFinite(n) && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_HOUR);
+        return {
+          range: { start, end: now, relative_label: `last ${n}h` },
+          matchedSubstring: compactHours[0]
+        };
+      }
+    }
+  }
+  const hoursMatch = lower.match(
+    /\b(?:past|last)\s+([\w]+|\d+)\s*(?:hr\b|hrs\b|hour|hours)/i
+  );
+  if (hoursMatch) {
+    const tok = hoursMatch[1];
+    if (tok !== void 0) {
+      const n = parseCount(tok);
+      if (n !== null && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_HOUR);
+        return {
+          range: { start, end: now, relative_label: `past ${n} hour${n === 1 ? "" : "s"}` },
+          matchedSubstring: hoursMatch[0]
+        };
+      }
+    }
+  }
+  if (/\b(?:past|last)\s+hour\b/.test(lower)) {
+    const start = new Date(now.getTime() - MS_PER_HOUR);
+    return {
+      range: { start, end: now, relative_label: "past hour" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+hour\b/i)[0]
+    };
+  }
+  const daysMatch = lower.match(
+    /\b(?:past|last)\s+([\w]+|\d+)\s*(?:d\b|day|days)/i
+  );
+  if (daysMatch) {
+    const tok = daysMatch[1];
+    if (tok !== void 0) {
+      const n = parseCount(tok);
+      if (n !== null && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_DAY);
+        return {
+          range: { start, end: now, relative_label: `past ${n} day${n === 1 ? "" : "s"}` },
+          matchedSubstring: daysMatch[0]
+        };
+      }
+    }
+  }
+  if (/\b(?:past|last)\s+day\b/.test(lower)) {
+    const start = new Date(now.getTime() - MS_PER_DAY);
+    return {
+      range: { start, end: now, relative_label: "past day" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+day\b/i)[0]
+    };
+  }
+  if (/\bthis\s+week\b/.test(lower)) {
+    const start = startOfWeek(now);
+    return {
+      range: { start, end: now, relative_label: "this week" },
+      matchedSubstring: lower.match(/\bthis\s+week\b/i)[0]
+    };
+  }
+  if (/\b(?:past|last)\s+week\b/.test(lower)) {
+    const start = new Date(now.getTime() - 7 * MS_PER_DAY);
+    return {
+      range: { start, end: now, relative_label: "past week" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+week\b/i)[0]
+    };
+  }
+  const isoMatch = normalized.match(
+    /\b(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})?)?)\b/
+  );
+  if (isoMatch) {
+    const tok = isoMatch[1];
+    if (tok !== void 0) {
+      const parsed = parseInstant(tok, now);
+      if (parsed) {
+        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(tok);
+        if (isDateOnly) {
+          return {
+            range: {
+              start: parsed,
+              end: new Date(parsed.getTime() + MS_PER_DAY - 1)
+            },
+            matchedSubstring: tok
+          };
+        }
+        return {
+          range: {
+            start: new Date(parsed.getTime() - 30 * 60 * 1e3),
+            end: new Date(parsed.getTime() + 30 * 60 * 1e3)
+          },
+          matchedSubstring: tok
+        };
+      }
+    }
+  }
+  return null;
+}
+function parseInstant(token, now) {
+  const trimmed = token.trim().replace(/[,.!?;]+$/g, "");
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  if (lower === "now") return now;
+  if (lower === "today") return startOfDay(now);
+  if (lower === "yesterday") {
+    return new Date(startOfDay(now).getTime() - MS_PER_DAY);
+  }
+  const isoLike = trimmed.replace(" ", "T");
+  const parsed = new Date(isoLike);
+  if (!Number.isNaN(parsed.getTime())) return parsed;
+  return null;
+}
+function parseCount(token) {
+  const lower = token.toLowerCase();
+  if (/^\d+$/.test(lower)) {
+    const n = Number.parseInt(lower, 10);
+    return Number.isFinite(n) ? n : null;
+  }
+  return NUMBER_WORDS[lower] ?? null;
+}
+function startOfDay(d) {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+function startOfWeek(d) {
+  const out = startOfDay(d);
+  const dayOfWeek = out.getDay();
+  const offsetToMonday = (dayOfWeek + 6) % 7;
+  out.setDate(out.getDate() - offsetToMonday);
+  return out;
+}
+function listFromRegistry(registry) {
+  if (!registry) return [];
+  if (Array.isArray(registry)) return registry;
+  if (typeof registry.list === "function") {
+    return registry.list();
+  }
+  return [];
+}
+function extractAgentNames(query, registry) {
+  const records = listFromRegistry(registry);
+  if (records.length === 0) return { matched: [], flagged: false };
+  const lowerQuery = query.toLowerCase();
+  const compactQuery = lowerQuery.replace(/[\s_-]+/g, "");
+  const matched = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rec of records) {
+    const id = rec.agent_id;
+    if (!id || seen.has(id)) continue;
+    const idLower = id.toLowerCase();
+    if (idLower.length < 3) continue;
+    const idCompact = idLower.replace(/[\s_-]+/g, "");
+    const wordRe = new RegExp(
+      `\\b${idLower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`,
+      "i"
+    );
+    if (wordRe.test(query)) {
+      matched.push(id);
+      seen.add(id);
+      continue;
+    }
+    if (idCompact.length >= 4 && compactQuery.includes(idCompact)) {
+      matched.push(id);
+      seen.add(id);
+    }
+  }
+  const agentMention = lowerQuery.match(/\bagent\s+([a-z0-9_-]{3,40})/i);
+  const flagged = matched.length === 0 && agentMention !== null && agentMention[1] !== void 0 && !records.some((r) => r.agent_id.toLowerCase() === agentMention[1]?.toLowerCase());
+  return { matched, flagged };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractEventTypes(query, enumValues) {
+  const lower = query.toLowerCase();
+  const matched = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ev of enumValues) {
+    if (seen.has(ev)) continue;
+    const re = new RegExp(`\\b${escapeRegex(ev)}\\b`, "i");
+    if (re.test(query)) {
+      matched.push(ev);
+      seen.add(ev);
+    }
+  }
+  for (const syn of EVENT_SYNONYMS) {
+    const re = new RegExp(
+      `\\b${syn.phrase.split(/\s+/).map(escapeRegex).join("\\s+")}\\b`,
+      "i"
+    );
+    if (re.test(query)) {
+      for (const c of syn.canonical) {
+        if (seen.has(c)) continue;
+        if (!enumValues.includes(c)) continue;
+        matched.push(c);
+        seen.add(c);
+      }
+    }
+  }
+  const globMatches = lower.match(/\b([a-z_]+)_\*/g) ?? [];
+  for (const glob of globMatches) {
+    const prefix = glob.slice(0, -2);
+    for (const ev of enumValues) {
+      if (seen.has(ev)) continue;
+      if (ev.startsWith(prefix)) {
+        matched.push(ev);
+        seen.add(ev);
+      }
+    }
+  }
+  const eventNounMention = /\b(?:event|events|class|classes)\b/i.test(query) && matched.length === 0;
+  return { matched, flagged: eventNounMention };
+}
+function deriveIntentPhrase(query, stripTokens) {
+  let out = query;
+  for (const tok of stripTokens) {
+    if (!tok) continue;
+    const re = new RegExp(escapeRegex(tok), "gi");
+    out = out.replace(re, " ");
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function computeConfidence(parsed) {
+  const dims = [
+    { present: parsed.hasTimeMention, resolved: parsed.timeResolved },
+    { present: parsed.hasAgentMention, resolved: parsed.agentResolved },
+    { present: parsed.hasEventMention, resolved: parsed.eventResolved }
+  ];
+  const present = dims.filter((d) => d.present);
+  let base;
+  if (present.length === 0) {
+    base = parsed.intentEmpty ? 0 : 0.3;
+  } else {
+    const resolved = present.filter((d) => d.resolved).length;
+    base = resolved / present.length;
+  }
+  const adjusted = base - 0.15 * parsed.ambiguityCount;
+  if (adjusted < 0) return 0;
+  if (adjusted > 1) return 1;
+  return adjusted;
+}
+function parseQuery(query, opts) {
+  const now = opts?.now ?? /* @__PURE__ */ new Date();
+  const enumValues = opts?.eventClassEnum ?? CANONICAL_AUDIT_EVENT_CLASSES;
+  const original = query ?? "";
+  const trimmed = original.trim();
+  if (trimmed.length === 0) {
+    return {
+      time_range: null,
+      agent_names: [],
+      event_types: [],
+      intent_phrase: "",
+      ambiguity_flags: ["no_signal_extracted"],
+      parse_confidence: 0
+    };
+  }
+  const ambiguity_flags = /* @__PURE__ */ new Set();
+  const timeMatch = resolveTimeRange(trimmed, now);
+  const hasTimeMention = TIME_MENTION_PROBE.test(trimmed);
+  if (hasTimeMention && !timeMatch) {
+    ambiguity_flags.add("unknown_time_token");
+  }
+  const agentResult = extractAgentNames(trimmed, opts?.registry);
+  if (agentResult.flagged) {
+    ambiguity_flags.add("unknown_agent_token");
+  }
+  const hasAgentMention = AGENT_MENTION_PROBE.test(trimmed);
+  const eventResult = extractEventTypes(trimmed, enumValues);
+  const hasEventMention = EVENT_MENTION_PROBE.test(trimmed);
+  if (eventResult.flagged) {
+    ambiguity_flags.add("unknown_event_token");
+  }
+  const stripTokens = [];
+  if (timeMatch) stripTokens.push(timeMatch.matchedSubstring);
+  for (const name of agentResult.matched) stripTokens.push(name);
+  for (const ev of eventResult.matched) {
+    if (trimmed.toLowerCase().includes(ev.toLowerCase())) {
+      stripTokens.push(ev);
+    }
+  }
+  const intent_phrase = deriveIntentPhrase(trimmed, stripTokens);
+  const parse_confidence = computeConfidence({
+    hasTimeMention,
+    timeResolved: timeMatch !== null,
+    hasAgentMention,
+    agentResolved: agentResult.matched.length > 0,
+    hasEventMention,
+    eventResolved: eventResult.matched.length > 0,
+    intentEmpty: intent_phrase.length === 0,
+    ambiguityCount: ambiguity_flags.size
+  });
+  if (timeMatch === null && agentResult.matched.length === 0 && eventResult.matched.length === 0 && intent_phrase.length === 0) {
+    ambiguity_flags.add("no_signal_extracted");
+  }
+  return {
+    time_range: timeMatch ? timeMatch.range : null,
+    agent_names: agentResult.matched,
+    event_types: eventResult.matched,
+    intent_phrase,
+    ambiguity_flags: Array.from(ambiguity_flags),
+    parse_confidence
+  };
+}
+function isLowConfidence(parsed) {
+  return parsed.parse_confidence < LLM_ASSIST_THRESHOLD;
+}
+async function parseQueryWithLlmAssist(query, llmAssist, opts) {
+  const parsed = parseQuery(query, opts);
+  if (!llmAssist || !isLowConfidence(parsed)) return parsed;
+  let completion;
+  try {
+    completion = await llmAssist(query, parsed);
+  } catch {
+    return parsed;
+  }
+  if (!completion || typeof completion !== "object") return parsed;
+  const merged = { ...parsed };
+  if (parsed.time_range === null && completion.time_range) {
+    merged.time_range = completion.time_range;
+  }
+  if (parsed.agent_names.length === 0 && Array.isArray(completion.agent_names)) {
+    merged.agent_names = completion.agent_names.filter(
+      (s) => typeof s === "string" && s.length > 0
+    );
+  }
+  if (parsed.event_types.length === 0 && Array.isArray(completion.event_types)) {
+    const allowed = new Set(opts?.eventClassEnum ?? CANONICAL_AUDIT_EVENT_CLASSES);
+    merged.event_types = completion.event_types.filter(
+      (s) => typeof s === "string" && allowed.has(s)
+    );
+  }
+  merged.parse_confidence = Math.max(
+    parsed.parse_confidence,
+    computeConfidence({
+      hasTimeMention: TIME_MENTION_PROBE.test(query),
+      timeResolved: merged.time_range !== null,
+      hasAgentMention: AGENT_MENTION_PROBE.test(query),
+      agentResolved: merged.agent_names.length > 0,
+      hasEventMention: EVENT_MENTION_PROBE.test(query),
+      eventResolved: merged.event_types.length > 0,
+      intentEmpty: merged.intent_phrase.length === 0,
+      ambiguityCount: merged.ambiguity_flags.length
+    })
+  );
+  return merged;
+}
+function auditSafeSummary(parsed) {
+  return {
+    time_range: parsed.time_range ? {
+      start_iso: parsed.time_range.start.toISOString(),
+      end_iso: parsed.time_range.end.toISOString(),
+      ...parsed.time_range.relative_label !== void 0 ? { relative_label: parsed.time_range.relative_label } : {}
+    } : null,
+    agent_names: [...parsed.agent_names],
+    event_types: [...parsed.event_types],
+    ambiguity_flags: [...parsed.ambiguity_flags],
+    parse_confidence: parsed.parse_confidence
+  };
+}
+var CANONICAL_AUDIT_EVENT_CLASSES, EVENT_SYNONYMS, MS_PER_HOUR, MS_PER_DAY, NUMBER_WORDS, TIME_MENTION_PROBE, AGENT_MENTION_PROBE, EVENT_MENTION_PROBE, LLM_ASSIST_THRESHOLD;
+var init_concierge_query_grammar = __esm({
+  "src/chat/concierge-query-grammar.ts"() {
+    init_constants4();
+    init_operator_chat_audit_events();
+    CANONICAL_AUDIT_EVENT_CLASSES = [
+      // Lifecycle / policy
+      "policy_change",
+      "approval_request",
+      "audit_truncate",
+      "lockdown",
+      "unwrap",
+      // Exit bundle (Tier 1)
+      "exit_bundle_export",
+      "exit_bundle_import_activate",
+      "exit_bundle_rekey",
+      // Cross-harness approval aggregator
+      "cross_harness_approval_aggregated",
+      "cross_harness_approval_resolved",
+      "cross_harness_approval_deduped",
+      "cross_harness_approval_payload_decrypted",
+      "cross_harness_approval_audit_trail_viewed",
+      "cross_harness_approval_replayed",
+      // Composition (full set from constants.ts)
+      ...COMPOSITION_EVENT_TYPES,
+      // Operator chat / concierge (full set from OPERATOR_CHAT_OPS)
+      OPERATOR_CHAT_OPS.CONCIERGE_CHAT,
+      OPERATOR_CHAT_OPS.AGENT_INSPECT_PANEL_OPENED,
+      OPERATOR_CHAT_OPS.CONCIERGE_HISTORY_READ,
+      OPERATOR_CHAT_OPS.CONCIERGE_THREAD_DELETED,
+      OPERATOR_CHAT_OPS.CONCIERGE_MEMORY_READ_FAILED,
+      OPERATOR_CHAT_OPS.CONCIERGE_CONTEXT_FETCHER_FAILED,
+      // Bridge / commitment
+      "bridge_commit",
+      "bridge_verify",
+      "bridge_attest",
+      "proof_commitment",
+      "proof_reveal",
+      // Reputation
+      "reputation_export",
+      "reputation_import",
+      "reputation_publish",
+      "reputation_record",
+      "reputation_query"
+    ];
+    EVENT_SYNONYMS = [
+      { phrase: "approvals", canonical: ["approval_request", "cross_harness_approval_aggregated", "cross_harness_approval_resolved"] },
+      { phrase: "approval", canonical: ["approval_request"] },
+      { phrase: "policy changes", canonical: ["policy_change"] },
+      { phrase: "policy change", canonical: ["policy_change"] },
+      { phrase: "policy edits", canonical: ["policy_change"] },
+      { phrase: "lockdowns", canonical: ["lockdown"] },
+      { phrase: "exit bundles", canonical: ["exit_bundle_export", "exit_bundle_import_activate"] },
+      { phrase: "exit bundle", canonical: ["exit_bundle_export"] },
+      { phrase: "audit truncations", canonical: ["audit_truncate"] },
+      { phrase: "audit truncation", canonical: ["audit_truncate"] },
+      { phrase: "compositions", canonical: ["composition_receipt_packed", "composition_receipt_verified"] },
+      { phrase: "receipts", canonical: ["composition_receipt_packed", "composition_receipt_verified"] },
+      { phrase: "receipt verifications", canonical: ["composition_receipt_verified"] },
+      { phrase: "concierge chats", canonical: [OPERATOR_CHAT_OPS.CONCIERGE_CHAT] },
+      { phrase: "cross harness approvals", canonical: ["cross_harness_approval_aggregated", "cross_harness_approval_resolved"] }
+    ];
+    MS_PER_HOUR = 60 * 60 * 1e3;
+    MS_PER_DAY = 24 * MS_PER_HOUR;
+    NUMBER_WORDS = {
+      a: 1,
+      an: 1,
+      one: 1,
+      two: 2,
+      three: 3,
+      four: 4,
+      five: 5,
+      six: 6,
+      seven: 7,
+      eight: 8,
+      nine: 9,
+      ten: 10,
+      twelve: 12,
+      twentyfour: 24
+    };
+    TIME_MENTION_PROBE = /\b(yesterday|today|now|past|last|this\s+week|this\s+month|since|from|between|\d{4}-\d{2}-\d{2})\b/i;
+    AGENT_MENTION_PROBE = /\bagent[s]?\b/i;
+    EVENT_MENTION_PROBE = /\b(event|events|class|classes|approvals?|policy)\b/i;
+    LLM_ASSIST_THRESHOLD = 0.5;
+  }
+});
+function approxTokenLen2(text) {
   return Math.ceil(text.length / 4);
 }
 function makeEventId(prefix) {
   return `${prefix}-${Date.now()}-${randomUUID().slice(0, 8)}`;
 }
+function classifyFetcherError(error) {
+  const msg = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  if (msg.includes("timeout") || msg.includes("timed out")) return "timeout";
+  if (msg.includes("schema") || msg.includes("invalid shape")) {
+    return "schema_mismatch";
+  }
+  if (msg.includes("io") || msg.includes("read") || msg.includes("enoent") || msg.includes("eacces")) {
+    return "io_failed";
+  }
+  return "unknown";
+}
 function formatPriorTurnLine(turn) {
   const label = turn.role === "user" ? "OPERATOR" : "CONCIERGE";
   return `${label}: ${turn.content}`;
@@ -33423,18 +34764,21 @@ function formatPriorTurnLine(turn) {
 function hashOf(input) {
   return hashToString(sha256(stringToBytes(input)));
 }
-var DEFAULT_CONCIERGE_MAX_TOKENS, DEFAULT_CONCIERGE_HISTORY_WINDOW_TURNS, DEFAULT_CONCIERGE_HISTORY_FRESHNESS_MS, DEFAULT_CONCIERGE_HISTORY_TOKEN_BUDGET, DEFAULT_CONCIERGE_SESSION_TTL_MS, SANCTUARY_DOMAIN_REFERENCE, OperatorChatService;
+var DEFAULT_CONCIERGE_MAX_TOKENS, DEFAULT_CONCIERGE_HISTORY_WINDOW_TURNS, DEFAULT_CONCIERGE_HISTORY_FRESHNESS_MS, DEFAULT_CONCIERGE_HISTORY_TOKEN_BUDGET, DEFAULT_CONCIERGE_SESSION_TTL_MS, DEFAULT_CONCIERGE_DYNAMIC_CONTEXT_BUDGET, SANCTUARY_DOMAIN_REFERENCE, OperatorChatService;
 var init_operator_chat_service = __esm({
   "src/chat/operator-chat-service.ts"() {
     init_hashing();
     init_encoding();
     init_operator_chat_audit_events();
     init_operator_chat_types();
+    init_concierge_context_router();
+    init_concierge_query_grammar();
     DEFAULT_CONCIERGE_MAX_TOKENS = 512;
     DEFAULT_CONCIERGE_HISTORY_WINDOW_TURNS = 10;
     DEFAULT_CONCIERGE_HISTORY_FRESHNESS_MS = 24 * 60 * 60 * 1e3;
     DEFAULT_CONCIERGE_HISTORY_TOKEN_BUDGET = 500;
     DEFAULT_CONCIERGE_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+    DEFAULT_CONCIERGE_DYNAMIC_CONTEXT_BUDGET = 2e3;
     SANCTUARY_DOMAIN_REFERENCE = `Castle Architecture (four enforcement layers):
 1. Castle Wall: OS-boundary egress filter enforced at the kernel level. Blocks unauthorized outbound calls even from prompt-injected agents.
 2. Sentinels: internal observation via process introspection. Surfaces anomalies to the operator; does not enforce.
@@ -33476,6 +34820,11 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
       historyTokenBudget;
       sessionTtlMs;
       clock;
+      contextFetchers;
+      contextLlmAssist;
+      dynamicContextBudget;
+      agentRegistry;
+      grammarLlmAssist;
       /**
        * In-memory thread_id assigned to the active concierge session.
        * The first sendConcierge call after construction allocates a fresh
@@ -33507,6 +34856,19 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
         this.historyTokenBudget = deps.conciergeHistoryTokenBudget !== void 0 && deps.conciergeHistoryTokenBudget > 0 ? deps.conciergeHistoryTokenBudget : DEFAULT_CONCIERGE_HISTORY_TOKEN_BUDGET;
         this.sessionTtlMs = deps.conciergeSessionTtlMs !== void 0 && deps.conciergeSessionTtlMs > 0 ? deps.conciergeSessionTtlMs : DEFAULT_CONCIERGE_SESSION_TTL_MS;
         this.clock = deps.conciergeClock ?? (() => Date.now());
+        if (deps.conciergeContextFetchers) {
+          this.contextFetchers = deps.conciergeContextFetchers;
+        }
+        if (deps.conciergeContextLlmAssist) {
+          this.contextLlmAssist = deps.conciergeContextLlmAssist;
+        }
+        this.dynamicContextBudget = deps.conciergeDynamicContextBudget !== void 0 && deps.conciergeDynamicContextBudget > 0 ? deps.conciergeDynamicContextBudget : DEFAULT_CONCIERGE_DYNAMIC_CONTEXT_BUDGET;
+        if (deps.conciergeAgentRegistry) {
+          this.agentRegistry = deps.conciergeAgentRegistry;
+        }
+        if (deps.conciergeGrammarLlmAssist) {
+          this.grammarLlmAssist = deps.conciergeGrammarLlmAssist;
+        }
       }
       // ── Concierge ─────────────────────────────────────────────────────────
       /**
@@ -33565,11 +34927,13 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           await this.memory.appendTurn(threadId, "user", trimmed).catch(() => {
           });
         }
+        const parsedGrammar = await this.runGrammarParse(filterResult.filtered);
         const start = Date.now();
         let conciergeBody;
         let servedBy = "disabled";
         let displayLabel = "Concierge: substrate not configured";
         let outcome = "substrate_disabled";
+        let dynamicCategoriesIncluded = [];
         if (!this.substrateSelector) {
           conciergeBody = "Concierge unavailable. The substrate selector is not configured for this fortress. Pick a substrate in the Policy center to enable concierge replies.";
         } else {
@@ -33581,7 +34945,15 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
               conciergeBody = "Concierge unavailable. The chosen substrate does not support summarization. Pick a different substrate in the Policy center.";
               outcome = "substrate_disabled";
             } else {
-              const context = await this.assembleConciergeContext(priorTurns);
+              const dynamicResult = await this.runDynamicContextFold(
+                filterResult.filtered,
+                parsedGrammar
+              );
+              dynamicCategoriesIncluded = dynamicResult.categoriesIncluded;
+              const context = await this.assembleConciergeContext(
+                priorTurns,
+                dynamicResult.section
+              );
               const response = await this.substrateSelector.invokeSummarize(
                 "concierge",
                 {
@@ -33645,7 +35017,9 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           ...assistantTurnId !== void 0 ? { turn_index: assistantTurnId } : {},
           ...this.memory ? {
             prior_turns_folded: memoryReadFailureReason === null ? priorTurns.length : 0
-          } : {}
+          } : {},
+          ...this.contextFetchers ? { dynamic_context_categories: [...dynamicCategoriesIncluded] } : {},
+          parsed_grammar: auditSafeSummary(parsedGrammar)
         };
         this.emit(OPERATOR_CHAT_OPS.CONCIERGE_CHAT, payload, outcome === "ok" ? "success" : "failure");
         return {
@@ -33796,10 +35170,13 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
        *   ## Sanctuary reference
        *   <static domain reference block>
        *
+       *   ## Live fortress context          ← WP-V1.3-9 Tau-3, when present
+       *   ### <Category>
+       *   <fetcher payload>
+       *
        *   ## Prior conversation             ← WP-V1.3-9 Tau-2, when present
        *   OPERATOR: ...
        *   CONCIERGE: ...
-       *   ---
        *
        *   ## Recent activity
        *   <recentActivity output>
@@ -33818,13 +35195,14 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
        * if available; the v1.2 selector does not expose one, so structured
        * serialization is the canonical path for v1.3.
        */
-      async assembleConciergeContext(priorTurns = []) {
+      async assembleConciergeContext(priorTurns = [], dynamicSection = "") {
         const ref = `## Sanctuary reference
 ${SANCTUARY_DOMAIN_REFERENCE}`;
         const priorSection = this.formatPriorTurnsSection(priorTurns);
         if (!this.contextProviders) {
           return [
             ref,
+            ...dynamicSection ? [dynamicSection] : [],
             ...priorSection ? [priorSection] : [],
             "## Recent activity\n(no providers wired)",
             "## Wrapped agents\n(no providers wired)",
@@ -33838,6 +35216,7 @@ ${SANCTUARY_DOMAIN_REFERENCE}`;
         ]);
         return [
           ref,
+          ...dynamicSection ? [dynamicSection] : [],
           ...priorSection ? [priorSection] : [],
           `## Recent activity
 ${activity}`,
@@ -33847,6 +35226,69 @@ ${agents}`,
 ${inbox}`
         ].join("\n\n");
       }
+      /**
+       * Run the WP-V1.3-9 Tau-3 dynamic-context fold for a single round-
+       * trip. Fail-soft on every axis: missing fetchers short-circuit to
+       * an empty fold, fetcher failures emit a per-category audit event
+       * and are omitted from the rendered section, an LLM-assist failure
+       * proceeds with no fold. Returns the rendered section + the list of
+       * categories whose data made it into the section (used for the
+       * round-trip audit emission).
+       *
+       * Tau-4: receives the pre-parsed `ParsedQuery` and forwards it as the
+       * `parsed` opt to `foldContext`, so fetchers see the structured
+       * `FetcherHints` derived from it.
+       */
+      async runDynamicContextFold(query, parsedGrammar) {
+        if (!this.contextFetchers) {
+          return { section: "", categoriesIncluded: [] };
+        }
+        const result = await foldContext(query, this.contextFetchers, {
+          maxTokens: this.dynamicContextBudget,
+          ...this.contextLlmAssist ? { llmAssistClassify: this.contextLlmAssist } : {},
+          onFetcherFailure: (category, error) => {
+            this.emitContextFetcherFailed(category, classifyFetcherError(error));
+          },
+          parsed: parsedGrammar
+        });
+        return result;
+      }
+      /**
+       * WP-V1.3-9 Tau-4: parse the (PII-filtered) operator query into a
+       * `ParsedQuery`. Routes through the LLM-assist completion hook when
+       * configured and the rule-based parse is below
+       * `LLM_ASSIST_THRESHOLD`. Always returns a parse object (never
+       * throws) so the audit emission can carry the result unconditionally.
+       */
+      async runGrammarParse(query) {
+        return parseQueryWithLlmAssist(query, this.grammarLlmAssist, {
+          ...this.agentRegistry !== void 0 ? { registry: this.agentRegistry } : {},
+          eventClassEnum: CANONICAL_AUDIT_EVENT_CLASSES
+        });
+      }
+      /**
+       * Emit the WP-V1.3-9 Tau-3 fetcher-failure audit event. Pulled out
+       * of the fold path so the dynamic-context handler stays readable.
+       * Emits with `result: "failure"` since the named category dropped
+       * from the rendered section for this round-trip.
+       */
+      emitContextFetcherFailed(category, failureReason) {
+        const payload = {
+          version: "1.2",
+          event_id: makeEventId("conc-ctxfail"),
+          emitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+          identity_id: this.identityId,
+          kind: "operator_concierge_context_fetcher_failed",
+          surface: "concierge",
+          category,
+          failure_reason: failureReason
+        };
+        this.emit(
+          OPERATOR_CHAT_OPS.CONCIERGE_CONTEXT_FETCHER_FAILED,
+          payload,
+          "failure"
+        );
+      }
       /**
        * Render the prior-conversation section with token-budget enforcement
        * (WP-V1.3-9 Tau-2). Drops oldest turns first when the rendered
@@ -33857,14 +35299,14 @@ ${inbox}`
         if (turns.length === 0) return "";
         const HEADER = "## Prior conversation";
         const lines = turns.map(formatPriorTurnLine);
-        const headerTokens = approxTokenLen(`${HEADER}
+        const headerTokens = approxTokenLen2(`${HEADER}
 `);
-        const sepTokens = approxTokenLen("\n");
+        const sepTokens = approxTokenLen2("\n");
         let runningTokens = headerTokens;
         let runningLines = [];
         for (let i = lines.length - 1; i >= 0; i--) {
           const line = lines[i];
-          const tokens = approxTokenLen(line) + (runningLines.length > 0 ? sepTokens : 0);
+          const tokens = approxTokenLen2(line) + (runningLines.length > 0 ? sepTokens : 0);
           if (runningTokens + tokens > this.historyTokenBudget) break;
           runningTokens += tokens;
           runningLines.push(line);
@@ -33892,7 +35334,7 @@ ${runningLines.join("\n")}`;
 function chatStorageKey(surface, threadKey) {
   return `${surface}.${threadKey}`;
 }
-var OPERATOR_CHAT_NAMESPACE, HKDF_INFO, OperatorChatStore;
+var OPERATOR_CHAT_NAMESPACE, HKDF_INFO2, OperatorChatStore;
 var init_operator_chat_store = __esm({
   "src/chat/operator-chat-store.ts"() {
     init_encryption();
@@ -33900,13 +35342,13 @@ var init_operator_chat_store = __esm({
     init_encoding();
     init_operator_chat_types();
     OPERATOR_CHAT_NAMESPACE = "_chat";
-    HKDF_INFO = "operator-chat-store-v1";
+    HKDF_INFO2 = "operator-chat-store-v1";
     OperatorChatStore = class {
       storage;
       encryptionKey;
       constructor(storage, masterKey) {
         this.storage = storage;
-        this.encryptionKey = derivePurposeKey(masterKey, HKDF_INFO);
+        this.encryptionKey = derivePurposeKey(masterKey, HKDF_INFO2);
       }
       /**
        * Load a thread. Returns null if no record exists or if the on-disk
@@ -33991,7 +35433,7 @@ var init_operator_chat_store = __esm({
 function bundleKey(threadId) {
   return `${CONCIERGE_MEMORY_KEY_PREFIX}${threadId}`;
 }
-function stripKeyPrefix(key) {
+function stripKeyPrefix2(key) {
   if (!key.startsWith(CONCIERGE_MEMORY_KEY_PREFIX)) return null;
   return key.slice(CONCIERGE_MEMORY_KEY_PREFIX.length);
 }
@@ -34002,7 +35444,7 @@ function lastTurnId(bundle) {
   }
   return max;
 }
-var CONCIERGE_MEMORY_NAMESPACE, CONCIERGE_MEMORY_KEY_PREFIX, HKDF_INFO2, DEFAULT_CONCIERGE_RETENTION_DAYS, MAX_BUNDLE_BYTES2, ConciergeMemoryStore;
+var CONCIERGE_MEMORY_NAMESPACE, CONCIERGE_MEMORY_KEY_PREFIX, HKDF_INFO3, DEFAULT_CONCIERGE_RETENTION_DAYS, MAX_BUNDLE_BYTES3, ConciergeMemoryStore;
 var init_concierge_memory_store = __esm({
   "src/chat/concierge-memory-store.ts"() {
     init_encryption();
@@ -34010,9 +35452,9 @@ var init_concierge_memory_store = __esm({
     init_encoding();
     CONCIERGE_MEMORY_NAMESPACE = "_chat";
     CONCIERGE_MEMORY_KEY_PREFIX = "concierge_memory.";
-    HKDF_INFO2 = "concierge-memory-store-v1";
+    HKDF_INFO3 = "concierge-memory-store-v1";
     DEFAULT_CONCIERGE_RETENTION_DAYS = 30;
-    MAX_BUNDLE_BYTES2 = 4 * 1024 * 1024;
+    MAX_BUNDLE_BYTES3 = 4 * 1024 * 1024;
     ConciergeMemoryStore = class {
       storage;
       encryptionKey;
@@ -34021,7 +35463,7 @@ var init_concierge_memory_store = __esm({
       locks;
       constructor(opts) {
         this.storage = opts.storage;
-        this.encryptionKey = derivePurposeKey(opts.masterKey, HKDF_INFO2);
+        this.encryptionKey = derivePurposeKey(opts.masterKey, HKDF_INFO3);
         this.fortressId = opts.fortressId;
         this.retentionDays = opts.retentionDays !== void 0 && opts.retentionDays > 0 ? opts.retentionDays : DEFAULT_CONCIERGE_RETENTION_DAYS;
         this.locks = /* @__PURE__ */ new Map();
@@ -34100,7 +35542,7 @@ var init_concierge_memory_store = __esm({
           return { ok: false, reason: "io_failed" };
         }
         if (!raw) return { ok: true, turns: [] };
-        if (raw.length > MAX_BUNDLE_BYTES2) {
+        if (raw.length > MAX_BUNDLE_BYTES3) {
           return { ok: false, reason: "oversize_bundle" };
         }
         let envelope;
@@ -34147,7 +35589,7 @@ var init_concierge_memory_store = __esm({
         );
         const summaries = [];
         for (const meta of entries) {
-          const threadId = stripKeyPrefix(meta.key);
+          const threadId = stripKeyPrefix2(meta.key);
           if (threadId === null) continue;
           const bundle = await this.loadBundle(threadId);
           if (!bundle || bundle.turns.length === 0) continue;
@@ -34200,7 +35642,7 @@ var init_concierge_memory_store = __esm({
         );
         let pruned = 0;
         for (const meta of entries) {
-          const threadId = stripKeyPrefix(meta.key);
+          const threadId = stripKeyPrefix2(meta.key);
           if (threadId === null) continue;
           pruned += await this.withLock(threadId, async () => {
             const bundle = await this.loadBundle(threadId);
@@ -34231,7 +35673,7 @@ var init_concierge_memory_store = __esm({
           return null;
         }
         if (!raw) return null;
-        if (raw.length > MAX_BUNDLE_BYTES2) return null;
+        if (raw.length > MAX_BUNDLE_BYTES3) return null;
         try {
           const envelope = JSON.parse(bytesToString(raw));
           const aad = stringToBytes(threadId);
@@ -34322,7 +35764,18 @@ function buildV11Bindings(inputs) {
         registry
       }),
       conciergePiiFilter: buildConciergePiiFilter(),
-      conciergeMemory
+      conciergeMemory,
+      conciergeContextFetchers: buildConciergeContextFetchers({
+        auditLog: inputs.auditLog,
+        identityId: inputs.identityId,
+        registry
+      }),
+      ...inputs.intelligenceSelector ? {
+        conciergeContextLlmAssist: buildConciergeContextLlmAssist({
+          selector: inputs.intelligenceSelector,
+          identityId: inputs.identityId
+        })
+      } : {}
     });
   }
   const hubService = new HubService({
@@ -34383,6 +35836,107 @@ function buildConciergeContextProviders(args) {
     }
   };
 }
+function buildConciergeContextFetchers(args) {
+  const empty = async () => "";
+  return {
+    templates: async () => {
+      const entries = listTemplates();
+      if (entries.length === 0) return "(no templates installed)";
+      const lines = entries.map((e) => {
+        const m = e.metadata;
+        return `${m.name} (tier ${m.tier}, channel ${m.channel}, target ${m.target_archetype})`;
+      });
+      return lines.join("\n");
+    },
+    agent_state: async (agentNameHint) => {
+      const records = args.registry.list({ identity_id: args.identityId });
+      if (records.length === 0) return "(no wrapped agents)";
+      const filtered = agentNameHint ? records.filter(
+        (r) => r.agent_id.toLowerCase().includes(agentNameHint.toLowerCase()) || r.harness.toLowerCase().includes(agentNameHint.toLowerCase())
+      ) : records;
+      const target = filtered.length > 0 ? filtered : records;
+      const lines = target.slice(0, 20).map((r) => {
+        const tmpl = typeof r.channel_template_id === "string" ? r.channel_template_id : "no_template";
+        return `${r.agent_id}  harness=${r.harness}  status=${r.status}  template=${tmpl}`;
+      });
+      return lines.join("\n");
+    },
+    agent_activity: async (agentNameHint) => {
+      const result = await args.auditLog.query({ limit: 50 });
+      const owned = result.entries.filter(
+        (e) => e.identity_id === args.identityId
+      );
+      const filtered = agentNameHint ? owned.filter((e) => {
+        const agentId = e.details && typeof e.details["agent_id"] === "string" ? e.details["agent_id"] : "";
+        return agentId.toLowerCase().includes(agentNameHint.toLowerCase());
+      }) : owned;
+      const tail = (filtered.length > 0 ? filtered : owned).slice(-20);
+      if (tail.length === 0) return "(no activity)";
+      return tail.map((e) => {
+        const agentId = (e.details && typeof e.details["agent_id"] === "string" ? e.details["agent_id"] : null) ?? "_fortress";
+        return `${e.timestamp}  ${e.layer}.${e.operation}  agent=${agentId}  result=${e.result}`;
+      }).join("\n");
+    },
+    audit_log: async () => {
+      const result = await args.auditLog.query({ limit: 30 });
+      const owned = result.entries.filter(
+        (e) => e.identity_id === args.identityId
+      );
+      if (owned.length === 0) return "(no audit log entries)";
+      return owned.slice(-30).map(
+        (e) => `${e.timestamp}  ${e.layer}.${e.operation}  result=${e.result}`
+      ).join("\n");
+    },
+    sentinel_findings: empty,
+    anomaly_alerts: empty,
+    recent_receipts: async () => {
+      const result = await args.auditLog.query({ limit: 100 });
+      const owned = result.entries.filter(
+        (e) => e.identity_id === args.identityId && e.operation.startsWith("composition_")
+      );
+      if (owned.length === 0) return "(no recent composition events)";
+      return owned.slice(-15).map((e) => `${e.timestamp}  ${e.operation}  result=${e.result}`).join("\n");
+    },
+    verascore_deltas: empty
+  };
+}
+function buildConciergeContextLlmAssist(args) {
+  return async (query, categories) => {
+    const labelList = categories.map((c) => `- ${c}`).join("\n");
+    const prompt2 = `You are a router. Classify the operator's query into one of the categories below or "none".
+Reply with exactly one token: one category name or "none".
+
+Categories:
+${labelList}
+
+Query: ${query}
+
+Category:`;
+    try {
+      const handle = await args.selector.getSubstrate("concierge");
+      if (!handle.capability.summarize) return "none";
+      const response = await args.selector.invokeSummarize("concierge", {
+        kind: "summarize",
+        context: prompt2,
+        query: "Output the single category token.",
+        maxTokens: 16
+      });
+      if (response.failureClass || response.body.kind !== "summarize") {
+        return "none";
+      }
+      const raw = response.body.text.trim().toLowerCase();
+      const head = raw.split(/\s|[.,!?:;]/)[0] ?? "";
+      const normalized = head.replace(/[^a-z_]/g, "");
+      const known = categories;
+      if (known.includes(normalized)) {
+        return normalized;
+      }
+      return "none";
+    } catch {
+      return "none";
+    }
+  };
+}
 function buildConciergePiiFilter() {
   return {
     filter(input) {
@@ -34410,6 +35964,7 @@ var init_wiring = __esm({
     init_agent_registry_persistence();
     init_operator_chat_index();
     init_privacy_filter();
+    init_registry();
     CapabilityErrorAgentController = class {
       fail(action) {
         throw new HubCapabilityError(
@@ -34557,7 +36112,7 @@ var init_defaults = __esm({
 });
 
 // src/intelligence/policy-store.ts
-var INTELLIGENCE_NAMESPACE, SUBSTRATE_CONFIG_KEY, HKDF_INFO3, IntelligenceConfigStore;
+var INTELLIGENCE_NAMESPACE, SUBSTRATE_CONFIG_KEY, HKDF_INFO4, IntelligenceConfigStore;
 var init_policy_store = __esm({
   "src/intelligence/policy-store.ts"() {
     init_encryption();
@@ -34566,13 +36121,13 @@ var init_policy_store = __esm({
     init_defaults();
     INTELLIGENCE_NAMESPACE = "_intelligence";
     SUBSTRATE_CONFIG_KEY = "substrate-config";
-    HKDF_INFO3 = "intelligence-substrate-config";
+    HKDF_INFO4 = "intelligence-substrate-config";
     IntelligenceConfigStore = class {
       storage;
       encryptionKey;
       constructor(storage, masterKey) {
         this.storage = storage;
-        this.encryptionKey = derivePurposeKey(masterKey, HKDF_INFO3);
+        this.encryptionKey = derivePurposeKey(masterKey, HKDF_INFO4);
       }
       /**
        * Load the operator's substrate config from disk. Returns the config
@@ -36222,7 +37777,7 @@ var init_memory = __esm({
 
 // src/contracts/v1.1/constants.ts
 var SIGNATURE_SCHEME_V12, EXIT_BUNDLE_MANIFEST_VERSION, EXIT_BUNDLE_ARTIFACT_KINDS;
-var init_constants4 = __esm({
+var init_constants5 = __esm({
   "src/contracts/v1.1/constants.ts"() {
     SIGNATURE_SCHEME_V12 = "ed25519-v1";
     EXIT_BUNDLE_MANIFEST_VERSION = "SANCTUARY_EXIT_BUNDLE_V1";
@@ -36640,7 +38195,7 @@ async function verifyExitBundle(bundleDir, options = {}) {
 var InvalidExitBundleError, PRIVATE_MATERIAL_KEYS;
 var init_verifier2 = __esm({
   "src/exit/verifier.ts"() {
-    init_constants4();
+    init_constants5();
     init_exit_bundle_manifest();
     init_encoding();
     init_hashing();
@@ -37452,7 +39007,7 @@ var init_bundle = __esm({
   "src/exit/bundle.ts"() {
     init_state_store();
     init_config();
-    init_constants4();
+    init_constants5();
     init_canonical_json();
     init_hashing();
     init_encoding();
@@ -38490,12 +40045,18 @@ ${err.message}
   } : void 0;
   const fortressIdForAggregator = fortressIdFromStoragePath(config.storage_path);
   const aggregatorIdentityId = identityManager.getPrimaryIdentityId() ?? `fortress:${config.storage_path}`;
+  const aggregatorPayloadStore = new AggregatorPayloadStore({
+    storage,
+    masterKey,
+    fortressId: fortressIdForAggregator
+  });
   const approvalAggregator = new ApprovalAggregator({
     storage,
     masterKey,
     auditLog,
     identityId: aggregatorIdentityId,
-    fortressId: fortressIdForAggregator
+    fortressId: fortressIdForAggregator,
+    payloadStore: aggregatorPayloadStore
   });
   const wrappedApprovalChannel = new AggregatorBackedChannel({
     underlying: approvalChannel,
@@ -38709,6 +40270,7 @@ var init_src = __esm({
     init_gate();
     init_approval_aggregator();
     init_aggregator_backed_channel();
+    init_aggregator_store();
     init_tools4();
     init_router();
     init_router();