phaedo-mcp 0.2.1 → 0.3.0

package/consult-core.js

@@ -16,6 +16,8 @@
 
 import { PhaedoError } from './errors.js';
 import { loadPolicies, applyPolicies, matchAuthorization } from './consult-policy.js';
+import { normalizeActionBinding, isBound } from './action-binding.js';
+import { normalizeDomain, canonicalDomain } from './lib/domain.js';
 
 export const CONSULTATION_TYPES = [
   'action_approval',
@@ -367,14 +369,31 @@ export function normalizeRequest(request) {
   }
   const ctx = (request.context && typeof request.context === 'object') ? request.context : {};
   const ev = ctx.evidence_provided;
+  // §10.2 action_binding: the concrete call this descriptor claims to describe.
+  // Optional — an unbound request resolves exactly as before — but an authored
+  // authorization may refuse to RELAX anything without it (§10.5 require_binding).
+  const binding = normalizeActionBinding(request.action_binding);
   return {
     type,
-    domain: typeof ad.domain === 'string' ? ad.domain : undefined,
+    // NORMALIZED only (case/whitespace) — deliberately NOT vocabulary-mapped. The
+    // request domain feeds §10.5 matching, and a relaxing rule must keep matching on
+    // the literal the agent sent; `domainCovers` applies the vocabulary itself, and
+    // only for restrictive rules. Mapping here instead would let an alias widen a
+    // grant. The RECEIPT stores the canonical form (that is the evidence axis).
+    domain: typeof ad.domain === 'string' ? (normalizeDomain(ad.domain) || undefined) : undefined,
     reversible: typeof ad.reversible === 'boolean' ? ad.reversible : undefined,
-    magnitude: magnitude || 'medium',
+    // UNSTATED STAYS UNSTATED (v0.1.68). This defaulted to 'medium', which meant the resolver could
+    // never tell "the agent said medium" from "the agent said nothing" — and §10.5 then let a
+    // medium-capped grant fire on the nothing. The receipt now records what was actually sent
+    // (null), which is also what situational precedent (OQ24) needs to band on. The inferred
+    // oracle path still reads an unknown as the middle of the scale (`magnitudeRank`); that is a
+    // disposition heuristic, not a grant, and it is unchanged.
+    magnitude,
     amount: typeof ad.amount === 'number' && isFinite(ad.amount) ? ad.amount : undefined,
     summary: typeof ad.summary === 'string' ? ad.summary : undefined,
     evidenceProvided: Array.isArray(ev) ? ev : (ev != null ? [ev] : []),
+    binding,
+    bound: isBound(binding),
   };
 }
 
