atris 3.42.0 → 3.44.0

package/lib/wish-audit.js

@@ -189,84 +189,6 @@ const VAGUE_SUPERLATIVE_WORDS = new Set([
   'perfect',
   'smartest',
 ]);
-const GENERIC_INTERPRETATION_VERBS = new Set([
-  'add',
-  'build',
-  'change',
-  'create',
-  'do',
-  'fix',
-  'get',
-  'improve',
-  'make',
-  'polish',
-  'tweak',
-  'update',
-]);
-const AMBIGUITY_INTERPRETATIONS = {
-  'vague-superlative': {
-    candidates: ['faster to use', 'smarter by default', 'more complete'],
-    recommendedIndex: 1,
-    ask: 'which should I optimize for',
-  },
-  'missing-audience': {
-    candidates: ['solo operator', 'team member', 'end user'],
-    recommendedIndex: 0,
-    ask: 'who is this for',
-  },
-  'missing-first-slice': {
-    candidates: ['capture path', 'resurfacing rule', 'closure loop'],
-    recommendedIndex: 1,
-    ask: 'what should I change first',
-  },
-};
-const SUBJECT_KIND_INTERPRETATIONS = {
-  list: {
-    'vague-superlative': {
-      candidates: ['fastest capture', 'smartest resurfacing', 'most closure'],
-      recommendedIndex: 1,
-    },
-    'missing-first-slice': {
-      candidates: ['capture path', 'resurfacing rule', 'closure loop'],
-      recommendedIndex: 1,
-    },
-  },
-  page: {
-    'vague-superlative': {
-      candidates: ['clearer layout', 'faster scanning', 'stronger action'],
-      recommendedIndex: 0,
-    },
-    'missing-first-slice': {
-      candidates: ['top section', 'content hierarchy', 'primary action'],
-      recommendedIndex: 1,
-    },
-  },
-  loop: {
-    'vague-superlative': {
-      candidates: ['fewer steps', 'smarter defaults', 'more reliable completion'],
-      recommendedIndex: 1,
-    },
-    'missing-first-slice': {
-      candidates: ['entry path', 'decision rule', 'completion check'],
-      recommendedIndex: 1,
-    },
-  },
-  generic: {
-    'vague-superlative': {
-      candidates: ['faster to use', 'smarter by default', 'more complete'],
-      recommendedIndex: 1,
-    },
-    'missing-first-slice': {
-      candidates: ['first step', 'default behavior', 'completion path'],
-      recommendedIndex: 1,
-    },
-  },
-};
-const SUBJECT_KIND_WORDS = {
-  list: new Set(['backlog', 'board', 'inbox', 'kanban', 'list', 'queue', 'reminder', 'task', 'todo']),
-  page: new Set(['card', 'dashboard', 'form', 'homepage', 'landing', 'modal', 'page', 'panel', 'screen', 'site', 'surface', 'ui', 'view', 'website']),
-  loop: new Set(['auth', 'automation', 'cadence', 'checkout', 'flow', 'import', 'login', 'loop', 'onboarding', 'pipeline', 'process', 'routine', 'signup', 'sync', 'workflow']),
-};
 // A conjunction followed by a determiner ("an ml researcher and a 2nd grade
 // teacher") joins noun phrases inside one clause, not two separate wishes.
 const PART_JOINER_WORDS = new Set(['and', 'plus', 'also', 'adn', 'nad', 'annd']);
@@ -770,12 +692,6 @@ function sharesMeaningfulWords(left, right) {
   return false;
 }
 
