@sanctuary-framework/mcp-server 1.2.4 → 1.2.5

package/dist/cli.cjs

@@ -4457,9 +4457,35 @@ function validatePolicy(raw) {
       };
       delete merged.auto_deny;
       return merged;
-    })()
+    })(),
+    approval_redirect: parseApprovalRedirect(raw.approval_redirect)
   };
 }
+function parseApprovalRedirect(raw) {
+  if (raw === void 0 || raw === null) {
+    return { ...DEFAULT_APPROVAL_REDIRECT };
+  }
+  if (typeof raw !== "object") {
+    return { ...DEFAULT_APPROVAL_REDIRECT };
+  }
+  const obj = raw;
+  const enabled = typeof obj.enabled === "boolean" ? obj.enabled : DEFAULT_APPROVAL_REDIRECT.enabled;
+  const modeRaw = obj.mode;
+  let mode = DEFAULT_APPROVAL_REDIRECT.mode;
+  if (modeRaw !== void 0) {
+    if (modeRaw !== "replace" && modeRaw !== "notify") {
+      throw new Error(
+        `approval_redirect.mode must be "replace" or "notify" (got ${JSON.stringify(modeRaw)})`
+      );
+    }
+    mode = modeRaw;
+  }
+  const result = { enabled, mode };
+  if (obj.per_agent !== void 0 && typeof obj.per_agent === "object" && obj.per_agent !== null) {
+    result.per_agent = obj.per_agent;
+  }
+  return result;
+}
 function generateDefaultPolicyYaml() {
   return `# Sanctuary Principal Policy v1
 # This file controls what your agent can do without asking.
@@ -4538,6 +4564,7 @@ tier3_always_allow:
   - handshake_status
   - handshake_exchange
   - handshake_verify_attestation
+  - handshake_abort
   - reputation_query_weighted
   - federation_peers
   - federation_trust_evaluate
@@ -4572,6 +4599,21 @@ tier3_always_allow:
 approval_channel:
   type: stderr
   timeout_seconds: 300
+
+# \u2500\u2500\u2500 Approval Redirect (v1.3 WP-V1.3-10 Upsilon-2) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# Cross-harness approval-inbox redirect. When enabled, Tier 1/2 approvals
+# resolve via the unified approval inbox at /api/approval-inbox/* instead
+# of (or in addition to) the configured approval_channel above.
+#
+# mode:
+#   replace: bypass the approval_channel entirely; the gate awaits a
+#            decision from the inbox (default once enabled).
+#   notify:  fire BOTH the approval_channel and the inbox; first decision
+#            wins. Right shape for harnesses that cannot fully suppress
+#            their local approval prompt (e.g. Mastra-class).
+approval_redirect:
+  enabled: false
+  mode: replace
 `;
 }
 async function loadPrincipalPolicy(storagePath) {
@@ -4608,7 +4650,7 @@ async function loadPrincipalPolicy(storagePath) {
     );
   }
 }
