phaedo-mcp 0.2.2 → 0.3.1

package/vendor/extraction/persist.js

@@ -0,0 +1,45 @@
+// Phaedo Loop 2 extraction — fingerprint persist merge (the CAS-safe contract).
+//
+// The offscreen pass produces a raw per-layer `update` delta. Merging that delta
+// INTO the persistent fingerprint is a read-modify-write, and it MUST run against
+// the freshest fingerprint under a lock — otherwise a pass that read the
+// fingerprint before it ran will blind-overwrite anything authored in between:
+// a subject-endorsed standing_rule, another tab's accumulated signals, or a
+// just-dismissed conflict (the extension-CAS lost-update finding).
+//
+// This module is the PURE core of that merge: reconcile the delta, stage any
+// newly-promotable suggested rules, stamp updated_at. The service worker
+// (background.js `mergeExtraction`) wraps it in `withVaultLock` against a fresh
+// `readVault`, so the whole read → merge → write is atomic. Keeping the merge
+// pure makes the race-safety contract node-testable without chrome.
+
+import { reconcileFingerprint } from './reconcile.js';
+import { promoteRules } from './rule-promotion.js';
+import { applyCaptureSources } from './capture-combine.js';
+
+// Reconcile `update` into `fingerprint` and return the next fingerprint. Never
+// mutates the input. reconcile merges layer signals accumulatively and upserts
+// conflict_records (dismissals stay sticky); promoteRules stages suggested_rules
+// for established, not-yet-authored D&R patterns (skipping dimensions the subject
+// already authored). Because both are pure and merge — rather than replace — the
+// current fingerprint, running them on a FRESH read is the whole lost-update fix.
+//
+// `captureSources` (optional): the vault's per-surface capture snapshots
+// (phaedo_capture_sources values). When present, the update's delta signals are
+// replaced by the CROSS-SURFACE combined set before reconcile (capture-combine.js)
+// — otherwise a delta write from one surface would clobber the accumulated counts
+// of the others (delta reconcile is replace-by-key). Callers that hold a vault
+// with capture sources MUST pass them on every delta-writing merge.
+//
+// `attr` (optional { sourceId, context }): which browser this pass ran in. Extraction evidence is
+// then recorded per source (signal-ledger.js), so learning from several browsers adds up at sync
+// instead of the newest copy replacing the rest.
+export function mergeExtractionInto(fingerprint, update, now = new Date().toISOString(), captureSources = null, attr = null) {
+  const effective = (Array.isArray(captureSources) && captureSources.length)
+    ? applyCaptureSources(update, captureSources, now)
+    : update;
+  const ropts = attr && attr.sourceId ? { now, sourceId: attr.sourceId, context: attr.context } : { now };
+  const merged = promoteRules(reconcileFingerprint(fingerprint || {}, effective, ropts), { now });
+  merged.updated_at = now;    // bump for sync last-write-wins
+  return merged;
+}

package/vendor/extraction/reconcile.js

