wayfind 2.0.22 → 2.0.24

package/bin/connectors/llm.js

@@ -44,6 +44,15 @@ function loadDigestFixture(personaId) {
   }
 }
 
+function loadScoringFixture() {
+  const fixturePath = path.join(getRepoRoot(), 'simulation', 'fixtures', 'intelligence', 'scores.json');
+  try {
+    return fs.readFileSync(fixturePath, 'utf8');
+  } catch {
+    return '[]';
+  }
+}
+
 // ── HTTP helpers ─────────────────────────────────────────────────────────────
 
 /**
@@ -274,6 +283,9 @@ async function callCLI(config, systemPrompt, userContent) {
 async function call(config, systemPrompt, userContent) {
   // Simulation mode overrides any provider setting
   if (isSimulation() || config.provider === 'simulate') {
+    if (config._callType === 'scoring') {
+      return loadScoringFixture();
+    }
     const personaId = config._personaId || 'engineering';
     return loadDigestFixture(personaId);
   }

package/bin/digest.js

@@ -7,9 +7,13 @@ const llm = require('./connectors/llm');
 const contentStore = require('./content-store');
 const telemetry = require('./telemetry');
 
+const intelligence = require('./intelligence');
+
 const HOME = process.env.HOME || process.env.USERPROFILE;
 const WAYFIND_DIR = path.join(HOME, '.claude', 'team-context');
 const ENV_FILE = path.join(WAYFIND_DIR, '.env');
+const ROOT = path.join(__dirname, '..');
+const DEFAULT_PERSONAS_PATH = path.join(ROOT, 'templates', 'personas.json');
 
 // Team repo allowlist — mirrors content-store.js logic for digest-time filtering.
 // When INCLUDE_REPOS is set, sections mentioning repos NOT on the list are removed.
@@ -73,6 +77,31 @@ function filterExcludedContent(content) {
   return content;
 }
 
+// ── Persona loading ─────────────────────────────────────────────────────────
+
+/**
+ * Load active personas from user config or bundled default.
+ * Same resolution as team-context.js:readPersonas.
+ * @returns {Array<{id: string, name: string, description: string}>}
+ */
+function loadPersonas() {
+  const candidates = [
+    path.join(HOME, '.claude', 'team-context', 'personas.json'),
+    path.join(HOME, '.ai-memory', 'team-context', 'personas.json'),
+  ];
+  let configPath = null;
+  for (const p of candidates) {
+    if (fs.existsSync(p)) { configPath = p; break; }
+  }
+  if (!configPath) configPath = DEFAULT_PERSONAS_PATH;
+  try {
+    const data = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return data.personas || [];
+  } catch {
+    return [];
+  }
+}
+
 // ── Env file helpers ────────────────────────────────────────────────────────
 
 /**
@@ -677,11 +706,23 @@ async function generateDigest(config, personaIds, sinceDate, onProgress) {
   journalContent = filterExcludedContent(journalContent);
   signalContent = filterExcludedContent(signalContent);
 
-  // Apply token budget
+  // Preserve original content refs for telemetry
+  const rawSignalContent = signalContent;
+  const rawJournalContent = journalContent;
+
+  // Intelligence layer: score items for persona relevance
+  const personas = loadPersonas();
+  let scores = null;
+  if (config.intelligence?.enabled !== false && personas.length > 0) {
+    const haikuConfig = {
+      provider: config.llm.provider,
+      model: config.intelligence?.model || 'claude-haiku-4-5-20251001',
+      api_key_env: config.llm.api_key_env,
+    };
+    scores = await intelligence.scoreItems(signalContent, journalContent, personas, haikuConfig);
+  }
+
   const maxInputChars = (config.llm && config.llm.max_input_chars) || 120000;
-  const budget = applyTokenBudget(signalContent, journalContent, maxInputChars);
-  signalContent = budget.signals;
-  journalContent = budget.journals;
 
   // Generate per-persona digests
   const digestDir = path.join(HOME, '.claude', 'team-context', 'digests');
@@ -696,8 +737,23 @@ async function generateDigest(config, personaIds, sinceDate, onProgress) {
     }
 
     const startTime = Date.now();
+
+    // Per-persona filtering: intelligence layer + token budget
+    let pSignals = signalContent;
+    let pJournals = journalContent;
+    if (scores) {
+      const threshold = config.intelligence?.thresholds?.[personaId]
+        ?? intelligence.DEFAULT_THRESHOLDS[personaId] ?? 1;
+      const allPersonaIds = personas.map(p => p.id);
+      ({ signals: pSignals, journals: pJournals } =
+        intelligence.filterForPersona(signalContent, journalContent, scores, personaId, threshold, allPersonaIds));
+    }
+    const budget = applyTokenBudget(pSignals, pJournals, maxInputChars);
+    pSignals = budget.signals;
+    pJournals = budget.journals;
+
     const promptContext = { teamContextDir: config.team_context_dir };
-    const { system, user } = buildPrompt(personaId, signalContent, journalContent, dateRange, promptContext);
+    const { system, user } = buildPrompt(personaId, pSignals, pJournals, dateRange, promptContext);
 
     // Debug: dump prompt if TEAM_CONTEXT_DEBUG_PROMPT is set
     if (process.env.TEAM_CONTEXT_DEBUG_PROMPT) {
@@ -729,10 +785,12 @@ async function generateDigest(config, personaIds, sinceDate, onProgress) {
     persona_count: personaIds.length,
     personas: personaIds.join(','),
     entry_count: storeResult.entryCount || 0,
-    journal_count: journalContent ? journalContent.split('\n---\n').length : 0,
-    signal_count: signalContent ? signalContent.split('\n---\n').length : 0,
+    journal_count: rawJournalContent ? rawJournalContent.split('\n---\n').length : 0,
+    signal_count: rawSignalContent ? rawSignalContent.split('\n---\n').length : 0,
     has_previous_digest: !!loadPreviousDigest(personaIds[0], toDate),
     has_team_context: !!loadTeamContext(config.team_context_dir),
+    intelligence_enabled: config.intelligence?.enabled !== false,
+    intelligence_items_scored: scores ? scores.length : 0,
   });
 
   // Write combined file
@@ -843,6 +901,7 @@ module.exports = {
   loadTeamContext,
   loadTeamMembers,
   loadPreviousDigest,
+  loadPersonas,
   buildFeedbackContext,
   buildPrompt,
   generateDigest,

package/bin/intelligence.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const llm = require('./connectors/llm');
+
+// Default thresholds per persona. 0=show everything, 1=tangential+relevant, 2=directly relevant only.
+const DEFAULT_THRESHOLDS = {
+  engineering: 1,
+  product: 2,
+  design: 2,
+  strategy: 1,
+  unified: 0,
+};
+
+/**
+ * Build the scoring system prompt dynamically from active personas.
+ * @param {Array<{id: string, description: string}>} personas
+ * @returns {string}
+ */
+function buildScoringPrompt(personas) {
+  const personaDefs = personas
+    .map(p => `- ${p.id}: ${p.description}`)
+    .join('\n');
+
+  const exampleKeys = personas.map(p => `"${p.id}":0`).join(',');
+
+  return `You score journal entries and signals for relevance to this team's personas.
+Score each item 0-2 for each persona:
+- 0 = not relevant to this persona
+- 1 = tangentially relevant (context, not action)
+- 2 = directly relevant (this persona should see this)
+
+Personas:
+${personaDefs}
+
+Return ONLY a JSON array. No explanation. Example:
+[{"id":0,${exampleKeys}},{"id":1,${exampleKeys}}]`;
+}
+
+/**
+ * Split content on section separators and number items.
+ * @param {string} content
+ * @param {number} startId - Starting item ID
+ * @returns {{ items: string[], labeled: string }}
+ */
+function splitAndLabel(content, startId) {
+  if (!content || !content.trim()) return { items: [], labeled: '' };
+  const items = content.split('\n\n---\n\n').filter(s => s.trim());
+  const labeled = items
+    .map((item, i) => `[ITEM ${startId + i}]\n${item}`)
+    .join('\n\n');
+  return { items, labeled };
+}
+
+/**
+ * Score signal and journal items for persona relevance using a single LLM call.
+ * @param {string} signalContent - Raw signal content (sections separated by \n\n---\n\n)
+ * @param {string} journalContent - Raw journal content (sections separated by \n\n---\n\n)
+ * @param {Array<{id: string, description: string}>} personas - Active personas
+ * @param {Object} llmConfig - LLM config for the scoring call
+ * @returns {Promise<Array<{id: number, [personaId]: number}>|null>} Scores array or null on failure
+ */
+async function scoreItems(signalContent, journalContent, personas, llmConfig) {
+  const signalResult = splitAndLabel(signalContent, 0);
+  const journalResult = splitAndLabel(journalContent, signalResult.items.length);
+
+  const totalItems = signalResult.items.length + journalResult.items.length;
+  if (totalItems === 0) return null;
+
+  const systemPrompt = buildScoringPrompt(personas);
+
+  const userParts = [];
+  if (signalResult.labeled) {
+    userParts.push('## Signals\n\n' + signalResult.labeled);
+  }
+  if (journalResult.labeled) {
+    userParts.push('## Journals\n\n' + journalResult.labeled);
+  }
+  const userContent = userParts.join('\n\n---\n\n');
+
+  const config = {
+    ...llmConfig,
+    _personaId: 'scoring',
+    _callType: 'scoring',
+    max_tokens: Math.max(256, totalItems * 80),
+  };
+
+  try {
+    const response = await llm.call(config, systemPrompt, userContent);
+    let jsonStr = response.trim();
+    // Strip markdown fences if present (reuse pattern from content-store.js)
+    if (jsonStr.startsWith('```')) {
+      jsonStr = jsonStr.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '');
+    }
+    const scores = JSON.parse(jsonStr);
+    if (!Array.isArray(scores)) return null;
+    return scores;
+  } catch {
+    // Graceful fallback: caller passes everything through
+    return null;
+  }
+}
+
+/**
+ * Filter content sections based on persona relevance scores.
+ * @param {string} signalContent - Raw signal content
+ * @param {string} journalContent - Raw journal content
+ * @param {Array<{id: number}>} scores - Scoring results from scoreItems
+ * @param {string} personaId - Persona to filter for
+ * @param {number} threshold - Minimum score to include (0, 1, or 2)
+ * @param {string[]} allPersonaIds - All active persona IDs (for unified union logic)
+ * @returns {{ signals: string, journals: string }}
+ */
+function filterForPersona(signalContent, journalContent, scores, personaId, threshold, allPersonaIds) {
+  const signalItems = (signalContent && signalContent.trim())
+    ? signalContent.split('\n\n---\n\n').filter(s => s.trim())
+    : [];
+  const journalItems = (journalContent && journalContent.trim())
+    ? journalContent.split('\n\n---\n\n').filter(s => s.trim())
+    : [];
+
+  function itemPasses(itemIndex) {
+    const score = scores.find(s => s.id === itemIndex);
+    if (!score) return true; // If no score for this item, include it (safe default)
+
+    if (personaId === 'unified') {
+      // Union: passes if ANY persona scores >= their threshold
+      return allPersonaIds.some(pid => {
+        const pidThreshold = DEFAULT_THRESHOLDS[pid] ?? 1;
+        return (score[pid] ?? 0) >= pidThreshold;
+      });
+    }
+
+    return (score[personaId] ?? 0) >= threshold;
+  }
+
+  const filteredSignals = signalItems
+    .filter((_, i) => itemPasses(i))
+    .join('\n\n---\n\n');
+
+  const signalCount = signalItems.length;
+  const filteredJournals = journalItems
+    .filter((_, i) => itemPasses(signalCount + i))
+    .join('\n\n---\n\n');
+
+  return { signals: filteredSignals, journals: filteredJournals };
+}
+
+module.exports = {
+  scoreItems,
+  filterForPersona,
+  DEFAULT_THRESHOLDS,
+  // Exported for testing
+  buildScoringPrompt,
+  splitAndLabel,
+};