-var DEFAULT_TIER2, DEFAULT_CHANNEL, DEFAULT_POLICY, MalformedPrincipalPolicyError;
+var DEFAULT_TIER2, DEFAULT_CHANNEL, DEFAULT_APPROVAL_REDIRECT, DEFAULT_POLICY, MalformedPrincipalPolicyError;
 var init_loader = __esm({
   "src/principal-policy/loader.ts"() {
     DEFAULT_TIER2 = {
@@ -4625,6 +4667,10 @@ var init_loader = __esm({
       // SEC-002: auto_deny is not configurable. Timeout always denies.
       // Field omitted intentionally — all channels hardcode deny on timeout.
     };
+    DEFAULT_APPROVAL_REDIRECT = {
+      enabled: false,
+      mode: "replace"
+    };
     DEFAULT_POLICY = {
       version: 1,
       tier1_always_approve: [
@@ -4698,6 +4744,7 @@ var init_loader = __esm({
         "handshake_status",
         "handshake_exchange",
         "handshake_verify_attestation",
+        "handshake_abort",
         "reputation_query_weighted",
         "federation_peers",
         "federation_trust_evaluate",
@@ -4739,7 +4786,8 @@ var init_loader = __esm({
         "compliance_eu_ai_act_annex_iii_classify"
         // Read-only; rule-based Annex III classifier
       ],
-      approval_channel: DEFAULT_CHANNEL
+      approval_channel: DEFAULT_CHANNEL,
+      approval_redirect: DEFAULT_APPROVAL_REDIRECT
     };
     MalformedPrincipalPolicyError = class extends Error {
       constructor(policyPath, reason) {
@@ -20570,6 +20618,174 @@ var init_approval_aggregator = __esm({
   }
 });
 
+// src/principal-policy/channels/aggregator-backed-channel.ts
+function auditEntryIdFor(request) {
+  return `${request.timestamp}:${request.operation}`;
+}
+function statusToDecision(entry) {
+  switch (entry.status) {
+    case "approved":
+      return {
+        decision: "approve",
+        decided_by: "human"
+      };
+    case "denied":
+      return {
+        decision: "deny",
+        decided_by: "human"
+      };
+    case "timeout":
+    case "expired":
+      return {
+        decision: "deny",
+        decided_by: "timeout"
+      };
+    default:
+      return null;
+  }
+}
+function makeRedirectResolverFromPolicySupplier(supplier) {
+  return (_request) => {
+    const cfg = supplier().approval_redirect;
+    if (!cfg || cfg.enabled !== true) {
+      return { enabled: false, mode: "replace" };
+    }
+    return {
+      enabled: true,
+      mode: cfg.mode === "notify" ? "notify" : "replace"
+    };
+  };
+}
+var DEFAULT_REPLACE_MODE_TIMEOUT_MS, AggregatorBackedChannel;
+var init_aggregator_backed_channel = __esm({
+  "src/principal-policy/channels/aggregator-backed-channel.ts"() {
+    DEFAULT_REPLACE_MODE_TIMEOUT_MS = 5 * 60 * 1e3;
+    AggregatorBackedChannel = class {
+      underlying;
+      aggregator;
+      resolveRedirect;
+      replaceModeTimeoutMs;
+      now;
+      constructor(opts) {
+        this.underlying = opts.underlying;
+        this.aggregator = opts.aggregator;
+        this.resolveRedirect = opts.resolveRedirect;
+        this.replaceModeTimeoutMs = opts.replaceModeTimeoutMs ?? DEFAULT_REPLACE_MODE_TIMEOUT_MS;
+        this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+      }
+      /** Expose underlying for tests / wire-up reuse. */
+      getUnderlying() {
+        return this.underlying;
+      }
+      async requestApproval(request) {
+        const cfg = this.resolveRedirect(request);
+        if (!cfg.enabled) {
+          return this.underlying.requestApproval(request);
+        }
+        if (cfg.mode === "replace") {
+          return this.awaitAggregatorDecision(request);
+        }
+        return this.notifyMode(request);
+      }
+      /**
+       * `replace` mode. Subscribe to the aggregator's event stream BEFORE
+       * checking already-stored entries (avoids a race where the entry resolves
+       * between list and subscribe). Match incoming events to this request by
+       * audit_entry_id. Time out after `replaceModeTimeoutMs` to honor SEC-002.
+       */
+      async awaitAggregatorDecision(request) {
+        const auditId = auditEntryIdFor(request);
+        return new Promise((resolveOuter) => {
+          let settled = false;
+          let unsubscribe = null;
+          let timeoutHandle = null;
+          const settle = (response) => {
+            if (settled) return;
+            settled = true;
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+            if (unsubscribe) {
+              try {
+                unsubscribe();
+              } catch {
+              }
+            }
+            resolveOuter(response);
+          };
+          const onEvent = (emit) => {
+            if (emit.type !== "resolved") return;
+            if (emit.entry.audit_log_entry_id !== auditId) return;
+            const mapped = statusToDecision(emit.entry);
+            if (!mapped) return;
+            settle({
+              decision: mapped.decision,
+              decided_at: emit.entry.resolved_at ?? this.now().toISOString(),
+              decided_by: mapped.decided_by
+            });
+          };
+          try {
+            unsubscribe = this.aggregator.onEvent(onEvent);
+          } catch (err) {
+            settle({
+              decision: "deny",
+              decided_at: this.now().toISOString(),
+              decided_by: "channel_failure"
+            });
+            throw err instanceof Error ? err : new Error(String(err));
+          }
+          void this.aggregator.list({ limit: 200 }).then((entries) => {
+            for (const entry of entries) {
+              if (entry.audit_log_entry_id !== auditId) continue;
+              const mapped = statusToDecision(entry);
+              if (!mapped) return;
+              settle({
+                decision: mapped.decision,
+                decided_at: entry.resolved_at ?? this.now().toISOString(),
+                decided_by: mapped.decided_by
+              });
+              return;
+            }
+          }).catch(() => {
+          });
+          timeoutHandle = setTimeout(() => {
+            settle({
+              decision: "deny",
+              decided_at: this.now().toISOString(),
+              decided_by: "timeout"
+            });
+          }, this.replaceModeTimeoutMs);
+        });
+      }
+      /**
+       * `notify` mode. Fire the underlying channel and listen on the
+       * aggregator simultaneously; whichever resolves first wins. Both
+       * paths produce identical `ApprovalResponse` shapes; the gate's
+       * downstream audit logging is unchanged.
+       *
+       * On underlying-channel failure, fall through to the aggregator wait
+       * (still bounded by `replaceModeTimeoutMs`). Operator can still
+       * resolve from the inbox even if the dashboard/webhook is down.
+       */
+      async notifyMode(request) {
+        const aggregatorPromise = this.awaitAggregatorDecision(request);
+        let underlyingPromise;
+        try {
+          underlyingPromise = this.underlying.requestApproval(request);
+        } catch (err) {
+          const response = await aggregatorPromise;
+          return response;
+        }
+        return Promise.race([
+          aggregatorPromise,
+          underlyingPromise.catch(
+            () => new Promise(() => {
+            })
+          )
+        ]);
+      }
+    };
+  }
+});
+
 // src/principal-policy/tools.ts
 function createPrincipalPolicyTools(policy, baseline, auditLog) {
   return [
@@ -21473,6 +21689,76 @@ var init_attestation = __esm({
   }
 });
 
+// src/handshake/audit.ts
+function auditHandshakeInitiated(auditLog, ctx) {
+  auditLog.append(
+    "l4",
+    HANDSHAKE_LIFECYCLE_OPS.INITIATED,
+    ctx.identity_id,
+    detailsFromContext(ctx),
+    "success"
+  );
+}
+function auditHandshakeCompleted(auditLog, ctx) {
+  const details = detailsFromContext(ctx);
+  if (ctx.trust_tier !== void 0) {
+    details.trust_tier = ctx.trust_tier;
+  }
+  auditLog.append(
+    "l4",
+    HANDSHAKE_LIFECYCLE_OPS.COMPLETED,
+    ctx.identity_id,
+    details,
+    "success"
+  );
+}
+function auditHandshakeFailed(auditLog, ctx) {
+  const details = detailsFromContext(ctx);
+  details.reason = ctx.reason;
+  if (ctx.error !== void 0) {
+    details.error = ctx.error;
+  }
+  auditLog.append(
+    "l4",
+    HANDSHAKE_LIFECYCLE_OPS.FAILED,
+    ctx.identity_id,
+    details,
+    "failure"
+  );
+}
+function auditHandshakeAborted(auditLog, ctx) {
+  const details = detailsFromContext(ctx);
+  details.reason = ctx.reason;
+  auditLog.append(
+    "l4",
+    HANDSHAKE_LIFECYCLE_OPS.ABORTED,
+    ctx.identity_id,
+    details,
+    "failure"
+  );
+}
+function detailsFromContext(ctx) {
+  const details = {
+    session_id: ctx.session_id,
+    role: ctx.role
+  };
+  if (ctx.counterparty_id !== void 0) {
+    details.counterparty_id = ctx.counterparty_id;
+  }
+  return details;
+}
+var HANDSHAKE_LIFECYCLE_OPS;
+var init_audit = __esm({
+  "src/handshake/audit.ts"() {
+    HANDSHAKE_LIFECYCLE_OPS = {
+      INITIATED: "handshake_initiated",
+      COMPLETED: "handshake_completed",
+      FAILED: "handshake_failed",
+      ABORTED: "handshake_aborted"
+    };
+  }
+});
+
 // src/handshake/tools.ts
 function createHandshakeTools(config, identityManager, masterKey, auditLog, options) {
   const autoPublishHandshakes = options?.autoPublishHandshakes ?? false;
@@ -21506,6 +21792,11 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
         const { challenge, session } = initiateHandshake(shr);
         sessions.set(session.session_id, session);
         auditLog.append("l4", "handshake_initiate", shr.body.instance_id);
+        auditHandshakeInitiated(auditLog, {
+          session_id: session.session_id,
+          role: "initiator",
+          identity_id: shr.body.instance_id
+        });
         return toolResult({
           session_id: session.session_id,
           challenge,
@@ -21545,10 +21836,23 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
         );
         if ("error" in result) {
           auditLog.append("l4", "handshake_respond", shr.body.instance_id, void 0, "failure");
+          auditHandshakeFailed(auditLog, {
+            session_id: "unknown",
+            role: "responder",
+            identity_id: shr.body.instance_id,
+            reason: classifyRespondFailure(result.error),
+            error: result.error
+          });
           return toolResult({ error: result.error });
         }
         sessions.set(result.session.session_id, result.session);
         auditLog.append("l4", "handshake_respond", shr.body.instance_id);
+        auditHandshakeInitiated(auditLog, {
+          session_id: result.session.session_id,
+          role: "responder",
+          identity_id: shr.body.instance_id,
+          counterparty_id: challenge.shr.body.instance_id
+        });
         let autoPublishResult;
         if (autoPublishHandshakes) {
           autoPublishResult = { attempted: true };
@@ -21656,9 +21960,23 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
         const response = args.response;
         const session = sessions.get(sessionId);
         if (!session) {
+          auditHandshakeFailed(auditLog, {
+            session_id: sessionId,
+            role: "initiator",
+            identity_id: "unknown",
+            reason: "session_unknown",
+            error: `No handshake session found: ${sessionId}`
+          });
           return toolResult({ error: `No handshake session found: ${sessionId}` });
         }
         if (session.state !== "initiated") {
+          auditHandshakeFailed(auditLog, {
+            session_id: sessionId,
+            role: "initiator",
+            identity_id: session.our_shr.body.instance_id,
+            reason: "session_state_mismatch",
+            error: `Session is in state '${session.state}', expected 'initiated'`
+          });
           return toolResult({
             error: `Session is in state '${session.state}', expected 'initiated'`
           });
@@ -21672,6 +21990,13 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
         if ("error" in result) {
           session.state = "failed";
           auditLog.append("l4", "handshake_complete", session.our_shr.body.instance_id, void 0, "failure");
+          auditHandshakeFailed(auditLog, {
+            session_id: sessionId,
+            role: "initiator",
+            identity_id: session.our_shr.body.instance_id,
+            reason: classifyCompleteFailure(result.error),
+            error: result.error
+          });
           return toolResult({ error: result.error });
         }
         session.state = "completed";
@@ -21680,6 +22005,13 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
         session.result = result.result;
         handshakeResults.set(result.result.counterparty_id, result.result);
         auditLog.append("l4", "handshake_complete", session.our_shr.body.instance_id);
+        auditHandshakeCompleted(auditLog, {
+          session_id: sessionId,
+          role: "initiator",
+          identity_id: session.our_shr.body.instance_id,
+          counterparty_id: result.result.counterparty_id,
+          trust_tier: result.result.trust_tier
+        });
         return toolResult({
           completion: result.completion,
           result: result.result,
@@ -21727,6 +22059,24 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
             void 0,
             result.verified ? "success" : "failure"
           );
+          if (result.verified) {
+            auditHandshakeCompleted(auditLog, {
+              session_id: session.session_id,
+              role: "responder",
+              identity_id: session.our_shr.body.instance_id,
+              counterparty_id: result.counterparty_id,
+              trust_tier: result.trust_tier
+            });
+          } else {
+            auditHandshakeFailed(auditLog, {
+              session_id: session.session_id,
+              role: "responder",
+              identity_id: session.our_shr.body.instance_id,
+              counterparty_id: result.counterparty_id,
+              reason: classifyCompleteFailure(result.errors.join("; ")),
+              error: result.errors.join("; ")
+            });
+          }
           return toolResult({ result });
         }
         return toolResult({
@@ -21834,10 +22184,74 @@ function createHandshakeTools(config, identityManager, masterKey, auditLog, opti
           _content_trust: "external"
         });
       }
+    },
+    {
+      name: "handshake_abort",
+      description: "Abort an in-flight handshake session. Drops the session record and appends a session-lifecycle audit entry (handshake_aborted) so the operator can distinguish operator-cancelled, timed-out, and dropped sessions from sessions that simply fell off the protocol path.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          session_id: {
+            type: "string",
+            description: "Session ID returned from handshake_initiate / handshake_respond."
+          },
+          reason: {
+            type: "string",
+            enum: [
+              "operator_cancelled",
+              "session_timeout",
+              "transport_dropped",
+              "shutdown",
+              "other"
+            ],
+            description: "Why the session is being aborted. Defaults to 'operator_cancelled'."
+          }
+        },
+        required: ["session_id"]
+      },
+      handler: async (args) => {
+        const sessionId = args.session_id;
+        const reason = args.reason ?? "operator_cancelled";
+        const session = sessions.get(sessionId);
+        if (!session) {
+          return toolResult({ error: `No handshake session found: ${sessionId}` });
+        }
+        if (session.state === "completed") {
+          return toolResult({
+            error: `Session ${sessionId} already completed; abort is only valid for in-flight sessions`
+          });
+        }
+        sessions.delete(sessionId);
+        auditHandshakeAborted(auditLog, {
+          session_id: sessionId,
+          role: session.role,
+          identity_id: session.our_shr.body.instance_id,
+          ...session.their_shr ? { counterparty_id: session.their_shr.body.instance_id } : {},
+          reason
+        });
+        return toolResult({
+          aborted: true,
+          session_id: sessionId,
+          reason
+        });
+      }
     }
   ];
   return { tools, handshakeResults };
 }
+function classifyRespondFailure(error) {
+  if (error.includes("Unsupported protocol version")) return "protocol_version_unsupported";
+  if (error.includes("SHR verification failed")) return "shr_invalid";
+  if (error.includes("No identity available")) return "no_signing_identity";
+  return "other";
+}
+function classifyCompleteFailure(error) {
+  if (error.includes("Unsupported protocol version")) return "protocol_version_unsupported";
+  if (error.includes("SHR verification failed") || error.includes("SHR")) return "shr_invalid";
+  if (error.includes("nonce signature is invalid")) return "nonce_signature_invalid";
+  if (error.includes("No identity available")) return "no_signing_identity";
+  return "other";
+}
 var init_tools6 = __esm({
   "src/handshake/tools.ts"() {
     init_router();
@@ -21847,6 +22261,7 @@ var init_tools6 = __esm({
     init_encoding();
     init_protocol();
     init_attestation();
+    init_audit();
     init_verifier();
   }
 });
@@ -32982,7 +33397,14 @@ var init_operator_chat_audit_events = __esm({
        * successful thread removal. Body carries thread_id + turn_count of
        * the deleted bundle.
        */
-      CONCIERGE_THREAD_DELETED: "operator_concierge_thread_deleted"
+      CONCIERGE_THREAD_DELETED: "operator_concierge_thread_deleted",
+      /**
+       * Concierge memory fold-read failed (WP-V1.3-9 Tau-2). Emitted when
+       * the multi-turn coherence fold cannot load the active thread's prior
+       * 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"
     };
   }
 });
@@ -32995,13 +33417,20 @@ var init_operator_chat_types = __esm({
     CONCIERGE_THREAD_KEY = "_fortress";
   }
 });
+function approxTokenLen(text) {
+  return Math.ceil(text.length / 4);
+}
 function makeEventId(prefix) {
   return `${prefix}-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
 }
+function formatPriorTurnLine(turn) {
+  const label = turn.role === "user" ? "OPERATOR" : "CONCIERGE";
+  return `${label}: ${turn.content}`;
+}
 function hashOf(input) {
   return hashToString(sha256.sha256(stringToBytes(input)));
 }
-var DEFAULT_CONCIERGE_MAX_TOKENS, 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, SANCTUARY_DOMAIN_REFERENCE, OperatorChatService;
 var init_operator_chat_service = __esm({
   "src/chat/operator-chat-service.ts"() {
     init_hashing();
@@ -33009,6 +33438,10 @@ var init_operator_chat_service = __esm({
     init_operator_chat_audit_events();
     init_operator_chat_types();
     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;
     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.
@@ -33045,6 +33478,11 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
       piiFilter;
       conciergeMaxTokens;
       memory;
+      historyWindowTurns;
+      historyFreshnessMs;
+      historyTokenBudget;
+      sessionTtlMs;
+      clock;
       /**
        * In-memory thread_id assigned to the active concierge session.
        * The first sendConcierge call after construction allocates a fresh
@@ -33052,6 +33490,14 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
        * folds the prior turns into context. Cleared by `resetConciergeMemoryThread`.
        */
       activeMemoryThreadId;
+      /**
+       * Wall-clock ms of the most recent sendConcierge that touched the
+       * active session thread. Drives the WP-V1.3-9 Tau-2 session-TTL
+       * check: a fresh sendConcierge after `sessionTtlMs` of quiet
+       * allocates a new thread_id even though the prior one is still
+       * readable from the memory store.
+       */
+      lastInteractionAt;
       constructor(deps) {
         this.store = deps.store;
         this.auditLog = deps.auditLog;
@@ -33063,6 +33509,11 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
         if (deps.conciergePiiFilter) this.piiFilter = deps.conciergePiiFilter;
         this.conciergeMaxTokens = deps.conciergeMaxTokens ?? DEFAULT_CONCIERGE_MAX_TOKENS;
         if (deps.conciergeMemory) this.memory = deps.conciergeMemory;
+        this.historyWindowTurns = deps.conciergeHistoryWindowTurns !== void 0 && deps.conciergeHistoryWindowTurns > 0 ? deps.conciergeHistoryWindowTurns : DEFAULT_CONCIERGE_HISTORY_WINDOW_TURNS;
+        this.historyFreshnessMs = deps.conciergeHistoryFreshnessMs !== void 0 && deps.conciergeHistoryFreshnessMs > 0 ? deps.conciergeHistoryFreshnessMs : DEFAULT_CONCIERGE_HISTORY_FRESHNESS_MS;
+        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());
       }
       // ── Concierge ─────────────────────────────────────────────────────────
       /**
@@ -33081,6 +33532,10 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           throw new Error("concierge query must not be empty");
         }
         const filterResult = this.piiFilter ? this.piiFilter.filter(trimmed) : { filtered: trimmed, redactions: 0 };
+        const nowMs = this.clock();
+        if (this.activeMemoryThreadId && this.lastInteractionAt !== void 0 && nowMs - this.lastInteractionAt > this.sessionTtlMs) {
+          this.activeMemoryThreadId = void 0;
+        }
         const operatorMessage = {
           message_id: crypto.randomUUID(),
           surface: "concierge",
@@ -33093,6 +33548,25 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           CONCIERGE_THREAD_KEY,
           operatorMessage
         );
+        let priorTurns = [];
+        let memoryReadFailureReason = null;
+        let activeThreadIdForRound;
+        if (this.memory) {
+          activeThreadIdForRound = this.ensureActiveMemoryThread();
+          const result = await this.memory.readThreadStrict(activeThreadIdForRound).catch(() => ({ ok: false, reason: "io_failed" }));
+          if (result.ok) {
+            const cutoff = nowMs - this.historyFreshnessMs;
+            const fresh = result.turns.filter((t) => {
+              const ts = Date.parse(t.created_at);
+              return Number.isFinite(ts) && ts >= cutoff;
+            });
+            const recent = fresh.length > this.historyWindowTurns ? fresh.slice(fresh.length - this.historyWindowTurns) : fresh;
+            priorTurns = recent;
+          } else {
+            memoryReadFailureReason = result.reason;
+            this.emitMemoryReadFailed(activeThreadIdForRound, result.reason);
+          }
+        }
         if (this.memory) {
           const threadId = this.ensureActiveMemoryThread();
           await this.memory.appendTurn(threadId, "user", trimmed).catch(() => {
@@ -33114,7 +33588,7 @@ 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();
+              const context = await this.assembleConciergeContext(priorTurns);
               const response = await this.substrateSelector.invokeSummarize(
                 "concierge",
                 {
@@ -33153,10 +33627,14 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           CONCIERGE_THREAD_KEY,
           responseMessage
         );
+        let assistantTurnId;
         if (this.memory) {
           const threadId = this.ensureActiveMemoryThread();
-          await this.memory.appendTurn(threadId, "assistant", conciergeBody).catch(() => {
-          });
+          const persisted = await this.memory.appendTurn(threadId, "assistant", conciergeBody).catch(() => void 0);
+          if (persisted) assistantTurnId = persisted.turn_id;
+        }
+        if (this.memory && activeThreadIdForRound) {
+          this.lastInteractionAt = nowMs;
         }
         const payload = {
           version: "1.2",
@@ -33169,7 +33647,12 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           response_hash: outcome === "ok" ? hashOf(conciergeBody) : null,
           substrate: servedBy,
           latency_ms: latencyMs,
-          outcome
+          outcome,
+          ...activeThreadIdForRound !== void 0 ? { thread_id: activeThreadIdForRound } : {},
+          ...assistantTurnId !== void 0 ? { turn_index: assistantTurnId } : {},
+          ...this.memory ? {
+            prior_turns_folded: memoryReadFailureReason === null ? priorTurns.length : 0
+          } : {}
         };
         this.emit(OPERATOR_CHAT_OPS.CONCIERGE_CHAT, payload, outcome === "ok" ? "success" : "failure");
         return {
@@ -33179,6 +33662,25 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
           outcome
         };
       }
+      /**
+       * Emit the WP-V1.3-9 Tau-2 graceful-degradation audit event. Pulled
+       * out of `sendConcierge` so the read-fold path stays readable. Emits
+       * with `result: "failure"` since the concierge fell back to
+       * single-turn mode for this round-trip.
+       */
+      emitMemoryReadFailed(threadId, reason) {
+        const payload = {
+          version: "1.2",
+          event_id: makeEventId("conc-memfail"),
+          emitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+          identity_id: this.identityId,
+          kind: "operator_concierge_memory_read_failed",
+          surface: "concierge",
+          thread_id: threadId,
+          failure_reason: reason
+        };
+        this.emit(OPERATOR_CHAT_OPS.CONCIERGE_MEMORY_READ_FAILED, payload, "failure");
+      }
       /**
        * Read the persisted concierge thread, oldest message first. Returns
        * an empty array when no thread exists yet.
@@ -33301,6 +33803,11 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
        *   ## Sanctuary reference
        *   <static domain reference block>
        *
+       *   ## Prior conversation             ← WP-V1.3-9 Tau-2, when present
+       *   OPERATOR: ...
+       *   CONCIERGE: ...
+       *   ---
+       *
        *   ## Recent activity
        *   <recentActivity output>
        *
@@ -33310,37 +33817,69 @@ Note: this is a static reference block (v1.2.x). Dynamic context injection (live
        *   ## Open inbox
        *   <openInbox output>
        *   ```
-       */
-      async assembleConciergeContext() {
+       *
+       * The substrate selector ships a `context: string` shape (not a
+       * messages array), so multi-turn coherence is folded as a structured
+       * prior-conversation section with explicit OPERATOR / CONCIERGE
+       * boundaries. Coordinator-CTO guidance: prefer messages-array shape
+       * if available; the v1.2 selector does not expose one, so structured
+       * serialization is the canonical path for v1.3.
+       */
+      async assembleConciergeContext(priorTurns = []) {
         const ref = `## Sanctuary reference
 ${SANCTUARY_DOMAIN_REFERENCE}`;
+        const priorSection = this.formatPriorTurnsSection(priorTurns);
         if (!this.contextProviders) {
-          return `${ref}
-
-## Recent activity
-(no providers wired)
-
-## Wrapped agents
-(no providers wired)
-
-## Open inbox
-(no providers wired)`;
+          return [
+            ref,
+            ...priorSection ? [priorSection] : [],
+            "## Recent activity\n(no providers wired)",
+            "## Wrapped agents\n(no providers wired)",
+            "## Open inbox\n(no providers wired)"
+          ].join("\n\n");
         }
         const [activity, agents, inbox] = await Promise.all([
           this.contextProviders.recentActivity(),
           this.contextProviders.agentInventory(),
           this.contextProviders.openInbox()
         ]);
-        return `${ref}
-
-## Recent activity
-${activity}
-
-## Wrapped agents
-${agents}
-
-## Open inbox
-${inbox}`;
+        return [
+          ref,
+          ...priorSection ? [priorSection] : [],
+          `## Recent activity
+${activity}`,
+          `## Wrapped agents
+${agents}`,
+          `## Open inbox
+${inbox}`
+        ].join("\n\n");
+      }
+      /**
+       * Render the prior-conversation section with token-budget enforcement
+       * (WP-V1.3-9 Tau-2). Drops oldest turns first when the rendered
+       * section exceeds `historyTokenBudget`. Returns an empty string when
+       * the input is empty or when the budget excludes every turn.
+       */
+      formatPriorTurnsSection(turns) {
+        if (turns.length === 0) return "";
+        const HEADER = "## Prior conversation";
+        const lines = turns.map(formatPriorTurnLine);
+        const headerTokens = approxTokenLen(`${HEADER}
+`);
+        const sepTokens = approxTokenLen("\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);
+          if (runningTokens + tokens > this.historyTokenBudget) break;
+          runningTokens += tokens;
+          runningLines.push(line);
+        }
+        if (runningLines.length === 0) return "";
+        runningLines = runningLines.reverse();
+        return `${HEADER}
+${runningLines.join("\n")}`;
       }
       // ── audit helpers ────────────────────────────────────────────────────
       emit(operation, payload, result) {
@@ -33545,6 +34084,65 @@ var init_concierge_memory_store = __esm({
         }
         return turns;
       }
+      /**
+       * Read turns with explicit failure surfacing (WP-V1.3-9 Tau-2). Where
+       * `readThread` collapses every failure mode to an empty array, this
+       * variant returns a discriminated result so the multi-turn fold path
+       * can degrade cleanly + emit `operator_concierge_memory_read_failed`
+       * with a concrete cause.
+       *
+       * - No bundle on disk → `{ ok: true, turns: [] }` (a fresh thread).
+       * - Bundle present, decode + decrypt + schema check pass → ok with turns.
+       * - Bundle present, oversize → `{ ok: false, reason: "oversize_bundle" }`.
+       * - Bundle present, decryption fails → `{ ok: false, reason: "decrypt_failed" }`.
+       * - Bundle present, schema mismatch (version / thread_id) → `schema_mismatch`.
+       * - Storage IO error → `io_failed`.
+       */
+      async readThreadStrict(threadId, opts) {
+        const key = bundleKey(threadId);
+        let raw;
+        try {
+          raw = await this.storage.read(CONCIERGE_MEMORY_NAMESPACE, key);
+        } catch {
+          return { ok: false, reason: "io_failed" };
+        }
+        if (!raw) return { ok: true, turns: [] };
+        if (raw.length > MAX_BUNDLE_BYTES2) {
+          return { ok: false, reason: "oversize_bundle" };
+        }
+        let envelope;
+        try {
+          envelope = JSON.parse(bytesToString(raw));
+        } catch {
+          return { ok: false, reason: "schema_mismatch" };
+        }
+        let plaintext;
+        try {
+          const aad = stringToBytes(threadId);
+          plaintext = decrypt(envelope, this.encryptionKey, aad);
+        } catch {
+          return { ok: false, reason: "decrypt_failed" };
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(bytesToString(plaintext));
+        } catch {
+          return { ok: false, reason: "schema_mismatch" };
+        }
+        if (parsed.version !== 1) return { ok: false, reason: "schema_mismatch" };
+        if (parsed.thread_id !== threadId) {
+          return { ok: false, reason: "schema_mismatch" };
+        }
+        let turns = parsed.turns;
+        if (opts?.sinceTurnId !== void 0) {
+          const cutoff = opts.sinceTurnId;
+          turns = turns.filter((t) => t.turn_id > cutoff);
+        }
+        if (opts?.limit !== void 0) {
+          turns = turns.slice(0, opts.limit);
+        }
+        return { ok: true, turns };
+      }
       /**
        * Enumerate concierge threads in this fortress with summary metadata.
        * Sorted newest-first by last_turn_at.
@@ -36442,7 +37040,7 @@ async function resolveSourceMasterKey(encryptedState, opts) {
   }
   return null;
 }
-async function rekeyState(encryptedState, opts, sourceMasterKey, publicKeysByIdentityId) {
+async function rekeyState(encryptedState, opts, sourceMasterKey, publicKeysByIdentityId, importedRekeyEntries) {
   const destinationSigner = opts.destinationSignerIdentityId ? opts.identityManager.get(opts.destinationSignerIdentityId) : opts.identityManager.getDefault();
   if (!destinationSigner) {
     return {
@@ -36504,8 +37102,9 @@ async function rekeyState(encryptedState, opts, sourceMasterKey, publicKeysByIde
         }
       }
     }
+    let plaintext;
     try {
-      const plaintext = decrypt(
+      plaintext = decrypt(
         item.entry.payload,
         deriveNamespaceKey(sourceMasterKey, item.namespace)
       );
@@ -36514,28 +37113,30 @@ async function rekeyState(encryptedState, opts, sourceMasterKey, publicKeysByIde
         skipped++;
         continue;
       }
-      await stateStore.write(
-        item.namespace,
-        item.key,
-        bytesToString(plaintext),
-        destinationSigner.identity_id,
-        destinationSigner.encrypted_private_key,
-        identityEncryptionKey,
-        {
-          content_type: item.entry.metadata.content_type,
-          ttl_seconds: item.entry.metadata.ttl_seconds,
-          tags: [
-            ...item.entry.metadata.tags ?? [],
-            "exit-import",
-            `source:${item.entry.kid}`
-          ]
-        }
-      );
-      imported++;
     } catch {
       skippedInvalidSig++;
       skipped++;
+      continue;
     }
+    await stateStore.write(
+      item.namespace,
+      item.key,
+      bytesToString(plaintext),
+      destinationSigner.identity_id,
+      destinationSigner.encrypted_private_key,
+      identityEncryptionKey,
+      {
+        content_type: item.entry.metadata.content_type,
+        ttl_seconds: item.entry.metadata.ttl_seconds,
+        tags: [
+          ...item.entry.metadata.tags ?? [],
+          "exit-import",
+          `source:${item.entry.kid}`
+        ]
+      }
+    );
+    imported++;
+    importedRekeyEntries?.push({ namespace: item.namespace, key: item.key });
   }
   return {
     status: "rekeyed",
@@ -36546,6 +37147,23 @@ async function rekeyState(encryptedState, opts, sourceMasterKey, publicKeysByIde
     conflicts
   };
 }
+async function cleanupStagedPaths(storage, staged) {
+  let removed = 0;
+  const failed = [];
+  for (const loc of staged) {
+    try {
+      const ok2 = await storage.delete(loc.namespace, loc.key);
+      if (ok2) {
+        removed++;
+      } else {
+        failed.push(loc);
+      }
+    } catch {
+      failed.push(loc);
+    }
+  }
+  return { removed, failed };
+}
 async function stageArtifact(storage, namespace, key, value) {
   await storage.write(namespace, key, jsonBytes(value));
 }
@@ -36670,6 +37288,8 @@ async function importExitBundle(opts) {
   }
   const importId = importIdForManifest(manifest);
   const stagedArtifacts = [];
+  const stagedLocations = [];
+  const importedRekeyEntries = [];
   if (identityArtifact) {
     await stageArtifact(
       opts.storage,
@@ -36678,10 +37298,15 @@ async function importExitBundle(opts) {
       identityArtifact.json
     );
     stagedArtifacts.push("public_identity");
+    stagedLocations.push({
+      namespace: EXIT_PUBLIC_IDENTITIES_NAMESPACE,
+      key: identityArtifact.json.bundle.identity_id
+    });
   }
   if (policySet) {
     await stageArtifact(opts.storage, EXIT_POLICY_SETS_NAMESPACE, importId, policySet.json);
     stagedArtifacts.push("policy_set");
+    stagedLocations.push({ namespace: EXIT_POLICY_SETS_NAMESPACE, key: importId });
   }
   if (auditReceipts) {
     await stageArtifact(
@@ -36691,10 +37316,12 @@ async function importExitBundle(opts) {
       auditReceipts.json
     );
     stagedArtifacts.push("audit_receipts");
+    stagedLocations.push({ namespace: EXIT_AUDIT_RECEIPTS_NAMESPACE, key: importId });
   }
   if (commitments) {
     await stageArtifact(opts.storage, EXIT_COMMITMENTS_NAMESPACE, importId, commitments.json);
     stagedArtifacts.push("commitments");
+    stagedLocations.push({ namespace: EXIT_COMMITMENTS_NAMESPACE, key: importId });
   }
   if (placeholderMetadata) {
     await stageArtifact(
@@ -36704,12 +37331,17 @@ async function importExitBundle(opts) {
       placeholderMetadata.json
     );
     stagedArtifacts.push("placeholder_vault_metadata");
+    stagedLocations.push({
+      namespace: EXIT_PLACEHOLDER_METADATA_NAMESPACE,
+      key: importId
+    });
   }
   await stageArtifact(opts.storage, EXIT_IMPORT_NAMESPACE, importId, {
     manifest: manifest.body,
     verified_at: verification.verified_at,
     activated_at: (/* @__PURE__ */ new Date()).toISOString()
   });
+  stagedLocations.push({ namespace: EXIT_IMPORT_NAMESPACE, key: importId });
   const publicKeys = identityArtifact ? publicKeysFromIdentityArtifact(identityArtifact.json) : { byIdentityId: /* @__PURE__ */ new Map(), byDid: /* @__PURE__ */ new Map() };
   let reputationResult = {
     imported_attestations: 0,
@@ -36734,26 +37366,57 @@ async function importExitBundle(opts) {
     encryptedState?.json ?? null,
     opts
   );
-  const stateResult = encryptedState && encryptedState.json.entries.length > 0 ? sourceMasterKey ? await rekeyState(
-    encryptedState.json,
-    opts,
-    sourceMasterKey,
-    publicKeys.byIdentityId
-  ) : {
-    status: "staged_requires_source_key",
-    imported_keys: 0,
-    skipped_keys: encryptedState.json.entries.length,
-    skipped_invalid_sig: 0,
-    skipped_unknown_kid: 0,
-    conflicts: conflicts.state_conflicts.length
-  } : {
-    status: "not_requested",
-    imported_keys: 0,
-    skipped_keys: 0,
-    skipped_invalid_sig: 0,
-    skipped_unknown_kid: 0,
-    conflicts: 0
-  };
+  let stateResult;
+  try {
+    stateResult = encryptedState && encryptedState.json.entries.length > 0 ? sourceMasterKey ? await rekeyState(
+      encryptedState.json,
+      opts,
+      sourceMasterKey,
+      publicKeys.byIdentityId,
+      importedRekeyEntries
+    ) : {
+      status: "staged_requires_source_key",
+      imported_keys: 0,
+      skipped_keys: encryptedState.json.entries.length,
+      skipped_invalid_sig: 0,
+      skipped_unknown_kid: 0,
+      conflicts: conflicts.state_conflicts.length
+    } : {
+      status: "not_requested",
+      imported_keys: 0,
+      skipped_keys: 0,
+      skipped_invalid_sig: 0,
+      skipped_unknown_kid: 0,
+      conflicts: 0
+    };
+  } catch (err) {
+    const toCleanup = [
+      ...importedRekeyEntries,
+      ...stagedLocations
+    ];
+    const cleanup = await cleanupStagedPaths(opts.storage, toCleanup);
+    opts.auditLog.append(
+      "l1",
+      "exit_bundle_rekey_failed_cleanup",
+      manifest.body.identity_binding.identity_id,
+      {
+        import_id: importId,
+        manifest_version: manifest.body.manifest_version,
+        rekey_entries_removed: importedRekeyEntries.length,
+        staged_artifacts_removed: stagedLocations.length,
+        removed_total: cleanup.removed,
+        cleanup_failed_count: cleanup.failed.length,
+        original_error: err instanceof Error ? err.message : String(err)
+      },
+      "failure"
+    );
+    await opts.auditLog.flush();
+    const originalMessage = err instanceof Error ? err.message : String(err);
+    throw new ExitBundleImportError(
+      "REKEY_FAILED_AND_CLEANED",
+      `Exit-bundle re-key failed: ${originalMessage}. Cleanup removed ${cleanup.removed} of ${toCleanup.length} staged paths (${importedRekeyEntries.length} re-keyed entries plus ${stagedLocations.length} staged artifacts; ${cleanup.failed.length} cleanup deletes failed).`
+    );
+  }
   opts.auditLog.append("l1", "exit_bundle_import_activate", manifest.body.identity_binding.identity_id, {
     import_id: importId,
     manifest_version: manifest.body.manifest_version,
@@ -37832,7 +38495,6 @@ ${err.message}
       timestamp: alert.timestamp
     });
   } : void 0;
-  const gate = new ApprovalGate(policy, baseline, approvalChannel, auditLog, injectionDetector, onInjectionAlert);
   const fortressIdForAggregator = fortressIdFromStoragePath(config.storage_path);
   const aggregatorIdentityId = identityManager.getPrimaryIdentityId() ?? `fortress:${config.storage_path}`;
   const approvalAggregator = new ApprovalAggregator({
@@ -37842,6 +38504,20 @@ ${err.message}
     identityId: aggregatorIdentityId,
     fortressId: fortressIdForAggregator
   });
+  const wrappedApprovalChannel = new AggregatorBackedChannel({
+    underlying: approvalChannel,
+    aggregator: approvalAggregator,
+    resolveRedirect: makeRedirectResolverFromPolicySupplier(() => policy),
+    replaceModeTimeoutMs: policy.approval_channel.timeout_seconds * 1e3
+  });
+  const gate = new ApprovalGate(
+    policy,
+    baseline,
+    wrappedApprovalChannel,
+    auditLog,
+    injectionDetector,
+    onInjectionAlert
+  );
   gate.setApprovalEventCallback((event) => {
     void approvalAggregator.ingest(event);
   });
@@ -38039,6 +38715,7 @@ var init_src = __esm({
     init_webhook();
     init_gate();
     init_approval_aggregator();
+    init_aggregator_backed_channel();
     init_tools4();
     init_router();
     init_router();
@@ -41003,6 +41680,22 @@ var init_broker = __esm({
       auditLog;
       issuer;
       principalIdentityId;
+      /**
+       * Per-secret-name mutex. Hardening wave 6 finding #64: two concurrent
+       * addSecret() / rotateSecret() / deleteSecret() calls on the same name
+       * MUST serialize cleanly. The keychain backend's `find-then-add` and
+       * `find-then-delete-then-add` shapes (KeychainBackend.addSecret /
+       * .rotateSecret) are not atomic against another caller racing the same
+       * service-name; without serialization the second caller can observe a
+       * stale "exists" check and either drop the new value or leave a
+       * duplicate keychain entry.
+       *
+       * Implementation: an in-memory promise chain per name. Subsequent
+       * callers `await` the chain tail and append their own work; failures
+       * propagate to the failing caller without poisoning the chain for
+       * later callers.
+       */
+      nameLocks = /* @__PURE__ */ new Map();
       constructor(opts) {
         this.backend = opts.backend;
         this.auditLog = opts.auditLog;
@@ -41013,6 +41706,40 @@ var init_broker = __esm({
           grants: opts.grants
         });
       }
+      /**
+       * Serialize `op` against any other in-flight write to the same secret
+       * `name`. Per-name fairness only, distinct names run in parallel.
+       * The current chain tail is used as the acceptance gate; we then
+       * publish a new tail that swallows the operation's outcome so a
+       * thrown error does not poison the next caller's wait.
+       */
+      async withNameLock(name, op) {
+        const previous = this.nameLocks.get(name) ?? Promise.resolve();
+        let release = () => {
+        };
+        const next = new Promise((resolve8) => {
+          release = resolve8;
+        });
+        this.nameLocks.set(name, next);
+        try {
+          await previous.catch(() => {
+          });
+          return await op();
+        } finally {
+          release();
+          if (this.nameLocks.get(name) === next) {
+            this.nameLocks.delete(name);
+          }
+        }
+      }
+      /**
+       * Diagnostic-only: visible for tests so they can assert that distinct
+       * names do not contend on a shared lock. Not part of the public broker
+       * contract; do not consume from production code.
+       */
+      __nameLockCountForTests() {
+        return this.nameLocks.size;
+      }
       /** Ensure backend is initialized and unlocked. Audits the unlock. */
       async ensureUnlocked(passphrase) {
         await this.backend.ensureInitialized(passphrase);
@@ -41025,31 +41752,37 @@ var init_broker = __esm({
         );
       }
       async addSecret(name, value) {
-        await this.backend.addSecret(name, value);
-        this.auditLog.append(
-          "l3",
-          BROKER_OPS.SECRET_ADDED,
-          this.principalIdentityId,
-          { secret: name }
-        );
+        await this.withNameLock(name, async () => {
+          await this.backend.addSecret(name, value);
+          this.auditLog.append(
+            "l3",
+            BROKER_OPS.SECRET_ADDED,
+            this.principalIdentityId,
+            { secret: name }
+          );
+        });
       }
       async rotateSecret(name, newValue) {
-        await this.backend.rotateSecret(name, newValue);
-        this.auditLog.append(
-          "l3",
-          BROKER_OPS.SECRET_ROTATED,
-          this.principalIdentityId,
-          { secret: name }
-        );
+        await this.withNameLock(name, async () => {
+          await this.backend.rotateSecret(name, newValue);
+          this.auditLog.append(
+            "l3",
+            BROKER_OPS.SECRET_ROTATED,
+            this.principalIdentityId,
+            { secret: name }
+          );
+        });
       }
       async deleteSecret(name) {
-        await this.backend.deleteSecret(name);
-        this.auditLog.append(
-          "l3",
-          BROKER_OPS.SECRET_DELETED,
-          this.principalIdentityId,
-          { secret: name }
-        );
+        await this.withNameLock(name, async () => {
+          await this.backend.deleteSecret(name);
+          this.auditLog.append(
+            "l3",
+            BROKER_OPS.SECRET_DELETED,
+            this.principalIdentityId,
+            { secret: name }
+          );
+        });
       }
       async listSecretNames() {
         return this.backend.listSecretNames();
@@ -41089,6 +41822,19 @@ var init_broker = __esm({
       liveTokenCount() {
         return this.issuer.liveTokenCount();
       }
+      /**
+       * Drop expired tokens from the in-memory issuer map. Hardening wave 6
+       * finding #86: previously expiry pruning depended on opportunistic
+       * `pruneExpired()` calls; now the cocoon-unlock initialization path
+       * (openBroker -> after backend.ensureInitialized -> after Broker
+       * construction) fires this once so each cocoon-unlock cycle drops
+       * stale bindings before any operator interaction.
+       *
+       * Returns the number of tokens removed. Safe to call repeatedly; idempotent.
+       */
+      pruneExpiredTokens() {
+        return this.issuer.pruneExpired();
+      }
       /**
        * Audit query restricted to broker-scoped operations. Returns entries
        * with their timestamps, op, and result (never the secret value).
@@ -41247,6 +41993,7 @@ async function openBroker(opts = {}) {
     grants,
     principalIdentityId: opts.principalIdentityId ?? "sanctuary-broker"
   });
+  broker.pruneExpiredTokens();
   return {
     broker,
     close: async () => {
@@ -42115,8 +42862,6 @@ var init_health = __esm({
     DEFAULT_TIMEOUT_MS4 = 500;
   }
 });
-
-// src/cli/agents/cli.ts
 function resolveCtx(args) {
   const env = args.env ?? process.env;
   const discoverOpts = {
@@ -42154,6 +42899,8 @@ async function runAgentsCommand(args) {
         return await cmdShow2(rest, ctx);
       case "status":
         return await cmdStatus(rest, ctx);
+      case "config":
+        return await cmdConfig(rest, ctx);
       default:
         ctx.err.write(`Unknown subcommand: ${sub}
 `);
@@ -42169,10 +42916,18 @@ async function runAgentsCommand(args) {
 }
 function printUsage4(s) {
   s.write(`Usage: sanctuary agents <command> [flags]
+       sanctuary agent  <command> [flags]   (alias)
 
   list [--json]                 List every tenant visible on this host.
-  show <tenant> [--json]        Show details for one tenant.
+  show <tenant> [--json]        Show details for one tenant (includes
+                                approval-redirect state).
   status [--json]               One-line-per-tenant running/stopped summary.
+  config <tenant> [opts]        Write tenant principal-policy.yaml fields.
+    --approval-redirect=<bool>    Toggle cross-harness inbox redirect.
+    --approval-redirect-mode=<replace|notify>
+                                  Pick replace (bypass underlying channel)
+                                  or notify (race both paths). Default
+                                  replace when toggled on.
 
 Options:
   --fortress <path>             Scope discovery to a specific storage path
@@ -42274,6 +43029,7 @@ async function cmdShow2(argv, ctx) {
     return 1;
   }
   const probe = await ctx.probe(tenant);
+  const approvalRedirect = await readApprovalRedirectState(tenant);
   const payload = {
     name: tenant.name,
     storage_path: tenant.storage_path,
@@ -42287,7 +43043,8 @@ async function cmdShow2(argv, ctx) {
       running: probe.running,
       status: probe.status,
       reason: probe.reason
-    }
+    },
+    approval_redirect: approvalRedirect
   };
   if (hasJsonFlag(argv)) {
     ctx.out.write(JSON.stringify(payload, null, 2) + "\n");
@@ -42331,10 +43088,173 @@ async function cmdShow2(argv, ctx) {
   }
   ctx.out.write(
     `probe:             ${probe.running ? "running" : "not-running"}${probe.reason ? ` (${probe.reason})` : ""}
+`
+  );
+  ctx.out.write(
+    `approval_redirect: ${approvalRedirect.enabled ? `on (${approvalRedirect.mode})` : "off"}
 `
   );
   return 0;
 }
+async function readApprovalRedirectState(tenant) {
+  const policyPath = path.join(tenant.storage_path, "principal-policy.yaml");
+  try {
+    const content = await promises.readFile(policyPath, "utf-8");
+    const parsed = parsePolicy(content);
+    const cfg = parsed.approval_redirect;
+    if (!cfg) return { enabled: false, mode: "replace" };
+    return {
+      enabled: !!cfg.enabled,
+      mode: cfg.mode === "notify" ? "notify" : "replace"
+    };
+  } catch {
+    return { enabled: false, mode: "replace" };
+  }
+}
+function parseBoolFlag(raw) {
+  if (raw === void 0) return null;
+  const v = raw.toLowerCase();
+  if (v === "true" || v === "yes" || v === "on" || v === "1") return true;
+  if (v === "false" || v === "no" || v === "off" || v === "0") return false;
+  return null;
+}
+function findFlagValue(argv, name) {
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === name) {
+      return argv[i + 1];
+    }
+    const eq = `${name}=`;
+    if (a.startsWith(eq)) {
+      return a.slice(eq.length);
+    }
+  }
+  return void 0;
+}
+async function cmdConfig(argv, ctx) {
+  const positional = argv.find((a) => !a.startsWith("--"));
+  if (!positional) {
+    ctx.err.write(
+      "Missing tenant. Usage: sanctuary agents config <tenant> --approval-redirect=<bool>\n"
+    );
+    return 2;
+  }
+  const tenant = await findTenant(positional, ctx.discoverOpts);
+  if (!tenant) {
+    ctx.err.write(`sanctuary agents: unknown tenant "${positional}"
+`);
+    return 1;
+  }
+  const redirectFlag = parseBoolFlag(
+    findFlagValue(argv, "--approval-redirect")
+  );
+  const modeFlag = findFlagValue(argv, "--approval-redirect-mode");
+  if (redirectFlag === null && modeFlag === void 0) {
+    ctx.err.write(
+      "sanctuary agents config: nothing to do. Pass --approval-redirect=<bool> or --approval-redirect-mode=<replace|notify>.\n"
+    );
+    return 2;
+  }
+  if (modeFlag !== void 0 && modeFlag !== "replace" && modeFlag !== "notify") {
+    ctx.err.write(
+      `sanctuary agents config: --approval-redirect-mode must be "replace" or "notify" (got "${modeFlag}")
+`
+    );
+    return 2;
+  }
+  const current = await readApprovalRedirectState(tenant);
+  const next = {
+    enabled: redirectFlag !== null ? redirectFlag : current.enabled,
+    mode: modeFlag === "notify" || modeFlag === "replace" ? modeFlag : current.mode
+  };
+  await writeApprovalRedirectToPolicyFile(tenant.storage_path, next);
+  if (hasJsonFlag(argv)) {
+    ctx.out.write(
+      JSON.stringify(
+        {
+          tenant: tenant.name,
+          approval_redirect: next
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } else {
+    ctx.out.write(
+      `sanctuary agents config: tenant "${tenant.name}" approval_redirect=${next.enabled ? `on (${next.mode})` : "off"}
+`
+    );
+    ctx.out.write(
+      `  Takes effect on the next gate request for the running server.
+`
+    );
+  }
+  return 0;
+}
+async function writeApprovalRedirectToPolicyFile(storagePath, state) {
+  const policyPath = path.join(storagePath, "principal-policy.yaml");
+  let content;
+  try {
+    content = await promises.readFile(policyPath, "utf-8");
+  } catch (err) {
+    const code = err?.code;
+    if (code !== "ENOENT") throw err;
+    content = await defaultPolicyTextForBootstrap();
+  }
+  const block = renderApprovalRedirectBlock(state);
+  const updated = upsertApprovalRedirectBlock(content, block);
+  await promises.writeFile(policyPath, updated, "utf-8");
+  await promises.chmod(policyPath, 384);
+}
+function renderApprovalRedirectBlock(state) {
+  return [
+    "# Approval Redirect (v1.3 WP-V1.3-10 Upsilon-2)",
+    "approval_redirect:",
+    `  enabled: ${state.enabled ? "true" : "false"}`,
+    `  mode: ${state.mode}`
+  ].join("\n");
+}
+function upsertApprovalRedirectBlock(content, block) {
+  const lines = content.split("\n");
+  const startIdx = lines.findIndex((l) => l.startsWith("approval_redirect:"));
+  if (startIdx === -1) {
+    const trimmed = content.endsWith("\n") ? content : content + "\n";
+    return trimmed + "\n" + block + "\n";
+  }
+  let blockStart = startIdx;
+  if (blockStart > 0 && lines[blockStart - 1] !== void 0 && lines[blockStart - 1].startsWith("# Approval Redirect")) {
+    blockStart = blockStart - 1;
+  }
+  let blockEnd = startIdx + 1;
+  while (blockEnd < lines.length) {
+    const l = lines[blockEnd];
+    if (l === "") {
+      blockEnd++;
+      continue;
+    }
+    if (/^[A-Za-z0-9#]/.test(l)) {
+      break;
+    }
+    blockEnd++;
+  }
+  const before = lines.slice(0, blockStart);
+  const after = lines.slice(blockEnd);
+  const replaced = [...before, ...block.split("\n"), ...after].join("\n");
+  return replaced.endsWith("\n") ? replaced : replaced + "\n";
+}
+async function defaultPolicyTextForBootstrap() {
+  return [
+    "version: 1",
+    "tier1_always_approve:",
+    "  - state_export",
+    "  - state_import",
+    "  - state_delete",
+    "approval_channel:",
+    "  type: stderr",
+    "  timeout_seconds: 300",
+    ""
+  ].join("\n");
+}
 async function cmdStatus(argv, ctx) {
   const tenants = await discoverTenants(ctx.discoverOpts);
   const probes = await Promise.all(tenants.map((t) => ctx.probe(t)));
@@ -42375,6 +43295,7 @@ var init_cli5 = __esm({
   "src/cli/agents/cli.ts"() {
     init_discovery();
     init_health();
+    init_loader();
   }
 });
 
@@ -43803,7 +44724,7 @@ async function main() {
     const code = await runIdentityCommand2({ argv: args.slice(1) });
     process.exit(code);
   }
-  if (args[0] === "agents") {
+  if (args[0] === "agents" || args[0] === "agent") {
     const { runAgentsCommand: runAgentsCommand2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
     const code = await runAgentsCommand2({ argv: args.slice(1) });
     process.exit(code);