@@ -0,0 +1,310 @@
+// Phaedo Loop 2 extraction — reconciliation (update → fingerprint).
+//
+// Merges a partial fingerprint update (projection.buildFingerprintUpdate) into
+// the stored fingerprint, per extraction-task-spec §6/§7 and §4.3:
+//
+//   - Signals are keyed by (field, polarity). A new pass either reinforces an
+//     existing signal (same key → merge) or adds a new one.
+//   - Reinforcement raises confidence (more consistent observations = more
+//     likely a stable trait, §7), sums observation_count, unions session_refs,
+//     advances last_observed.
+//   - Anti-preference precedence (§4.3, §6): when a layer holds both a positive
+//     and a negative signal for the same field, the negative (anti-preference)
+//     is the effective one. Both are retained for provenance; effectiveSignals()
+//     applies the precedence for downstream consumers.
+//   - Non-destructive: questionnaire data on a layer (e.g. `responses[]`, the
+//     cold-start shape in §2) is preserved. Extraction only writes the §4.2
+//     signal-bearing fields. Authored User Configuration (§5) is a sibling
+//     artifact extraction never touches.
+//
+// NUMERIC CALIBRATION IS DEFERRED (§7): the confidence-combine curve and
+// contradiction handling below are honest placeholders to be tuned by the eval
+// harness once a real model exists. They are monotone and bounded, not claimed
+// to be calibrated.
+
+import { renderLayerSummary } from './fingerprint-update.js';
+import { resolveDimension, valKey, authoredGovernedKeys } from './resolve.js';
+// Per-source ledgers (multi-browser): a classic UMD file, loaded for its side effect and read off
+// globalThis so the same file serves the popup's classic scripts, this module and Node.
+import '../signal-ledger.js';
+const SL = globalThis.PhaedoSignalLedger;
+
+const CONFIDENCE_CAP = 0.95;
+
+// Noisy-OR: independent consistent observations push confidence up, never past
+// the cap. Placeholder pending calibration; contradiction-driven *lowering*
+// (§7, persona-algorithm "adversarial robustness") is a deferred refinement.
+function combineConfidence(a, b) {
+  return Math.min(CONFIDENCE_CAP, 1 - (1 - (a ?? 0)) * (1 - (b ?? 0)));
+}
+
+function unionArrays(a = [], b = []) {
+  return Array.from(new Set([...a, ...b]));
+}
+
+// Merge two signal objects with the same (field, polarity) key.
+//
+// `attr` ({ sourceId, context }, optional): WHO produced this increment. When given, the evidence
+// is recorded in the signal's per-source ledger (signal-ledger.js) and the totals are re-derived
+// from it, so a second browser's learning ADDS to this one's at sync instead of replacing it.
+// Without it (tests, the desktop fold) the behaviour is exactly the pre-ledger accumulate.
+function mergeSignal(existing, incoming, now, attr) {
+  // Delta signals carry Path A's CUMULATIVE count — a re-lift is a fresh
+  // snapshot of the same counters, not new evidence. Replace wholesale so
+  // re-running the lift every pass is idempotent (no count/confidence
+  // inflation). Keep the stable signal_id.
+  if (incoming.source === 'delta') {
+    return { ...incoming, signal_id: existing.signal_id || incoming.signal_id };
+  }
+  if (attr && attr.sourceId && SL && SL.isLedgered(incoming)) {
+    return SL.attribute(existing, incoming, attr.sourceId, { now, context: attr.context });
+  }
+  const observation_count = (existing.observation_count || 1) + (incoming.observation_count || 1);
+  // Value merge: arrays union; scalar/enum/string keep the higher-confidence
+  // value (a contradiction across passes resolves to the better-supported one).
+  let value = existing.value;
+  if (Array.isArray(existing.value) && Array.isArray(incoming.value)) {
+    value = unionArrays(existing.value, incoming.value);
+  } else if ((incoming.confidence ?? 0) > (existing.confidence ?? 0)) {
+    value = incoming.value;
+  }
+  return {
+    ...existing,
+    // A questionnaire (self-reported) signal that observation now corroborates is
+    // no longer "stated only" — adopt the observing source so it counts as
+    // learned (and surfaces in the §5b summary). Pure self-report keeps
+    // source 'questionnaire' and stays out of the summary.
+    source: incoming.source || existing.source,
+    value,
+    confidence: Number(combineConfidence(existing.confidence, incoming.confidence).toFixed(3)),
+    observation_count,
+    session_refs: unionArrays(existing.session_refs, incoming.session_refs),
+    last_observed: maxIso(existing.last_observed, incoming.last_observed) || now,
+  };
+}
+
+function maxIso(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a > b ? a : b;
+}
+
+// Dedupe key. Domain-scoped Decision & Risk signals (§4.2.7 optional `domain`)
+// reconcile per (field, polarity, domain) so "financial caution" and "writing
+// boldness" coexist and reinforce independently; an untagged signal keeps the
+// legacy key — fully backward-compatible.
+const sigKey = s => `${s.field}::${s.polarity}${typeof s.domain === 'string' ? `::${s.domain}` : ''}`;
+
+// Reconcile one incoming layer doc into an existing layer doc (or undefined).
+// Returns a new layer object; does not mutate inputs. `suppress` (optional Set of
+// "field"/"field::domain") withholds those dimensions from the rendered summary —
+// the §4.7 injection-suppression of an open-conflict dimension. `attr` — see mergeSignal.
+export function reconcileLayer(existingLayer, incomingLayer, now, suppress, attr) {
+  const base = existingLayer ? { ...existingLayer } : {};
+  const existingSignals = Array.isArray(base.signals) ? base.signals : [];
+  const byKey = new Map(existingSignals.map(s => [sigKey(s), s]));
+  const attributed = !!(attr && attr.sourceId && SL);
+
+  for (const inc of incomingLayer.signals || []) {
+    const k = sigKey(inc);
+    if (byKey.has(k)) byKey.set(k, mergeSignal(byKey.get(k), inc, now, attr));
+    // A NEW signal is attributed too, or the same signal first seen independently on two
+    // browsers would carry no ledger on either and merge last-write-wins.
+    else byKey.set(k, attributed && SL.isLedgered(inc) ? SL.attribute(null, inc, attr.sourceId, { now, context: attr.context }) : inc);
+  }
+
+  const mergedSignals = Array.from(byKey.values());
+  return {
+    ...base,                       // preserve questionnaire `responses`, `label`, etc.
+    layer_version: incomingLayer.layer_version || base.layer_version || '0.1',
+    last_updated: now,
+    confidence: Number((mergedSignals.reduce((a, s) => a + (s.confidence || 0), 0) /
+                        (mergedSignals.length || 1)).toFixed(3)),
+    signals: mergedSignals,
+    // §5b "Learned from your conversations" should reflect observation, not
+    // restate the interview (§5 already renders questionnaire answers). Render
+    // only observation-backed signals; pure self-report (source 'questionnaire',
+    // never corroborated) stays in signals[] for provenance but is excluded here.
+    summary: renderLayerSummary(effectiveSignals(mergedSignals).filter(s => s.source !== 'questionnaire'), suppress),
+  };
+}
+
+// Apply §4.3/§6 anti-preference precedence: if a field has a negative signal,
+// the positive one for that field is suppressed from the effective set (kept in
+// storage for provenance, dropped from the rendered/consumed view).
+export function effectiveSignals(signals) {
+  const negFields = new Set(signals.filter(s => s.polarity === 'negative').map(s => s.field));
+  return signals.filter(s => !(s.polarity === 'positive' && negFields.has(s.field)));
+}
+
+// ── Conflict records (the update gate's "contradict" outcome) ────────────────
+//
+// mergeSignal() above collapses same-(field,polarity,domain) signals by confidence,
+// so a genuine contradiction — a new OBSERVED value that disagrees with the subject's
+// SELF-REPORT while the observed evidence is still thin (< §4.7 floor) — would vanish
+// silently. Detect it at the merge moment (both values still visible), classify it
+// with the SHARED §4.7 resolver, and stage a durable, reviewable record. This is the
+// producer-written `suggested_rules` pattern (Proposal 0007): never injected, never
+// consulted — a queue the subject reviews. We do NOT change what is stored or injected
+// here (that injection-suppression fix is a separate, behaviour-changing follow-up);
+// this only makes the contradiction visible and keeps both sides' provenance.
+
+const uuid = () =>
+  (typeof crypto !== 'undefined' && crypto.randomUUID) ? crypto.randomUUID()
+    : 'cfl-' + Math.random().toString(36).slice(2, 10);
+
+const conflictKey = (layer, field, domain) =>
+  `${layer}::${field}${typeof domain === 'string' ? `::${domain}` : ''}`;
+
+// Compare an incoming layer's signals against the existing ones BEFORE the merge
+// collapses them. For each incoming signal that shares a (field,polarity,domain) key
+// with an existing one but carries a DIFFERENT scalar/enum value, ask the §4.7 resolver:
+//   - status "unresolved" (thin inferred value vs a self-report) → an OPEN conflict.
+//   - status "resolved" (the inferred side crossed the floor, or observed-vs-observed) →
+//     the dimension now settles; if a record was open for it, CLOSE it.
+// Array-valued fields union (never conflict) and are skipped. Pure; no mutation.
+export function detectConflicts(existingSignals, incomingSignals) {
+  const byKey = new Map((Array.isArray(existingSignals) ? existingSignals : []).map((s) => [sigKey(s), s]));
+  const open = [], settled = [], overrides = [];
+  for (const inc of (Array.isArray(incomingSignals) ? incomingSignals : [])) {
+    const ex = byKey.get(sigKey(inc));
+    if (!ex) continue;                                                  // novel → not a conflict
+    if (Array.isArray(ex.value) || Array.isArray(inc.value)) continue; // list fields union
+    if (valKey(ex.value) === valKey(inc.value)) continue;              // agree → corroboration
+    const r = resolveDimension([ex, inc]);
+    const dim = { field: inc.field, domain: typeof inc.domain === 'string' ? inc.domain : undefined, candidates: r.provenance };
+    if (r.status === 'unresolved') { open.push(dim); continue; }
+    settled.push(dim);
+    // OVERRIDE detection: inferred behavior crossed the §4.7 floor AND there was a
+    // contradicting self_reported candidate → behavior just silently overrode what the
+    // subject said in the interview. Stage it so the subject SEES it (the existing
+    // "settled" path only closes already-open records; without this an override produces
+    // zero visibility — the subject's stated preference vanishes silently). Read by
+    // upsertConflictRecords to create a resolved record with resolution.by:'system'.
+    const selfReport = (r.provenance || []).find(c => c && c.evidence_basis === 'self_reported');
+    const winnerNotSelfReport = r.evidence_basis !== 'self_reported';
+    if (selfReport && winnerNotSelfReport && valKey(r.value) !== valKey(selfReport.value)) {
+      overrides.push({ ...dim, chosen_value: r.value, prior_value: selfReport.value });
+    }
+  }
+  return { open, settled, overrides };
+}
+
+// Fold a layer's detected conflicts into the fingerprint-level records list. Open a
+// new record (or refresh an existing open one); close an open record whose dimension
+// now settles. A subject's `dismissed` is sticky — never auto-reopened or closed.
+function upsertConflictRecords(records, layerId, detected, now) {
+  const list = (Array.isArray(records) ? records : []).map((r) => ({ ...r }));
+  const byKey = new Map(list.map((r) => [conflictKey(r.layer, r.field, r.domain), r]));
+  for (const d of detected.open) {
+    const k = conflictKey(layerId, d.field, d.domain);
+    const ex = byKey.get(k);
+    if (ex && ex.status === 'dismissed') continue;
+    if (ex && ex.status === 'open') { ex.last_seen = now; ex.candidates = d.candidates; continue; }
+    const rec = { conflict_id: uuid(), layer: layerId, field: d.field, status: 'open', detected_at: now, last_seen: now, candidates: d.candidates };
+    if (d.domain) rec.domain = d.domain;
+    byKey.set(k, rec);
+  }
+  for (const d of detected.settled) {
+    const ex = byKey.get(conflictKey(layerId, d.field, d.domain));
+    if (ex && ex.status === 'open') { ex.status = 'resolved'; ex.resolved_at = now; }
+  }
+  // Overrides: stage a `resolved` record marked as a system-auto-resolution against a
+  // self-report, so the subject can see + acknowledge or revert. Dismissed records
+  // stay sticky; an existing record gets refreshed last_seen + candidates instead of
+  // duplicating. by:'system' is the cue conflict-review uses to surface for review.
+  for (const d of (detected.overrides || [])) {
+    const k = conflictKey(layerId, d.field, d.domain);
+    const ex = byKey.get(k);
+    if (ex && ex.status === 'dismissed') continue;
+    if (ex) {
+      ex.last_seen = now; ex.candidates = d.candidates;
+      // Don't re-stamp an override the subject already acknowledged (by:'user').
+      if (!ex.resolution || ex.resolution.by !== 'user') {
+        ex.status = 'resolved'; ex.resolved_at = now;
+        ex.resolution = { chosen_value: d.chosen_value, prior_value: d.prior_value, by: 'system' };
+      }
+      continue;
+    }
+    const rec = {
+      conflict_id: uuid(), layer: layerId, field: d.field,
+      status: 'resolved', detected_at: now, last_seen: now, resolved_at: now,
+      candidates: d.candidates,
+      resolution: { chosen_value: d.chosen_value, prior_value: d.prior_value, by: 'system' },
+    };
+    if (d.domain) rec.domain = d.domain;
+    byKey.set(k, rec);
+  }
+  return Array.from(byKey.values());
+}
+
+// Reconcile a full update ({ layerId: layerDoc }) into a fingerprint.
+// Fingerprint shape: { layers: { layerId: layerDoc }, ... }. Returns a new
+// fingerprint object (shallow-cloned down to touched layers). Also stages
+// `conflict_records[]` for genuine self-report↔observed contradictions (above).
+export function reconcileFingerprint(fingerprint, update, opts = {}) {
+  const now = opts.now || new Date().toISOString();
+  const fp = { ...(fingerprint || {}) };
+  fp.layers = { ...(fp.layers || {}) };
+  let conflicts = Array.isArray(fp.conflict_records) ? fp.conflict_records : null;
+  for (const [layerId, incomingLayer] of Object.entries(update || {})) {
+    const prev = fp.layers[layerId];
+    const detected = detectConflicts(prev && prev.signals, incomingLayer.signals);
+    if (detected.open.length || detected.settled.length || (detected.overrides && detected.overrides.length) || (conflicts && conflicts.length)) {
+      conflicts = upsertConflictRecords(conflicts || [], layerId, detected, now);
+    }
+    // Build the summary AFTER the conflict set is finalized, withholding from the
+    // projection (§4.7): (a) any dimension with an OPEN conflict, and (b) any dimension an
+    // AUTHORED bound rule governs — the authored value is canonical for the projection, so
+    // the inferred summary must not restate/contradict it (resolveEffective decides; the
+    // rule is injected separately via renderOperatingRules). authoredGovernedKeys runs over
+    // both the existing and incoming signals so every field that could render is covered.
+    const rules = Array.isArray(fp.standing_rules) ? fp.standing_rules : [];
+    const suppress = new Set([
+      ...openConflictFieldKeys(conflicts, layerId),
+      ...authoredGovernedKeys([...((prev && prev.signals) || []), ...(incomingLayer.signals || [])], rules, opts.domain || null),
+    ]);
+    fp.layers[layerId] = reconcileLayer(prev, incomingLayer, now, suppress, opts.sourceId ? { sourceId: opts.sourceId, context: opts.context } : null);
+  }
+  if (conflicts && conflicts.length) fp.conflict_records = conflicts;
+  return fp;
+}
+
+// Re-render every layer's `summary` from its CURRENT signals, with the same suppression
+// reconcileFingerprint applies (open conflicts + dimensions an authored rule governs).
+//
+// A cross-browser sync merges signals without running a pass (signal-ledger.js mergeLayers), and
+// the injected context reads `summary`, not signals — so without this, evidence that just arrived
+// from another browser would sit in storage and never reach a prompt until this browser's next
+// extraction pass. Returns the same object when no summary changes.
+export function rerenderSummaries(fingerprint, opts = {}) {
+  if (!fingerprint || !fingerprint.layers) return fingerprint;
+  const rules = Array.isArray(fingerprint.standing_rules) ? fingerprint.standing_rules : [];
+  let out = null;
+  for (const [layerId, layer] of Object.entries(fingerprint.layers)) {
+    if (!layer || !Array.isArray(layer.signals) || !layer.signals.length) continue;
+    const suppress = new Set([
+      ...openConflictFieldKeys(fingerprint.conflict_records, layerId),
+      ...authoredGovernedKeys(layer.signals, rules, opts.domain || null),
+    ]);
+    const summary = renderLayerSummary(effectiveSignals(layer.signals).filter(s => s.source !== 'questionnaire'), suppress);
+    if (summary === layer.summary) continue;
+    out = out || { ...fingerprint, layers: { ...fingerprint.layers } };
+    out.layers[layerId] = { ...layer, summary };
+  }
+  return out || fingerprint;
+}
+
+// The (field / field::domain) keys of the OPEN conflicts on a layer — the dimensions
+// the projection withholds (renderLayerSummary skips them).
+function openConflictFieldKeys(records, layerId) {
+  const out = new Set();
+  for (const r of (Array.isArray(records) ? records : [])) {
+    if (r && r.layer === layerId && r.status === 'open') {
+      out.add(r.field + (typeof r.domain === 'string' ? `::${r.domain}` : ''));
+    }
+  }
+  return out;
+}
+
+export { combineConfidence, sigKey };