package/bin/team-context.js

@@ -4729,6 +4729,21 @@ const COMMANDS = {
   'sync-public': {
     desc: 'Sync code to the public usewayfind/wayfind repo',
     run: () => {
+      // Source must be the repo checkout you're working in, not the npm global install.
+      // Use cwd if it looks like a wayfind repo, otherwise fall back to ROOT.
+      const cwdPkg = path.join(process.cwd(), 'package.json');
+      let sourceRoot = ROOT;
+      if (fs.existsSync(cwdPkg)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(cwdPkg, 'utf8'));
+          if (pkg.name === 'wayfind') sourceRoot = process.cwd();
+        } catch {}
+      }
+      if (sourceRoot === ROOT && ROOT !== process.cwd()) {
+        console.log(`Syncing from: ${sourceRoot}`);
+        console.log('Tip: run from your wayfind repo checkout to sync local changes.');
+      }
+
       const tmpDir = path.join(os.tmpdir(), 'wayfind-public-sync');
       const publicRepo = process.env.WAYFIND_PUBLIC_REPO || 'https://github.com/usewayfind/wayfind.git';
 
@@ -4761,13 +4776,13 @@ const COMMANDS = {
       const privateOnlyWorkflows = ['sync-public.yml', 'simulation.yml'];
 
       // Also sync public-staging docs if they exist
-      const publicDocsDir = path.join(ROOT, 'public-staging', 'docs');
+      const publicDocsDir = path.join(sourceRoot, 'public-staging', 'docs');
 
       console.log('Syncing files...');
       for (const item of syncItems) {
         const isDir = item.endsWith('/');
         const name = item.replace(/\/$/, '');
-        const src = path.join(ROOT, name);
+        const src = path.join(sourceRoot, name);
         if (!fs.existsSync(src)) continue;
         if (isDir) {
           // rsync without trailing slash on source copies the directory itself into dest
@@ -4787,7 +4802,7 @@ const COMMANDS = {
 
       // Sync public-staging/ → public repo root (recursive)
       // This overlays LICENSE, README, CHANGELOG, SECURITY, CONTRIBUTING, docs/, etc.
-      const publicStagingDir = path.join(ROOT, 'public-staging');
+      const publicStagingDir = path.join(sourceRoot, 'public-staging');
       if (fs.existsSync(publicStagingDir)) {
         spawnSync('rsync', ['-a', publicStagingDir + '/', tmpDir + '/'], { stdio: 'inherit' });
       }
@@ -4795,7 +4810,7 @@ const COMMANDS = {
       // ── Sanitization gate ───────────────────────────────────────────────
       // Scan all tracked text files for proprietary patterns before pushing.
       // Patterns loaded from .sync-blocklist (not synced to public repo).
-      const blocklistPath = path.join(ROOT, '.sync-blocklist');
+      const blocklistPath = path.join(sourceRoot, '.sync-blocklist');
       const BLOCKED_PATTERNS = [];
       if (fs.existsSync(blocklistPath)) {
         for (const line of fs.readFileSync(blocklistPath, 'utf8').split('\n')) {
@@ -4873,7 +4888,7 @@ const COMMANDS = {
 
       // Get version for commit message
       let version = 'unknown';
-      try { version = require(path.join(ROOT, 'package.json')).version; } catch {}
+      try { version = require(path.join(sourceRoot, 'package.json')).version; } catch {}
 
       // Commit and push
       spawnSync('git', ['add', '-A'], { cwd: tmpDir, stdio: 'inherit' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wayfind",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "description": "Team decision trail for AI-assisted development. The connective tissue between product, engineering, and strategy.",
   "bin": {
     "wayfind": "./bin/team-context.js"

package/templates/autopilot/design.md

@@ -8,6 +8,8 @@ Find the 5 most consequential design items from this period. "Consequential" mea
 
 ## Rules
 
+- **Translate to user impact.** If a code change made the cut, describe what the user sees or
+  interacts with differently. Translate technical changes into UX consequences.
 - **Maximum 5 items.** If fewer than 5 things matter, output fewer. Never pad.
 - **Rank by consequence, not category.** Lead with the item that most affects user experience.
 - **No category headers.** No "UX Consistency" / "Accessibility" sections. Just a ranked list.

package/templates/autopilot/product.md

@@ -8,6 +8,9 @@ Find the 5 most consequential product items from this period. "Consequential" me
 
 ## Rules
 
+- **Translate, don't transcribe.** If an engineering item made the cut, describe its product
+  implication — not its technical cause. "Hotel data gaps visible to customers in analytics"
+  not "nestedSource config missing in Function App." The reader is a PM, not a developer.
 - **Maximum 5 items.** If fewer than 5 things matter, output fewer. Never pad.
 - **Rank by consequence, not category.** Lead with the item that most affects customers or roadmap.
 - **No category headers.** No "Scope Drift" / "Customer Issues" sections. Just a ranked list.

package/templates/autopilot/strategy.md

@@ -8,6 +8,9 @@ Find the 5 most consequential strategic items from this period. "Consequential"
 
 ## Rules
 
+- **Extract the strategic pattern.** If day-to-day engineering work made the cut, connect it to
+  business goals, competitive positioning, or resource allocation. The reader thinks in quarters,
+  not sprints.
 - **Maximum 5 items.** If fewer than 5 things matter, output fewer. Never pad.
 - **Rank by consequence, not category.** Lead with the item that most affects the business trajectory.
 - **No category headers.** No "Competitive" / "Strategic Drift" sections. Just a ranked list.