wayfind 2.0.19 → 2.0.20

package/BOOTSTRAP_PROMPT.md

@@ -7,34 +7,39 @@ Copy and paste the block below into a new Claude Code session. That's it.
 ```
 Please set up Wayfind for my Claude Code environment.
 
-Run these commands:
+Step 1 — Install the CLI:
 npm install -g wayfind
 wayfind init
 
-Once it completes:
+Step 2 — Install the Claude Code plugin:
+/plugin marketplace add usewayfind/wayfind
+/plugin install wayfind@usewayfind
+
+Once both steps complete:
 1. Tell me what was installed and what still needs to be configured
-2. Run /init-memory to initialize memory for the current repo
+2. Run /wayfind:init-memory to initialize memory for the current repo
 3. Ask me what my preferences are (communication style, tool preferences, commit
    conventions, anything I want Claude to always know) so we can fill in
    global-state.md together
 4. Ask me if I want to set up backup (see below) — I will need to provide a
    private GitHub repo URL before you can proceed with that step
 5. Run `wayfind whoami --setup` so I can provide my Slack user ID (used for @mentions and DMs)
-6. Ask me if I want to set up team context (/init-team) for shared journals,
+6. Ask me if I want to set up team context (/wayfind:init-team) for shared journals,
    digests, and product state
-7. Let me know about opt-in telemetry (set TEAM_CONTEXT_TELEMETRY=true to enable)
+7. Let me know that anonymous usage telemetry is enabled by default (set TEAM_CONTEXT_TELEMETRY=false to opt out)
 ```
 
 ---
 
 ## What happens
 
-The install command will:
-- Create `~/.claude/memory/` and `~/.claude/memory/journal/`
-- Install `~/.claude/global-state.md` (your persistent index)
-- Install `~/.claude/hooks/check-global-state.sh` (warns when state is stale)
-- Install slash commands: `/init-memory`, `/init-team`, `/journal`, `/doctor`
-- Register the hook in `~/.claude/settings.json`
+The CLI install creates:
+- `~/.claude/memory/` and `~/.claude/memory/journal/`
+- `~/.claude/global-state.md` (your persistent index)
+
+The plugin provides:
+- SessionStart and Stop hooks (context loading, decision extraction)
+- Slash commands: `/wayfind:init-memory`, `/wayfind:init-team`, `/wayfind:journal`, `/wayfind:doctor`, `/wayfind:standup`
 
 After the paste, Claude will walk you through filling in your preferences. From
 then on, every session in every repo will start with full context of where you
@@ -72,7 +77,7 @@ After that, your memory is backed up silently on every session — no manual ste
 
 ## Setting up team context (optional)
 
-Once you have the basics working, run `/init-team` in a Claude Code session to set up:
+Once you have the basics working, run `/wayfind:init-team` in a Claude Code session to set up:
 - A shared team context repo for journals and digests
 - Slack integration for weekly digest posts
 - Notion integration for browseable product state and digest archives
@@ -87,7 +92,7 @@ visibility across product, engineering, and strategy.
 
 In any repo you work in, run:
 ```
-/init-memory
+/wayfind:init-memory
 ```
 
 Claude will create `.claude/team-state.md` (shared) and `.claude/personal-state.md`
@@ -102,6 +107,8 @@ npm install -g wayfind
 wayfind init-cursor
 ```
 
+(The Claude Code plugin is not available for Cursor — use the CLI-only setup.)
+
 ---
 
 ## Source
@@ -110,11 +117,11 @@ https://github.com/usewayfind/wayfind
 
 To install a specific version:
 ```
-npm install -g wayfind@1.1.0
+npm install -g wayfind@2.0.15
 wayfind init
 ```
 
 Or via the shell installer with a pinned version:
 ```
