phaedo-mcp 0.3.21 → 0.3.22

package/hooks/pre-ship.mjs

@@ -506,6 +506,7 @@ export async function realDeps({ agentId = AGENT_ID, statePath } = {}) {
   const { resolveConsultation, consultDrivers, withRevision, checkAuthorization } = await import('../consult.js');
   const { buildReceipt, appendReceipt, receiptsCapFromEnv, readReceipts } = await import('../receipts.js');
   const { sourceOf } = await import('../fingerprint-source.js');
+  const { precedentAdjustment } = await import('../precedent.js');
   const { defaultStateDir } = await import('../cache.js');
   const stateDir = defaultStateDir();
   const quiet = () => {};
@@ -531,9 +532,14 @@ export async function realDeps({ agentId = AGENT_ID, statePath } = {}) {
     async consult(request) {
       const vd = await loadConsultVd(MCP_DIR, { preferCache: true, warn: quiet, onRead: (plain) => { readSource = sourceOf(plain); } });
       consultedVd = vd;
-      const response = await resolveConsultation(vd, request, opts);
+      let response = await resolveConsultation(vd, request, opts);
       let drivers = [];
       try { drivers = withRevision(consultDrivers(vd, request, opts), response); } catch { /* provenance is non-critical */ }
+      // Your past decisions in this situation move the confidence only (precedent.js Phase 3).
+      try {
+        const adj = precedentAdjustment(await readReceipts(stateDir), { request, drivers, response });
+        if (adj) { response = { ...response, confidence: adj.confidence }; drivers = [adj.driver, ...drivers]; }
+      } catch { /* precedent is non-critical */ }
       // The plain read's provenance — `sourceOf(vd)` on the overlay always says "live", which is
       // also why the 14-day refresh nudge below never fired before 0.3.17.
       return { response, drivers, source: readSource };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phaedo-mcp",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",

package/precedent.js

@@ -6,8 +6,21 @@
 // derived view that would say so — over the §10.6 receipt store, never a stored artifact.
 //
 // PURE: (receipts, opts) -> report. No I/O, `now` injected — the agreement.js discipline.
-// NOT WIRED into consult: 0009 is a draft, and its rail 4 says precedent informs and never
-// authorizes. Dev-only readout: `npm run precedent`.
+// Readout: `npm run precedent`.
+//
+// PHASE 3 (2026-11-03, Randy: "Yes, all four" — design doc §9 decisions 2–5). A consult now reads
+// the precedent for its own situation, and it moves the answer's CONFIDENCE only:
+//   - the key is CONSULT_FIELDS: domain × kind × reversible × magnitude × amount band × binding.
+//     The amount bands are the subject's own edges; size/touched stay out until most receipts
+//     carry them (0009 Decided 1). On the reference store this groups exactly as the coarse key;
+//   - N = 5 within 180 days (the defaults below);
+//   - the SIGNAL never changes — not escalate → decisive, never anything → autoproceed (rail 4);
+//   - confidence is RAISED only once rejections are measured for the shape (MIN_SUPPORT marked
+//     decisions since "no" capture shipped, NO_CAPTURE_SINCE). Before that, "no" is undercounted
+//     and every shape looks agreeable, so precedent may only LOWER confidence (0009 Decided 3);
+//   - the counts reach NO agent. Disclosure is scoped to agents the subject allowed (decision 2),
+//     and in this version that set is empty — the counts stay on the device, in the receipt's
+//     `precedent` driver. Only the moved confidence crosses, a field every answer already has.
 //
 // The SHAPE is the situation key — banded features only, a closed vocabulary per field, so
 // nothing a receipt holds on-device (summary, exact amount, counterparty, ids, previews) can
@@ -42,6 +55,17 @@ export const DEFAULT_WINDOW_DAYS = 180;
 export const MIN_SUPPORT = 5;
 export const BATCH_MIN = 3;                 // this many marks inside BATCH_WINDOW_MS = a burst
 export const PREFLIGHT_VIA = 'phaedo_check_authorization';
+// The key a consult matches on (Phase 3): every field but size/touched.
+export const CONSULT_FIELDS = Object.freeze(['domain', 'kind', 'reversible', 'magnitude', 'amount_band', 'binding']);
+// Claude Code's ship hook began recording a denied prompt here (phaedo-mcp 0.3.14). Before it,
+// a "no" reached the store only if the agent remembered to record one.
+export const NO_CAPTURE_SINCE = Date.parse('2026-10-27T00:00:00Z');
+export const RECENT_MISS_DAYS = 30;
+const RAISE_AT = 0.9;         // this share of your outcomes agree with the answer → more sure
+const LOWER_BELOW = 0.6;      // under this share → less sure
+const RAISE_BY = 0.1;
+const LOWER_FACTOR = 0.75;
+const CEILING = 0.95;         // precedent alone never makes an inferred answer certain
 
 const DAY = 24 * 60 * 60 * 1000;
 const OUTCOMES = new Set(['approved', 'rejected', 'modified']);
@@ -173,6 +197,9 @@ export function precedentFor(receipts, shape, {
   if (main.length < minSupport) return null;
   const pre = match.filter(({ r }) => r.via === PREFLIGHT_VIA);
   const { observed, user_actions, oracle_agreement, most_recent_divergence_days_ago } = tally(main, now);
+  // The bias disclosed beside the figure (0009 Decided 3): enough of these decisions postdate
+  // "no" capture that a rejection rate is measured, not missing.
+  const rejections_measured = main.filter(({ t }) => t >= NO_CAPTURE_SINCE).length >= minSupport;
   return {
     shape: projectShape(shape, fields),
     shape_revision: SHAPE_REVISION,
@@ -181,10 +208,46 @@ export function precedentFor(receipts, shape, {
     oracle_agreement,
     window_days: windowDays,
     most_recent_divergence_days_ago,
+    rejections_measured,
     preflight: { observed: pre.length, user_actions: tally(pre, now).user_actions },
   };
 }
 
+const round2 = (x) => Math.round(x * 100) / 100;
+
+/**
+ * How the subject's past decisions in this situation bear on a consult's answer (Phase 3).
+ * `request` is the consult request, `drivers` its provenance (the amount band rides there),
+ * `response` the answer after every guard. Returns null when precedent has nothing to say —
+ * an undecisive signal, no confidence, or under minimum support — else
+ *   { confidence, effect: 'raised' | 'lowered' | 'held', driver }
+ * where `driver` is the on-device receipt entry: `precedent`, value `<effect>:<agreeing>/<observed>`.
+ * Never touches the signal (rail 4). Pure.
+ */
+export function precedentAdjustment(receipts, { request, drivers, response } = {}, opts = {}) {
+  const signal = response?.signal;
+  if (!DECISIVE.includes(signal) || typeof response.confidence !== 'number') return null;
+  const p = precedentFor(receipts, shapeOf({ request, drivers }), { ...opts, fields: CONSULT_FIELDS });
+  if (!p) return null;
+  const agreeing = signal === 'decline' ? p.user_actions.rejected : p.user_actions.approved;
+  const share = agreeing / p.observed;
+  const recentMiss = p.most_recent_divergence_days_ago !== null && p.most_recent_divergence_days_ago <= RECENT_MISS_DAYS;
+  let effect = 'held';
+  let confidence = response.confidence;
+  if (share < LOWER_BELOW || recentMiss) {
+    effect = 'lowered';
+    confidence = round2(confidence * LOWER_FACTOR);
+  } else if (share >= RAISE_AT && p.rejections_measured && confidence < CEILING) {
+    effect = 'raised';
+    confidence = round2(Math.min(CEILING, confidence + RAISE_BY));
+  }
+  return {
+    confidence,
+    effect,
+    driver: { cue: 'precedent', value: `${effect}:${agreeing}/${p.observed}`, confidence: null, basis: 'observed' },
+  };
+}
+
 /**
  * The divergence episodes — the only thing 0009's principle says is worth keeping: receipts
  * where a decisive prediction did not match what the subject did. Banded, newest first.
@@ -236,6 +299,46 @@ export function precedentTable(receipts, {
   };
 }
 
+/**
+ * Did precedent help? (Randy, 2026-11-05: "improve what we built".) Over the receipts it touched
+ * since `since`: how often it made an answer less sure, more sure or left it, and — among those
+ * the subject has since marked — how often that was right. Lowering was right when the subject
+ * decided against the answer; raising was right when they decided with it. Pure.
+ */
+export function precedentCheck(receipts, { now = Date.now(), since = 0 } = {}) {
+  const out = {
+    lowered: { n: 0, marked: 0, right: 0 },
+    raised: { n: 0, marked: 0, right: 0 },
+    held: { n: 0, marked: 0, right: 0 },
+  };
+  for (const r of Array.isArray(receipts) ? receipts : []) {
+    const t = Date.parse(r?.created_at);
+    if (!Number.isFinite(t) || t < since || t > now) continue;
+    const d = Array.isArray(r?.drivers) ? r.drivers.find((x) => x?.cue === 'precedent') : null;
+    const effect = typeof d?.value === 'string' ? d.value.split(':')[0] : null;
+    if (!out[effect]) continue;
+    out[effect].n++;
+    if (!OUTCOMES.has(r?.user_action) || !DECISIVE.includes(r?.response?.signal)) continue;
+    out[effect].marked++;
+    const sided = agrees(r.response.signal, r.user_action);
+    if (effect === 'lowered' ? !sided : sided) out[effect].right++;
+  }
+  return out;
+}
+
+export function formatCheck(c) {
+  const total = c.lowered.n + c.raised.n + c.held.n;
+  if (!total) return 'Your past decisions have not touched an answer yet.';
+  const line = (label, x, rightWord) => x.n
+    ? `  ${label} ${x.n}× — ${x.marked ? `${x.right} of ${x.marked} you decided were ${rightWord}` : 'none decided yet'}`
+    : null;
+  return ['How your past decisions changed answers:',
+    line('Less sure', c.lowered, 'right to doubt'),
+    line('More sure', c.raised, 'right to trust'),
+    line('Unchanged', c.held, 'as answered'),
+  ].filter(Boolean).join('\n');
+}
+
 const show = (shape) => Object.entries(shape).filter(([, v]) => v !== null && v !== 'none' && v !== '(none)').map(([k, v]) => `${k}=${v}`).join(' ');
 
 export function formatTable(t) {
@@ -263,5 +366,5 @@ if (isMainModule(import.meta.url)) {
   const { defaultStateDir } = await import('./cache.js');
   const receipts = await readReceipts(defaultStateDir()).catch(() => []);
   const t = precedentTable(receipts, { windowDays: num('--days', DEFAULT_WINDOW_DAYS), minSupport: num('--min', MIN_SUPPORT), fields: fields.length ? fields : SHAPE_FIELDS });
-  process.stdout.write(formatTable(t) + '\n');
+  process.stdout.write(formatTable(t) + '\n\n' + formatCheck(precedentCheck(receipts)) + '\n');
 }

package/server.js

@@ -32,6 +32,7 @@ import { resolveConsultation, checkAuthorization, standingRuleRelaxes, CONSULTAT
 import { defaultStateDir, readCacheTime } from './cache.js';
 import { ruleLeeway, RULE_FRESH_DAYS } from './lib/rule-leeway.js';
 import { standingRuleDriver } from './weekly.js';
+import { precedentAdjustment } from './precedent.js';
 import { buildConsultOpts, loadConsultVd } from './consult-runtime.js';
 import { buildReceipt, appendReceipt, receiptsCapFromEnv, readReceipts, markOutcome, USER_ACTIONS } from './receipts.js';
 
@@ -105,6 +106,19 @@ async function guardFacts(vd, req, ruleDecided = ruleRelaxes(vd, req)) {
 
 // The receipt's note that one of the subject's standing rules let this go ahead (weekly.js counts
 // it for the phone). First in the list, since buildReceipt keeps only the first 16 drivers.
+// Situational precedent (precedent.js Phase 3): the subject's past decisions in this situation
+// may move the answer's confidence, never its signal. The counts stay on the receipt (the
+// `precedent` driver); no agent is allowed them yet. Best-effort: a failure leaves the answer as is.
+async function withPrecedent(req, response, drivers) {
+  try {
+    const adj = precedentAdjustment(await readReceipts(defaultStateDir()), { request: req, drivers, response });
+    if (!adj) return { response, drivers };
+    return { response: { ...response, confidence: adj.confidence }, drivers: [adj.driver, ...drivers] };
+  } catch {
+    return { response, drivers };
+  }
+}
+
 function ruleAnsweredDriver(vd, req, response) {
   if (response?.signal !== 'proceed') return [];
   try { return standingRuleDriver(checkAuthorization(vd, req, CONSULT_OPTS), response); } catch { return []; }
@@ -382,11 +396,12 @@ server.registerTool(
       // profile with no downgrade and no provenance. That is the 2026-07-25 device defect (a
       // revoked $500 grant honoured from a 22h cache) still live on the paths that matter most.
       const raw = await resolveConsultation(vd, args || {}, CONSULT_OPTS);
-      const response = withStaleAuthorityGuard(raw, vd, await guardFacts(vd, args || {}));
+      let response = withStaleAuthorityGuard(raw, vd, await guardFacts(vd, args || {}));
       // Provenance for the local audit receipt only — the cues that drove this
       // (never in `response`; §10.4). Best-effort: a failure must not block the answer.
       let drivers = [];
       try { drivers = withRevision(consultDrivers(vd, args || {}, CONSULT_OPTS), raw); } catch { /* provenance is non-critical */ }
+      ({ response, drivers } = await withPrecedent(args || {}, response, drivers));
       drivers = [...ruleAnsweredDriver(vd, args || {}, response), ...drivers];
       const receiptId = await emitReceipt('phaedo_consult', args, response, drivers); // every resolution, abstains included
       if (receiptId) response.receipt_id = receiptId;   // the handle for phaedo_record_outcome
@@ -600,9 +615,10 @@ server.registerTool(
       // and then told the agent the signal was not blocking — i.e. "just proceed", and never
       // wake the subject, on authority that may have been revoked hours earlier.
       const raw = await resolveConsultation(vd, req, CONSULT_OPTS);
-      const response = withStaleAuthorityGuard(raw, vd, await guardFacts(vd, req));
+      let response = withStaleAuthorityGuard(raw, vd, await guardFacts(vd, req));
       let drivers = [];
       try { drivers = withRevision(consultDrivers(vd, req, CONSULT_OPTS), raw); } catch { /* non-critical */ }
+      ({ response, drivers } = await withPrecedent(req, response, drivers));
       drivers = [...ruleAnsweredDriver(vd, req, response), ...drivers];
       const escReceiptId = await emitReceipt('phaedo_escalate', req, response, drivers);   // the decision being escalated
       await maybeDepositReceiptsDigest();                              // G1+G2 audit channel

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.phaedo-labs/phaedo-mcp",
   "description": "Make AI apps answer your way, check with you before acting, and get approvals on your phone.",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "repository": {
     "url": "https://github.com/phaedo-labs/phaedo-mcp",
     "source": "github",
@@ -13,7 +13,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "phaedo-mcp",
-      "version": "0.3.21",
+      "version": "0.3.22",
       "transport": {
         "type": "stdio"
       }

package/weekly.js

@@ -13,6 +13,9 @@
 // "Handled" is went_ahead + stopped. `by_rule` is the part of went_ahead that one of the subject's
 // standing rules decided — the receipt carries a `standingRule` (server) or `standingGrant` (ship
 // hook) driver saying so — which is how they see a rule they accepted actually being used.
+// `less_sure` / `more_sure` count the answers the subject's own past decisions moved (precedent.js
+// Phase 3: the receipt's `precedent` driver says `lowered:` / `raised:`), so they see that working
+// too — without the counts themselves, which never leave this computer.
 // Pure over the receipts list; the CLI reads the local store.
 //
 //   npm run week
@@ -22,6 +25,7 @@ import { defaultStateDir } from './cache.js';
 import { isMainModule } from './lib/is-main.js';
 
 export const WEEK_DAYS = 7;
+export const SUMMARY_MAX = 240;   // mobile/src/lib/receiptsSync.ts parseWeek
 const DAY_MS = 24 * 60 * 60 * 1000;
 const BUCKET = {
   proceed: 'went_ahead', proceed_with_note: 'went_ahead',
@@ -45,15 +49,25 @@ export function standingRuleDriver(auth, response) {
     ? [{ cue: 'standingRule', value: 'answered', confidence: 1, basis: 'authored' }] : [];
 }
 
+/** What the subject's past decisions did to this answer: 'lowered' | 'raised' | 'held' | null. */
+export function precedentEffect(r) {
+  const d = Array.isArray(r?.drivers) ? r.drivers.find((x) => x?.cue === 'precedent') : null;
+  const effect = typeof d?.value === 'string' ? d.value.split(':')[0] : null;
+  return effect === 'lowered' || effect === 'raised' || effect === 'held' ? effect : null;
+}
+
 export function weeklyHandled(receipts, { now = Date.now(), days = WEEK_DAYS } = {}) {
   const since = now - days * DAY_MS;
-  const out = { days, went_ahead: 0, by_rule: 0, stopped: 0, came_to_you: 0, unsure: 0 };
+  const out = { days, went_ahead: 0, by_rule: 0, stopped: 0, came_to_you: 0, unsure: 0, less_sure: 0, more_sure: 0 };
   for (const r of Array.isArray(receipts) ? receipts : []) {
     const t = Date.parse(r?.created_at);
     if (!Number.isFinite(t) || t < since || t > now) continue;
     const b = BUCKET[r?.response?.signal];
     if (b) out[b]++;
     if (b === 'went_ahead' && answeredByRule(r)) out.by_rule++;
+    const p = precedentEffect(r);
+    if (p === 'lowered') out.less_sure++;
+    else if (p === 'raised') out.more_sure++;
   }
   out.handled = out.went_ahead + out.stopped;
   out.total = out.handled + out.came_to_you + out.unsure;
@@ -61,6 +75,7 @@ export function weeklyHandled(receipts, { now = Date.now(), days = WEEK_DAYS } =
 }
 
 const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const times = (n) => (n === 1 ? 'once' : n === 2 ? 'twice' : `${n} times`);
 
 /** One plain sentence (two at most) for a person. */
 export function formatWeekly(w) {
@@ -74,7 +89,12 @@ export function formatWeekly(w) {
   const asked = w.came_to_you ? ` and brought ${w.came_to_you} to you` : '';
   const rule = w.by_rule ? ` Your standing rule decided ${w.handled === 1 ? 'it' : `${w.by_rule === 1 ? 'one' : w.by_rule} of them`}.` : '';
   const unsure = w.unsure ? ` ${w.unsure === 1 ? 'One more was' : `${w.unsure} more were`} too unclear to call.` : '';
-  return `${handled}${asked}.${rule}${unsure}`;
+  const sure = [w.less_sure ? `less sure ${times(w.less_sure)}` : '', w.more_sure ? `surer ${times(w.more_sure)}` : '']
+    .filter(Boolean).join(', ');
+  const past = sure ? ` Past choices made it ${sure}.` : '';
+  // The phone shows SUMMARY_MAX characters; this sentence is the one to drop rather than be cut.
+  const full = `${handled}${asked}.${rule}${past}${unsure}`;
+  return full.length <= SUMMARY_MAX ? full : `${handled}${asked}.${rule}${unsure}`;
 }
 
 if (isMainModule(import.meta.url)) {