@@ -500,22 +519,50 @@ export function consultDrivers(vd, request) {
 // action's domain when it had one, so a financial override never reshapes writing.
 const PERMISSIVE_SIGNAL = new Set(['proceed', 'proceed_with_note']);
 const CAUTIOUS_SIGNAL   = new Set(['escalate', 'decline', 'clarify']);
-const OVERRIDE_WEIGHT   = { rejected: 1.0, modified: 0.5 };
+
+// A delegated correction's signed weight — direction read from the subject's action
+// RELATIVE to the oracle's signal, NOT the signal class alone. This is the fix for a
+// direction inversion: a lesson requires DISAGREEMENT between signal and action.
+//   permissive + rejected  → +1  said go, subject didn't proceed  → wants CAUTION
+//   cautious   + approved  → -1  said hold, subject proceeded     → wants BOLD
+//   modified               → ±0.5 (ambiguous change; signal-relative, half weight)
+//   permissive + approved  →  0  AGREEMENT (both proceed) — teaches nothing
+//   cautious   + rejected  →  0  AGREEMENT (both hold)    — teaches nothing
+// This keeps the anti-obedience rail intact (a rubber-stamp `approved` on a `proceed`
+// signal is agreement, not a "be bolder" lesson) while no longer misreading the
+// subject AGREEING with a cautious signal as a demand to be bolder — which was
+// eroding the very guardrails the subject was upholding (agreement.js counts
+// decline+rejected as agreement; this now matches).
+function delegationCorrection(signal, userAction) {
+  const permissive = PERMISSIVE_SIGNAL.has(signal);
+  const cautious   = CAUTIOUS_SIGNAL.has(signal);
+  if (!permissive && !cautious) return 0;                     // abstain / unknown signal
+  if (userAction === 'modified') return permissive ? 0.5 : -0.5;
+  if (permissive && userAction === 'rejected') return 1;      // override toward caution
+  if (cautious   && userAction === 'approved') return -1;     // override toward bold (proceeded anyway)
+  return 0;                                                   // agreement / unknown → no lesson
+}
 
 export function deriveDelegationSignals(receipts, { now = new Date().toISOString(), floor = 1 } = {}) {
   const tally = new Map(); // `${cue}|${domain}` → { cue, domain, sum, n }
   for (const r of (Array.isArray(receipts) ? receipts : [])) {
-    const w = OVERRIDE_WEIGHT[r && r.user_action];
-    if (!w) continue;                                              // only rejected/modified teach
     const sig = r?.response?.signal;
-    const correct = PERMISSIVE_SIGNAL.has(sig) ? 1 : CAUTIOUS_SIGNAL.has(sig) ? -1 : 0; // +1 cautious / -1 bold
-    if (!correct) continue;                                        // abstain/unknown → no direction
-    const domain = (typeof r?.request?.action_descriptor?.domain === 'string') ? r.request.action_descriptor.domain : '';
+    const contribution = delegationCorrection(sig, r && r.user_action); // signed; 0 = agreement/no lesson
+    if (!contribution) continue;
+    // Canonicalize the domain BEFORE bucketing, or one concept spelled several ways
+    // (finance / financial / Finance) fragments into several near-identical buckets — the
+    // drift §10.2's published vocabulary exists to end. Both the live overlay
+    // (deriveDelegationSignals) and the promotion cards (buildDelegationPromotions) key on
+    // this, so both must canonicalize or a card floods / an overlay splits. Free text still
+    // survives — an unrecognized domain canonicalizes to itself — so only known synonyms
+    // merge, never distinct classes.
+    const domain = canonicalDomain(
+      (typeof r?.request?.action_descriptor?.domain === 'string') ? r.request.action_descriptor.domain : '');
     for (const d of (Array.isArray(r.drivers) ? r.drivers : [])) {
       if (!CUES[d && d.cue]) continue;                             // scalar caution cues only (ambiguity later)
       const k = `${d.cue}|${domain}`;
       const t = tally.get(k) || { cue: d.cue, domain, sum: 0, n: 0 };
-      t.sum += correct * w; t.n += 1;
+      t.sum += contribution; t.n += 1;
       tally.set(k, t);
     }
   }
@@ -600,22 +647,28 @@ function delegationText(dimension, dir, domain) {
 
 export function buildDelegationPromotions(receipts, fp, { now = new Date().toISOString(), floor = DELEGATION_PROMOTION_FLOOR } = {}) {
   // Aggregate overrides per CANONICAL (dimension, domain): signed weight + count. Same
-  // honesty rail + direction rule as deriveDelegationSignals (only rejected/modified;
-  // direction read from the oracle's own signal).
+  // signal-relative direction rule as deriveDelegationSignals — a lesson requires the
+  // subject's action to DISAGREE with the oracle's signal; agreement teaches nothing.
   const tally = new Map(); // `${dimension}|${domain}` → { dimension, domain, sum, n }
   for (const r of (Array.isArray(receipts) ? receipts : [])) {
-    const w = OVERRIDE_WEIGHT[r && r.user_action];
-    if (!w) continue;
     const sig = r?.response?.signal;
-    const correct = PERMISSIVE_SIGNAL.has(sig) ? 1 : CAUTIOUS_SIGNAL.has(sig) ? -1 : 0;
-    if (!correct) continue;
-    const domain = (typeof r?.request?.action_descriptor?.domain === 'string') ? r.request.action_descriptor.domain : '';
+    const contribution = delegationCorrection(sig, r && r.user_action);
+    if (!contribution) continue;
+    // Canonicalize the domain BEFORE bucketing, or one concept spelled several ways
+    // (finance / financial / Finance) fragments into several near-identical buckets — the
+    // drift §10.2's published vocabulary exists to end. Both the live overlay
+    // (deriveDelegationSignals) and the promotion cards (buildDelegationPromotions) key on
+    // this, so both must canonicalize or a card floods / an overlay splits. Free text still
+    // survives — an unrecognized domain canonicalizes to itself — so only known synonyms
+    // merge, never distinct classes.
+    const domain = canonicalDomain(
+      (typeof r?.request?.action_descriptor?.domain === 'string') ? r.request.action_descriptor.domain : '');
     for (const d of (Array.isArray(r.drivers) ? r.drivers : [])) {
       const dim = CUE_DIMENSION[d && d.cue];
       if (!dim) continue;
       const k = `${dim}|${domain}`;
       const t = tally.get(k) || { dimension: dim, domain, sum: 0, n: 0 };
-      t.sum += correct * w; t.n += 1; tally.set(k, t);
+      t.sum += contribution; t.n += 1; tally.set(k, t);
     }
   }
   const keyOf = (dim, domain) => `${dim}|${domain || ''}`;
@@ -726,6 +779,15 @@ export function ruleResponse(vd, n) {
   return shape(n.type, resolved.signal, cal.confidence, resolved.hint, cal.deference_level);
 }
 
+// The §10.5 evaluation context, lifted out of `opts` once so both public entries
+// gate identically. `clientId` is the SERVING paired client's own `client_id` (from
+// the server's `pairing.json`, supplied by the transport layer) — the identity
+// `agents` scoping matches on; never anything the caller asserted. Absent here means
+// unpaired, which makes every `agents`-scoped relaxing rule inert. Passing `now`
+// through as well keeps rule expiry on the same clock `loadPolicies` already gives
+// §5.7 commitments; both fall back to `Date.now()` when a caller omits them.
+const policyCtx = (opts = {}) => ({ now: opts.now, clientId: opts.clientId ?? null });
+
 // ── Public pure entry ─────────────────────────────────────────────────────────
 // (vd, request[, opts]) -> §10.3 response. Deterministic; applies authored §10.5
 // policies last so a standing guardrail wins (even over an abstain). `opts.policies`
@@ -734,7 +796,7 @@ export function ruleResponse(vd, n) {
 export function resolveConsultationCore(vd, request = {}, opts = {}) {
   assertVaultUsable(vd);
   const n = normalizeRequest(request);
-  return applyPolicies(ruleResponse(vd, n), n, loadPolicies(vd, opts));
+  return applyPolicies(ruleResponse(vd, n), n, loadPolicies(vd, opts), policyCtx(opts));
 }
 
 // Back-compat alias: the prior public name of the sync rule entry. Kept so existing
@@ -751,7 +813,7 @@ export const buildConsultationResponse = resolveConsultationCore;
 export function checkAuthorization(vd, request = {}, opts = {}) {
   assertVaultUsable(vd);
   const n = normalizeRequest(request);
-  const auth = matchAuthorization(n, loadPolicies(vd, opts));
+  const auth = matchAuthorization(n, loadPolicies(vd, opts), policyCtx(opts));
   return {
     phaedo_response_version: '0.1',
     request_type: 'authorization_check',