phaedo-mcp 0.2.2 → 0.3.1

package/vendor/extraction/catalog.js

@@ -0,0 +1,232 @@
+// Phaedo Loop 2 extraction — field catalog (Stage-2 source of truth).
+//
+// Promoted verbatim from the proven prototype (scripts/local-model-eval/lib/
+// mapper.mjs + embed-mapper.mjs). The architecture decision
+// (docs/roadmap/extraction-engine-decision.md §6) explicitly DEPRIORITIZES
+// further hand-tuning of this catalog — the real gains are in the v2 fine-tuned
+// model, not more vocabulary. So this is a faithful copy, not a rewrite: the
+// cross-persona F1 the eval established (~48% avg, ~70% peak) rides on these
+// exact triggers/anchors. Touch only with a re-run of the eval harness.
+//
+// Maps to protocol §4.2 layers / extraction-task-spec §5.4 fields. Each catalog
+// entry names the (layer, field) it produces and how to resolve its value +
+// polarity once the field is matched (lexically here, or via embedding in
+// mapper.js — both share resolveValueAndPolarity once the field is chosen).
+
+export const NEG_CUES = [
+  'dislike', 'hate', 'avoid', "doesn't", 'does not', "don't want", 'do not want',
+  'stop ', 'no ', 'without', 'annoy', 'frustrat', 'pet peeve', 'bothered', 'against',
+];
+
+// Each entry: field, layer, default polarity, trigger phrases, and optional
+// value resolver (cues → enum value, or a fixed scalar/array).
+//
+// `detectNeg: true` opts a field into polarity flipping on negation cues. Only
+// fields whose negative form is a real, distinct signal (formatting "no
+// bullets") use it. Enum/scalar fields encode direction in their VALUE, so a
+// phrase like "don't dumb it down" (→ full_technical) must stay positive.
+export const CATALOG = [
+  // ── surface ──
+  { field: 'response_length_pref', layer: 'surface', triggers: ['length', 'how long', 'thorough', 'concise', 'brief', 'short answer', 'detailed answer', 'verbose', 'quick version', 'short on time', 'too much detail', 'the short answer', 'full picture', 'complete picture', 'even if it', 'keep it short', 'long answer'],
+    values: { short: ['short', 'brief', 'concise', 'tight', 'quick version', 'the short answer', 'too much detail', 'short on time', 'bottom line'], thorough: ['thorough', 'detailed', 'long', 'deep', 'comprehensive', 'full picture', 'complete picture', 'even if it', 'full pathway'], medium: ['medium', 'moderate'] } },
+  { field: 'tone_register', layer: 'surface', triggers: ['tone', 'casual', 'formal', 'informal', 'conversational', 'professional', 'friendly', 'punchy', 'like a human', 'like a friend', 'corporate'],
+    values: { casual: ['casual', 'informal', 'conversational', 'relaxed', 'friendly', 'punchy', 'like a human', 'like a friend', 'texting'], formal: ['formal', 'professional', 'corporate'], neutral: ['neutral'] } },
+  { field: 'formatting_prefs', layer: 'surface', detectNeg: true, triggers: ['bullet', 'prose', 'paragraph', 'numbered', 'table', 'header', 'heading', 'code block', 'code', 'list', 'inline example', 'example', 'in order', 'steps', 'scan'],
+    values: { prose: ['prose', 'paragraph'], bullets: ['bullet', 'list', 'scan'], numbered: ['numbered', 'in order', 'step'], tables: ['table'], headers: ['header', 'heading'], code_blocks: ['code block', 'code', 'just the code', 'give me the code'], inline_examples: ['inline example', 'example', 'use an example'] }, arrayValue: true },
+  { field: 'jargon_tolerance', layer: 'surface', triggers: ['jargon', 'technical term', 'define', 'plain language', 'plain english', 'assume i know', 'not techy', 'not technical', 'lose the thread', 'what it means', 'cut the jargon', 'no jargon', 'simple', 'simpler'],
+    scalar: t => /assume|already know|no need to define|skip the .*primer|skip the basics/.test(t) ? 0.85 : /define|explain.*term|plain|not techy|not technical|cut the jargon|no jargon|what it means|simpl/.test(t) ? 0.15 : 0.5 },
+  { field: 'directness', layer: 'surface', triggers: ['get to the point', 'direct', 'bottom line', 'no preamble', 'skip the intro', 'cut to', 'cut to the chase', 'blunt', 'straight', 'no fluff', 'give it to me straight', 'just tell me'],
+    scalar: () => 0.85 },
+  { field: 'pet_peeves', layer: 'surface', forcePolarity: 'negative', triggers: ['dislike', 'annoy', 'pet peeve', 'bother', 'opener', 'great question', "don't like", 'frustrat', 'hate when', 'gets on'],
+    arrayValueFromText: true },
+
+  // ── behavioral ──
+  { field: 'iteration_style', layer: 'behavioral', triggers: ['iterate', 'refine', 'keep going', 'revise', 'rework', 'passes', 'one shot', 'single pass', 'keep refining', 'until it', 'improve later'],
+    values: { iterative_refine: ['iterate', 'refine', 'keep going', 'revise', 'keep refining', 'until it'], deep_rework: ['rework', 'rewrite', 'overhaul'], single_pass: ['one shot', 'single pass', 'one pass'] } },
+  { field: 'ambiguity_response', layer: 'behavioral', triggers: ['ask first', 'clarify', 'clarifying question', 'ask before', 'state assumption', 'offer options'],
+    values: { ask_first: ['ask first', 'clarify', 'clarifying', 'ask before'], assume_state_proceed: ['assume and proceed', 'state assumption'], offer_options: ['offer options'] } },
+  { field: 'detail_vs_principle', layer: 'behavioral', triggers: ['principle', 'step by step', 'steps', 'big idea first', 'detail', 'in order', 'what do i actually do', 'understand why', 'why it works', 'concept first'],
+    values: { principle_first: ['principle first', 'big idea first', 'understand why', 'why it works', 'concept first', 'principle.*then'], principle: ['principle'], steps: ['step by step', 'steps', 'in order', 'what do i actually do', 'what do i do'] } },
+  { field: 'autonomy_pref', layer: 'behavioral', triggers: ['just do it', 'stop asking', 'confirm', 'check with me', 'act without', 'fewer questions', 'just go', 'without asking'],
+    scalar: t => /just do|stop asking|fewer question|without asking|just go/.test(t) ? 0.85 : /confirm|check with|ask me/.test(t) ? 0.2 : 0.5 },
+  { field: 'reasoning_visibility', layer: 'behavioral', triggers: ['show your reasoning', 'show your work', 'walk me through', 'skip the explanation', 'just the answer', 'no explanation', "i'll read it", 'just the code', 'without explanation', 'no need to explain'],
+    values: { show: ['show your reasoning', 'show your work', 'walk me through'], skip: ['skip the explanation', 'just the answer', 'no explanation', "i'll read", 'just the code', 'without explanation', 'no need to explain'] } },
+  { field: 'scope_discipline', layer: 'behavioral', triggers: ['stay scoped', 'just what i asked', 'be proactive', 'anticipate', "what i'm missing", 'what else'],
+    values: { stay_scoped: ['stay scoped', 'just what i asked', 'only what'], wants_proactive: ['proactive', 'anticipate', 'what else', 'missing'] } },
+
+  // ── creative ──
+  { field: 'quality_word', layer: 'creative', triggers: ['elegant', 'rigorous', 'clear', 'surprising', 'useful', 'honest', 'beautiful', 'original', 'unexpected', 'practical', 'works', 'stands out', 'clean', 'simple'],
+    values: { elegant: ['elegant', 'clean', 'simple', 'strip', 'less is more'], rigorous: ['rigorous', 'precise', 'exact'], clear: ['clear', 'clarity'], surprising: ['surprising', 'unexpected', 'original', 'different angle', 'stands out', 'nobody else', 'angle nobody'], useful: ['useful', 'practical', 'works', 'gets it done', 'fancy', 'something that works'], honest: ['honest'], beautiful: ['beautiful'] } },
+  { field: 'problem_solving_move', layer: 'creative', triggers: ['decompose', 'break it down', 'analogy', 'analogous', 'map the system', 'systems', 'sketch', 'sit with', 'bottleneck', 'constraint', 'where the time goes', 'think of it as', 'hang together'],
+    values: { decompose: ['decompose', 'break it down'], analogize: ['analogy', 'analogous', 'like a', 'think of it as'], map_system: ['map the system', 'systems', 'bottleneck', 'constraint', 'where the noise', 'where the time', 'hang together', 'as a system'], discuss: ['talk it through', 'discuss'], sketch: ['sketch', 'draw'], sit_with: ['sit with', 'let it sit'] } },
+  { field: 'mental_model_inventory', layer: 'creative', triggers: ['first principles', 'systems thinking', 'theory of constraints', 'second order', 'second-order', 'tradeoff', 'trade-off', 'decomposition', 'scenario', 'analogical', 'downstream', 'cascade', 'ripple'],
+    values: { first_principles: ['first principles'], systems_thinking: ['systems thinking', 'as a system', 'hang together'], theory_of_constraints: ['theory of constraints', 'constraint', 'bottleneck'], second_order_effects: ['second order', 'second-order', 'downstream', 'cascade', 'ripple', 'knock-on'], tradeoff_reasoning: ['tradeoff', 'trade-off'], analogical_reasoning: ['analogical', 'analogy'], decomposition: ['decomposition', 'decompose'], scenario_planning: ['scenario'] }, arrayValue: true },
+
+  // ── domain_and_expertise ──
+  { field: 'primary_expertise', layer: 'domain_and_expertise', triggers: ['expert in', 'expertise', 'works in', 'background in', 'professional', 'specializes', 'hr', 'immigration', 'engineer', 'designer', 'researcher', 'lawyer', 'distributed systems', 'molecular biology', 'marketing', 'design', 'business owner', 'i work in', 'i run a', 'years of'],
+    stringFromText: true },
+  { field: 'domain_depth_pref', layer: 'domain_and_expertise', triggers: ['go deep', 'technical depth', 'high level', 'surface level', 'match my question', "don't dumb", 'full picture', 'complete picture', "don't oversimplify", 'full pathway', 'no basics', 'just the concept', 'under the hood'],
+    values: { full_technical: ['go deep', 'technical depth', 'under the hood', "don't dumb", 'no basics', 'full picture', 'complete picture', "don't oversimplify", 'full pathway', 'the full'], surface: ['high level', 'surface level', 'just the concept', 'too much detail'], match_my_question: ['match my question', 'follow my lead'] } },
+  { field: 'active_learning_areas', layer: 'domain_and_expertise', triggers: ['learning', 'interested in', 'wants to learn', 'curious about'],
+    arrayValueFromText: true },
+  { field: 'domain_vocabulary', layer: 'domain_and_expertise', triggers: ['uses term', 'specialized vocab', 'jargon like', 'terms like', 'h-1b', 'lca', 'cap-exempt', 'raft', 'postgres', 'cassandra', 'kinase', 'mapk', 'technical vocabulary'],
+    arrayValueFromText: true },
+  { field: 'expertise_level', layer: 'domain_and_expertise', triggers: ['expert', 'power user', 'experienced', 'years of', 'years', 'novice', 'beginner', 'general user', 'not techy', 'not technical', "don't know enough", 'i work in this field', 'run this', "i've been", 'i run a'],
+    values: { power: ['expert', 'power user', 'years', 'experienced', 'run this', 'work in this field', "i've been", 'i run a', 'seasoned'], technical: ['technical', 'some knowledge', 'comfortable with'], general: ['novice', 'beginner', 'general', 'not techy', 'not technical', "don't know enough", "don't know much"] } },
+
+  // ── temporal_and_context ──
+  { field: 'early_project_mode', layer: 'temporal_and_context', triggers: ['explore', 'wander', 'early stage', 'early on', 'not ready to commit', 'brainstorm', 'frame first', 'commit fast', 'just exploring', 'angles'],
+    values: { explore_wide: ['explore', 'wander', 'brainstorm', 'angles', 'widely', 'just exploring', 'not ready to commit'], frame_then_explore: ['frame first', 'narrow then'], commit_fast: ['commit fast', 'decide quickly'] } },
+  { field: 'urgency_baseline', layer: 'temporal_and_context', triggers: ['in a hurry', 'urgent', 'quick', 'no rush', 'take your time', 'asap', 'today', "don't have time", 'between job', 'short on time', 'time-pressured', 'need it now'],
+    scalar: t => /hurry|urgent|asap|today|don.t have time|between job|short on time|need it now|need it today/.test(t) ? 0.85 : /no rush|take your time|have time|no hurry/.test(t) ? 0.15 : 0.5 },
+  { field: 'working_mode', layer: 'temporal_and_context', triggers: ['exploring', 'build mode', 'ready to build', 'implementation', 'just thinking', 'still figuring'],
+    values: { exploring: ['exploring', 'just thinking', 'early', 'still figuring'], build_mode: ['build mode', 'ready to build', 'implementation', 'ship'] } },
+
+  // ── collaboration_and_relationship ──
+  { field: 'feedback_pref', layer: 'collaboration_and_relationship', triggers: ['blunt', 'direct feedback', "don't soften", 'tell me what is wrong', 'diplomatic', 'gentle', 'be direct', "don't sugarcoat", 'honest but kind', 'real problems', 'tell me if', "don't be harsh", 'be honest'],
+    values: { blunt: ['blunt', "don't soften", "don't sugarcoat", 'tell me what is wrong', 'be direct', 'real problems', 'tell me if', 'be honest', "don't hold back"], direct_balanced: ['direct but', 'balanced'], diplomatic: ['diplomatic', 'gentle', 'honest but kind', "don't be harsh", 'kind'] } },
+  { field: 'disagreement_style', layer: 'collaboration_and_relationship', triggers: ['push back', 'disagree', 'challenge', 'ask questions to understand', 'revisit later', 'disagree and commit', 'challenged'],
+    values: { push_back_now: ['push back', 'challenge', 'say it now', 'challenged'], ask_first: ['ask questions to understand', 'understand their reasoning'], revisit_later: ['revisit later'], disagree_commit: ['disagree and commit'] } },
+  { field: 'audience_adaptation', layer: 'collaboration_and_relationship', triggers: ['for my audience', 'simplify for', 'non-technical audience', 'same level', 'pull up', 'going to', 'cut the jargon for', 'they would say', 'not marketers', 'small-business owners', 'the way they'],
+    values: { simplify_aggressive: ['simplify for', 'dumb down', 'lay terms', 'cut the jargon', 'they would say', 'not marketers', 'small-business', 'the way they'], accuracy_slow: ['accurate', "don't oversimplify"], same_level: ['same level'], pull_up: ['pull up', 'level up'] } },
+
+  // ── decision_and_risk ──
+  { field: 'options_vs_recommendation', layer: 'decision_and_risk', triggers: ['recommend', 'which one', 'give me options', 'lay out choices', 'just decide', 'make the call', 'one recommendation', 'just pick', 'pick one', 'pick for me', 'what would you', 'three or four', 'several approaches', 'compare', 'different approaches', "don't just give me one", 'alternatives'],
+    values: { single_recommendation: ['recommend', 'which one', 'make the call', 'just decide', 'one recommendation', 'just pick', 'pick one', 'pick for me', 'what would you go', 'go with'], option_set: ['give me options', 'lay out choices', 'show me options', 'alternatives', 'three or four', 'several approaches', 'different approaches', 'compare', "don't just give me one", "don't just give me"] } },
+  { field: 'ambiguity_posture', layer: 'decision_and_risk', triggers: ['decisive', "don't hedge", 'stop hedging', 'be definitive', 'commit to a position', 'wrong and decisive', 'be confident'],
+    values: { default: ['decisive', "don't hedge", 'stop hedging', 'definitive', 'wrong and decisive', 'commit', 'be confident'], ask: ['ask before deciding'], delay: ['wait', 'delay'] } },
+  { field: 'speed_vs_quality', layer: 'decision_and_risk', triggers: ['speed over', 'quality over', 'accuracy over', 'thorough over', 'fast over', 'good enough', "don't need it perfect", "don't overthink", 'ship', 'speed matters', 'perfect on the first', 'a/b test'],
+    scalar: t => /quality over|accuracy over|thorough over|cover the risk/.test(t) ? 0.8 : /speed over|fast over|quick over|good enough|don.t need it perfect|don.t overthink|ship|speed matters|improve later/.test(t) ? 0.15 : 0.5 },
+  { field: 'evidence_threshold', layer: 'decision_and_risk', triggers: ['cover the risks', 'evidence', 'certainty', 'nail it down', 'need proof', 'ballpark is fine', 'cite', 'source', 'trace back', 'strength of the evidence', "don't state that as settled", 'contested', 'be careful', 'replicated'],
+    scalar: t => /cover the risk|evidence|certainty|nail it down|proof|high bar|cite|source|trace back|strength of the evidence|don.t state|contested|be careful|replicated/.test(t) ? 0.8 : /ballpark|rough|good enough/.test(t) ? 0.2 : 0.5 },
+
+  // ── big_picture ──
+  { field: 'stable_principles', layer: 'big_picture', triggers: ['believes', 'principle', 'values', 'open to changing', 'pragmatic', 'idealist', 'always'],
+    arrayValueFromText: true },
+  { field: 'process_narration_pref', layer: 'big_picture', triggers: ['skip the meta', 'no commentary', 'show your thinking', 'think out loud', "don't narrate"],
+    values: { skip_meta: ['skip the meta', 'no commentary', "don't narrate", 'no meta'], show_meta: ['show your thinking', 'think out loud', 'show your plan'] } },
+];
+
+// Human-readable anchor per field: a short natural sentence describing what the
+// field captures. Embedded once and cached by the embedding mapper. Falls back
+// to joining the field's triggers if no explicit anchor is given.
+export const FIELD_ANCHORS = {
+  response_length_pref: 'how long or short the user wants answers to be',
+  tone_register: 'how casual or formal the user wants the tone',
+  formatting_prefs: 'whether the user prefers prose, bullets, tables, headers, or code blocks',
+  jargon_tolerance: 'whether to define technical terms or assume the user knows them',
+  directness: 'the user wants the answer to get to the point with no preamble',
+  pet_peeves: 'things the AI does that annoy or bother the user',
+  iteration_style: 'whether the user iterates and refines or wants one final answer',
+  ambiguity_response: 'whether the user wants clarifying questions or wants the AI to proceed',
+  detail_vs_principle: 'whether the user wants step-by-step detail or the principle first',
+  autonomy_pref: 'whether the user wants the AI to just act or to confirm before acting',
+  reasoning_visibility: 'whether the user wants to see the reasoning or just the answer',
+  scope_discipline: 'whether the user wants the AI to stay scoped or be proactive',
+  quality_word: 'the quality the user values most, like elegant, useful, or surprising',
+  problem_solving_move: 'how the user approaches problems, like decomposing or mapping the system',
+  mental_model_inventory: 'mental models the user reasons with, like first principles or theory of constraints',
+  primary_expertise: 'the field the user is an expert in or works in professionally',
+  domain_depth_pref: 'whether the user wants deep technical depth or a high-level overview',
+  active_learning_areas: 'topics the user is currently learning or curious about',
+  domain_vocabulary: 'specialized terms or jargon the user uses',
+  expertise_level: 'whether the user is an expert, technical, or general user',
+  early_project_mode: 'whether the user explores widely or commits fast early in a project',
+  urgency_baseline: 'whether the user is in a hurry or has no rush',
+  working_mode: 'whether the user is exploring or in build mode',
+  feedback_pref: 'whether the user wants blunt or diplomatic feedback',
+  disagreement_style: 'how the user handles disagreement, like pushing back or asking questions first',
+  audience_adaptation: 'how the user adapts communication for different audiences',
+  options_vs_recommendation: 'whether the user wants a single recommendation or a set of options',
+  ambiguity_posture: 'whether the user wants the AI to be decisive or to hedge',
+  speed_vs_quality: 'whether the user values speed or quality more',
+  evidence_threshold: 'how much evidence the user needs before committing',
+  stable_principles: 'enduring principles or values the user holds',
+  process_narration_pref: 'whether the user wants the AI to narrate its process or skip the meta',
+};
+
+export function anchorFor(entry) {
+  return FIELD_ANCHORS[entry.field] || entry.triggers.join(', ');
+}
+
+export function hasNeg(text) {
+  const t = text.toLowerCase();
+  return NEG_CUES.some(c => t.includes(c));
+}
+
+// Cues that are short, common substrings of unrelated words
+// (table↔comfortable, code↔decode, list↔realistic, scan↔scandal,
+// prose↔prosecutor). Match THESE at word boundaries; everything else stays
+// substring, to preserve intended stem matches ("frustrat"→frustrated,
+// "annoy"→annoying). Used for both trigger and value-cue matching.
+const WHOLE_WORD_CUES = new Set(['table', 'tables', 'code', 'list', 'scan', 'prose']);
+export function cueHit(text, cue) {
+  if (WHOLE_WORD_CUES.has(cue)) return new RegExp(`\\b${cue}\\b`).test(text);
+  return text.includes(cue);
+}
+
+// Decide a single value's polarity by PROXIMITY to a negation cue: a value is
+// negative only when a negation cue ("no", "stop", "don't", "avoid", "without",
+// …) sits just before one of its cue words. So "stop using bullets, just write
+// prose" splits into bullets→negative + prose→positive, instead of the old
+// blanket flip that wrongly marked prose negative too. Window-based, so a
+// negation distributed across a clause ("avoid bullets and headers") can miss
+// the second item — the embedding mapper is the fuller fix.
+const NEG_WINDOW = 16;
+function valuePolarity(t, cues) {
+  for (const c of cues) {
+    let idx = t.indexOf(c);
+    while (idx !== -1) {
+      const before = t.slice(Math.max(0, idx - NEG_WINDOW), idx);
+      if (NEG_CUES.some(n => before.includes(n.trim()))) return 'negative';
+      idx = t.indexOf(c, idx + c.length);
+    }
+  }
+  return 'positive';
+}
+
+// Field-level base polarity for non-split fields: forced (pet_peeves) >
+// whole-observation negation for opted-in fields > positive. Enum/scalar fields
+// encode direction in their VALUE, so "don't dumb it down" stays positive.
+function basePolarity(entry, t) {
+  if (entry.forcePolarity) return entry.forcePolarity;
+  if (entry.detectNeg && hasNeg(t)) return 'negative';
+  return 'positive';
+}
+
+// Resolve a matched catalog entry to ZERO OR MORE {value, polarity} signal
+// groups. Most fields yield one group; a detectNeg ranked_list
+// (formatting_prefs) can yield two — a positive subset and a negative subset —
+// when one observation expresses both a wanted and an unwanted format.
+// Shared by the lexical and embedding mappers once the FIELD is chosen.
+export function resolveSignalGroups(entry, obs) {
+  const t = obs.toLowerCase().replace(/^[-*•]\s*/, '').trim();
+
+  if (entry.values && entry.arrayValue) {
+    const pos = [], neg = [];
+    for (const [val, cues] of Object.entries(entry.values)) {
+      if (!cues.some(c => cueHit(t, c))) continue;
+      const pol = entry.detectNeg ? valuePolarity(t, cues) : 'positive';
+      (pol === 'negative' ? neg : pos).push(val);
+    }
+    const out = [];
+    if (pos.length) out.push({ value: pos, polarity: 'positive' });
+    if (neg.length) out.push({ value: neg, polarity: 'negative' });
+    return out;
+  }
+  if (entry.values) {
+    for (const [val, cues] of Object.entries(entry.values))
+      if (cues.some(c => cueHit(t, c))) return [{ value: val, polarity: basePolarity(entry, t) }];
+    return [];
+  }
+  if (entry.scalar)             return [{ value: entry.scalar(t), polarity: basePolarity(entry, t) }];
+  if (entry.arrayValueFromText) return [{ value: [obs.replace(/^[-*•]\s*/, '').trim()], polarity: basePolarity(entry, t) }];
+  if (entry.stringFromText)     return [{ value: obs.replace(/^[-*•]\s*/, '').trim(), polarity: basePolarity(entry, t) }];
+  return [];
+}
+
+// Back-compat shim: first group only (or a null value when nothing matched).
+export function resolveValueAndPolarity(entry, obs) {
+  const groups = resolveSignalGroups(entry, obs);
+  return groups.length ? groups[0] : { value: null, polarity: 'positive' };
+}