-WAYFIND_VERSION=v1.1.0 bash <(curl -fsSL https://raw.githubusercontent.com/usewayfind/wayfind/main/install.sh)
+WAYFIND_VERSION=v2.0.15 bash <(curl -fsSL https://raw.githubusercontent.com/usewayfind/wayfind/main/install.sh)
 ```

package/bin/content-store.js

@@ -604,6 +604,11 @@ function searchText(query, options = {}) {
 function applyFilters(entry, filters) {
   if (isRepoExcluded(entry.repo)) return false;
   if (filters.repo && entry.repo.toLowerCase() !== filters.repo.toLowerCase()) return false;
+  if (filters.repos && filters.repos.length > 0) {
+    const lower = (entry.repo || '').toLowerCase();
+    const matches = filters.repos.some(r => lower === r.toLowerCase() || lower.endsWith('/' + r.split('/').pop().toLowerCase()));
+    if (!matches) return false;
+  }
   if (filters.since && entry.date < filters.since) return false;
   if (filters.until && entry.date > filters.until) return false;
   if (filters.drifted !== undefined && entry.drifted !== filters.drifted) return false;

package/bin/slack-bot.js

@@ -10,6 +10,10 @@ const telemetry = require('./telemetry');
 
 // ── Slack connection state (for healthcheck) ────────────────────────────────
 let slackConnected = false;
+
+// ── Feature map (loaded at startup, reloaded on-demand) ──────────────────────
+/** In-memory feature map: { "org/repo": { tags: string[], description: string } } */
+let featureMap = null;
 let slackLastConnected = null;
 let slackLastDisconnected = null;
 
@@ -53,6 +57,62 @@ Rules:
 - Do not invent information that isn't in the provided context.`;
 }
 
+// ── Feature map ──────────────────────────────────────────────────────────────
+
+/**
+ * Load features.json from the team-context repo into memory.
+ * Silently no-ops if the file doesn't exist.
+ * @param {Object} config - Bot config (uses team_context_dir or TEAM_CONTEXT_TEAM_CONTEXT_DIR)
+ */
+function loadFeatureMap(config) {
+  const teamDir = config.team_context_dir || process.env.TEAM_CONTEXT_TEAM_CONTEXT_DIR || '';
+  if (!teamDir) return;
+  const featuresFile = path.join(teamDir, 'features.json');
+  try {
+    const raw = fs.readFileSync(featuresFile, 'utf8');
+    featureMap = JSON.parse(raw);
+  } catch {
+    featureMap = null;
+  }
+}
+
+/**
+ * Use Haiku to determine which repos are relevant to a query, based on the feature map.
+ * Returns an array of repo slugs (e.g. ["org/api-service", "org/analytics"]).
+ * Returns null if routing cannot be determined (map empty, LLM fails, etc.).
+ * @param {string} query
+ * @param {Object} map - Feature map object
+ * @param {Object} llmConfig - LLM configuration
+ * @returns {Promise<string[]|null>}
+ */
+async function routeQueryToRepos(query, map, llmConfig) {
+  if (!map || Object.keys(map).length === 0) return null;
+
+  const repoList = Object.entries(map).map(([repo, entry]) => {
+    const tags = (entry.tags || []).join(', ');
+    const desc = entry.description ? ` — ${entry.description}` : '';
+    return `${repo}: ${tags}${desc}`;
+  }).join('\n');
+
+  const systemPrompt = `You are a routing assistant. Given a user query and a list of repositories with their feature tags, return a JSON array of repository slugs (e.g. ["org/repo"]) that are most relevant to the query. Return only the repos that are clearly relevant. If no repos match, return an empty array. Return only valid JSON — no explanation.`;
+
+  const userContent = `Query: ${query}\n\nRepositories:\n${repoList}`;
+
+  const haikuConfig = {
+    ...llmConfig,
+    model: process.env.TEAM_CONTEXT_HAIKU_MODEL || 'claude-haiku-4-5-20251001',
+  };
+
+  try {
+    const raw = await llm.call(haikuConfig, systemPrompt, userContent);
+    const parsed = JSON.parse(raw.trim());
+    if (Array.isArray(parsed)) return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function ask(question) {
@@ -504,6 +564,9 @@ async function searchDecisionTrail(query, config) {
   if (config.journal_dir) {
     searchOpts.journalDir = config.journal_dir;
   }
+  if (config._repoFilter && config._repoFilter.length > 0) {
+    searchOpts.repos = config._repoFilter;
+  }
 
   // Resolve temporal references to date filters
   const dateFilters = resolveDateFilters(query);
@@ -984,6 +1047,19 @@ async function handleQuery(query, config, threadHistory) {
     return { text: promptResult, results: [], _promptQuery: true };
   }
 
+  // On-demand feature map reload — user signals they just updated features
+  if (/\b(?:just\s+(?:added|updated|set|ran)\s+(?:features?|wayfind\s+features?))\b/i.test(query) ||
+      /\bwayfind\s+features\s+(?:add|set|describe)\b/i.test(query)) {
+    loadFeatureMap(config);
+    const count = featureMap ? Object.keys(featureMap).length : 0;
+    return {
+      text: count > 0
+        ? `Feature map reloaded. I now know about ${count} repo(s): ${Object.keys(featureMap).join(', ')}`
+        : 'Feature map reloaded, but no repos are configured yet. Run `wayfind features add` in a repo.',
+      results: [],
+    };
+  }
+
   const intent = classifyIntent(query);
   const llmConfig = config.llm || {};
   const contentOpts = {};
@@ -1061,7 +1137,27 @@ async function handleQuery(query, config, threadHistory) {
         (priorDates.until !== priorDates.since ? ` ${priorDates.until}` : '');
     }
   }
-  const results = await searchDecisionTrail(searchQuery, config);
+
+  // Feature map routing: if a map exists, ask Haiku which repos are relevant
+  let repoFilter = null;
+  if (featureMap && Object.keys(featureMap).length > 0) {
+    const routedRepos = await routeQueryToRepos(query, featureMap, llmConfig);
+    if (routedRepos !== null) {
+      if (routedRepos.length === 0) {
+        return {
+          text: "I couldn't determine which repositories are relevant to your question. If this seems wrong, run `wayfind features add` in the relevant repo(s) and try again.",
+          results: [],
+        };
+      }
+      repoFilter = routedRepos;
+    }
+  }
+
+  const searchConfig = repoFilter
+    ? { ...config, _repoFilter: repoFilter }
+    : config;
+
+  const results = await searchDecisionTrail(searchQuery, searchConfig);
   const answer = await synthesizeAnswer(query, results, llmConfig, contentOpts, threadHistory);
   const text = formatResponse(answer, results);
   return {
@@ -1141,6 +1237,12 @@ async function start(config) {
   const teamContextDir = config.team_context_dir || process.env.TEAM_CONTEXT_TEAM_CONTEXT_DIR || null;
   const membersDir = teamContextDir ? path.join(teamContextDir, 'members') : null;
 
+  // Load feature map for repo routing
+  loadFeatureMap(config);
+  if (featureMap && Object.keys(featureMap).length > 0) {
+    console.log(`Loaded feature map: ${Object.keys(featureMap).length} repo(s)`);
+  }
+
   // Handle @mentions
   app.event('app_mention', async ({ event, client }) => {
     const channel = event.channel;

package/bin/slack.js

@@ -194,39 +194,51 @@ function postToWebhook(webhookUrl, payload) {
 
 /**
  * Deliver a digest to Slack via chat.postMessage (bot token).
- * Returns the message ts for reaction tracking.
+ * Posts a scannable one-liner header to the channel, then the full digest
+ * content as the first thread reply. Reaction tracking keys on the digest
+ * reply ts, not the header.
  *
  * @param {string} botToken - Slack bot OAuth token (xoxb-...)
  * @param {string} channel - Slack channel ID or name
- * @param {string} content - Formatted mrkdwn content (already converted)
+ * @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
  * @returns {Promise<{ ok: true, persona: string, ts: string, channel: string }>}
  */
-async function deliverViaBot(botToken, channel, content, personaName) {
+async function deliverViaBot(botToken, channel, header, content, personaName) {
   const { WebClient } = require('@slack/web-api');
   const client = new WebClient(botToken);
 
-  const truncated = content.length > 3900 ? content.slice(0, 3900) + '\n\n_...truncated_' : content;
+  // Post scannable header to channel
+  const headerResult = await client.chat.postMessage({
+    channel,
+    text: header,
+    unfurl_links: false,
+  });
 
-  const result = await client.chat.postMessage({
+  // Post full digest as first thread reply
+  const truncated = content.length > 3900 ? content.slice(0, 3900) + '\n\n_...truncated_' : content;
+  const digestResult = await client.chat.postMessage({
     channel,
+    thread_ts: headerResult.ts,
     text: truncated,
     unfurl_links: false,
   });
 
-  // Post a threaded follow-up asking for feedback
+  // Post feedback prompt as second thread reply
   try {
     await client.chat.postMessage({
       channel,
-      thread_ts: result.ts,
-      text: '_React to the digest or reply here with feedback — what was useful? What was missing? Your input shapes future digests._',
+      thread_ts: headerResult.ts,
+      text: '_React to the digest above or reply here with feedback — what was useful? What was missing? Your input shapes future digests._',
       unfurl_links: false,
     });
   } catch (err) {
     // Non-fatal — digest was delivered, feedback prompt is optional
   }
 
-  return { ok: true, persona: personaName, ts: result.ts, channel: result.channel };
+  // Return digest reply ts (not header ts) so reactions land on the content
+  return { ok: true, persona: personaName, ts: digestResult.ts, channel: digestResult.channel };
 }
 
 // ── Deliver ─────────────────────────────────────────────────────────────────
@@ -249,7 +261,8 @@ async function deliver(webhookUrl, digestContent, personaName, dateRange, option
   const label = personaName === 'unified' ? 'Wayfind' : capitalize(personaName);
   const range = formatDateRange(dateRange);
   const mrkdwn = markdownToMrkdwn(digestContent);
-  const formattedText = `${emoji} *${label} Digest* (${range})\n\n${mrkdwn}`;
+  const header = `${emoji} *${label} Digest* (${range})`;
+  const formattedText = `${header}\n\n${mrkdwn}`;
 
   const payload = {
     text: formattedText,
@@ -270,7 +283,7 @@ async function deliver(webhookUrl, digestContent, personaName, dateRange, option
   const opts = options || {};
   if (opts.botToken && opts.channel) {
     try {
-      return await deliverViaBot(opts.botToken, opts.channel, formattedText, personaName);
+      return await deliverViaBot(opts.botToken, opts.channel, header, mrkdwn, personaName);
     } catch (err) {
       console.error(`Bot delivery failed for ${personaName}, falling back to webhook: ${err.message}`);
     }

package/bin/team-context.js

@@ -2061,6 +2061,248 @@ function commitAndPushTeamJournals(teamContextPath, copied) {
   }
 }
 
+// ── Features command ─────────────────────────────────────────────────────────
+
+/**
+ * Get the repo slug (org/repo) from the git remote origin URL.
+ * Falls back to the directory name if git remote is unavailable.
+ * @returns {string}
+ */
+function getRepoSlug() {
+  const result = spawnSync('git', ['remote', 'get-url', 'origin'], {
+    cwd: process.cwd(),
+    stdio: 'pipe',
+  });
+  if (result.status === 0) {
+    const url = result.stdout.toString().trim();
+    // Extract org/repo from https or ssh URLs
+    const match = url.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (match) return match[1];
+  }
+  return path.basename(process.cwd());
+}
+
+/**
+ * Compile features.json in the team-context repo from the local repo's wayfind.json.
+ * Reads existing features.json, merges/updates the entry for this repo, writes back.
+ * @param {string} teamContextPath
+ * @param {string} repoSlug
+ * @param {Object} features - { tags, description }
+ */
+function updateFeaturesJson(teamContextPath, repoSlug, features) {
+  const featuresFile = path.join(teamContextPath, 'features.json');
+
+  // Pull latest before modifying to reduce conflicts
+  spawnSync('git', ['pull', '--rebase'], { cwd: teamContextPath, stdio: 'pipe', timeout: 30000 });
+
+  const existing = readJSONFile(featuresFile) || {};
+  existing[repoSlug] = {
+    ...(existing[repoSlug] || {}),
+    ...features,
+    updated_at: new Date().toISOString().slice(0, 10),
+  };
+  fs.writeFileSync(featuresFile, JSON.stringify(existing, null, 2) + '\n');
+
+  // Commit and push
+  const gitAdd = spawnSync('git', ['add', 'features.json'], { cwd: teamContextPath, stdio: 'pipe' });
+  if (gitAdd.status !== 0) {
+    console.error('git add features.json failed');
+    return;
+  }
+  const diffIndex = spawnSync('git', ['diff', '--cached', '--quiet'], { cwd: teamContextPath, stdio: 'pipe' });
+  if (diffIndex.status === 0) {
+    console.log('  features.json up to date — nothing to commit.');
+    return;
+  }
+  const msg = `Update features: ${repoSlug}`;
+  const gitCommit = spawnSync('git', ['commit', '-m', msg], { cwd: teamContextPath, stdio: 'pipe' });
+  if (gitCommit.status !== 0) {
+    console.error('git commit features.json failed');
+    return;
+  }
+  const gitPush = spawnSync('git', ['push'], { cwd: teamContextPath, stdio: 'pipe', timeout: 30000 });
+  if (gitPush.status !== 0) {
+    const stderr = (gitPush.stderr || '').toString().trim();
+    if (stderr.includes('fetch first') || stderr.includes('non-fast-forward')) {
+      spawnSync('git', ['pull', '--rebase'], { cwd: teamContextPath, stdio: 'pipe', timeout: 30000 });
+      spawnSync('git', ['push'], { cwd: teamContextPath, stdio: 'pipe', timeout: 30000 });
+    }
+  }
+  console.log('  Synced features.json to team-context repo.');
+}
+
+/**
+ * Features command: manage per-repo feature tags for Slack bot routing.
+ * Usage:
+ *   wayfind features add <tag1> [tag2] ...   — append tags
+ *   wayfind features set <tag1> [tag2] ...   — replace all tags
+ *   wayfind features describe <text>         — set description
+ *   wayfind features list                    — list all repos in team features map
+ *   wayfind features search <query>          — keyword search over features map
+ *   wayfind features suggest                 — suggest tags via LLM
+ */
+async function runFeatures(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  if (!sub || sub === 'help') {
+    console.log(`wayfind features — manage feature-to-repo map for Slack bot routing
+
+Commands:
+  add <tag1> [tag2...]   Add tags to this repo (appends to existing)
+  set <tag1> [tag2...]   Replace all tags for this repo
+  describe <text>        Set a description for this repo
+  list                   Show all repos in the team features map
+  search <query>         Search repos by tag or description keyword
+  suggest                Use AI to suggest tags based on repo content`);
+    return;
+  }
+
+  if (sub === 'list') {
+    const teamPath = getTeamContextPath();
+    if (!teamPath) {
+      console.error('No team configured. Run "wayfind context add" first.');
+      process.exit(1);
+    }
+    const featuresFile = path.join(teamPath, 'features.json');
+    const map = readJSONFile(featuresFile);
+    if (!map || Object.keys(map).length === 0) {
+      console.log('No feature map found. Run "wayfind features add" in a repo to get started.');
+      return;
+    }
+    for (const [repo, entry] of Object.entries(map).sort()) {
+      const tags = (entry.tags || []).join(', ') || '—';
+      const desc = entry.description ? `  ${entry.description}` : '';
+      console.log(`${repo}\n  tags: ${tags}${desc}\n`);
+    }
+    return;
+  }
+
+  if (sub === 'search') {
+    if (rest.length === 0) {
+      console.error('Usage: wayfind features search <query>');
+      process.exit(1);
+    }
+    const query = rest.join(' ').toLowerCase();
+    const teamPath = getTeamContextPath();
+    if (!teamPath) {
+      console.error('No team configured.');
+      process.exit(1);
+    }
+    const featuresFile = path.join(teamPath, 'features.json');
+    const map = readJSONFile(featuresFile) || {};
+    const matches = Object.entries(map).filter(([repo, entry]) => {
+      const text = [
+        repo,
+        ...(entry.tags || []),
+        entry.description || '',
+      ].join(' ').toLowerCase();
+      return text.includes(query);
+    });
+    if (matches.length === 0) {
+      console.log(`No repos match "${query}".`);
+      return;
+    }
+    for (const [repo, entry] of matches) {
+      const tags = (entry.tags || []).join(', ') || '—';
+      console.log(`${repo} — ${tags}${entry.description ? ' — ' + entry.description : ''}`);
+    }
+    return;
+  }
+
+  if (sub === 'suggest') {
+    const llm = require('./connectors/llm');
+    const repoSlug = getRepoSlug();
+    const repoName = path.basename(process.cwd());
+
+    // Read recent journal entries or README for context
+    let context = `Repository: ${repoSlug}\n`;
+    const readmePath = ['README.md', 'readme.md', 'Readme.md'].find(f => fs.existsSync(path.join(process.cwd(), f)));
+    if (readmePath) {
+      const readme = fs.readFileSync(path.join(process.cwd(), readmePath), 'utf8');
+      context += `README (first 1000 chars):\n${readme.slice(0, 1000)}\n`;
+    }
+    const packagePath = path.join(process.cwd(), 'package.json');
+    if (fs.existsSync(packagePath)) {
+      const pkg = readJSONFile(packagePath);
+      if (pkg && pkg.description) context += `package.json description: ${pkg.description}\n`;
+      if (pkg && pkg.keywords) context += `keywords: ${(pkg.keywords || []).join(', ')}\n`;
+    }
+
+    const llmConfig = {
+      provider: 'anthropic',
+      model: process.env.TEAM_CONTEXT_HAIKU_MODEL || 'claude-haiku-4-5-20251001',
+      api_key_env: 'ANTHROPIC_API_KEY',
+    };
+
+    const systemPrompt = `You suggest concise feature tags for a software repository. Tags describe what features live in this repo, in both technical terms (component names, services) and business/domain language (user-facing features). Return a JSON object with two fields: "tags" (array of 5-15 short lowercase tags) and "description" (one sentence describing the repo's purpose). Return only valid JSON.`;
+
+    console.log(`Analyzing ${repoSlug}...`);
+    try {
+      const raw = await llm.call(llmConfig, systemPrompt, context);
+      const parsed = JSON.parse(raw.trim());
+      console.log(`\nSuggested tags: ${(parsed.tags || []).join(', ')}`);
+      if (parsed.description) console.log(`Description: ${parsed.description}`);
+      console.log(`\nTo apply: wayfind features set ${(parsed.tags || []).join(' ')}`);
+      if (parsed.description) console.log(`           wayfind features describe "${parsed.description}"`);
+    } catch (err) {
+      console.error(`Suggestion failed: ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // add / set / describe — all require writing to .claude/wayfind.json and syncing
+  if (sub === 'add' || sub === 'set' || sub === 'describe') {
+    if (rest.length === 0) {
+      console.error(`Usage: wayfind features ${sub} <value...>`);
+      process.exit(1);
+    }
+
+    const claudeDir = path.join(process.cwd(), '.claude');
+    fs.mkdirSync(claudeDir, { recursive: true });
+    const bindingFile = path.join(claudeDir, 'wayfind.json');
+    const binding = readJSONFile(bindingFile) || {};
+
+    if (sub === 'describe') {
+      binding.features = binding.features || {};
+      binding.features.description = rest.join(' ');
+    } else if (sub === 'set') {
+      binding.features = binding.features || {};
+      binding.features.tags = rest.map(t => t.toLowerCase().replace(/^#/, ''));
+    } else if (sub === 'add') {
+      binding.features = binding.features || {};
+      const newTags = rest.map(t => t.toLowerCase().replace(/^#/, ''));
+      const existing = binding.features.tags || [];
+      binding.features.tags = [...new Set([...existing, ...newTags])];
+    }
+
+    fs.writeFileSync(bindingFile, JSON.stringify(binding, null, 2) + '\n');
+
+    const repoSlug = getRepoSlug();
+    const tags = binding.features.tags || [];
+    const description = binding.features.description || '';
+
+    if (sub === 'describe') {
+      console.log(`Set description for ${repoSlug}: "${description}"`);
+    } else {
+      console.log(`Tags for ${repoSlug}: ${tags.join(', ')}`);
+    }
+
+    // Sync to team-context repo if configured
+    const teamPath = getTeamContextPath();
+    if (teamPath) {
+      updateFeaturesJson(teamPath, repoSlug, { tags, description });
+    } else {
+      console.log('  (No team configured — skipping team-context sync)');
+    }
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${sub}. Run "wayfind features help" for usage.`);
+  process.exit(1);
+}
+
 // ── Standup command ─────────────────────────────────────────────────────────
 
 /**
@@ -4370,6 +4612,10 @@ const COMMANDS = {
     desc: 'Show cross-project status (or rebuild Active Projects table)',
     run: (args) => runStatus(args),
   },
+  features: {
+    desc: 'Manage feature-to-repo map for Slack bot routing (add, set, describe, list, search, suggest)',
+    run: (args) => runFeatures(args),
+  },
   standup: {
     desc: 'Show a daily standup summary (last session, plan, blockers)',
     run: (args) => runStandup(args),
@@ -4448,7 +4694,7 @@ const COMMANDS = {
       // Files and directories to sync
       const syncItems = [
         'bin/', 'templates/', 'specializations/', 'plugin/', 'tests/', 'simulation/',
-        'backup/', '.github/', 'Dockerfile', 'package.json', 'marketplace.json', 'setup.sh',
+        'backup/', '.github/', '.claude-plugin/', 'Dockerfile', 'package.json', 'setup.sh',
         'install.sh', 'uninstall.sh', 'doctor.sh', 'journal-summary.sh',
         'BOOTSTRAP_PROMPT.md', '.gitattributes', '.gitignore', 'VERSIONS.md',
       ];
@@ -4720,6 +4966,60 @@ function spawn(cmd, args) {
   process.exit(result.status == null ? 1 : result.status);
 }
 
+// --- Update notifier --------------------------------------------------------
+// Checks npm registry in the background, caches the result for 24h,
+// and prints a one-liner on next run if a newer version is available.
+// Users can silence with NO_UPDATE_NOTIFIER=1.
+
+const UPDATE_CHECK_FILE = path.join(WAYFIND_DIR, '.update-check.json');
+const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+
+function checkForUpdateBackground() {
+  if (process.env.NO_UPDATE_NOTIFIER) return;
+  try {
+    if (fs.existsSync(UPDATE_CHECK_FILE)) {
+      const cached = JSON.parse(fs.readFileSync(UPDATE_CHECK_FILE, 'utf8'));
+      if (Date.now() - cached.checkedAt < UPDATE_CHECK_INTERVAL) return;
+    }
+  } catch { /* check anyway */ }
+  // Fire and forget — don't block the CLI
+  const child = spawnChild('npm', ['view', 'wayfind', 'version'], {
+    stdio: ['ignore', 'pipe', 'ignore'],
+    detached: true,
+    env: { ...process.env, NO_UPDATE_NOTIFIER: '1' },
+  });
+  let stdout = '';
+  child.stdout.on('data', (d) => { stdout += d; });
+  child.on('close', () => {
+    const latest = stdout.trim();
+    if (!latest || !/^\d+\.\d+\.\d+/.test(latest)) return;
+    try {
+      fs.mkdirSync(WAYFIND_DIR, { recursive: true });
+      fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify({ latest, checkedAt: Date.now() }));
+    } catch { /* best effort */ }
+  });
+  child.unref();
+}
+
+function showUpdateNotice() {
+  if (process.env.NO_UPDATE_NOTIFIER) return;
+  try {
+    if (!fs.existsSync(UPDATE_CHECK_FILE)) return;
+    const { latest } = JSON.parse(fs.readFileSync(UPDATE_CHECK_FILE, 'utf8'));
+    const pkg = require(path.join(ROOT, 'package.json'));
+    if (!latest || latest === pkg.version) return;
+    // Simple semver comparison: split, compare numerically
+    const cur = pkg.version.split('.').map(Number);
+    const lat = latest.split('.').map(Number);
+    const isNewer = lat[0] > cur[0] || (lat[0] === cur[0] && lat[1] > cur[1]) ||
+      (lat[0] === cur[0] && lat[1] === cur[1] && lat[2] > cur[2]);
+    if (isNewer) {
+      console.error(`\n\x1b[33m  Update available: v${pkg.version} → v${latest}\x1b[0m`);
+      console.error(`\x1b[33m  Run \x1b[1mnpm update -g wayfind\x1b[22m to update\x1b[0m\n`);
+    }
+  } catch { /* best effort */ }
+}
+
 // --- Main ---
 
 const args = process.argv.slice(2);
@@ -4727,9 +5027,11 @@ const command = args[0] || 'help';
 const commandArgs = args.slice(1);
 
 async function main() {
+  checkForUpdateBackground();
   telemetry.capture('command_run', { command }, CLI_USER);
   if (COMMANDS[command]) {
     await COMMANDS[command].run(commandArgs);
+    showUpdateNotice();
     await telemetry.flush();
   } else {
     console.error(`Unknown command: ${command}`);

package/bin/telemetry.js

@@ -12,7 +12,7 @@ let enabled = false;
 function init() {
   if (client !== null) return; // already initialized (or disabled)
 
-  enabled = (process.env.TEAM_CONTEXT_TELEMETRY || '').toLowerCase() === 'true';
+  enabled = (process.env.TEAM_CONTEXT_TELEMETRY || '').toLowerCase() !== 'false';
   if (!enabled) {
     client = false; // marker: checked but disabled
     return;

package/doctor.sh

@@ -17,9 +17,45 @@ info() { echo "  $1"; }
 
 ISSUES=0
 
+is_plugin_installed() {
+    # Check if wayfind is installed as a Claude Code plugin
+    # Method 1: Check enabledPlugins in settings.json (authoritative — what Claude Code reads)
+    local SETTINGS="$HOME/.claude/settings.json"
+    if [ -f "$SETTINGS" ] && grep -q '"wayfind@' "$SETTINGS" 2>/dev/null; then
+        return 0
+    fi
+
+    # Method 2: Check plugin files on disk
+    local PLUGINS_DIR="$HOME/.claude/plugins"
+    if [ -d "$PLUGINS_DIR" ]; then
+        if find "$PLUGINS_DIR" -path '*/wayfind/plugin/.claude-plugin/plugin.json' -print -quit 2>/dev/null | grep -q .; then
+            return 0
+        fi
+        if find "$PLUGINS_DIR" -name 'plugin.json' -exec grep -l '"name": "wayfind"' {} + 2>/dev/null | grep -q .; then
+            return 0
+        fi
+    fi
+    return 1
+}
+
 check_hook_registered() {
     echo ""
     echo "Hook registration"
+
+    # If installed as a plugin, hooks are provided by the plugin — skip legacy checks
+    if is_plugin_installed; then
+        ok "Installed as Claude Code plugin (hooks provided by plugin)"
+        # Warn if old specialization hook files are still present — they cause duplicate execution
+        for old_hook in check-global-state.sh session-end.sh; do
+            if [ -f "$HOME/.claude/hooks/$old_hook" ]; then
+                warn "Orphaned legacy hook: ~/.claude/hooks/$old_hook"
+                info "Plugin now handles hooks. Remove with: rm ~/.claude/hooks/$old_hook"
+                ISSUES=$((ISSUES + 1))
+            fi
+        done
+        return
+    fi
+
     local SETTINGS="$HOME/.claude/settings.json"
     if [ ! -f "$SETTINGS" ]; then
         err "settings.json not found — hook is not registered"

package/package.json

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

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wayfind",
-  "version": "2.0.14",
+  "version": "2.0.20",
   "description": "Team decision trail for AI-assisted development. Session memory, decision journals, and team digests.",
   "author": {
     "name": "Wayfind",
@@ -10,6 +10,5 @@
   "repository": "https://github.com/usewayfind/wayfind",
   "license": "Apache-2.0",
   "keywords": ["team", "context", "memory", "decisions", "digest", "journal", "session"],
-  "skills": "./skills/",
-  "hooks": "./hooks/hooks.json"
+  "skills": "./skills/"
 }

package/plugin/README.md

@@ -22,7 +22,6 @@ Or from the official Anthropic marketplace (once approved):
 - **Session memory protocol** — loads team and personal state files at session start, saves at session end
 - **Slash commands** — `/wayfind:init-memory`, `/wayfind:init-team`, `/wayfind:doctor`, `/wayfind:journal`, `/wayfind:standup`, `/wayfind:review-prs`
 - **Hooks** — auto-rebuild project index on session start, auto-extract decisions on session end
-- **Drift detection** — flags when work diverges from the stated session goal
 
 ### Tier 2: Plugin + npm CLI (`npm i -g wayfind`)
 
@@ -35,6 +34,24 @@ Everything in Tier 1, plus:
 - **Slack + Notion delivery** — digests post to Slack channels and Notion pages via GitHub Actions
 - **Bot mode** — `wayfind bot` runs a Slack bot for on-demand queries
 
+## Removing legacy session prompts
+
+If you installed Wayfind before the plugin existed, you likely have a "Session State Protocol"
+section in your CLAUDE.md files that tells the AI to ask "What's the goal for this session?"
+and flag drift. The plugin now handles session memory without these prompts.
+
+To clean up:
+
+1. **Run `/wayfind:init-memory`** in each repo — Step 4 removes the legacy protocol from CLAUDE.md automatically.
+
+2. **Or manually:** delete the `## Session State Protocol` section from these files:
+   - `~/CLAUDE.md`
+   - `~/.claude/CLAUDE.md`
+   - Each repo's `CLAUDE.md`
+
+The plugin's hooks and session-protocol skill handle state file loading without
+requiring any CLAUDE.md instructions or interactive prompts.
+
 ## Documentation
 
 Full docs: https://github.com/usewayfind/wayfind

package/plugin/skills/init-memory/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: init-memory
-description: Initialize Wayfind for the current repo. Creates .claude/team-state.md (tracked in git) and .claude/personal-state.md (gitignored), ensures correct .gitignore entries, appends session protocol to CLAUDE.md, and registers the repo in the global index. Safe to run multiple times (idempotent).
+description: Initialize Wayfind for the current repo. Creates .claude/team-state.md (tracked in git) and .claude/personal-state.md (gitignored), ensures correct .gitignore entries, cleans up legacy session protocol from CLAUDE.md, and registers the repo in the global index. Safe to run multiple times (idempotent).
 user-invocable: true
 ---
 
@@ -67,21 +67,6 @@ Last updated: [today's date]
 ## Current Sprint Focus
 <!-- Team-level "what are we working on right now" -->
 
-## Elicitation Prompts
-
-<!-- These prompts guide the AI to capture richer context at decision moments.
-     The answers aren't for you — they're for your teammates who read the digest. -->
-
-When a technical or product decision is made without stated reasoning, ask one of:
-- "What alternatives did you consider?"
-- "What constraint or requirement drove this choice?"
-- "What would need to change for you to reverse this decision?"
-- "Who else on the team does this affect, and how?"
-- "What's the risk if this assumption is wrong?"
-
-Do not ask if the decision already includes reasoning, tradeoffs, or constraints.
-Do not ask more than once per decision. Do not ask during routine implementation.
-
 ## Shared Gotchas
 <!-- Hard-won lessons. What surprised us. What NOT to do. -->
 ```
@@ -123,30 +108,17 @@ Check `.gitignore`. Ensure these lines are present:
 
 If any of those lines are missing, append them. If `.claude/` (as a directory) is already in `.gitignore`, remove it and replace with the four file-level entries above.
 
-## Step 4: Append Session Protocol to CLAUDE.md
+## Step 4: Clean up legacy session protocol from CLAUDE.md
 
-Read the repo's `CLAUDE.md`. If it does NOT already contain "Session State Protocol", append this:
+Read the repo's `CLAUDE.md` (if it exists). If it contains a "## Session State Protocol" section, **remove the entire section** — the plugin's session-protocol skill and hooks handle this now.
 
-```markdown
-
-## Session State Protocol
+Also remove the legacy "## Session State Protocol (AI Memory Kit)" variant if present.
 
-**At session start (REQUIRED):**
-1. Read `~/.claude/global-state.md` — preferences, active projects, memory file manifest
-2. Read `.claude/team-state.md` in this repo — shared team context: architecture decisions, conventions, sprint focus, gotchas
-3. Read `.claude/personal-state.md` in this repo — your personal context: current focus, working notes, opinions
-4. Check the Memory Files table in global-state.md — load any `~/.claude/memory/` files relevant to this session's topic
+If the CLAUDE.md has no other content after removal, leave it with just the repo name heading.
 
-**At session end (when user says stop/done/pause/tomorrow):**
-1. Update `.claude/team-state.md` with shared context: architecture decisions, conventions, gotchas the team should know
-2. Update `.claude/personal-state.md` with personal context: your next steps, working notes, opinions
-3. Do NOT update `~/.claude/global-state.md` — its Active Projects table is rebuilt automatically by `wayfind status`.
-4. If significant new cross-repo context was created (patterns, strategies, decisions), create or update a file in `~/.claude/memory/` and add it to the Memory Files manifest in global-state.md
-
-**Do NOT use external memory databases or CLI tools for state storage.** Use plain markdown files only.
-```
+Report: "Removed legacy Session State Protocol from CLAUDE.md — the plugin handles this now."
 
-If `CLAUDE.md` doesn't exist, create a minimal one with the repo name as a heading and the block above.
+If no session protocol section was found, skip silently.
 
 ## Step 5: Register State Files in Global Index
 
@@ -166,7 +138,7 @@ Tell the user:
 - `.claude/team-state.md` — created or already existed (committed to git, shared with team)
 - `.claude/personal-state.md` — created or already existed (gitignored, personal only)
 - `.gitignore` — updated or already correct
-- `CLAUDE.md` — protocol appended or already present
+- `CLAUDE.md` — legacy session protocol removed (or was already clean)
 - `global-state.md` — repo registered or already listed
 
 **If they haven't set up team context yet**, mention:

package/plugin/skills/session-protocol/SKILL.md

@@ -1,15 +1,14 @@
 ---
 name: session-protocol
-description: Wayfind session memory protocol — behavioral instructions for AI sessions. Elicitation prompts, drift detection, and state file conventions. The plugin's hooks handle automation (loading/saving); this skill defines how the AI should behave.
+description: Wayfind session memory protocol — state file locations and conventions. The plugin's hooks handle automation (loading/saving); this skill tells the AI where state files live.
 disable-model-invocation: false
 user-invocable: false
 ---
 
-## Wayfind — Session Behavior Protocol
+## Wayfind — Session Memory Protocol
 
-This skill defines behavioral instructions for AI sessions. Automation (state file loading,
-decision extraction, journal sync) is handled by the plugin's hooks — this skill covers
-the human-judgment parts that hooks can't automate.
+Automation (project index rebuild, decision extraction, journal sync) is handled by
+the plugin's hooks. This skill tells you where state files live so you can load context.
 
 ### State File Locations
 
@@ -29,24 +28,7 @@ the human-judgment parts that hooks can't automate.
 1. Read `~/.claude/global-state.md`
 2. Read `.claude/team-state.md` and `.claude/personal-state.md` in the current repo (fall back to `.claude/state.md` for legacy repos)
 3. Check the Memory Files table — load any `~/.claude/memory/` files whose keywords match this session's topic
-4. Summarize current state, then ask: **"What's the goal for this session? What does success look like?"**
-
-### Mid-Session — Drift Detection
-
-If work drifts from the stated goal, flag it:
-> *"Quick check — we set out to [goal]. This feels like [tangent]. Stay the course or pivot?"*
-
-### Elicitation Prompts
-
-When a technical or product decision is made without stated reasoning, ask ONE of:
-- "What alternatives did you consider?"
-- "What constraint or requirement drove this choice?"
-- "What would need to change for you to reverse this decision?"
-- "Who else on the team does this affect, and how?"
-- "What's the risk if this assumption is wrong?"
-
-Do not ask if the decision already includes reasoning, tradeoffs, or constraints.
-Do not ask more than once per decision. Do not ask during routine implementation.
+4. Briefly summarize current state for the user
 
 ### Rules