wayfind 2.0.24 → 2.0.26

package/bin/digest.js

@@ -805,7 +805,7 @@ async function generateDigest(config, personaIds, sinceDate, onProgress) {
   fs.writeFileSync(combinedFile, combinedContent, 'utf8');
   files.push(combinedFile);
 
-  return { files, personas: personaIds, dateRange };
+  return { files, personas: personaIds, dateRange, scores };
 }
 
 /**

package/bin/intelligence.js

@@ -145,9 +145,73 @@ function filterForPersona(signalContent, journalContent, scores, personaId, thre
   return { signals: filteredSignals, journals: filteredJournals };
 }
 
+/**
+ * Build per-member mention data for a digest persona.
+ * Counts how many items scored 2 (directly relevant) for each member's personas.
+ *
+ * @param {Array<{id: number, [personaId]: number}>} scores - Scoring results
+ * @param {Array<{name: string, slack_user_id?: string, personas?: string[]}>} members - Team members
+ * @param {string} digestPersonaId - The persona this digest is for
+ * @returns {Array<{name: string, slackId: string, count: number}>} Members to mention, sorted by count desc
+ */
+function buildMentions(scores, members, digestPersonaId) {
+  if (!scores || !members || members.length === 0) return [];
+
+  const MENTION_THRESHOLD = 2; // Only mention for directly relevant items
+  const mentions = [];
+
+  for (const member of members) {
+    if (!member.slack_user_id) continue;
+    const memberPersonas = member.personas || [];
+
+    // For unified digest: check all of the member's personas
+    // For persona-specific digest: only mention if member has that persona
+    const relevantPersonas = digestPersonaId === 'unified'
+      ? memberPersonas
+      : memberPersonas.filter(p => p === digestPersonaId);
+
+    if (relevantPersonas.length === 0) continue;
+
+    // Count items that scored >= MENTION_THRESHOLD for any of the member's relevant personas
+    let count = 0;
+    for (const score of scores) {
+      const isRelevant = relevantPersonas.some(p => (score[p] ?? 0) >= MENTION_THRESHOLD);
+      if (isRelevant) count++;
+    }
+
+    if (count > 0) {
+      mentions.push({
+        name: member.name || 'unknown',
+        slackId: member.slack_user_id,
+        count,
+      });
+    }
+  }
+
+  return mentions.sort((a, b) => b.count - a.count);
+}
+
+/**
+ * Format mentions into a Slack mrkdwn message for thread reply.
+ * @param {Array<{name: string, slackId: string, count: number}>} mentions
+ * @returns {string|null} Formatted message or null if no mentions
+ */
+function formatMentionsMessage(mentions) {
+  if (!mentions || mentions.length === 0) return null;
+
+  const lines = mentions.map(m => {
+    const items = m.count === 1 ? '1 item' : `${m.count} items`;
+    return `<@${m.slackId}> — ${items} directly relevant to you`;
+  });
+
+  return `:bell: *Heads up*\n${lines.join('\n')}`;
+}
+
 module.exports = {
   scoreItems,
   filterForPersona,
+  buildMentions,
+  formatMentionsMessage,
   DEFAULT_THRESHOLDS,
   // Exported for testing
   buildScoringPrompt,

package/bin/slack.js

@@ -203,9 +203,11 @@ function postToWebhook(webhookUrl, payload) {
  * @param {string} header - One-liner header (e.g. ":compass: *Wayfind Digest* (Mar 11–18)")
  * @param {string} content - Full digest body as mrkdwn
  * @param {string} personaName - Persona ID
+ * @param {Object} [extras] - Optional extras
+ * @param {string} [extras.mentionsMessage] - Pre-formatted @mentions message for thread reply
  * @returns {Promise<{ ok: true, persona: string, ts: string, channel: string }>}
  */
-async function deliverViaBot(botToken, channel, header, content, personaName) {
+async function deliverViaBot(botToken, channel, header, content, personaName, extras) {
   const { WebClient } = require('@slack/web-api');
   const client = new WebClient(botToken);
 
@@ -225,7 +227,22 @@ async function deliverViaBot(botToken, channel, header, content, personaName) {
     unfurl_links: false,
   });
 
-  // Post feedback prompt as second thread reply
+  // Post @mentions as thread reply (before feedback prompt)
+  const ext = extras || {};
+  if (ext.mentionsMessage) {
+    try {
+      await client.chat.postMessage({
+        channel,
+        thread_ts: headerResult.ts,
+        text: ext.mentionsMessage,
+        unfurl_links: false,
+      });
+    } catch (err) {
+      // Non-fatal — digest was delivered, mentions are optional
+    }
+  }
+
+  // Post feedback prompt as thread reply
   try {
     await client.chat.postMessage({
       channel,
@@ -254,6 +271,7 @@ async function deliverViaBot(botToken, channel, header, content, personaName) {
  * @param {Object} [options] - Optional delivery options
  * @param {string} [options.botToken] - Slack bot token for chat.postMessage delivery
  * @param {string} [options.channel] - Slack channel for bot delivery
+ * @param {string} [options.mentionsMessage] - Pre-formatted @mentions for thread reply
  * @returns {Promise<{ ok: true, persona: string, ts?: string, channel?: string }>}
  */
 async function deliver(webhookUrl, digestContent, personaName, dateRange, options) {
@@ -283,7 +301,9 @@ async function deliver(webhookUrl, digestContent, personaName, dateRange, option
   const opts = options || {};
   if (opts.botToken && opts.channel) {
     try {
-      return await deliverViaBot(opts.botToken, opts.channel, header, mrkdwn, personaName);
+      return await deliverViaBot(opts.botToken, opts.channel, header, mrkdwn, personaName, {
+        mentionsMessage: opts.mentionsMessage,
+      });
     } catch (err) {
       console.error(`Bot delivery failed for ${personaName}, falling back to webhook: ${err.message}`);
     }
@@ -308,6 +328,7 @@ async function deliver(webhookUrl, digestContent, personaName, dateRange, option
  * @param {Object} [options] - Optional delivery options
  * @param {string} [options.botToken] - Slack bot token for chat.postMessage delivery
  * @param {string} [options.channel] - Slack channel for bot delivery
+ * @param {Object} [options.mentionsByPersona] - Map of personaId → formatted mentions message
  * @returns {Promise<Array<{ ok: true, persona: string, ts?: string, channel?: string }>>}
  */
 async function deliverAll(webhookUrl, digestResult, personaIds, options) {
@@ -336,7 +357,12 @@ async function deliverAll(webhookUrl, digestResult, personaIds, options) {
         await new Promise((r) => setTimeout(r, 1000));
       }
 
-      const result = await deliver(webhookUrl, content, persona, digestResult.dateRange, options);
+      const deliverOpts = { ...(options || {}) };
+      // Attach per-persona mentions if available
+      if (deliverOpts.mentionsByPersona && deliverOpts.mentionsByPersona[persona]) {
+        deliverOpts.mentionsMessage = deliverOpts.mentionsByPersona[persona];
+      }
+      const result = await deliver(webhookUrl, content, persona, digestResult.dateRange, deliverOpts);
       results.push(result);
     } catch (err) {
       results.push({ ok: false, persona, error: err.message });

package/bin/team-context.js

@@ -1018,10 +1018,32 @@ async function runDigest(args) {
       process.exit(1);
     }
 
+    // Build per-persona @mentions from intelligence scores + member profiles
+    const mentionsByPersona = {};
+    if (result.scores) {
+      const intelligence = require('./intelligence');
+      const teamContextPath = getTeamContextPath();
+      const membersDir = teamContextPath ? path.join(teamContextPath, 'members') : null;
+      if (membersDir && fs.existsSync(membersDir)) {
+        const memberFiles = fs.readdirSync(membersDir).filter(f => f.endsWith('.json'));
+        const members = memberFiles.map(f => {
+          try { return JSON.parse(fs.readFileSync(path.join(membersDir, f), 'utf8')); }
+          catch { return null; }
+        }).filter(Boolean);
+
+        for (const pid of personaIds) {
+          const mentions = intelligence.buildMentions(result.scores, members, pid);
+          const msg = intelligence.formatMentionsMessage(mentions);
+          if (msg) mentionsByPersona[pid] = msg;
+        }
+      }
+    }
+
     console.log('Delivering to Slack...');
     const deliveryResults = await slack.deliverAll(webhookUrl, result, personaIds, {
       botToken: process.env.SLACK_BOT_TOKEN,
       channel: process.env.SLACK_DIGEST_CHANNEL,
+      mentionsByPersona,
     });
     let failures = 0;
     const dateStr = result.dateRange.to;
@@ -4508,11 +4530,11 @@ const COMMANDS = {
       const skipNpm = args.includes('--skip-npm');
       if (!skipNpm) {
         console.log('Updating wayfind from npm...');
-        const npmResult = spawnSync('npm', ['update', '-g', 'wayfind'], {
+        const npmResult = spawnSync('npm', ['install', '-g', 'wayfind@latest'], {
           stdio: 'inherit',
         });
         if (npmResult.error || (npmResult.status && npmResult.status !== 0)) {
-          console.error('npm update failed. Try running: npm update -g wayfind');
+          console.error('npm install failed. Try running: npm install -g wayfind@latest');
           console.error('Then re-run: wayfind update --skip-npm');
           process.exit(1);
         }

package/package.json

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