phaedo-mcp 0.3.0 → 0.3.2

package/ship-actions.js

@@ -0,0 +1,164 @@
+// Ship actions — which shell commands are a decision the subject would want consulted on.
+//
+// The precedent track's Phase 1 (docs/roadmap/precedent-and-sync-design-2026-09-13.md) is
+// starved of outcome data because nothing consults: no receipt has been written since
+// 2026-07-28. The decisions the subject actually delegates, every week, are the ones a
+// coding agent takes on their behalf — merging a PR, deploying the relay, cutting a phone
+// build. This module names those, so the PreToolUse hook (hooks/pre-ship.mjs) can consult
+// before they run. Everything else a shell does is not a decision and is ignored.
+//
+// PURE: (command string) -> classification | null. No I/O.
+
+import { createHash } from 'node:crypto';
+
+// One entry per class. `match` sees one simple command, already split out of a compound
+// line and stripped of env assignments and `npx`. The descriptor is what the consult
+// reasons about — magnitude is the stakes, reversible is whether it can be walked back.
+const CLASSES = [
+  {
+    id: 'merge_pr',
+    // `gh pr merge` — reversible (a revert), medium. `--admin` skips required checks, which
+    // is a different act: high.
+    match: (w) => w[0] === 'gh' && w[1] === 'pr' && w[2] === 'merge',
+    describe: (w) => {
+      const num = w.slice(3).find((x) => /^#?\d+$/.test(x));
+      const admin = w.includes('--admin');
+      // `-R/--repo` names the repository when the agent is not inside it; the hook passes it
+      // through when it asks GitHub for the PR's check state (B6).
+      const ri = w.findIndex((x) => x === '-R' || x === '--repo');
+      const repo = ri >= 0 ? w[ri + 1] : (w.find((x) => x.startsWith('--repo='))?.split('=')[1]);
+      return {
+        magnitude: admin ? 'high' : 'medium',
+        reversible: true,
+        summary: `${admin ? 'admin-merge' : 'merge'} ${num ? `PR #${num.replace('#', '')}` : "this branch's PR"}`,
+        pr: num ? num.replace('#', '') : null,
+        repo: repo || null,
+      };
+    },
+  },
+  {
+    id: 'deploy',
+    // `fly deploy` — production for every paired phone. Reversible (`fly releases` rollback)
+    // but high: a bad relay breaks sync for everyone until it is rolled back.
+    match: (w) => (w[0] === 'fly' || w[0] === 'flyctl') && w[1] === 'deploy',
+    describe: (w) => {
+      const i = w.findIndex((x) => x === '-a' || x === '--app');
+      const app = i >= 0 ? w[i + 1] : null;
+      return { magnitude: 'high', reversible: true, summary: `deploy${app ? ` ${app}` : ''} to Fly` };
+    },
+  },
+  {
+    id: 'app_build',
+    // `eas build` — a build artifact, nothing reaches a device yet. Low.
+    match: (w) => isEas(w[0]) && w[1] === 'build',
+    describe: (w) => ({ magnitude: 'low', reversible: true, summary: `phone build${platform(w)}` }),
+  },
+  {
+    id: 'app_submit',
+    // `eas submit` (or `eas build --auto-submit`) — the build goes to TestFlight / the store.
+    match: (w) => isEas(w[0]) && (w[1] === 'submit' || (w[1] === 'build' && w.includes('--auto-submit'))),
+    describe: (w) => ({ magnitude: 'medium', reversible: true, summary: `submit phone build${platform(w)}` }),
+  },
+  {
+    id: 'push_main',
+    // A direct push to the default branch, skipping review. A force-push there rewrites
+    // shared history: high, and not cleanly reversible.
+    match: (w) => w[0] === 'git' && w[1] === 'push' && w.slice(2).some((x) => /^\+?(?:[^:]*:)?(?:refs\/heads\/)?(?:main|master)$/.test(x)),
+    describe: (w) => {
+      const force = w.some((x) => x === '-f' || x === '--force' || x.startsWith('--force-with-lease') || x.startsWith('+'));
+      return force
+        ? { magnitude: 'high', reversible: false, summary: 'force-push to main' }
+        : { magnitude: 'medium', reversible: true, summary: 'push directly to main' };
+    },
+  },
+];
+
+// Order matters for one pair: `eas build --auto-submit` is a submit, not a build.
+const ORDER = ['merge_pr', 'deploy', 'app_submit', 'app_build', 'push_main'];
+
+function isEas(w0) { return w0 === 'eas' || w0 === 'eas-cli'; }
+function platform(w) {
+  const i = w.findIndex((x) => x === '--platform' || x === '-p');
+  const p = i >= 0 ? w[i + 1] : (w.find((x) => x.startsWith('--platform='))?.split('=')[1]);
+  return p ? ` (${p})` : '';
+}
+
+// Split a shell line into simple commands on && || ; | and newlines. Not a shell parser —
+// quotes are honoured only enough that `git commit -m "a && b"` does not split.
+export function splitCommands(line) {
+  const out = [];
+  let cur = '';
+  let q = null;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (q) { cur += c; if (c === q) q = null; continue; }
+    if (c === '"' || c === "'") { q = c; cur += c; continue; }
+    if (c === '\n' || c === ';' || c === '|' || (c === '&' && line[i + 1] === '&')) {
+      if (c === '&' || (c === '|' && line[i + 1] === '|')) i++;
+      out.push(cur); cur = '';
+      continue;
+    }
+    cur += c;
+  }
+  out.push(cur);
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+
+// Words of one simple command, with leading env assignments, `npx`/`npx --yes`, and a
+// quoted-string's quotes removed.
+export function words(cmd) {
+  const w = (cmd.match(/"[^"]*"|'[^']*'|\S+/g) || []).map((x) => x.replace(/^["']|["']$/g, ''));
+  while (w.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(w[0])) w.shift();
+  if (w[0] === 'npx') { w.shift(); while (w[0] && w[0].startsWith('-')) w.shift(); }
+  // A path to the binary (`/opt/homebrew/bin/gh`, `./node_modules/.bin/eas`) is the binary.
+  if (w[0]) w[0] = w[0].split('/').pop();
+  return w;
+}
+
+// Stakes order for a line that chains several ship actions: irreversible first, then by
+// magnitude. A line that merges and then deploys is consulted on the deploy — consulting on
+// the merge would let the riskier half ride on the safer half's answer.
+const MAG_RANK = { low: 0, medium: 1, high: 2 };
+const stakes = (d) => (d.reversible === false ? 10 : 0) + (MAG_RANK[d.magnitude] ?? 1);
+
+/**
+ * Classify a Bash command. Returns null when no part of it is a ship action, else the
+ * highest-stakes ship action in it (ties: the first), with `multiple` set when the line
+ * chains more than one.
+ *
+ * @returns {null | { class, summary, multiple, action_descriptor, action_binding }}
+ */
+export function classifyShipCommand(command) {
+  if (typeof command !== 'string' || !command.trim()) return null;
+  const hits = [];
+  for (const seg of splitCommands(command)) {
+    const w = words(seg);
+    if (!w.length) continue;
+    for (const id of ORDER) {
+      const k = CLASSES.find((c) => c.id === id);
+      if (k.match(w)) { hits.push({ id, seg, d: k.describe(w) }); break; }
+    }
+  }
+  if (!hits.length) return null;
+  const first = hits.reduce((best, h) => (stakes(h.d) > stakes(best.d) ? h : best));
+  return {
+    class: first.id,
+    summary: first.d.summary,
+    multiple: hits.length > 1,
+    // merge_pr only: which PR, and in which repo (null = the current branch's, here).
+    ...(first.id === 'merge_pr' ? { pr: first.d.pr, repo: first.d.repo } : {}),
+    action_descriptor: {
+      domain: 'engineering',
+      reversible: first.d.reversible,
+      magnitude: first.d.magnitude,
+      summary: first.d.summary,
+    },
+    // §10.2 binding: the concrete call this descriptor claims to describe — a digest of the
+    // whole line, never the line itself beyond a short preview.
+    action_binding: {
+      tool_name: 'Bash',
+      arguments_hash: createHash('sha256').update(command).digest('hex'),
+      arguments_preview: first.seg.slice(0, 120),
+    },
+  };
+}