package/vendor/extraction/resolve.js

@@ -0,0 +1,178 @@
+// §4.7 Conflict Resolution (Proposal 0006, Route A) — pure, deterministic, no I/O.
+//
+// Single source of truth for resolving multiple signals on ONE dimension (field)
+// into a single value + provenance. Evidence-tier precedence (corroborated >
+// observed > self_reported), observation-count then recency tiebreak, with a
+// minimum-evidence FLOOR: thin observed evidence does NOT confidently override a
+// self-reported (interview) value — below the floor a genuine conflict resolves to
+// status:"unresolved", which consumers treat conservatively (assert nothing / an
+// agent escalates rather than proceeds).
+//
+// Lives here (browser-safe ESM, packaged with the extension's extraction engine so
+// the producer can render FROM it) and is re-exported by spec/validate-fingerprint.mjs
+// so the spec test-vectors and mcp/health use the exact same resolver. Pure: any
+// conformant implementation computes the same result from the same evidence log, so
+// the fingerprint stays the raw signal log and provenance is derived (no wire change).
+
+const isObj = (x) => typeof x === 'object' && x !== null && !Array.isArray(x);
+
+export const RESOLUTION_FLOOR = 3;            // observed/corroborated needs ≥ this to override self_reported
+const EV_TIER = { corroborated: 3, observed: 2, self_reported: 1 };
+const tierOf = (s) => EV_TIER[s && s.evidence_basis] || 1;   // unknown basis → weakest
+const obsOf  = (s) => (typeof s.observation_count === 'number' && s.observation_count > 0) ? s.observation_count : 1;
+const isoOf  = (s) => typeof s.last_observed === 'string' ? s.last_observed : '';
+export const valKey = (v) => JSON.stringify(v ?? null);
+
+// Strict total order: tier, then observation_count, then recency, then value
+// string — fully deterministic, no ties.
+function moreAuthoritative(a, b) {
+  if (tierOf(a) !== tierOf(b)) return tierOf(a) - tierOf(b);
+  if (obsOf(a)  !== obsOf(b))  return obsOf(a) - obsOf(b);
+  if (isoOf(a)  !== isoOf(b))  return isoOf(a) < isoOf(b) ? -1 : 1;
+  const va = valKey(a.value), vb = valKey(b.value);
+  return va < vb ? -1 : va > vb ? 1 : 0;
+}
+
+export function resolveDimension(signals) {
+  const cand = (signals || []).filter(isObj);
+  if (!cand.length) return null;
+  const winner = cand.reduce((best, s) => moreAuthoritative(s, best) > 0 ? s : best);
+  const distinct = new Set(cand.map((s) => valKey(s.value)));
+  let status = 'resolved';
+  if (distinct.size > 1) {                                   // a genuine value conflict
+    const inferredWinner = tierOf(winner) >= EV_TIER.observed;
+    const contradictingSelfReport = cand.some(
+      (s) => tierOf(s) === EV_TIER.self_reported && valKey(s.value) !== valKey(winner.value));
+    if (inferredWinner && contradictingSelfReport && obsOf(winner) < RESOLUTION_FLOOR) status = 'unresolved';
+  }
+  return {
+    field: winner.field,
+    value: winner.value,
+    evidence_basis: winner.evidence_basis,
+    confidence: winner.confidence,
+    status,                                                   // "resolved" | "unresolved"
+    provenance: cand.map((s) => ({
+      value: s.value, source: s.source, evidence_basis: s.evidence_basis,
+      confidence: s.confidence, observation_count: s.observation_count, last_observed: s.last_observed,
+    })),
+  };
+}
+
+// Resolve a whole layer's signals → { field: resolution }. Groups by field, then
+// resolveDimension per field. (Polarity precedence per §4.3 is applied upstream by
+// the producer's effectiveSignals(); this resolves VALUE conflicts.)
+export function resolveLayer(signals) {
+  const byField = new Map();
+  for (const s of (signals || [])) {
+    if (!isObj(s) || s.field == null) continue;
+    if (!byField.has(s.field)) byField.set(s.field, []);
+    byField.get(s.field).push(s);
+  }
+  const out = {};
+  for (const [field, sigs] of byField) out[field] = resolveDimension(sigs);
+  return out;
+}
+
+// ── §4.7 effective resolution in context (v0.1.43, resolves OQ7) ──────────────
+//
+// Composes AUTHORED configuration (§5.2 decision-bound standing instructions)
+// with the INFERRED evidence log above, per dimension, in an optional domain
+// context — the exact rules for "a standing instruction that contradicts a
+// high-confidence fingerprint signal in only one domain". The specificity
+// ladder (a lower tier is consulted only when every higher tier is empty):
+//
+//   1. authored_domain — a decision-bound instruction whose decision.domain
+//      matches the context domain (resolver substring namespace: the context
+//      domain string CONTAINS the rule's domain, case-insensitive). A
+//      domain-bound rule NEVER governs outside its domain: with a
+//      non-matching or unknown context it is skipped entirely, so the
+//      inferred signal keeps governing everywhere else — that is the OQ7
+//      one-domain-override semantics.
+//   2. authored_global — a decision-bound instruction with no domain binding.
+//      Authored beats inferred regardless of the signal's confidence or
+//      evidence tier (§4.7 authored-canonical, unchanged — now stated at
+//      dimension granularity).
+//   3. inferred_domain — §4.2.7 domain-tagged signals matching the context
+//      domain, resolved among themselves by resolveDimension. An
+//      "unresolved" here does NOT fall through to tier 4: a contested
+//      domain-specific dimension stays contested (assert nothing).
+//   4. inferred_global — untagged signals, resolved by resolveDimension.
+//      Signals tagged with a DIFFERENT domain are excluded when a context
+//      domain is known (they describe another context); with no context
+//      domain, all signals resolve together (pre-v0.1.43 behavior).
+//
+// Within an authored tier, ties break §5.2-style: lowest priority number,
+// then created_at, then instruction_id — fully deterministic.
+//
+// Pure; same conformance surface as resolveDimension (TC-RESOLVE vectors).
+const prioOf = (r) => (typeof r.priority === 'number' && Number.isFinite(r.priority)) ? r.priority : Infinity;
+const cmpStr = (a, b) => { const x = String(a ?? ''), y = String(b ?? ''); return x < y ? -1 : x > y ? 1 : 0; };
+
+export function resolveEffective({ field, signals = [], rules = [], domain = null } = {}) {
+  if (field == null) return null;
+  const d = (typeof domain === 'string' && domain) ? domain.toLowerCase() : null;
+
+  const bound = (rules || []).filter((r) => isObj(r) && r.kind === 'instruction'
+    && isObj(r.decision) && r.decision.dimension === field);
+  const ruleDomain = (r) => (typeof r.decision.domain === 'string' && r.decision.domain)
+    ? r.decision.domain.toLowerCase() : null;
+  const tier1 = d ? bound.filter((r) => { const rd = ruleDomain(r); return rd && d.includes(rd); }) : [];
+  const tier2 = bound.filter((r) => !ruleDomain(r));
+  const pickRule = (arr) => arr.slice().sort((a, b) =>
+    (prioOf(a) - prioOf(b)) || cmpStr(a.created_at, b.created_at) || cmpStr(a.instruction_id, b.instruction_id))[0];
+
+  const authoredTier = tier1.length ? 'authored_domain' : tier2.length ? 'authored_global' : null;
+  if (authoredTier) {
+    const rule = pickRule(tier1.length ? tier1 : tier2);
+    return {
+      field,
+      status: 'resolved',
+      basis: authoredTier,
+      authored: true,
+      // A bound rule may carry a precise catalog value (template-sourced) or
+      // none — a valueless negative binding is a cautious bias, which §10
+      // consumers already map (consult-policy.js). Surface both faithfully.
+      value: rule.decision.value ?? null,
+      polarity: rule.decision.polarity || 'positive',
+      rule_id: rule.instruction_id || null,
+    };
+  }
+
+  const sigs = (signals || []).filter(isObj);
+  const sigDomain = (s) => (typeof s.domain === 'string' && s.domain) ? s.domain.toLowerCase() : null;
+  const tagged = d ? sigs.filter((s) => { const sd = sigDomain(s); return sd && d.includes(sd); }) : [];
+  const pool = tagged.length ? tagged
+    : d ? sigs.filter((s) => !sigDomain(s))     // other-domain-tagged excluded in a known context
+        : sigs;                                  // no context → all signals (back-compat)
+  const resolved = resolveDimension(pool);
+  if (!resolved) return null;
+  return { ...resolved, basis: tagged.length ? 'inferred_domain' : 'inferred_global', authored: false };
+}
+
+// The (field / field::domain) suppress keys for a layer's INFERRED summary that an
+// AUTHORED bound rule already governs. §4.7 makes a bound rule authored-canonical for
+// its dimension in the projection, so the summary must not ALSO assert a (possibly
+// contradictory) inferred line for that dimension — the authored rule is already injected
+// verbatim (context-block.js renderOperatingRules, higher priority than inferred style).
+// This routes the decision through resolveEffective: a field whose resolution is authored
+// (`authored:true`) has all its rendered-signal keys suppressed. `domain` is optional —
+// null at extraction time, where only authored_GLOBAL rules govern; domain-scoped rules
+// defer to injection-time rendering, which carries the session domain. Pure.
+export function authoredGovernedKeys(signals, rules, domain = null) {
+  const out = new Set();
+  const list = (Array.isArray(signals) ? signals : []).filter(isObj);
+  if (!list.length || !Array.isArray(rules) || !rules.length) return out;
+  const byField = new Map();
+  for (const s of list) {
+    if (typeof s.field !== 'string') continue;
+    if (!byField.has(s.field)) byField.set(s.field, []);
+    byField.get(s.field).push(s);
+  }
+  for (const [field, sigs] of byField) {
+    const r = resolveEffective({ field, signals: sigs, rules, domain });
+    if (r && r.authored) {
+      for (const s of sigs) out.add(s.field + (typeof s.domain === 'string' ? `::${s.domain}` : ''));
+    }
+  }
+  return out;
+}

