wayfind 2.0.38 → 2.0.40

package/bin/content-store.js

@@ -17,6 +17,98 @@ const DEFAULT_SIGNALS_DIR = HOME ? path.join(HOME, '.claude', 'team-context', 's
 const INDEX_VERSION = '2.0.0';
 const FILE_PERMS = 0o600;
 
+// ── Team-scoped path resolution ──────────────────────────────────────────────
+
+/** Cache team ID for the process lifetime (cwd doesn't change mid-command). */
+let _cachedTeamId;
+
+/**
+ * Resolve the active team ID from the local repo binding or context.json default.
+ * @returns {string|null}
+ */
+function _resolveTeamId() {
+  if (_cachedTeamId !== undefined) return _cachedTeamId;
+
+  // 1. .claude/wayfind.json in cwd
+  try {
+    const bindingFile = require('path').join(process.cwd(), '.claude', 'wayfind.json');
+    if (require('fs').existsSync(bindingFile)) {
+      const binding = JSON.parse(require('fs').readFileSync(bindingFile, 'utf8'));
+      if (binding.team_id) { _cachedTeamId = binding.team_id; return _cachedTeamId; }
+    }
+  } catch (_) {}
+
+  // 2. context.json default team
+  try {
+    const contextFile = HOME ? require('path').join(HOME, '.claude', 'team-context', 'context.json') : null;
+    if (contextFile && require('fs').existsSync(contextFile)) {
+      const ctx = JSON.parse(require('fs').readFileSync(contextFile, 'utf8'));
+      if (ctx.default) { _cachedTeamId = ctx.default; return _cachedTeamId; }
+    }
+  } catch (_) {}
+
+  _cachedTeamId = null;
+  return null;
+}
+
+/**
+ * One-time migration: copy global content store to the team-scoped path.
+ * Safe to call repeatedly — exits immediately if team store already exists.
+ */
+function _autoMigrateToTeamStore(teamStorePath) {
+  if (fs.existsSync(teamStorePath)) return;
+  if (!DEFAULT_STORE_PATH || !fs.existsSync(DEFAULT_STORE_PATH)) return;
+  try {
+    fs.mkdirSync(teamStorePath, { recursive: true });
+    for (const f of fs.readdirSync(DEFAULT_STORE_PATH)) {
+      const src = path.join(DEFAULT_STORE_PATH, f);
+      if (fs.statSync(src).isFile()) {
+        fs.copyFileSync(src, path.join(teamStorePath, f));
+      }
+    }
+    fs.writeFileSync(path.join(teamStorePath, '.migrated-from-global'), new Date().toISOString());
+  } catch (_) {
+    // Non-fatal — fresh store will be created on first write
+  }
+}
+
+/**
+ * Resolve the content store path.
+ * Priority:
+ *   1. TEAM_CONTEXT_STORE_PATH env var (container always sets this)
+ *   2. Explicit teamId argument
+ *   3. Repo-level .claude/wayfind.json team_id
+ *   4. context.json default team
+ *   5. Legacy DEFAULT_STORE_PATH
+ * @param {string} [teamId] - Explicit team ID override
+ * @returns {string|null}
+ */
+function resolveStorePath(teamId) {
+  if (process.env.TEAM_CONTEXT_STORE_PATH) return process.env.TEAM_CONTEXT_STORE_PATH;
+  const tid = teamId || _resolveTeamId();
+  if (tid && HOME) {
+    const teamStorePath = path.join(HOME, '.claude', 'team-context', 'teams', tid, 'content-store');
+    _autoMigrateToTeamStore(teamStorePath);
+    return teamStorePath;
+  }
+  return DEFAULT_STORE_PATH;
+}
+
+/**
+ * Resolve the signals directory path.
+ * Same priority chain as resolveStorePath.
+ * @param {string} [teamId] - Explicit team ID override
+ * @returns {string|null}
+ */
+function resolveSignalsDir(teamId) {
+  if (process.env.TEAM_CONTEXT_SIGNALS_DIR) return process.env.TEAM_CONTEXT_SIGNALS_DIR;
+  const tid = teamId || _resolveTeamId();
+  if (tid && HOME) {
+    return path.join(HOME, '.claude', 'team-context', 'teams', tid, 'signals');
+  }
+  return DEFAULT_SIGNALS_DIR;
+}
+
 // Field mapping for journal entries
 const FIELD_MAP = {
   'Why': 'why',
@@ -310,7 +402,7 @@ function cosineSimilarity(a, b) {
  */
 async function indexJournals(options = {}) {
   const journalDir = options.journalDir || DEFAULT_JOURNAL_DIR;
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const doEmbeddings = options.embeddings !== undefined
     ? options.embeddings
     : !!(process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_EMBEDDING_ENDPOINT || llm.isSimulation());
@@ -468,7 +560,7 @@ async function indexJournals(options = {}) {
  * @returns {Promise<Array<{ id: string, score: number, entry: Object }>>}
  */
 async function searchJournals(query, options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const limit = options.limit || 10;
 
   const backend = getBackend(storePath);
@@ -522,7 +614,7 @@ async function searchJournals(query, options = {}) {
  * @returns {Array<{ id: string, score: number, entry: Object }>}
  */
 function searchText(query, options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const journalDir = options.journalDir || DEFAULT_JOURNAL_DIR;
   const limit = options.limit || 10;
 
@@ -571,7 +663,7 @@ function searchText(query, options = {}) {
 
     // For signal entries, read content directly from the signal file
     if (entry.source === 'signal') {
-      const signalsDir = options.signalsDir || DEFAULT_SIGNALS_DIR;
+      const signalsDir = options.signalsDir || resolveSignalsDir();
       if (signalsDir) {
         // Signal files live at signalsDir/<channel>/<date>.md or signalsDir/<channel>/<owner>/<repo>/<date>.md
         // The repo field tells us the path: "signals/<channel>" or "<owner>/<repo>"
@@ -677,7 +769,7 @@ function applyFilters(entry, filters) {
  * @returns {Array<{ id: string, entry: Object }>}
  */
 function queryMetadata(options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const index = getBackend(storePath).loadIndex();
   if (!index) return [];
 
@@ -699,7 +791,7 @@ function queryMetadata(options = {}) {
  * @returns {Object} - Insights object
  */
 function extractInsights(options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const index = getBackend(storePath).loadIndex();
   if (!index || index.entryCount === 0) {
     return {
@@ -781,9 +873,9 @@ function extractInsights(options = {}) {
  * @returns {string|null} - Full entry text, or null if not found
  */
 function getEntryContent(entryId, options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const journalDir = options.journalDir || DEFAULT_JOURNAL_DIR;
-  const signalsDir = options.signalsDir || DEFAULT_SIGNALS_DIR;
+  const signalsDir = options.signalsDir || resolveSignalsDir();
 
   const index = getBackend(storePath).loadIndex();
   if (!index || !index.entries[entryId]) return null;
@@ -1258,7 +1350,7 @@ function fileFingerprint(filePath) {
  */
 async function indexConversations(options = {}) {
   const projectsDir = options.projectsDir || DEFAULT_PROJECTS_DIR;
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const doEmbeddings = options.embeddings !== undefined
     ? options.embeddings
     : !!(process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_EMBEDDING_ENDPOINT || llm.isSimulation());
@@ -1505,7 +1597,7 @@ Rules:
  * @returns {Promise<string>} - Synthesized onboarding document in markdown
  */
 async function generateOnboardingPack(repoQuery, options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const journalDir = options.journalDir || DEFAULT_JOURNAL_DIR;
   const days = options.days || 90;
   const llmConfig = options.llmConfig || {
@@ -1683,8 +1775,8 @@ async function indexConversationsWithExport(options = {}) {
  * @returns {Promise<Object>} - Stats: { fileCount, newEntries, updatedEntries, skippedEntries }
  */
 async function indexSignals(options = {}) {
-  const signalsDir = options.signalsDir || DEFAULT_SIGNALS_DIR;
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const signalsDir = options.signalsDir || resolveSignalsDir();
+  const storePath = options.storePath || resolveStorePath();
   const doEmbeddings = options.embeddings !== undefined
     ? options.embeddings
     : !!(process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_EMBEDDING_ENDPOINT || llm.isSimulation());
@@ -1973,11 +2065,11 @@ async function indexSignals(options = {}) {
 // ── Digest feedback ─────────────────────────────────────────────────────────
 
 function loadFeedback(storePath) {
-  return getBackend(storePath || DEFAULT_STORE_PATH).loadFeedback();
+  return getBackend(storePath || resolveStorePath()).loadFeedback();
 }
 
 function saveFeedback(storePath, feedback) {
-  getBackend(storePath || DEFAULT_STORE_PATH).saveFeedback(feedback);
+  getBackend(storePath || resolveStorePath()).saveFeedback(feedback);
 }
 
 /**
@@ -2082,7 +2174,7 @@ function getDigestFeedback(options = {}) {
  *             focus: string[] }}
  */
 function computeQualityProfile(options = {}) {
-  const storePath = options.storePath || DEFAULT_STORE_PATH;
+  const storePath = options.storePath || resolveStorePath();
   const days = options.days || 30;
   const index = getBackend(storePath).loadIndex();
 
@@ -2217,12 +2309,12 @@ module.exports = {
   getBackend,
   getBackendType,
   // Backward-compatible storage wrappers (delegate to backend)
-  loadIndex: (storePath) => getBackend(storePath || DEFAULT_STORE_PATH).loadIndex(),
-  saveIndex: (storePath, index) => getBackend(storePath || DEFAULT_STORE_PATH).saveIndex(index),
-  loadEmbeddings: (storePath) => getBackend(storePath || DEFAULT_STORE_PATH).loadEmbeddings(),
-  saveEmbeddings: (storePath, embeddings) => getBackend(storePath || DEFAULT_STORE_PATH).saveEmbeddings(embeddings),
-  loadConversationIndex: (storePath) => getBackend(storePath || DEFAULT_STORE_PATH).loadConversationIndex(),
-  saveConversationIndex: (storePath, convIndex) => getBackend(storePath || DEFAULT_STORE_PATH).saveConversationIndex(convIndex),
+  loadIndex: (storePath) => getBackend(storePath || resolveStorePath()).loadIndex(),
+  saveIndex: (storePath, index) => getBackend(storePath || resolveStorePath()).saveIndex(index),
+  loadEmbeddings: (storePath) => getBackend(storePath || resolveStorePath()).loadEmbeddings(),
+  saveEmbeddings: (storePath, embeddings) => getBackend(storePath || resolveStorePath()).saveEmbeddings(embeddings),
+  loadConversationIndex: (storePath) => getBackend(storePath || resolveStorePath()).loadConversationIndex(),
+  saveConversationIndex: (storePath, convIndex) => getBackend(storePath || resolveStorePath()).saveConversationIndex(convIndex),
 
   // Filtering
   isRepoExcluded,
@@ -2256,6 +2348,8 @@ module.exports = {
   DEFAULT_JOURNAL_DIR,
   DEFAULT_PROJECTS_DIR,
   DEFAULT_SIGNALS_DIR,
+  resolveStorePath,
+  resolveSignalsDir,
 
   // Digest feedback
   loadFeedback,

package/bin/mcp-server.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Wayfind MCP Server — stdio transport.
+ *
+ * Exposes team context (journals, signals, decisions) as MCP tools so any
+ * MCP-compatible AI tool can query the same knowledge base that Wayfind builds.
+ * Team-scoped from day one: resolveStorePath() picks the right store for the
+ * active team based on the working directory.
+ *
+ * Usage (Claude Code):
+ *   Add to ~/.claude/claude_desktop_config.json:
+ *   {
+ *     "mcpServers": {
+ *       "wayfind": { "command": "wayfind-mcp" }
+ *     }
+ *   }
+ *
+ * Or run directly: wayfind-mcp
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const path = require('path');
+const fs = require('fs');
+const contentStore = require('./content-store.js');
+
+const pkg = require('../package.json');
+
+// ── Tool definitions ─────────────────────────────────────────────────────────
+
+const TOOLS = [
+  {
+    name: 'search_context',
+    description: 'Search team context by natural language or keyword. Returns ranked journal entries, decisions, and signals. Use this to answer questions about past work, architectural decisions, and team activity.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural language search query' },
+        limit: { type: 'number', description: 'Max results (default: 10)' },
+        repo: { type: 'string', description: 'Filter by repository name (e.g. "MyService", "MyOrg/my-repo")' },
+        since: { type: 'string', description: 'Filter to entries on or after this date (YYYY-MM-DD)' },
+        mode: { type: 'string', enum: ['semantic', 'text'], description: 'Search mode — semantic uses embeddings, text uses keyword matching. Defaults to semantic if embeddings available.' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_entry',
+    description: 'Retrieve the full content of a specific journal or signal entry by ID. Use the IDs returned by search_context or list_recent.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Entry ID from search_context or list_recent results' },
+      },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'list_recent',
+    description: 'List recent journal entries and decisions, optionally filtered by repo or date range. Returns metadata (no full content — use get_entry for that).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max entries to return (default: 20)' },
+        repo: { type: 'string', description: 'Filter by repository name' },
+        since: { type: 'string', description: 'Filter to entries on or after this date (YYYY-MM-DD)' },
+        source: { type: 'string', enum: ['journal', 'conversation', 'signal'], description: 'Filter by entry source type' },
+      },
+    },
+  },
+  {
+    name: 'get_signals',
+    description: 'Retrieve recent signal entries (GitHub activity, Slack summaries, Intercom updates, Notion pages) for a specific channel or all channels.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Signal channel name (e.g. "github", "slack", "intercom"). Omit for all channels.' },
+        since: { type: 'string', description: 'Filter to signals on or after this date (YYYY-MM-DD). Defaults to last 7 days.' },
+        limit: { type: 'number', description: 'Max signals to return (default: 20)' },
+      },
+    },
+  },
+  {
+    name: 'get_team_status',
+    description: 'Get the current team state: who is working on what, active projects, recent decisions, and open blockers. Reads from team-state.md and personal-state.md files.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_personal: { type: 'boolean', description: 'Include personal-state.md in addition to team-state.md (default: true)' },
+      },
+    },
+  },
+  {
+    name: 'get_personas',
+    description: 'List the configured Wayfind personas (e.g. Greg/engineering, Sean/strategy). Each persona gets a tailored digest. Useful for understanding who uses this team context and how.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'record_feedback',
+    description: 'Record that a context result was helpful or not. This improves future retrieval quality by down-weighting unhelpful entries.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        entry_id: { type: 'string', description: 'ID of the entry being rated' },
+        helpful: { type: 'boolean', description: 'Was this entry useful for the task?' },
+        query: { type: 'string', description: 'The original query that surfaced this entry (for context)' },
+      },
+      required: ['entry_id', 'helpful'],
+    },
+  },
+  {
+    name: 'add_context',
+    description: 'Add a new context entry to the team knowledge base. Use this to capture decisions, blockers, or key context from an AI session that should be available to future sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Short title for the entry (< 80 chars)' },
+        content: { type: 'string', description: 'Full content in markdown. Should include Why, What, and any key decisions.' },
+        repo: { type: 'string', description: 'Repository this entry belongs to (e.g. "MyOrg/my-repo")' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' },
+      },
+      required: ['title', 'content'],
+    },
+  },
+];
+
+// ── Tool handlers ────────────────────────────────────────────────────────────
+
+async function handleSearchContext(args) {
+  const { query, limit = 10, repo, since, mode } = args;
+  const opts = { limit, repo, since };
+
+  let results;
+  if (mode === 'text') {
+    results = contentStore.searchText(query, opts);
+  } else {
+    results = await contentStore.searchJournals(query, opts);
+  }
+
+  if (!results || results.length === 0) {
+    return { found: 0, results: [], hint: 'No matches. Try a broader query or check wayfind reindex.' };
+  }
+
+  return {
+    found: results.length,
+    results: results.map(r => ({
+      id: r.id,
+      score: r.score ? Math.round(r.score * 1000) / 1000 : null,
+      date: r.entry.date,
+      repo: r.entry.repo,
+      title: r.entry.title,
+      source: r.entry.source,
+      tags: r.entry.tags || [],
+      summary: r.entry.summary || null,
+    })),
+  };
+}
+
+function handleGetEntry(args) {
+  const { id } = args;
+  const storePath = contentStore.resolveStorePath();
+  const journalDir = contentStore.DEFAULT_JOURNAL_DIR;
+
+  // Get entry metadata
+  const index = contentStore.getBackend(storePath).loadIndex();
+  if (!index || !index.entries || !index.entries[id]) {
+    return { error: `Entry not found: ${id}` };
+  }
+
+  const entry = index.entries[id];
+  const fullContent = contentStore.getEntryContent(id, { storePath, journalDir });
+
+  return {
+    id,
+    date: entry.date,
+    repo: entry.repo,
+    title: entry.title,
+    source: entry.source,
+    tags: entry.tags || [],
+    content: fullContent || entry.summary || null,
+  };
+}
+
+function handleListRecent(args) {
+  const { limit = 20, repo, since, source } = args;
+  const opts = { limit, repo, since, source };
+  const results = contentStore.queryMetadata(opts);
+  const top = results.slice(0, limit);
+
+  return {
+    total: results.length,
+    showing: top.length,
+    entries: top.map(r => ({
+      id: r.id,
+      date: r.entry.date,
+      repo: r.entry.repo,
+      title: r.entry.title,
+      source: r.entry.source,
+      tags: r.entry.tags || [],
+    })),
+  };
+}
+
+function handleGetSignals(args) {
+  const { channel, limit = 20 } = args;
+  const signalsDir = contentStore.resolveSignalsDir();
+  const sinceDate = args.since || (() => {
+    const d = new Date();
+    d.setDate(d.getDate() - 7);
+    return d.toISOString().slice(0, 10);
+  })();
+
+  if (!signalsDir || !fs.existsSync(signalsDir)) {
+    return { error: 'No signals directory found. Run "wayfind pull --all" first.', signals: [] };
+  }
+
+  const channels = channel
+    ? [channel]
+    : fs.readdirSync(signalsDir).filter(d => {
+        try { return fs.statSync(path.join(signalsDir, d)).isDirectory(); } catch { return false; }
+      });
+
+  const signals = [];
+  for (const ch of channels) {
+    const chDir = path.join(signalsDir, ch);
+    if (!fs.existsSync(chDir)) continue;
+
+    const files = fs.readdirSync(chDir)
+      .filter(f => f.endsWith('.md') && f >= sinceDate)
+      .sort()
+      .reverse()
+      .slice(0, limit);
+
+    for (const f of files) {
+      const filePath = path.join(chDir, f);
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        signals.push({
+          channel: ch,
+          date: f.slice(0, 10),
+          file: f,
+          content: content.slice(0, 2000) + (content.length > 2000 ? '\n...(truncated)' : ''),
+        });
+      } catch (_) {}
+    }
+  }
+
+  signals.sort((a, b) => b.date.localeCompare(a.date));
+  return { signals: signals.slice(0, limit) };
+}
+
+function handleGetTeamStatus(args) {
+  const { include_personal = true } = args;
+  const HOME = process.env.HOME || process.env.USERPROFILE;
+  const wayfindDir = process.env.WAYFIND_DIR || (HOME ? path.join(HOME, '.claude', 'team-context') : null);
+
+  const result = {};
+
+  // Try to read team-state.md from cwd's .claude/ directory
+  const cwdTeamState = path.join(process.cwd(), '.claude', 'team-state.md');
+  const cwdPersonalState = path.join(process.cwd(), '.claude', 'personal-state.md');
+
+  for (const [key, filePath] of [['team_state', cwdTeamState], ['personal_state', cwdPersonalState]]) {
+    if (key === 'personal_state' && !include_personal) continue;
+    try {
+      if (fs.existsSync(filePath)) {
+        result[key] = fs.readFileSync(filePath, 'utf8');
+      }
+    } catch (_) {}
+  }
+
+  if (Object.keys(result).length === 0) {
+    return { error: 'No state files found in .claude/. Make sure Wayfind is initialized in this repo.' };
+  }
+
+  return result;
+}
+
+function handleGetPersonas() {
+  const HOME = process.env.HOME || process.env.USERPROFILE;
+  const connectorsFile = HOME ? path.join(HOME, '.claude', 'team-context', 'connectors.json') : null;
+
+  if (!connectorsFile || !fs.existsSync(connectorsFile)) {
+    return { error: 'connectors.json not found. Run "wayfind context init" first.', personas: [] };
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(connectorsFile, 'utf8'));
+    const personas = config.personas || config.digest?.personas || [];
+    return { personas };
+  } catch (e) {
+    return { error: `Failed to read connectors.json: ${e.message}`, personas: [] };
+  }
+}
+
+function handleRecordFeedback(args) {
+  const { entry_id, helpful, query } = args;
+  const storePath = contentStore.resolveStorePath();
+
+  try {
+    const feedback = contentStore.loadFeedback(storePath);
+    const existing = feedback.entries || {};
+    existing[entry_id] = existing[entry_id] || { helpful: 0, unhelpful: 0, queries: [] };
+
+    if (helpful) {
+      existing[entry_id].helpful = (existing[entry_id].helpful || 0) + 1;
+    } else {
+      existing[entry_id].unhelpful = (existing[entry_id].unhelpful || 0) + 1;
+    }
+    if (query) {
+      existing[entry_id].queries = [...(existing[entry_id].queries || []).slice(-4), query];
+    }
+
+    contentStore.saveFeedback(storePath, { ...feedback, entries: existing });
+    return { recorded: true, entry_id, helpful };
+  } catch (e) {
+    return { error: `Failed to record feedback: ${e.message}` };
+  }
+}
+
+function handleAddContext(args) {
+  const { title, content, repo, tags = [] } = args;
+  const journalDir = contentStore.DEFAULT_JOURNAL_DIR;
+
+  if (!journalDir) {
+    return { error: 'Cannot resolve journal directory.' };
+  }
+
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const sanitizedTitle = title.replace(/[^a-zA-Z0-9\s\-_]/g, '').slice(0, 60);
+    const repoLine = repo ? `\n**Repo:** ${repo}` : '';
+    const tagsLine = tags.length ? `\n**Tags:** ${tags.join(', ')}` : '';
+
+    const entry = [
+      `## ${repo || 'general'} — ${sanitizedTitle}`,
+      `**Why:** Added via Wayfind MCP`,
+      `**What:** ${content}`,
+      repoLine,
+      tagsLine,
+    ].filter(Boolean).join('\n');
+
+    const filePath = path.join(journalDir, `${today}.md`);
+    fs.mkdirSync(journalDir, { recursive: true });
+
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+    fs.writeFileSync(filePath, existing + (existing ? '\n\n' : '') + entry + '\n');
+
+    return {
+      added: true,
+      date: today,
+      title: sanitizedTitle,
+      file: filePath,
+      hint: 'Run "wayfind index-journals" to make this entry searchable.',
+    };
+  } catch (e) {
+    return { error: `Failed to add context: ${e.message}` };
+  }
+}
+
+// ── Server setup ─────────────────────────────────────────────────────────────
+
+const server = new Server(
+  { name: 'wayfind', version: pkg.version },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  let result;
+  switch (name) {
+    case 'search_context':   result = await handleSearchContext(args); break;
+    case 'get_entry':        result = handleGetEntry(args); break;
+    case 'list_recent':      result = handleListRecent(args); break;
+    case 'get_signals':      result = handleGetSignals(args); break;
+    case 'get_team_status':  result = handleGetTeamStatus(args); break;
+    case 'get_personas':     result = handleGetPersonas(); break;
+    case 'record_feedback':  result = handleRecordFeedback(args); break;
+    case 'add_context':      result = handleAddContext(args); break;
+    default:
+      return { content: [{ type: 'text', text: JSON.stringify({ error: `Unknown tool: ${name}` }) }], isError: true };
+  }
+
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+
+// ── Entry point ──────────────────────────────────────────────────────────────
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // stderr so it doesn't pollute the MCP stdio channel
+  process.stderr.write(`Wayfind MCP server v${pkg.version} ready\n`);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/bin/team-context.js

@@ -1109,7 +1109,7 @@ function parseCSArgs(args) {
 async function runIndexJournals(args) {
   const { opts } = parseCSArgs(args);
   const journalDir = opts.dir || contentStore.DEFAULT_JOURNAL_DIR;
-  const storePath = opts.store || contentStore.DEFAULT_STORE_PATH;
+  const storePath = opts.store || contentStore.resolveStorePath();
 
   console.log(`Indexing journals from: ${journalDir}`);
   console.log(`Store: ${storePath}`);
@@ -1137,7 +1137,7 @@ async function runIndexJournals(args) {
 async function runIndexConversations(args) {
   const { opts } = parseCSArgs(args);
   const projectsDir = opts.dir || contentStore.DEFAULT_PROJECTS_DIR;
-  const storePath = opts.store || contentStore.DEFAULT_STORE_PATH;
+  const storePath = opts.store || contentStore.resolveStorePath();
 
   console.log(`Indexing conversations from: ${projectsDir}`);
   console.log(`Store: ${storePath}`);
@@ -1322,7 +1322,7 @@ function buildRepoToTeamResolver() {
 async function runIndexConversationsWithExport(args, detectShifts = false) {
   const { opts } = parseCSArgs(args);
   const projectsDir = opts.dir || contentStore.DEFAULT_PROJECTS_DIR;
-  const storePath = opts.store || contentStore.DEFAULT_STORE_PATH;
+  const storePath = opts.store || contentStore.resolveStorePath();
   const journalDir = opts.exportDir || contentStore.DEFAULT_JOURNAL_DIR;
 
   console.log(`Indexing conversations from: ${projectsDir}`);
@@ -2973,7 +2973,7 @@ async function runBot(args) {
 
   // Check content store has entries (warn if empty)
   const index = contentStore.loadIndex(
-    config.slack_bot.store_path || contentStore.DEFAULT_STORE_PATH
+    config.slack_bot.store_path || contentStore.resolveStorePath()
   );
   if (!index || index.entryCount === 0) {
     console.log('Warning: Content store is empty. Run "wayfind index-journals" first for best results.');
@@ -3753,21 +3753,169 @@ function runPrompts(args) {
 const DEPLOY_TEMPLATES_DIR = path.join(ROOT, 'templates', 'deploy');
 
 async function runDeploy(args) {
-  const sub = args[0] || 'init';
+  // Parse --team <teamId> flag
+  const teamIdx = args.indexOf('--team');
+  const teamId = teamIdx !== -1 ? args[teamIdx + 1] : null;
+  const portIdx = args.indexOf('--port');
+  const port = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : null;
+
+  const filteredArgs = args.filter((a, i) => {
+    if (a === '--team' || a === '--port') return false;
+    if (i > 0 && (args[i - 1] === '--team' || args[i - 1] === '--port')) return false;
+    return true;
+  });
+  const sub = filteredArgs[0] || 'init';
+
   switch (sub) {
     case 'init':
-      deployInit();
+      if (teamId) {
+        deployTeamInit(teamId, { port });
+      } else {
+        deployInit();
+      }
+      break;
+    case 'list':
+      deployList();
       break;
     case 'status':
       deployStatus();
       break;
     default:
       console.error(`Unknown deploy subcommand: ${sub}`);
-      console.error('Available: init, status');
+      console.error('Available: init [--team <id>], list, status');
       process.exit(1);
   }
 }
 
+/**
+ * Scaffold a per-team container config at ~/.claude/team-context/teams/<teamId>/deploy/
+ */
+function deployTeamInit(teamId, { port } = {}) {
+  const teamsBaseDir = HOME ? path.join(HOME, '.claude', 'team-context', 'teams') : null;
+  if (!teamsBaseDir) {
+    console.error('Cannot resolve home directory.');
+    process.exit(1);
+  }
+
+  const deployDir = path.join(teamsBaseDir, teamId, 'deploy');
+  const storeDir = path.join(teamsBaseDir, teamId, 'content-store');
+
+  // Check for duplicate running container
+  const psResult = spawnSync('docker', ['ps', '--filter', `label=com.wayfind.team=${teamId}`, '--format', '{{.Names}}'], { stdio: 'pipe' });
+  const running = (psResult.stdout || '').toString().trim();
+  if (running) {
+    console.log(`Warning: container already running for team "${teamId}": ${running}`);
+    console.log('Use "docker compose down" in the deploy directory before re-initializing.');
+    process.exit(1);
+  }
+
+  fs.mkdirSync(deployDir, { recursive: true });
+  fs.mkdirSync(storeDir, { recursive: true });
+  console.log(`Scaffolding deploy config for team: ${teamId}`);
+  console.log(`Deploy dir: ${deployDir}`);
+
+  // Resolve team-context repo path for volume mount
+  const config = readContextConfig();
+  const teamEntry = config.teams && config.teams[teamId];
+  const teamContextPath = teamEntry ? teamEntry.path : null;
+
+  // Assign port (default 3141; if taken, user should pass --port)
+  const assignedPort = port || 3141;
+  const containerName = `wayfind-${teamId}`;
+
+  // Build docker-compose.yml content with per-team overrides
+  const templatePath = path.join(DEPLOY_TEMPLATES_DIR, 'docker-compose.yml');
+  let composeContent = fs.readFileSync(templatePath, 'utf8');
+  composeContent = composeContent
+    .replace(/container_name: wayfind/, `container_name: ${containerName}`)
+    .replace(/- "3141:3141"/, `- "${assignedPort}:3141"`)
+    .replace(/(TEAM_CONTEXT_TENANT_ID:.*$)/m, `TEAM_CONTEXT_TENANT_ID: \${TEAM_CONTEXT_TENANT_ID:-${teamId}}`);
+
+  // Inject Docker label for discovery
+  composeContent = composeContent.replace(
+    /restart: unless-stopped/,
+    `restart: unless-stopped\n    labels:\n      com.wayfind.team: "${teamId}"`
+  );
+
+  const composePath = path.join(deployDir, 'docker-compose.yml');
+  if (!fs.existsSync(composePath)) {
+    fs.writeFileSync(composePath, composeContent, 'utf8');
+    console.log('  docker-compose.yml — created');
+  } else {
+    console.log('  docker-compose.yml — already exists, skipping');
+  }
+
+  // .env.example
+  const envExampleSrc = path.join(DEPLOY_TEMPLATES_DIR, '.env.example');
+  const envExampleDst = path.join(deployDir, '.env.example');
+  if (!fs.existsSync(envExampleDst) && fs.existsSync(envExampleSrc)) {
+    let envContent = fs.readFileSync(envExampleSrc, 'utf8');
+    if (teamContextPath) {
+      envContent += `\nTEAM_CONTEXT_TEAM_CONTEXT_PATH=${teamContextPath}\n`;
+    }
+    fs.writeFileSync(envExampleDst, envContent, 'utf8');
+    console.log('  .env.example — created');
+  }
+
+  // .env from .env.example
+  const envPath = path.join(deployDir, '.env');
+  if (!fs.existsSync(envPath) && fs.existsSync(envExampleDst)) {
+    fs.copyFileSync(envExampleDst, envPath);
+    console.log('  .env — created from .env.example (fill in your tokens)');
+  }
+
+  const ghToken = detectGitHubToken();
+  if (ghToken && fs.existsSync(envPath)) {
+    let envContent = fs.readFileSync(envPath, 'utf8');
+    if (!envContent.match(/^GITHUB_TOKEN=.+/m)) {
+      envContent = envContent.replace(/^GITHUB_TOKEN=.*$/m, `GITHUB_TOKEN=${ghToken}`);
+      if (!envContent.includes('GITHUB_TOKEN=')) envContent += `\nGITHUB_TOKEN=${ghToken}\n`;
+      fs.writeFileSync(envPath, envContent, 'utf8');
+      console.log('  GITHUB_TOKEN — auto-detected from gh CLI');
+    }
+  }
+
+  console.log('');
+  console.log('Next steps:');
+  console.log(`  1. Fill in ${deployDir}/.env with your tokens`);
+  console.log(`  2. cd "${deployDir}" && docker compose up -d`);
+  console.log(`  3. Verify: curl http://localhost:${assignedPort}/healthz`);
+  console.log('');
+  console.log(`Tip: run "wayfind deploy list" to see all running team containers.`);
+
+  telemetry.capture('deploy_team_init', { teamId }, CLI_USER);
+}
+
+/**
+ * List all running Wayfind team containers.
+ */
+function deployList() {
+  const psResult = spawnSync('docker', [
+    'ps',
+    '--filter', 'label=com.wayfind.team',
+    '--format', '{{.Names}}\t{{.Status}}\t{{.Label "com.wayfind.team"}}',
+  ], { stdio: 'pipe' });
+
+  if (psResult.error) {
+    console.log('Docker not available.');
+    return;
+  }
+
+  const rows = (psResult.stdout || '').toString().trim();
+  if (!rows) {
+    console.log('No Wayfind team containers running.');
+    console.log('Start one with: wayfind deploy --team <teamId> && cd ~/.claude/team-context/teams/<teamId>/deploy && docker compose up -d');
+    return;
+  }
+
+  console.log('Running Wayfind team containers:');
+  console.log('');
+  for (const row of rows.split('\n')) {
+    const [name, status, team] = row.split('\t');
+    console.log(`  ${name} (team: ${team || 'unknown'}) — ${status}`);
+  }
+}
+
 function deployInit() {
   const deployDir = path.join(process.cwd(), 'deploy');
 
@@ -3962,7 +4110,7 @@ function startHealthServer() {
   const server = http.createServer((req, res) => {
     if (req.url === '/healthz' && req.method === 'GET') {
       // Enrich with index freshness
-      const storePath = process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH;
+      const storePath = contentStore.resolveStorePath();
       const index = contentStore.loadIndex(storePath);
       const indexInfo = index ? {
         entryCount: index.entryCount || 0,
@@ -4240,7 +4388,7 @@ async function indexConversationsIfAvailable() {
 }
 
 async function indexSignalsIfAvailable() {
-  const signalsDir = process.env.TEAM_CONTEXT_SIGNALS_DIR || contentStore.DEFAULT_SIGNALS_DIR;
+  const signalsDir = contentStore.resolveSignalsDir();
   if (!signalsDir || !fs.existsSync(signalsDir)) {
     console.log(`No signals at ${signalsDir} — skipping index.`);
     return;
@@ -4310,9 +4458,9 @@ function ensureContainerConfig() {
         api_key_env: 'ANTHROPIC_API_KEY',
       },
       lookback_days: 7,
-      store_path: process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH,
+      store_path: contentStore.resolveStorePath(),
       journal_dir: process.env.TEAM_CONTEXT_JOURNALS_DIR || '/data/journals',
-      signals_dir: process.env.TEAM_CONTEXT_SIGNALS_DIR || contentStore.DEFAULT_SIGNALS_DIR,
+      signals_dir: contentStore.resolveSignalsDir(),
       team_context_dir: process.env.TEAM_CONTEXT_TEAM_CONTEXT_DIR || '',
       slack: {
         webhook_url: process.env.TEAM_CONTEXT_SLACK_WEBHOOK || '',
@@ -4326,9 +4474,9 @@ function ensureContainerConfig() {
   // may have host paths that don't exist inside the container
   if (config.digest) {
     const containerPaths = {
-      store_path: process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH,
+      store_path: contentStore.resolveStorePath(),
       journal_dir: process.env.TEAM_CONTEXT_JOURNALS_DIR || '/data/journals',
-      signals_dir: process.env.TEAM_CONTEXT_SIGNALS_DIR || contentStore.DEFAULT_SIGNALS_DIR,
+      signals_dir: contentStore.resolveSignalsDir(),
       team_context_dir: process.env.TEAM_CONTEXT_TEAM_CONTEXT_DIR || '',
     };
     for (const [key, val] of Object.entries(containerPaths)) {
@@ -4345,7 +4493,7 @@ function ensureContainerConfig() {
       bot_token_env: 'SLACK_BOT_TOKEN',
       app_token_env: 'SLACK_APP_TOKEN',
       mode: process.env.TEAM_CONTEXT_BOT_MODE || 'local',
-      store_path: process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH,
+      store_path: contentStore.resolveStorePath(),
       journal_dir: process.env.TEAM_CONTEXT_JOURNALS_DIR || '/data/journals',
       llm: {
         provider: 'anthropic',
@@ -4359,7 +4507,7 @@ function ensureContainerConfig() {
   // Override container-specific paths in bot config (same reason as digest above)
   if (config.slack_bot) {
     const botPaths = {
-      store_path: process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH,
+      store_path: contentStore.resolveStorePath(),
       journal_dir: process.env.TEAM_CONTEXT_JOURNALS_DIR || '/data/journals',
     };
     for (const [key, val] of Object.entries(botPaths)) {
@@ -4438,7 +4586,7 @@ function buildBotConfigFromEnv() {
     bot_token_env: 'SLACK_BOT_TOKEN',
     app_token_env: 'SLACK_APP_TOKEN',
     mode: process.env.TEAM_CONTEXT_BOT_MODE || 'local',
-    store_path: process.env.TEAM_CONTEXT_STORE_PATH || contentStore.DEFAULT_STORE_PATH,
+    store_path: contentStore.resolveStorePath(),
     journal_dir: process.env.TEAM_CONTEXT_JOURNALS_DIR || '/data/journals',
     llm: {
       provider: 'anthropic',
@@ -4664,6 +4812,194 @@ function runCheckVersion() {
   }, CLI_USER);
 }
 
+// ── Container doctor ────────────────────────────────────────────────────────
+
+/**
+ * Detect if we're running inside a Docker container.
+ */
+function isRunningInContainer() {
+  try {
+    return fs.existsSync('/.dockerenv');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Container-specific health checks. Prints PASS/WARN lines and exits with
+ * appropriate code. Useful as a post-startup self-check or via
+ * `docker exec wayfind npx wayfind doctor --container`.
+ */
+async function runContainerDoctor() {
+  const GREEN = '\x1b[32m', YELLOW = '\x1b[33m', RED = '\x1b[31m', RESET = '\x1b[0m';
+  const pass = (msg) => console.log(`${GREEN}PASS${RESET}  ${msg}`);
+  const warn = (msg) => console.log(`${YELLOW}WARN${RESET}  ${msg}`);
+  let issues = 0;
+
+  console.log('');
+  console.log('Wayfind — Container Doctor');
+  console.log('══════════════════════════════');
+
+  // 1. Backend type — is SQLite active or JSON fallback?
+  const storePath = path.join(EFFECTIVE_DIR, 'content-store');
+  try {
+    const storage = require('./storage/index.js');
+    storage.getBackend(storePath);
+    const info = storage.getBackendInfo(storePath);
+    if (!info) {
+      warn('Storage backend: not initialized');
+      issues++;
+    } else if (info.type === 'sqlite' && !info.fallback) {
+      pass(`Storage backend: sqlite`);
+    } else if (info.type === 'json' && info.fallback) {
+      warn('Storage backend: JSON (fallback — SQLite failed to load)');
+      console.log('       Install better-sqlite3 or rebuild the container image');
+      issues++;
+    } else if (info.type === 'json') {
+      warn('Storage backend: JSON (not SQLite)');
+      issues++;
+    } else {
+      pass(`Storage backend: ${info.type}`);
+    }
+  } catch (e) {
+    warn(`Storage backend: error — ${e.message}`);
+    issues++;
+  }
+
+  // 2. Entry count — are there entries in the content store?
+  let entryCount = 0;
+  try {
+    const storage = require('./storage/index.js');
+    const backend = storage.getBackend(storePath);
+    const idx = backend.loadIndex();
+    if (idx && idx.entries) {
+      entryCount = Object.keys(idx.entries).length;
+    }
+    if (entryCount > 0) {
+      pass(`Content store: ${entryCount} entries`);
+    } else {
+      warn('Content store: 0 entries — no signals have been indexed');
+      console.log('       Run: wayfind pull --all');
+      issues++;
+    }
+  } catch (e) {
+    warn(`Content store: error — ${e.message}`);
+    issues++;
+  }
+
+  // 3. Embedding coverage — what % of entries have embeddings?
+  if (entryCount > 0) {
+    try {
+      const storage = require('./storage/index.js');
+      const backend = storage.getBackend(storePath);
+      const idx = backend.loadIndex();
+      let total = 0, embedded = 0;
+      if (idx && idx.entries) {
+        for (const e of Object.values(idx.entries)) {
+          total++;
+          if (e.hasEmbedding) embedded++;
+        }
+      }
+      const pct = total > 0 ? Math.round(100 * embedded / total) : 0;
+      if (pct >= 50) {
+        pass(`Embedding coverage: ${embedded}/${total} (${pct}%)`);
+      } else {
+        warn(`Embedding coverage: ${embedded}/${total} (${pct}%) — search quality degraded`);
+        console.log('       Run: wayfind reindex');
+        issues++;
+      }
+    } catch (e) {
+      warn(`Embedding coverage: error — ${e.message}`);
+      issues++;
+    }
+  }
+
+  // 4. Signal freshness — are there signal files from today?
+  const signalsDir = path.join(EFFECTIVE_DIR, 'signals');
+  const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+  try {
+    if (!fs.existsSync(signalsDir)) {
+      warn('Signal freshness: no signals directory');
+      issues++;
+    } else {
+      const channels = fs.readdirSync(signalsDir).filter((f) => {
+        try { return fs.statSync(path.join(signalsDir, f)).isDirectory(); } catch { return false; }
+      });
+      if (channels.length === 0) {
+        warn('Signal freshness: no signal channels found');
+        issues++;
+      } else {
+        let freshCount = 0;
+        for (const ch of channels) {
+          const chDir = path.join(signalsDir, ch);
+          const files = fs.readdirSync(chDir).filter((f) => f.endsWith('.md')).sort().reverse();
+          const newest = files[0] || '';
+          // Signal files are named with date prefix, e.g. 2026-03-28-....md
+          if (newest.startsWith(today)) {
+            freshCount++;
+          }
+        }
+        if (freshCount === channels.length) {
+          pass(`Signal freshness: ${freshCount}/${channels.length} channels have signals from today`);
+        } else {
+          warn(`Signal freshness: ${freshCount}/${channels.length} channels have signals from today`);
+          console.log('       Run: wayfind pull --all');
+          issues++;
+        }
+      }
+    }
+  } catch (e) {
+    warn(`Signal freshness: error — ${e.message}`);
+    issues++;
+  }
+
+  // 5. Slack bot / health endpoint — is /healthz responding?
+  const healthPort = parseInt(process.env.TEAM_CONTEXT_HEALTH_PORT || '3141', 10);
+  try {
+    const healthResult = await new Promise((resolve) => {
+      const req = http.get(`http://localhost:${healthPort}/healthz`, { timeout: 3000 }, (res) => {
+        let body = '';
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => resolve({ status: res.statusCode, body }));
+      });
+      req.on('error', (e) => resolve({ status: 0, error: e.message }));
+      req.on('timeout', () => { req.destroy(); resolve({ status: 0, error: 'timeout' }); });
+    });
+
+    if (healthResult.status === 200) {
+      let detail = '';
+      try {
+        const data = JSON.parse(healthResult.body);
+        if (data.slack && data.slack.connected) {
+          detail = ' (Slack connected)';
+        } else if (data.slack && !data.slack.connected) {
+          detail = ' (Slack disconnected)';
+        }
+      } catch { /* ignore parse errors */ }
+      pass(`Health endpoint: http://localhost:${healthPort}/healthz${detail}`);
+    } else if (healthResult.status > 0) {
+      warn(`Health endpoint: responded with ${healthResult.status}`);
+      issues++;
+    } else {
+      warn(`Health endpoint: not reachable — ${healthResult.error}`);
+      console.log('       Is the container running? Check: docker ps');
+      issues++;
+    }
+  } catch (e) {
+    warn(`Health endpoint: error — ${e.message}`);
+    issues++;
+  }
+
+  console.log('');
+  console.log('══════════════════════════════');
+  if (issues === 0) {
+    console.log(`${GREEN}All container checks passed${RESET}`);
+  } else {
+    console.log(`${YELLOW}${issues} issue(s) found${RESET}`);
+    process.exit(1);
+  }
+}
+
 // ── Command registry ────────────────────────────────────────────────────────
 
 const COMMANDS = {
@@ -4741,48 +5077,92 @@ const COMMANDS = {
         process.exit(result.status);
       }
 
-      // Step 3: Update Wayfind container if one is running
+      // Step 3: Update all Wayfind containers (per-team labeled + legacy 'wayfind')
       const dockerCheck = spawnSync('docker', ['compose', 'version'], { stdio: 'pipe' });
       if (!dockerCheck.error && dockerCheck.status === 0) {
-        const psResult = spawnSync('docker', ['ps', '--filter', 'name=wayfind', '--format', '{{.Names}}'], { stdio: 'pipe' });
-        const containers = (psResult.stdout || '').toString().trim();
-        if (containers && containers.split('\n').some(c => c === 'wayfind')) {
-          console.log('\nWayfind container detected — pulling latest image...');
-
-          // Find compose file directory: check container labels, then known paths
-          let composeDir = '';
-          const inspectResult = spawnSync('docker', ['inspect', 'wayfind', '--format', '{{index .Config.Labels "com.docker.compose.project.working_dir"}}'], { stdio: 'pipe' });
-          const labelDir = (inspectResult.stdout || '').toString().trim();
-          if (labelDir && fs.existsSync(path.join(labelDir, 'docker-compose.yml'))) {
-            composeDir = labelDir;
-          } else {
-            const teamCtx = process.env.TEAM_CONTEXT_TEAM_CONTEXT_DIR || '';
-            const candidates = [
-              teamCtx ? path.join(teamCtx, 'deploy') : '',
-              process.cwd(),
-              path.join(HOME, 'team-context', 'deploy'),
-            ].filter(Boolean);
-            for (const dir of candidates) {
-              if (fs.existsSync(path.join(dir, 'docker-compose.yml'))) {
-                composeDir = dir;
-                break;
+        // Discover containers: prefer com.wayfind.team label, fall back to legacy 'wayfind' name
+        const labeledResult = spawnSync('docker', [
+          'ps',
+          '--filter', 'label=com.wayfind.team',
+          '--format', '{{.Names}}\t{{index .Labels "com.wayfind.team"}}',
+        ], { stdio: 'pipe' });
+        const legacyResult = spawnSync('docker', ['ps', '--filter', 'name=^wayfind$', '--format', '{{.Names}}\t'], { stdio: 'pipe' });
+
+        const containerRows = [
+          ...(labeledResult.stdout || '').toString().trim().split('\n').filter(Boolean),
+          ...(legacyResult.stdout || '').toString().trim().split('\n').filter(Boolean),
+        ];
+
+        if (containerRows.length > 0) {
+          console.log(`\nWayfind container(s) detected — updating ${containerRows.length} container(s)...`);
+
+          for (const row of containerRows) {
+            const [containerName] = row.split('\t');
+            if (!containerName) continue;
+
+            // Find compose dir via docker label
+            const inspectResult = spawnSync('docker', [
+              'inspect', containerName,
+              '--format', '{{index .Config.Labels "com.docker.compose.project.working_dir"}}',
+            ], { stdio: 'pipe' });
+            const labelDir = (inspectResult.stdout || '').toString().trim();
+
+            let composeDir = '';
+            if (labelDir && fs.existsSync(path.join(labelDir, 'docker-compose.yml'))) {
+              composeDir = labelDir;
+            } else {
+              // For per-team containers, check teams dir
+              const teamsBase = HOME ? path.join(HOME, '.claude', 'team-context', 'teams') : '';
+              if (teamsBase && fs.existsSync(teamsBase)) {
+                for (const tid of fs.readdirSync(teamsBase)) {
+                  const candidate = path.join(teamsBase, tid, 'deploy');
+                  if (fs.existsSync(path.join(candidate, 'docker-compose.yml'))) {
+                    // Check if this compose file manages this container
+                    const checkResult = spawnSync('docker', ['compose', 'ps', '--format', '{{.Name}}'], { cwd: candidate, stdio: 'pipe' });
+                    const composeContainers = (checkResult.stdout || '').toString();
+                    if (composeContainers.includes(containerName)) {
+                      composeDir = candidate;
+                      break;
+                    }
+                  }
+                }
+              }
+              // Legacy fallback
+              if (!composeDir) {
+                const legacyCandidates = [process.cwd(), path.join(HOME || '', 'team-context', 'deploy')];
+                for (const dir of legacyCandidates) {
+                  if (dir && fs.existsSync(path.join(dir, 'docker-compose.yml'))) {
+                    composeDir = dir;
+                    break;
+                  }
+                }
               }
             }
-          }
 
-          if (composeDir) {
-            console.log(`Using compose file in: ${composeDir}`);
-            const pullResult = spawnSync('docker', ['compose', 'pull'], { cwd: composeDir, stdio: 'inherit' });
-            if (!pullResult.error && pullResult.status === 0) {
-              console.log('Recreating container with new image...');
-              spawnSync('docker', ['compose', 'up', '-d'], { cwd: composeDir, stdio: 'inherit' });
-              console.log('Container updated.');
+            if (composeDir) {
+              console.log(`\nUpdating ${containerName} (compose: ${composeDir})...`);
+              const pullResult = spawnSync('docker', ['compose', 'pull'], { cwd: composeDir, stdio: 'inherit' });
+              if (!pullResult.error && pullResult.status === 0) {
+                spawnSync('docker', ['compose', 'up', '-d'], { cwd: composeDir, stdio: 'inherit' });
+                console.log(`${containerName} updated.`);
+
+                // Post-deploy smoke check
+                spawnSync('sleep', ['5']);
+                const logsResult = spawnSync('docker', ['logs', '--tail', '50', containerName], { stdio: 'pipe' });
+                const logOutput = (logsResult.stdout || '').toString() + (logsResult.stderr || '').toString();
+                const warnings = logOutput.split('\n').filter(l => /Warning:|Error:|failed|fallback/i.test(l) && l.trim());
+                if (warnings.length > 0) {
+                  warnings.forEach(w => console.log(`  \u26A0 ${w.trim()}`));
+                  console.log('  Post-deploy warnings detected — review above');
+                } else {
+                  console.log('  Post-deploy check: no warnings');
+                }
+              } else {
+                console.error(`Docker pull failed for ${containerName}.`);
+              }
             } else {
-              console.error('Docker pull failed — container not updated.');
+              console.log(`Could not locate docker-compose.yml for ${containerName}. Update manually.`);
             }
-          } else {
-            console.log('Could not locate docker-compose.yml for the Wayfind container.');
-            console.log('Run "docker compose pull && docker compose up -d" manually in your deploy directory.');
           }
         }
       }
@@ -4829,9 +5209,13 @@ const COMMANDS = {
     run: (args) => runMigrateToPlugin(args),
   },
   doctor: {
-    desc: 'Check your Wayfind installation for issues',
+    desc: 'Check your Wayfind installation for issues (--container for container checks)',
     run: (args) => {
-      spawn('bash', [path.join(ROOT, 'doctor.sh'), ...args]);
+      if (args.includes('--container') || isRunningInContainer()) {
+        runContainerDoctor();
+      } else {
+        spawn('bash', [path.join(ROOT, 'doctor.sh'), ...args]);
+      }
     },
   },
   version: {
@@ -5210,6 +5594,7 @@ function showHelp() {
   console.log('  wayfind update                Update from npm, re-sync hooks, update container');
   console.log('  wayfind migrate-to-plugin     Remove old hooks/commands — let the plugin handle them');
   console.log('  wayfind doctor                Check installation health');
+  console.log('  wayfind doctor --container    Container-specific health checks (auto-detected in Docker)');
   console.log('');
   console.log('Publishing:');
   console.log('  wayfind sync-public           Sync code to usewayfind/wayfind (triggers npm + Docker publish)');

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "wayfind",
-  "version": "2.0.38",
+  "version": "2.0.40",
   "description": "Team decision trail for AI-assisted development. The connective tissue between product, engineering, and strategy.",
   "bin": {
-    "wayfind": "./bin/team-context.js"
+    "wayfind": "./bin/team-context.js",
+    "wayfind-mcp": "./bin/mcp-server.js"
   },
   "keywords": [
     "ai",
@@ -48,6 +49,7 @@
     "node": ">=16"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
     "@slack/bolt": "^4.6.0",
     "posthog-node": "^5.28.0"
   },