package/ship-readout.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// Ship-hook readout — what the Claude Code ship hook (hooks/pre-ship.mjs) has seen: how many
+// merges / deploys / phone builds it consulted on, what Phaedo answered, what the subject
+// said, and whether agreement has anything to score yet. The precedent track's Phase 1
+// exit is "receipts gain marked outcomes in normal use"; this is how to see whether they do.
+//
+//   npm run ship-readout              # last 30 days
+//   npm run ship-readout -- --days 90
+//
+// All local: decrypts the receipt store with the local key; prints counts and the summary
+// line each receipt already carries (never layer content).
+
+import { computeAgreement } from './agreement.js';
+import { AGENT_ID } from './hooks/pre-ship.mjs';
+
+export const DEFAULT_DAYS = 30;
+const PERMISSIVE = new Set(['proceed', 'proceed_with_note']);
+const ASKING = new Set(['escalate', 'clarify', 'decline']);
+
+// The action a hook receipt was about, from the summary ship-actions.js wrote.
+export function actionKind(summary) {
+  const s = String(summary || '');
+  if (/^(admin-)?merge\b/.test(s)) return 'merge';
+  if (/^deploy\b/.test(s)) return 'deploy';
+  if (/^submit\b/.test(s)) return 'phone submit';
+  if (/^phone build\b/.test(s)) return 'phone build';
+  if (/push/.test(s)) return 'push to main';
+  return 'other';
+}
+
+/**
+ * (receipts, { now, windowDays }) -> the readout, PURE. Only receipts the ship hook wrote
+ * count — the agreement figure here is the hook's own, not the whole store's.
+ */
+export function shipReadout(receipts, { now = Date.now(), windowDays = DEFAULT_DAYS } = {}) {
+  const since = now - windowDays * 24 * 60 * 60 * 1000;
+  const mine = (Array.isArray(receipts) ? receipts : []).filter((r) => r?.agent_id === AGENT_ID);
+  const inWindow = mine.filter((r) => { const t = Date.parse(r?.created_at); return Number.isFinite(t) && t >= since && t <= now; });
+  const kinds = {};
+  const answers = { go_ahead: 0, flagged: 0, unsure: 0 };
+  const outcomes = { approved: 0, rejected: 0, modified: 0, unmarked: 0 };
+  for (const r of inWindow) {
+    const k = actionKind(r.request?.action_descriptor?.summary);
+    kinds[k] = (kinds[k] || 0) + 1;
+    const sig = r.response?.signal;
+    if (PERMISSIVE.has(sig)) answers.go_ahead++; else if (ASKING.has(sig)) answers.flagged++; else answers.unsure++;
+    const a = r.user_action;
+    if (a === 'approved' || a === 'rejected' || a === 'modified') outcomes[a]++; else outcomes.unmarked++;
+  }
+  const agreement = computeAgreement(inWindow, { now, windowDays }).overall;
+  const newest = inWindow[inWindow.length - 1] || null;
+  return {
+    window_days: windowDays,
+    total_ever: mine.length,
+    consults: inWindow.length,
+    kinds,
+    answers,
+    outcomes,
+    agreement: { scored: agreement.scored, agreements: agreement.agreements, rate: agreement.rate },
+    newest: newest && {
+      at: newest.created_at,
+      summary: newest.request?.action_descriptor?.summary || null,
+      signal: newest.response?.signal || null,
+      user_action: newest.user_action || null,
+    },
+  };
+}
+
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const KIND_PLURAL = { merge: 'merges', deploy: 'deploys', 'phone build': 'phone builds', 'phone submit': 'phone submits', 'push to main': 'pushes to main', other: 'others' };
+const saidIt = (sig) => (PERMISSIVE.has(sig) ? 'go ahead' : ASKING.has(sig) ? 'flagged for you' : "didn't know");
+
+// Plain lines for the terminal. No confidences, no protocol terms beyond the summary.
+export function formatReadout(o) {
+  const lines = [`Ship hook — last ${o.window_days} days`];
+  if (!o.consults) {
+    lines.push(o.total_ever
+      ? `  Nothing in this window (${plural(o.total_ever, 'consult')} before it). Try --days ${o.window_days * 3}.`
+      : '  No consults yet. Is the hook installed? (npm run setup:code-hook, then a new Claude Code session)');
+    return lines.join('\n');
+  }
+  const kinds = Object.entries(o.kinds).sort((a, b) => b[1] - a[1]).map(([k, n]) => plural(n, k, KIND_PLURAL[k]));
+  lines.push(`  ${plural(o.consults, 'consult')}: ${kinds.join(', ')}`);
+  const ans = [`go ahead ${o.answers.go_ahead}×`, `flagged for you ${o.answers.flagged}×`];
+  if (o.answers.unsure) ans.push(`didn't know ${o.answers.unsure}×`);
+  lines.push(`  Phaedo said: ${ans.join(', ')}`);
+  const { approved, rejected, modified, unmarked } = o.outcomes;
+  lines.push(`  You said: yes ${approved}, no ${rejected}, changed it ${modified} — ${unmarked} not marked`);
+  lines.push(o.agreement.scored
+    ? `  Phaedo matched you on ${o.agreement.agreements} of ${o.agreement.scored} decisions it could be scored on`
+    : '  Nothing to score yet (needs a "go ahead" you then answered)');
+  if (o.newest) {
+    const day = String(o.newest.at).slice(0, 10);
+    lines.push(`  Newest: ${day} ${o.newest.summary || '(no summary)'} → Phaedo: ${saidIt(o.newest.signal)}${o.newest.user_action ? ` · you: ${o.newest.user_action}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
+if (process.argv[1] && process.argv[1].endsWith('ship-readout.js')) {
+  const i = process.argv.indexOf('--days');
+  const days = i > 0 ? Number(process.argv[i + 1]) : DEFAULT_DAYS;
+  const { readReceipts } = await import('./receipts.js');
+  const { defaultStateDir } = await import('./cache.js');
+  const rs = await readReceipts(defaultStateDir());
+  console.log(formatReadout(shipReadout(rs, { windowDays: Number.isFinite(days) && days > 0 ? days : DEFAULT_DAYS })));
+}

package/vendor/capture/detectors.js

@@ -35,14 +35,14 @@ export const CORRECTION_PATTERNS = [
   // Surface — tone
   { pattern: /\b(too formal|less formal|more casual|relax the tone|conversational(ly)?|informal)\b/i,                                     layer: 'surface',        signal: 'prefers_casual' },
   { pattern: /\b(too casual|more formal|professional(ly)?|keep it formal)\b/i,                                                            layer: 'surface',        signal: 'prefers_formal' },
-  { pattern: /\b(too roundabout|get to the point|be direct|skip the preamble|lead with|bottom.?line (up )?front)\b/i,                    layer: 'surface',        signal: 'more_direct' },
+  { pattern: /\b(too roundabout|get to the point|be (more )?direct|skip the preamble|lead with|bottom.?line (up )?front)\b/i,                    layer: 'surface',        signal: 'more_direct' },
   { pattern: /\b(no (intro|preamble|opener)|skip the intro|don'?t start with|cut the opener|dive right in)\b/i,                          layer: 'surface',        signal: 'no_preamble' },
   { pattern: /\b(no examples?|skip the examples?|I don'?t need examples?|without examples?)\b/i,                                         layer: 'surface',        signal: 'no_examples' },
   { pattern: /\b(give me an example|show me an example|illustrate|for example|can you show|concrete example)\b/i,                         layer: 'surface',        signal: 'wants_examples' },
   { pattern: /\b(simpler words?|plain(er)? (language|english)|avoid jargon|less jargon|plain terms?)\b/i,                                layer: 'surface',        signal: 'plainer_language' },
 
   // Behavioral — autonomy and initiative
-  { pattern: /\b(just do it|stop asking|don'?t (ask|check)|fewer questions?|just (go|start|write|build|do)|no need to ask)\b/i,          layer: 'behavioral',     signal: 'fewer_questions' },
+  { pattern: /\b(just do it|stop asking|don'?t (ask|check)|fewer questions?|just (go ahead|start|write it|build it|do it)|no need to ask)\b/i,          layer: 'behavioral',     signal: 'fewer_questions' },
   { pattern: /\b(ask (me )?first|confirm before|check (with me|before)|get my (input|approval)|don'?t assume)\b/i,                        layer: 'behavioral',     signal: 'wants_confirmation' },
   { pattern: /\b(show your (work|reasoning)|explain your reasoning|walk me through|how (did you|do you) (get|arrive))\b/i,                layer: 'behavioral',     signal: 'show_reasoning' },
   { pattern: /\b(just (give me|the) (answer|result)|skip the explanation|don'?t explain (how|why)|bottom line only)\b/i,                 layer: 'behavioral',     signal: 'skip_reasoning' },
@@ -86,7 +86,7 @@ export const CORRECTION_PATTERNS = [
   { pattern: /\b(ballpark (is fine|estimate|answer)|rough estimate|in the ballpark|order of magnitude|approximate(ly)?( is fine)?)\b/i,  layer: 'decision_and_risk',       signal: 'rough_estimate_ok' },
 
   // Creative — style and originality
-  { pattern: /\b(too conventional|be (more )?creative|unexpected (approach|angle|idea)|think (differently|outside)|original)\b/i,        layer: 'creative',       signal: 'wants_creative' },
+  { pattern: /\b(too conventional|be (more )?creative|unexpected (approach|angle|idea)|think (differently|outside))\b/i,        layer: 'creative',       signal: 'wants_creative' },
   { pattern: /\b(simpler|more elegant|too complex|less is more|strip (it )?down|over.?engineered|over.?complicated)\b/i,                 layer: 'creative',       signal: 'wants_elegance' },
   { pattern: /\b(standard (approach|solution)|conventional|don'?t overthink|keep it (simple|straightforward|standard))\b/i,              layer: 'creative',       signal: 'wants_conventional' },
   { pattern: /\b(more original|surprise me|not the obvious|unconventional|different (angle|approach|way)|unexpected)\b/i,                layer: 'creative',       signal: 'wants_originality' },
@@ -95,7 +95,7 @@ export const CORRECTION_PATTERNS = [
   { pattern: /\b(don'?t explain what you'?re doing|just do it|skip the (meta|commentary|preamble)|no meta)\b/i,                          layer: 'big_picture',           signal: 'skip_meta' },
   { pattern: /\b(show your reasoning|think out loud|walk me through your (logic|thinking|approach)|what'?s your (plan|approach|thinking))\b/i, layer: 'big_picture',    signal: 'show_meta' },
   { pattern: /\b(what (assumptions?|are you assuming)|be transparent|tell me your reasoning|what'?s your (basis|rationale))\b/i,         layer: 'big_picture',           signal: 'wants_transparency' },
-  { pattern: /\b(commit|stop second.?guessing|be confident|don'?t hedge|pick and go|just (pick|commit|decide))\b/i,                      layer: 'big_picture',           signal: 'less_second_guessing' },
+  { pattern: /\b(commit to (it|one|a decision|an answer)|stop second.?guessing|be confident|don'?t hedge|pick and go|just (pick|commit|decide))\b/i,                      layer: 'big_picture',           signal: 'less_second_guessing' },
 ];
 
 // Positive reinforcement — mirror of content.js

package/vendor/capture/transcript.js

@@ -46,6 +46,29 @@ function isUserPrompt(rec) {
   return rec && rec.type === 'user' && rec.message && rec.message.role !== 'assistant'
     && !isMachineAuthored(rec);
 }
+
+// WHO wrote a user-role line, when the transcript says (2026-10-20). Newer Claude Code writes
+// `origin` on user records: `{kind: "human"}` for a typed turn, another kind (e.g.
+// "task-notification") or null for text the app injects — CI-monitor events, background-task
+// notices, side-session reports. Those carry plain prose, so isMachineAuthored above let them
+// through and the detectors read an injected "do not stop to report" as the SUBJECT's
+// correction. Measured on the dev Mac since 2026-09-20: 363 human lines, 33 task notifications,
+// 21 unmarked lines in marked files (scripted probes) — all of the latter counted as Randy's.
+//   - a transcript that carries origin markers → only `kind: "human"` lines are the subject's;
+//   - a transcript with none (older format) → today's behaviour, minus prose that opens with an
+//     app envelope tag, which no person types.
+// Includes Phaedo's OWN injected profile (`<phaedo_user_profile>`, the SessionStart hook's
+// projection): it describes the subject in their words ("too long", "be concise"), so read as a
+// prompt it scored the profile as the subject correcting the AI — a loop feeding itself.
+const MACHINE_ENVELOPE = /^<(task-notification|ci-monitor-event|side-sessions-event|system-reminder|command-(name|message|args)|local-command-stdout|user-prompt-submit-hook|phaedo_user_profile|phaedo_fingerprint)\b/i;
+function hasOriginMarkers(recs) {
+  return recs.some((r) => r && r.type === 'user' && Object.prototype.hasOwnProperty.call(r, 'origin'));
+}
+function isSubjectAuthored(rec, text, marked) {
+  if (MACHINE_ENVELOPE.test(text)) return false;      // an app envelope is never typed, marked or not
+  if (marked) return !!(rec.origin && typeof rec.origin === 'object' && rec.origin.kind === 'human');
+  return true;
+}
 function isAssistant(rec) {
   return rec && rec.type === 'assistant' && rec.message && !rec.isSidechain;
 }
@@ -103,8 +126,10 @@ export function recordsToBatch(records, opts = {}) {
     || recs.find((r) => r && r.sessionId)?.sessionId
     || null;
 
+  const marked = hasOriginMarkers(recs);
   const exchanges = [];
   const user_prompts = [];                  // EVERY genuine user prompt (answered or not)
+  const user_prompt_times = [];             // parallel to user_prompts: each prompt's timestamp (or null)
   let pending = null;                       // the open user prompt awaiting a reply
   let replyParts = [];
 
@@ -131,9 +156,15 @@ export function recordsToBatch(records, opts = {}) {
     if (isUserPrompt(rec)) {
       const text = contentText(rec.message.content);
       if (!text) continue;                  // tool_result-only user line — not prose
+      if (!isSubjectAuthored(rec, text, marked)) continue;   // app-injected prose — not the subject
+      // Pasted blocks are someone else's words — terminal output, a log, a document — that the
+      // subject quoted, not typed. The app wraps them; keep only what was typed around them.
+      const typed = text.replace(/<pasted_content\b[^>]*>[\s\S]*?<\/pasted_content\b[^>]*>/gi, ' ').trim();
+      if (!typed) continue;
       flush();                              // close any previous exchange first
-      user_prompts.push(text);              // count Path-A per SENT prompt (extension parity)
-      pending = { id: rec.uuid || `ex-${exchanges.length}`, text, timestamp: rec.timestamp || null };
+      user_prompts.push(typed);             // count Path-A per SENT prompt (extension parity)
+      user_prompt_times.push(rec.timestamp || null);
+      pending = { id: rec.uuid || `ex-${exchanges.length}`, text: typed, timestamp: rec.timestamp || null };
     } else if (isAssistant(rec) && pending) {
       const text = contentText(rec.message.content);
       if (text) replyParts.push(text);
@@ -144,7 +175,7 @@ export function recordsToBatch(records, opts = {}) {
   // exchanges = COMPLETE pairs (for the future model/Loop-2 path); user_prompts = every
   // sent prompt (for Path-A counters — the web path counts at SEND time, so an
   // interrupted / unanswered correction must still count, unlike exchange shipping).
-  return { exchange_batch_version: 'v0.1', session_local_id: sessionId, exchanges, user_prompts };
+  return { exchange_batch_version: 'v0.1', session_local_id: sessionId, exchanges, user_prompts, user_prompt_times };
 }
 
 // Convenience: raw JSONL text → batch in one call.

package/vendor/extraction/persist.js

@@ -30,11 +30,16 @@ import { applyCaptureSources } from './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.
-export function mergeExtractionInto(fingerprint, update, now = new Date().toISOString(), captureSources = null) {
+//
+// `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 merged = promoteRules(reconcileFingerprint(fingerprint || {}, effective, { now }), { now });
+  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

@@ -24,6 +24,10 @@
 
 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;
 
@@ -39,7 +43,12 @@ function unionArrays(a = [], b = []) {
 }
 
 // Merge two signal objects with the same (field, polarity) key.
-function mergeSignal(existing, incoming, now) {
+//
+// `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
@@ -47,6 +56,9 @@ function mergeSignal(existing, incoming, now) {
   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).
@@ -86,15 +98,19 @@ const sigKey = s => `${s.field}::${s.polarity}${typeof s.domain === 'string' ? `
 // 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.
-export function reconcileLayer(existingLayer, incomingLayer, now, suppress) {
+// 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);
-    byKey.set(k, byKey.has(k) ? mergeSignal(byKey.get(k), inc, now) : 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());
@@ -248,12 +264,37 @@ export function reconcileFingerprint(fingerprint, update, opts = {}) {
       ...openConflictFieldKeys(conflicts, layerId),
       ...authoredGovernedKeys([...((prev && prev.signals) || []), ...(incomingLayer.signals || [])], rules, opts.domain || null),
     ]);
-    fp.layers[layerId] = reconcileLayer(prev, incomingLayer, now, suppress);
+    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) {

package/vendor/extraction/rule-promotion.js

@@ -14,6 +14,8 @@
 // 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';
@@ -24,47 +26,11 @@ const uuid = () =>
 
 const keyOf = (dim, val) => `${dim}::${JSON.stringify(val ?? null)}`;
 
-// (dimension, value) → a first-person candidate. Unknown pairs fall back to a
-// generic sentence; the subject edits before endorsing either way.
-const TEMPLATES = {
-  evidence_threshold: { high: 'I want the main risks covered and the key facts nailed down before I commit.' },
-  ambiguity_posture:  { ask: 'When a request is ambiguous, I ask one clarifying question before acting.',
-                        default: 'When things are ambiguous I stay decisive and commit rather than hedge.',
-                        delay: 'When things are ambiguous I would rather wait than commit prematurely.' },
-  speed_vs_quality:   { quality: 'I trade speed for accuracy on work that matters.',
-                        accuracy: 'I trade speed for accuracy on work that matters.',
-                        speed: 'I favor moving fast and accept rough edges when speed matters.' },
-  reversible_vs_irreversible: { more_cautious: "On decisions I can't easily undo, I slow down and seek more input.",
-                        consistent_style: 'I bring the same care to a decision whether or not it can be undone.' },
-  options_vs_recommendation: { single_recommendation: 'Give me a single clear recommendation, not a menu of options.',
-                        option_set: 'I prefer to see a set of options and make the call myself.' },
-  // Surface (response/style) — the dimensions auto-overrides surface against.
-  response_length_pref: { short: 'Default to concise — keep responses tight.',
-                        thorough: 'Default to thorough responses; go deep and cover the edge cases.',
-                        medium: 'Default to medium-length responses — neither terse nor exhaustive.' },
-  tone_register:       { casual: 'Default to a casual, conversational tone.',
-                        formal: 'Default to a formal, professional tone.' },
-};
-const DIM_LABEL = {
-  evidence_threshold: 'how much evidence I need before committing',
-  ambiguity_posture: 'how I handle ambiguity',
-  speed_vs_quality: 'how I weigh speed against quality',
-  reversible_vs_irreversible: 'how I treat irreversible decisions',
-  options_vs_recommendation: 'whether I want options or a single call',
-  response_length_pref: 'response length',
-  tone_register: 'tone',
-  directness: 'directness',
-  jargon_tolerance: 'jargon level',
-  formatting_prefs: 'formatting',
-  autonomy_pref: 'how much autonomy I give the assistant',
-  reasoning_visibility: 'whether I want the reasoning shown',
-};
+// (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) {
-  const v = Array.isArray(value) ? value[0] : value;
-  const byDim = TEMPLATES[dimension];
-  if (byDim && v != null && byDim[v]) return byDim[v];
-  const label = DIM_LABEL[dimension] || dimension;
-  return v != null ? `I have a consistent way I handle ${label} (${v}).` : `I have a consistent way I handle ${label}.`;
+  return globalThis.PhaedoTraitPhrases.phrase(dimension, value);
 }
 
 function endorsedDimensions(fp) {