package/vendor/extraction/rule-promotion.js

@@ -0,0 +1,103 @@
+// Proposal 0007 §E — delta promotion (the steady-state path).
+//
+// When the extraction engine's INFERRED Decision & Risk signals show a pattern that
+// has recurred enough to be established (evidence_basis observed/corroborated,
+// observation_count ≥ floor) and the subject has NOT already turned it into an
+// authored rule, propose a `suggested` standing rule into a STAGING queue
+// (`phaedo_fingerprint.suggested_rules`). This is the one rule-shaped object the
+// producer writes — and it is explicitly a *proposal*: never injected, never
+// consulted. Only the subject's endorsement (rule-review.js) turns a suggestion into
+// an authored `standing_rules` entry. So the authored-only invariant on standing_rules
+// holds: the producer stages, the user authors.
+//
+// Pure + deterministic, zero-dep — the house style. The review UI lets the subject
+// edit the proposed text before endorsing, so `proposed_text` only needs to be a
+// reasonable starting sentence.
+
+import '../trait-phrases.js';   // UMD side-effect import → globalThis.PhaedoTraitPhrases
+
+export const PROMOTION_FLOOR = 3;                       // §4.7 RESOLUTION_FLOOR — same "established" bar
+const PROMOTABLE_TIERS = new Set(['observed', 'corroborated']); // never promote a self_reported guess
+const DR_LAYER = 'decision_and_risk';
+
+const uuid = () =>
+  (typeof crypto !== 'undefined' && crypto.randomUUID) ? crypto.randomUUID()
+    : 'sug-' + Math.random().toString(36).slice(2, 10);
+
+const keyOf = (dim, val) => `${dim}::${JSON.stringify(val ?? null)}`;
+
+// (dimension, value) → the candidate sentence, from the shared phrasebook (trait-phrases.js):
+// one written sentence for every trait and value, so a suggestion never reads
+// "I have a consistent way I handle … (0.85)". The subject can still edit before endorsing.
+export function proposeText(dimension, value) {
+  return globalThis.PhaedoTraitPhrases.phrase(dimension, value);
+}
+
+function endorsedDimensions(fp) {
+  const rules = Array.isArray(fp?.standing_rules) ? fp.standing_rules : [];
+  return new Set(rules.map((r) => r?.decision?.dimension).filter(Boolean));
+}
+function stagedKeys(fp) {
+  const sug = Array.isArray(fp?.suggested_rules) ? fp.suggested_rules : [];
+  return new Set(sug.map((s) => keyOf(s?.decision?.dimension, s?.evidence?.value)));
+}
+
+// Inspect a fingerprint's Decision & Risk signals and return suggested-rule
+// candidates (does NOT mutate the fingerprint). A candidate is produced for an
+// established, not-yet-authored, not-yet-staged/dismissed (dimension,value).
+export function detectPromotions(fp, { floor = PROMOTION_FLOOR, now = new Date().toISOString() } = {}) {
+  const dr = fp?.layers?.[DR_LAYER];
+  const signals = Array.isArray(dr?.signals) ? dr.signals : [];
+  const covered = endorsedDimensions(fp);
+  const seen = stagedKeys(fp);                // already suggested OR dismissed → skip
+  const local = new Set();
+  const out = [];
+  for (const s of signals) {
+    if (!s || typeof s !== 'object') continue;
+    const dim = s.dimension || s.field;
+    if (!dim) continue;
+    if (!PROMOTABLE_TIERS.has(s.evidence_basis)) continue;
+    if ((s.observation_count || 0) < floor) continue;
+    if (covered.has(dim)) continue;            // already an authored rule on this dimension
+    const k = keyOf(dim, s.value);
+    if (seen.has(k) || local.has(k)) continue;
+    local.add(k);
+    out.push({
+      suggestion_id: uuid(),
+      status: 'suggested',
+      source: 'delta_promotion',
+      proposed_text: proposeText(dim, s.value),
+      decision: { dimension: dim, polarity: s.polarity === 'negative' ? 'negative' : 'positive', ...(s.domain ? { domain: s.domain } : {}) },
+      evidence: {
+        observation_count: s.observation_count || 0,
+        last_observed: s.last_observed || null,
+        evidence_basis: s.evidence_basis,
+        value: s.value,
+        ...(s.signal_id ? { signal_id: s.signal_id } : {}),
+      },
+      created: now,
+    });
+  }
+  return out;
+}
+
+// Merge new suggestions into the staging queue (dedup by dimension+value). Writes
+// ONLY suggested_rules — never standing_rules. Returns a new fingerprint.
+export function stageSuggestions(fp, suggestions) {
+  if (!Array.isArray(suggestions) || !suggestions.length) return fp;
+  const existing = Array.isArray(fp?.suggested_rules) ? fp.suggested_rules : [];
+  const seen = stagedKeys(fp);
+  const add = suggestions.filter((s) => {
+    const k = keyOf(s?.decision?.dimension, s?.evidence?.value);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+  if (!add.length) return fp;
+  return { ...fp, suggested_rules: [...existing, ...add] };
+}
+
+// Producer convenience: detect + stage in one pass.
+export function promoteRules(fp, opts) {
+  return stageSuggestions(fp, detectPromotions(fp, opts));
+}