package/vendor/extraction/delta-lift.js

@@ -0,0 +1,109 @@
+// Phaedo Loop 2 extraction — Path A signal lift (ported from the parallel impl).
+//
+// Turns the long-running phaedo_behavioral_signals counter map (Path A's
+// regex-correction hits, accumulated for months) into §5.1 signals tagged
+// source='delta'. Path A produces the bulk of Phaedo's real signal, but the
+// projection layer otherwise only sees questionnaire + extraction signals; this
+// lift surfaces "things the user actively pushed back on" into the same §4.2
+// fingerprint, with provenance that lets the receiving AI weight them highly.
+//
+// Pure: counters in → signals out. The orchestrator concats these with the
+// extraction signals so they reconcile in one merge. Emits CANONICAL layer ids
+// (projection.LAYER_ID_MAP maps them to the questionnaire's ids, same as
+// extraction signals).
+//
+// IDEMPOTENCY: a delta signal's observation_count is Path A's CUMULATIVE total,
+// not new evidence — so reconcile REPLACES a delta signal on key match rather
+// than summing (reconcile.js treats source==='delta' as a snapshot). Re-lifting
+// the same counters every pass is therefore a no-op, not inflation.
+
+// Path A signal name → (canonical layer, field, polarity, value). Values match
+// the enums/scalars projection renders, so its PHRASING table picks them up.
+// Unmapped Path A signals are simply skipped.
+export const SIGNAL_MAP = {
+  // ── surface ──
+  too_long:         { layer: 'surface', field: 'response_length_pref', polarity: 'positive', value: 'short' },
+  too_short:        { layer: 'surface', field: 'response_length_pref', polarity: 'positive', value: 'thorough' },
+  avoid_bullets:    { layer: 'surface', field: 'formatting_prefs',     polarity: 'negative', value: ['bullets'] },
+  prefer_bullets:   { layer: 'surface', field: 'formatting_prefs',     polarity: 'positive', value: ['bullets'] },
+  no_headers:       { layer: 'surface', field: 'formatting_prefs',     polarity: 'negative', value: ['headers'] },
+  use_headers:      { layer: 'surface', field: 'formatting_prefs',     polarity: 'positive', value: ['headers'] },
+  use_table:        { layer: 'surface', field: 'formatting_prefs',     polarity: 'positive', value: ['tables'] },
+  use_code_block:   { layer: 'surface', field: 'formatting_prefs',     polarity: 'positive', value: ['code_blocks'] },
+  no_examples:      { layer: 'surface', field: 'formatting_prefs',     polarity: 'negative', value: ['inline_examples'] },
+  wants_examples:   { layer: 'surface', field: 'formatting_prefs',     polarity: 'positive', value: ['inline_examples'] },
+  prefers_casual:   { layer: 'surface', field: 'tone_register',        polarity: 'positive', value: 'casual' },
+  prefers_formal:   { layer: 'surface', field: 'tone_register',        polarity: 'positive', value: 'formal' },
+  more_direct:      { layer: 'surface', field: 'directness',           polarity: 'positive', value: 0.85 },
+  no_preamble:      { layer: 'surface', field: 'directness',           polarity: 'positive', value: 0.85 },
+  plainer_language: { layer: 'surface', field: 'jargon_tolerance',     polarity: 'positive', value: 0.15 },
+
+  // ── behavioral ──
+  fewer_questions:    { layer: 'behavioral', field: 'autonomy_pref',        polarity: 'positive', value: 0.85 },
+  wants_confirmation: { layer: 'behavioral', field: 'autonomy_pref',        polarity: 'positive', value: 0.15 },
+  show_reasoning:     { layer: 'behavioral', field: 'reasoning_visibility', polarity: 'positive', value: 'show' },
+  skip_reasoning:     { layer: 'behavioral', field: 'reasoning_visibility', polarity: 'positive', value: 'skip' },
+  iterate_more:       { layer: 'behavioral', field: 'iteration_style',      polarity: 'positive', value: 'iterative_refine' },
+
+  // ── domain_and_expertise (legacy Path A layer 'domain') ──
+  overexplaining:   { layer: 'domain_and_expertise', field: 'expertise_level',   polarity: 'positive', value: 'power' },
+  too_technical:    { layer: 'domain_and_expertise', field: 'expertise_level',   polarity: 'positive', value: 'general' },
+  wants_depth:      { layer: 'domain_and_expertise', field: 'domain_depth_pref', polarity: 'positive', value: 'full_technical' },
+  conceptual_only:  { layer: 'domain_and_expertise', field: 'domain_depth_pref', polarity: 'positive', value: 'surface' },
+
+  // ── temporal_and_context ──
+  urgent:           { layer: 'temporal_and_context', field: 'urgency_baseline',   polarity: 'positive', value: 0.85 },
+  no_rush:          { layer: 'temporal_and_context', field: 'urgency_baseline',   polarity: 'positive', value: 0.15 },
+  exploring_phase:  { layer: 'temporal_and_context', field: 'early_project_mode', polarity: 'positive', value: 'explore_wide' },
+  build_mode:       { layer: 'temporal_and_context', field: 'working_mode',       polarity: 'positive', value: 'build_mode' },
+
+  // ── decision_and_risk ──
+  wants_decisiveness:     { layer: 'decision_and_risk', field: 'ambiguity_posture',         polarity: 'positive', value: 'default' },
+  wants_bold_call:        { layer: 'decision_and_risk', field: 'ambiguity_posture',         polarity: 'positive', value: 'default' },
+  fewer_options:          { layer: 'decision_and_risk', field: 'options_vs_recommendation', polarity: 'positive', value: 'single_recommendation' },
+  wants_options:          { layer: 'decision_and_risk', field: 'options_vs_recommendation', polarity: 'positive', value: 'option_set' },
+  wants_options_decision: { layer: 'decision_and_risk', field: 'options_vs_recommendation', polarity: 'positive', value: 'option_set' },
+};
+
+// Confidence as a stepped function of corrective hit count: one hit is
+// suggestive (0.4); five is solid (0.75); ten+ is strong (0.85).
+export function countConfidence(n) {
+  if (!n || n <= 0) return 0;
+  if (n >= 10) return 0.85;
+  if (n >= 5)  return 0.75;
+  if (n >= 3)  return 0.65;
+  if (n >= 2)  return 0.55;
+  return 0.4;
+}
+
+// liftDeltaSignals(behavioralSignals, now?) → mapper-shaped signals tagged
+// source='delta'. behavioralSignals is the { layer: { signalName: count } } map
+// (phaedo_behavioral_signals); the outer layer key is ignored — SIGNAL_MAP
+// determines the canonical layer/field from the signal name. `now` is injected
+// for deterministic timestamps. Empty/missing input → [].
+export function liftDeltaSignals(behavioralSignals, now) {
+  if (!behavioralSignals || typeof behavioralSignals !== 'object') return [];
+  const stamp = now || new Date().toISOString();
+  const out = [];
+  for (const signalCounts of Object.values(behavioralSignals)) {
+    if (!signalCounts || typeof signalCounts !== 'object') continue;
+    for (const [signalName, count] of Object.entries(signalCounts)) {
+      const mapping = SIGNAL_MAP[signalName];
+      if (!mapping) continue;
+      const confidence = countConfidence(count);
+      if (confidence <= 0) continue;
+      out.push({
+        layer: mapping.layer,
+        field: mapping.field,
+        polarity: mapping.polarity,
+        value: mapping.value,
+        confidence,
+        source: 'delta',
+        observation_count: count,
+        session_refs: [],
+        last_observed: stamp,
+      });
+    }
+  }
+  return out;
+}