-function capitalizeFirst(text) {
-  const clean = String(text || '').trim();
-  if (!clean) return '';
-  return clean.charAt(0).toUpperCase() + clean.slice(1);
-}
-
 function singularInterpretationWord(word) {
   const clean = cleanWord(word);
   if (clean.length > 3 && clean.endsWith('s')) return clean.slice(0, -1);
@@ -799,15 +715,6 @@ function interpretationWords(text, subject) {
   return values;
 }
 
-function interpretationVerb(text) {
-  for (const word of wordList(text)) {
-    const clean = cleanWord(word);
-    if (!clean || GENERIC_INTERPRETATION_VERBS.has(clean)) continue;
-    if (VERBS.has(clean)) return clean;
-  }
-  return '';
-}
-
 function superlativeWord(text) {
   for (const word of wordList(text)) {
     const clean = cleanWord(word);
@@ -818,114 +725,12 @@ function superlativeWord(text) {
 
 function interpretationContext(text, subject) {
   const nouns = interpretationWords(text, subject);
-  const topic = nouns.slice(0, 2).join(' ');
   return {
-    words: wordList(text).map(cleanWord).filter(Boolean),
-    topicWords: nouns,
-    topic,
-    topicHead: nouns[0] || '',
-    action: interpretationVerb(text),
+    topic: nouns.slice(0, 2).join(' '),
     superlative: superlativeWord(text),
   };
 }
 
-function subjectKindForInterpretation(ctx) {
-  const topicWords = Array.isArray(ctx.topicWords) ? ctx.topicWords : [];
-  if (!topicWords.length) return 'generic';
-  const words = new Set(topicWords);
-  for (const [kind, kindWords] of Object.entries(SUBJECT_KIND_WORDS)) {
-    if (Array.from(words).some((word) => kindWords.has(word))) return kind;
-  }
-  return 'generic';
-}
-
-function subjectKindInterpretation(kind, ctx) {
-  const subjectKind = subjectKindForInterpretation(ctx);
-  return (SUBJECT_KIND_INTERPRETATIONS[subjectKind] && SUBJECT_KIND_INTERPRETATIONS[subjectKind][kind])
-    || (SUBJECT_KIND_INTERPRETATIONS.generic && SUBJECT_KIND_INTERPRETATIONS.generic[kind])
-    || null;
-}
-
-function uniqueInterpretations(values) {
-  const seen = new Set();
-  const unique = [];
-  for (const value of values) {
-    const clean = String(value || '').trim().replace(/\s+/g, ' ');
-    const key = clean.toLowerCase();
-    if (!clean || seen.has(key)) continue;
-    seen.add(key);
-    unique.push(clean);
-  }
-  return unique;
-}
-
-function joinInterpretations(values) {
-  if (values.length <= 1) return values[0] || '';
-  if (values.length === 2) return `${values[0]} or ${values[1]}`;
-  return `${values.slice(0, -1).join(', ')}, or ${values[values.length - 1]}`;
-}
-
-function interpretationCandidates(kind, ctx) {
-  const domain = kind === 'vague-superlative' || kind === 'missing-first-slice'
-    ? subjectKindInterpretation(kind, ctx)
-    : null;
-  const table = domain || AMBIGUITY_INTERPRETATIONS[kind];
-  const candidates = table ? [...table.candidates] : [];
-  if (kind === 'missing-audience' && ctx.topic) candidates[0] = `${ctx.topic} owner`;
-  if (kind === 'missing-first-slice' && domain && ctx.topic && subjectKindForInterpretation(ctx) !== 'generic') {
-    candidates[0] = `${ctx.topic} ${candidates[0]}`;
-  }
-  if (kind === 'missing-first-slice' && !domain && ctx.topic) candidates[0] = `${ctx.topic} capture path`;
-  if (kind === 'missing-first-slice' && !domain && ctx.action) candidates[0] = `${ctx.action} path`;
-  return uniqueInterpretations(candidates).slice(0, 3);
-}
-
-function recommendedInterpretationIndex(kind, ctx, candidates) {
-  const words = new Set(ctx.words);
-  if (kind === 'missing-audience') {
-    if (words.has('team') || words.has('member')) return Math.min(1, candidates.length - 1);
-    if (words.has('customer') || words.has('visitor') || words.has('client')) return Math.min(2, candidates.length - 1);
-  }
-  if (kind === 'vague-superlative' || kind === 'missing-first-slice') {
-    if (['fast', 'faster', 'fastest', 'speed', 'quick', 'quickly'].some((word) => words.has(word))) return 0;
-    if (['done', 'finish', 'finished', 'close', 'closure', 'complete', 'ship'].some((word) => words.has(word))) {
-      return Math.min(2, candidates.length - 1);
-    }
-    if (['todo', 'task', 'tasks', 'list', 'backlog', 'inbox', 'remind', 'reminder', 'surface', 'resurface'].some((word) => words.has(word))) {
-      return Math.min(1, candidates.length - 1);
-    }
-  }
-  const domain = kind === 'vague-superlative' || kind === 'missing-first-slice'
-    ? subjectKindInterpretation(kind, ctx)
-    : null;
-  const table = domain || AMBIGUITY_INTERPRETATIONS[kind];
-  return Math.min(table ? table.recommendedIndex : 0, candidates.length - 1);
-}
-
-function recommendedInterpretationName(candidate) {
-  return String(candidate || '').replace(/^(?:fastest|smartest|most)\s+/i, '').trim();
-}
-
-function interpretationLabel(kind, ctx) {
-  if (kind === 'vague-superlative') {
-    if (ctx.superlative && ctx.topic) return `${capitalizeFirst(ctx.superlative)} ${ctx.topic}`;
-    return capitalizeFirst(ctx.superlative || ctx.topic || 'this');
-  }
-  const topic = ctx.topic ? `${ctx.topic} ` : '';
-  if (kind === 'missing-audience') return capitalizeFirst(`${topic}audience`);
-  if (kind === 'missing-first-slice') return capitalizeFirst(`${topic}first slice`);
-  return capitalizeFirst(ctx.topic || 'this');
-}
-
-function buildInterpretationQuestion(text, subject, kind) {
-  const table = AMBIGUITY_INTERPRETATIONS[kind];
-  const ctx = interpretationContext(text, subject);
-  const candidates = interpretationCandidates(kind, ctx);
-  const recommended = recommendedInterpretationName(candidates[recommendedInterpretationIndex(kind, ctx, candidates)]);
-  const label = interpretationLabel(kind, ctx);
-  return `${label} could mean ${joinInterpretations(candidates)}. I would bet on ${recommended}, so ${table.ask}?`;
-}
-
 function hasSubjectBearingSuperlative(text, subject) {
   const ctx = interpretationContext(text, subject);
   return Boolean(ctx.superlative && ctx.topic);
@@ -936,15 +741,10 @@ function buildClarityQuestions(text, subject, vague, options = {}) {
     ? hasSubjectBearingSuperlative(text, subject)
     : !!options.subjectSuperlative;
   if (!vague && !subjectSuperlative) return [];
-  if (subjectSuperlative) return [buildInterpretationQuestion(text, subject, 'vague-superlative')];
-  const questions = [
-    buildInterpretationQuestion(text, subject, 'vague-superlative'),
-  ];
-  if (!AUDIENCE_WORDS.test(text)) {
-    questions.push(buildInterpretationQuestion(text, subject, 'missing-audience'));
-  }
-  questions.push(buildInterpretationQuestion(text, subject, 'missing-first-slice'));
-  return questions;
+  const topic = interpretationContext(text, subject).topic;
+  return [topic
+    ? `What should be different about ${topic} when this is done?`
+    : 'What should be different when this is done?'];
 }
 
 function priorQuestionRowForAuditTextAnyQuestion(text, root) {

package/lib/wish-delegate.js

@@ -212,7 +212,7 @@ function wishTitle(wish) {
 
 // One question at a time, always ending with how to answer it.
 function printQuestion(wish, question) {
-  console.log(`Got it, wish ${wishTitle(wish)}.`);
+  console.log(`Got it: ${quoteText(wish.text || '')}.`);
   console.log(String(question || 'What should be different when this wish comes true?'));
   console.log('Answer with: atris wish answer "your words"');
 }
@@ -1097,7 +1097,7 @@ function builderWish(wish, audit, root, asJson) {
 
 // Plain per-part reply: what started, what lives elsewhere, and one question per unclear part.
 function printDecomposed(wish, parts, delegatedParts, waitingParts) {
-  console.log(`Got it, wish ${wishTitle(wish)}. It has ${parts.length} parts.`);
+  console.log(`Got it: ${quoteText(wish.text || '')}. It has ${parts.length} parts.`);
   delegatedParts.forEach((part) => {
     if (part.attached_to_existing_flight) {
       printGranted(part.text, null, {
@@ -1267,6 +1267,9 @@ function intakeQuestionSubject(question) {
   const interpretationMarker = ' could mean ';
   const interpretationIndex = normalized.indexOf(interpretationMarker);
   if (interpretationIndex > 0) return `interpretation:${normalized.slice(0, interpretationIndex)}`;
+  const grounded = normalized.match(/^what should be different about (.+?) when this is done\?$/);
+  if (grounded) return `interpretation:${grounded[1]}`;
+  if (normalized === 'what should be different when this is done?') return 'interpretation:this';
   return `question:${normalized}`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.42.0",
+  "version": "3.44.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -43,6 +43,11 @@
     "atris/team/mission-lead/MEMBER.md",
     "atris/team/mission-lead/MISSION.md",
     "atris/team/mission-lead/START_HERE.md",
+    "atris/team/improver/MEMBER.md",
+    "atris/team/customer-lead/MEMBER.md",
+    "atris/team/customer-lead/SOUL.md",
+    "atris/team/customer-lead/START_HERE.md",
+    "atris/team/customer-lead/skills/customer-commitments/SKILL.md",
     "atris/team/opus-overnight/MEMBER.md",
     "atris/team/opus-overnight/MISSION.md",
     "atris/team/opus-overnight/START_HERE.md",