package/vendor/extraction/fingerprint-update.js

@@ -0,0 +1,227 @@
+// Phaedo Loop 2 extraction — fingerprint-update builder (signals → §4.2 layer docs).
+//
+// NOTE: distinct from the INJECTION projection (context-block.js renderContextBlock
+// / mcp/projection.js), which renders the user-facing profile block. THIS step turns
+// the mapper's flat signal list into the persistent fingerprint's §4.2 layer
+// documents. (Renamed from extraction/projection.js to disambiguate "projection".)
+//
+// The extraction model emits signals[] + confidence ONLY; the human-readable
+// `summary` is rendered downstream by this deterministic step (task-spec §4.2). It
+// takes the flat signal list from the mapper and produces a partial fingerprint
+// update: one protocol §4.2 layer document per layer that has signal —
+//   { layer_version, last_updated, confidence, signals[], summary }
+// where each signal is enriched to the full §5.1 object.
+//
+// No raw transcript text ever enters a layer doc — only derived structured
+// values + provenance counts (§7 privacy constraint).
+
+import { CATALOG } from './catalog.js';
+import { resolveDimension, valKey } from './resolve.js';   // §4.7 deterministic resolution (Proposal 0006)
+
+const LAYER_VERSION = '0.1';
+
+// The §4.7 canonical layer-key rename has landed (migration.js canonicalizes on
+// vault read; Path A + the questionnaire schema now use canonical ids), so
+// extraction's canonical layer ids match the stored fingerprint directly — no
+// down-mapping needed.
+
+function uuid() {
+  if (typeof crypto !== 'undefined' && crypto.randomUUID) return crypto.randomUUID();
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = Math.random() * 16 | 0;
+    return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+  });
+}
+
+// Readable field labels for the rendered summary. Missing fields fall back to a
+// humanized version of the field id.
+const FIELD_LABELS = {
+  response_length_pref: 'Response length', tone_register: 'Tone',
+  formatting_prefs: 'Formatting', jargon_tolerance: 'Jargon', directness: 'Directness',
+  pet_peeves: 'Pet peeves', iteration_style: 'Iteration', ambiguity_response: 'On ambiguity',
+  detail_vs_principle: 'Detail vs principle', autonomy_pref: 'Autonomy',
+  reasoning_visibility: 'Reasoning', scope_discipline: 'Scope', quality_word: 'Values quality',
+  problem_solving_move: 'Problem-solving', mental_model_inventory: 'Mental models',
+  primary_expertise: 'Expertise', domain_depth_pref: 'Depth', active_learning_areas: 'Learning',
+  domain_vocabulary: 'Vocabulary', expertise_level: 'Level', early_project_mode: 'Early-project mode',
+  urgency_baseline: 'Urgency', working_mode: 'Working mode', feedback_pref: 'Feedback',
+  disagreement_style: 'Disagreement', audience_adaptation: 'Audience',
+  options_vs_recommendation: 'Options vs recommendation', ambiguity_posture: 'Decisiveness',
+  speed_vs_quality: 'Speed vs quality', evidence_threshold: 'Evidence bar',
+  stable_principles: 'Principles', process_narration_pref: 'Process narration',
+};
+
+// Allowed enum values per field, derived from the catalog (the same source of
+// truth the mapper resolves values against). Only fields that resolve to a fixed
+// value set appear here; scalar and free-text fields (no `.values`) admit
+// anything. Used to keep opaque/garbage values — e.g. a model emitting "s2_d"
+// for tone_register — OUT of the rendered summary. The signal is retained in
+// signals[] for provenance; it is simply never surfaced in the injected
+// projection. Ingestion-time enum validation is the stricter v0.2 fix (schema
+// tightening); this is the projection-layer guard.
+const ALLOWED_VALUES = (() => {
+  const m = {};
+  for (const entry of CATALOG) {
+    if (entry && entry.values && typeof entry.values === 'object')
+      m[entry.field] = new Set(Object.keys(entry.values));
+  }
+  return m;
+})();
+
+// A value conforms if the field has no fixed set (scalar/free-text), or every
+// token is in the set. Array fields are checked token-by-token.
+function valueConforms(field, value) {
+  const allowed = ALLOWED_VALUES[field];
+  if (!allowed) return true;
+  const tokens = Array.isArray(value) ? value : [value];
+  return tokens.length > 0 && tokens.every(v => allowed.has(v));
+}
+
+// Drop non-conforming members from an enum array value; scalars/free-text pass
+// through untouched (their conformance is decided by valueConforms).
+function sanitizeValue(field, value) {
+  const allowed = ALLOWED_VALUES[field];
+  if (!allowed || !Array.isArray(value)) return value;
+  return value.filter(v => allowed.has(v));
+}
+
+// §4.6 layer admission: behavioral layers carry persona patterns, never episodic
+// content. Drop a signal whose value reads as an episodic fact (URL / email /
+// domain — e.g. an extracted "principle" of "values getphaedo.com"). High-
+// precision markers only. MUST match the conformance check EPISODIC_RE in
+// spec/validate-fingerprint.mjs.
+const EPISODIC_RE = /(https?:\/\/|\bwww\.)|[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}|\b[a-z0-9][a-z0-9-]*\.(com|org|net|io|so|co|ai|app|xyz|info)\b/i;
+function isEpisodic(value) {
+  const text = Array.isArray(value) ? value.join(' ') : (value == null ? '' : String(value));
+  return EPISODIC_RE.test(text);
+}
+
+function humanizeValue(value) {
+  if (Array.isArray(value)) return value.map(humanizeValue).join(', ');
+  if (typeof value === 'number') {
+    if (value >= 0.7) return 'high';
+    if (value <= 0.3) return 'low';
+    return 'medium';
+  }
+  return String(value).replace(/_/g, ' ');
+}
+
+// One readable line per signal for the layer summary.
+export function describeSignal(sig) {
+  const label = FIELD_LABELS[sig.field] || sig.field.replace(/_/g, ' ');
+  const val = humanizeValue(sig.value);
+  return sig.polarity === 'negative' ? `${label}: avoids ${val}` : `${label}: ${val}`;
+}
+
+// Enrich a mapper signal to the full §5.1 object. sessionId/now provide
+// provenance (session_refs, last_observed); raw text (`_from`/`_sim`) is dropped
+// so no transcript leaks into the stored signal.
+// Evidence basis of a signal, derived from its `source` (proposal 0002 vocabulary):
+// how the signal was learned. Lets a consumer (e.g. the consultation resolver) weigh
+// observed/corroborated signals above self-reported ones without re-deriving it.
+function evidenceBasis(source) {
+  const s = String(source || '').toLowerCase();
+  if (s.includes('corrobor') || s.includes('reconcil')) return 'corroborated';
+  if (s.includes('question') || s.includes('self') || s.includes('interview')) return 'self_reported';
+  return 'observed'; // extraction/delta-sourced
+}
+
+function toSignalObject(sig, sessionId, now) {
+  const source = sig.source || 'extraction';
+  return {
+    signal_id: uuid(),
+    field: sig.field,
+    dimension: sig.field,                  // proposal 0002: the decision/style axis (== field)
+    // §4.2.7 optional domain (PROTOTYPE: set by extraction/domain-inference.js for
+    // Decision & Risk signals when a session's domain is unambiguous; else absent).
+    ...(typeof sig.domain === 'string' ? { domain: sig.domain } : {}),
+    polarity: sig.polarity,
+    value: sig.value,
+    confidence: sig.confidence ?? 0.6,
+    source,
+    evidence_basis: evidenceBasis(source), // proposal 0002: observed | corroborated | self_reported
+    observation_count: sig.observation_count ?? 1,
+    // Preserve provenance the producer set (delta signals carry [] + their own
+    // timestamp); fall back to this pass's session/time for extraction signals.
+    session_refs: sig.session_refs ?? (sessionId ? [sessionId] : []),
+    last_observed: sig.last_observed ?? now,
+  };
+}
+
+function mean(nums) {
+  return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : 0;
+}
+
+// Group mapper signals by layer into a partial fingerprint update.
+//   signals — flat array from mapObservations / mapObservationsEmbed
+//   opts.sessionId — session id for provenance (session_refs)
+//   opts.now — RFC 3339 timestamp (injected so the fn is pure/testable)
+// Returns { [layerId]: { layer_version, last_updated, confidence, signals, summary } }.
+export function buildFingerprintUpdate(signals, opts = {}) {
+  const now = opts.now || new Date().toISOString();
+  const byLayer = {};
+  for (const sig of signals) {
+    (byLayer[sig.layer] ??= []).push(toSignalObject(sig, opts.sessionId, now));
+  }
+  const update = {};
+  for (const [layerId, layerSignals] of Object.entries(byLayer)) {
+    update[layerId] = {
+      layer_version: LAYER_VERSION,
+      last_updated: now,
+      confidence: Number(mean(layerSignals.map(s => s.confidence)).toFixed(3)),
+      signals: layerSignals,
+      summary: renderLayerSummary(layerSignals),
+    };
+  }
+  return update;
+}
+
+// Render a layer's signals into a short readable summary block.
+//
+// Four projection-quality guards (none mutate signals[] — provenance is kept):
+//   1. Opaque-value drop — a signal whose enum value is not in the catalog's
+//      value set for its field is skipped (e.g. a model emitting "s2_d" for
+//      tone_register). Array values keep only their conforming members.
+//   2. Same-dimension resolution — collapse to one line per (field, polarity,
+//      domain) using the §4.7 / Proposal 0006 resolver (resolveDimension):
+//      evidence-tier precedence → observation-count → recency — the SAME
+//      deterministic rule every consumer applies, not raw confidence. So a
+//      contradiction that survives upstream merge resolves to the authoritative
+//      value, identically across implementations.
+//   3. Unresolved-drop — when the resolver returns status:"unresolved" (a thin
+//      inferred value contradicting a self-report, below the evidence floor) we
+//      DON'T assert it: an injected summary stating a confident-but-contradicted
+//      value is exactly the autonomy-class defect 0006 fixes. Omit the line.
+//   4. Duplicate-line drop — an untagged and a domain-tagged signal that
+//      humanize to the same text must not appear twice.
+export function renderLayerSummary(signals, suppress) {
+  const sup = suppress instanceof Set ? suppress : null;
+  const groups = new Map();
+  for (const s of signals || []) {
+    // §4.7 injection-suppression: a dimension with an OPEN conflict (a contested
+    // observed-vs-self-report value, below the evidence floor) is WITHHELD from the
+    // projection until the subject settles it — the popup conflict dot gates what the
+    // AI sees, rather than asserting a value we are not yet confident in.
+    if (sup && sup.has(s.field + (typeof s.domain === 'string' ? `::${s.domain}` : ''))) continue;
+    const value = sanitizeValue(s.field, s.value);           // array fields: strip bad members
+    if (!valueConforms(s.field, value)) continue;            // (1) drop opaque/garbage (or now-empty array)
+    if (isEpisodic(value)) continue;                         // §4.6: drop episodic content (URL/email/domain)
+    const key = `${s.field}::${s.polarity}${typeof s.domain === 'string' ? `::${s.domain}` : ''}`;
+    if (!groups.has(key)) groups.set(key, []);               // group the dimension; resolve below
+    groups.get(key).push({ ...s, value });
+  }
+  const seen = new Set();
+  const lines = [];
+  for (const sigs of groups.values()) {
+    const r = resolveDimension(sigs);                        // (2) §4.7 deterministic winner
+    if (!r || r.status === 'unresolved') continue;           // (3) don't assert a contested value
+    const winner = sigs.find(s => valKey(s.value) === valKey(r.value)) || sigs[0];
+    const line = `- ${describeSignal(winner)}`;
+    if (seen.has(line)) continue;                            // (4) dedupe identical display lines
+    seen.add(line);
+    lines.push(line);
+  }
+  return lines.join('\n');
+}
+
+export { uuid, LAYER_VERSION, FIELD_LABELS };

package/vendor/extraction/package.json

@@ -0,0 +1,4 @@
+{
+  "//": "Declares extraction/*.js as ES modules so Node (tests, the eval harness in scripts/local-model-eval) can import them directly. The extension itself loads these unbundled as ESM via manifest.json (service_worker type:module); browsers ignore package.json, so this is node-only and has no effect on the shipped extension.",
+  "type": "module"
+}