wayfind 2.0.43 → 2.0.45

package/bin/content-store.js

@@ -176,6 +176,27 @@ function isRepoExcluded(repo) {
   return false;
 }
 
+/**
+ * Check if a repo name matches a team scope pattern list.
+ * Patterns ending with '/' are prefix matches (e.g., 'acme/' matches 'acme/api', 'acme/frontend').
+ * All other patterns are exact matches.
+ * @param {string|null} repo
+ * @param {string[]} patterns
+ * @returns {boolean}
+ */
+function matchesTeamScope(repo, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  if (!repo) return false;
+  for (const p of patterns) {
+    if (p.endsWith('/')) {
+      if (repo.startsWith(p)) return true;
+    } else if (repo === p) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // ── Journal parsing ─────────────────────────────────────────────────────────
 
 /**
@@ -432,6 +453,7 @@ async function indexJournals(options = {}) {
 
     for (const entry of entries) {
       if (isRepoExcluded(entry.repo)) continue;
+      if (options.repoAllowlist && !matchesTeamScope(entry.repo, options.repoAllowlist)) continue;
       const id = generateEntryId(date, entry.repo, entry.title);
       const author = entry.author || options.defaultAuthor || '';
       const content = buildContent({ ...entry, date, author });
@@ -2290,6 +2312,47 @@ function deduplicateResults(results) {
   return results.filter(r => !absorbedIds.has(r.id));
 }
 
+/**
+ * Remove entries from a store whose repo doesn't match the allowed patterns.
+ * Trims both index and embeddings. Safe to call repeatedly (idempotent).
+ * @param {string} storePath
+ * @param {string[]} allowedPatterns - prefix patterns (ending '/') or exact names
+ * @returns {{ kept: number, removed: number, removedRepos: string[] }}
+ */
+async function trimStore(storePath, allowedPatterns) {
+  if (!allowedPatterns || allowedPatterns.length === 0) {
+    throw new Error('allowedPatterns is required — refusing to trim to empty set');
+  }
+  const backend = getBackend(storePath);
+  const idx = backend.loadIndex();
+  const embeddings = backend.loadEmbeddings() || {};
+
+  const keptEntries = {};
+  const keptEmbeddings = {};
+  const removedRepos = [];
+
+  for (const [id, entry] of Object.entries(idx.entries || {})) {
+    if (matchesTeamScope(entry.repo, allowedPatterns)) {
+      keptEntries[id] = entry;
+      if (embeddings[id]) keptEmbeddings[id] = embeddings[id];
+    } else {
+      removedRepos.push(entry.repo);
+    }
+  }
+
+  idx.entries = keptEntries;
+  idx.entryCount = Object.keys(keptEntries).length;
+  idx.lastUpdated = new Date().toISOString();
+  backend.saveIndex(idx);
+  backend.saveEmbeddings(keptEmbeddings);
+
+  return {
+    kept: idx.entryCount,
+    removed: removedRepos.length,
+    removedRepos: [...new Set(removedRepos)].sort(),
+  };
+}
+
 module.exports = {
   // Parsing
   parseJournalFile,
@@ -2318,8 +2381,12 @@ module.exports = {
 
   // Filtering
   isRepoExcluded,
+  matchesTeamScope,
   applyFilters,
 
+  // Store maintenance
+  trimStore,
+
   // Quality & dedup
   computeQualityScore,
   deduplicateResults,

package/bin/team-context.js

@@ -1111,8 +1111,16 @@ async function runIndexJournals(args) {
   const journalDir = opts.dir || contentStore.DEFAULT_JOURNAL_DIR;
   const storePath = opts.store || contentStore.resolveStorePath();
 
+  // Load team scope allowlist from context.json — only index repos bound to the active team.
+  const ctxConfig = readContextConfig();
+  const teamId = readRepoTeamBinding() || ctxConfig.default;
+  const teamConfig = teamId && ctxConfig.teams && ctxConfig.teams[teamId];
+  const repoAllowlist = (teamConfig && teamConfig.bound_repos && teamConfig.bound_repos.length > 0)
+    ? teamConfig.bound_repos : undefined;
+
   console.log(`Indexing journals from: ${journalDir}`);
   console.log(`Store: ${storePath}`);
+  if (repoAllowlist) console.log(`Team scope (${teamId}): ${repoAllowlist.join(', ')}`);
   console.log('');
 
   try {
@@ -1120,6 +1128,7 @@ async function runIndexJournals(args) {
       journalDir,
       storePath,
       embeddings: opts.noEmbeddings ? false : undefined,
+      repoAllowlist,
     });
 
     console.log(`Indexed: ${stats.entryCount} entries`);
@@ -3591,6 +3600,21 @@ function contextBind(args) {
   writeRepoTeamBinding(teamId);
   console.log(`Bound this repo to: ${config.teams[teamId].name} (${teamId})`);
   console.log('Journals from this repo will sync to that team\'s context repo.');
+
+  // Derive repo label (e.g., "acme/api") and add to the team's bound_repos allowlist.
+  const cwdParts = process.cwd().split(path.sep);
+  const reposIdx = cwdParts.lastIndexOf('repos');
+  const repoLabel = (reposIdx >= 0 && reposIdx + 2 <= cwdParts.length)
+    ? cwdParts.slice(reposIdx + 1).join('/')
+    : cwdParts[cwdParts.length - 1];
+
+  const team = config.teams[teamId];
+  if (!team.bound_repos) team.bound_repos = [];
+  if (!team.bound_repos.includes(repoLabel)) {
+    team.bound_repos.push(repoLabel);
+    writeContextConfig(config);
+    console.log(`Added "${repoLabel}" to team scope.`);
+  }
 }
 
 function contextList() {
@@ -3788,17 +3812,25 @@ async function runDeploy(args) {
 }
 
 /**
- * Scaffold a per-team container config at ~/.claude/team-context/teams/<teamId>/deploy/
+ * Scaffold a per-team container config in the team's registered repo (deploy/ subdir).
+ * Falls back to ~/.claude/team-context/teams/<teamId>/deploy/ if no repo is registered.
  */
 function deployTeamInit(teamId, { port } = {}) {
-  const teamsBaseDir = HOME ? path.join(HOME, '.claude', 'team-context', 'teams') : null;
-  if (!teamsBaseDir) {
+  if (!HOME) {
     console.error('Cannot resolve home directory.');
     process.exit(1);
   }
 
-  const deployDir = path.join(teamsBaseDir, teamId, 'deploy');
-  const storeDir = path.join(teamsBaseDir, teamId, 'content-store');
+  // Resolve deploy dir: team repo path first, fallback to store-adjacent
+  const config = readContextConfig();
+  const teamEntry = config.teams && config.teams[teamId];
+  const teamContextPath = teamEntry ? teamEntry.path : null;
+  const deployDir = teamContextPath
+    ? path.join(teamContextPath, 'deploy')
+    : path.join(HOME, '.claude', 'team-context', 'teams', teamId, 'deploy');
+
+  // Ensure the per-team store dir exists
+  const storeDir = path.join(HOME, '.claude', 'team-context', 'teams', teamId, 'content-store');
 
   // Check for duplicate running container
   const psResult = spawnSync('docker', ['ps', '--filter', `label=com.wayfind.team=${teamId}`, '--format', '{{.Names}}'], { stdio: 'pipe' });
@@ -3814,22 +3846,42 @@ function deployTeamInit(teamId, { port } = {}) {
   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;
+  // Auto-detect port: find all wayfind containers, pick next available
   const containerName = `wayfind-${teamId}`;
+  let assignedPort = port;
+  if (!assignedPort) {
+    const usedPorts = new Set();
+    // Check labeled containers
+    const portsResult = spawnSync('docker', [
+      'ps', '--filter', 'label=com.wayfind.team',
+      '--format', '{{.Ports}}',
+    ], { stdio: 'pipe' });
+    // Also check legacy container named "wayfind"
+    const legacyPortsResult = spawnSync('docker', [
+      'ps', '--filter', 'name=^wayfind',
+      '--format', '{{.Ports}}',
+    ], { stdio: 'pipe' });
+    const allPortOutput = [
+      (portsResult.stdout || '').toString(),
+      (legacyPortsResult.stdout || '').toString(),
+    ].join('\n');
+    // Extract host ports from "0.0.0.0:3141->3141/tcp" patterns
+    for (const match of allPortOutput.matchAll(/:(\d+)->/g)) {
+      usedPorts.add(parseInt(match[1], 10));
+    }
+    assignedPort = 3141;
+    while (usedPorts.has(assignedPort)) assignedPort++;
+    if (assignedPort !== 3141) {
+      console.log(`Port 3141 in use — assigning port ${assignedPort}`);
+    }
+  }
 
   // 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}}`);
+    .replace(/- "3141:3141"/, `- "${assignedPort}:3141"`);
 
   // Inject Docker label for discovery
   composeContent = composeContent.replace(
@@ -3845,42 +3897,63 @@ function deployTeamInit(teamId, { port } = {}) {
     console.log('  docker-compose.yml — already exists, skipping');
   }
 
-  // .env.example
+  // .env.example — full reference with all options
   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');
+    fs.copyFileSync(envExampleSrc, envExampleDst);
+    console.log('  .env.example — created (full reference)');
   }
 
-  // .env from .env.example
+  // .env — minimal seed with only required keys
   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');
+  if (!fs.existsSync(envPath)) {
+    const ghToken = detectGitHubToken();
+    const lines = [
+      '# Wayfind — required configuration',
+      '# See .env.example for all available options.',
+      '',
+      '# Anthropic API key (for digests and bot answers)',
+      'ANTHROPIC_API_KEY=sk-ant-your-key',
+      '',
+      '# GitHub token (for pulling team journals and signals)',
+      `GITHUB_TOKEN=${ghToken || ''}`,
+      '',
+      `TEAM_CONTEXT_TENANT_ID=${teamId}`,
+    ];
+    // Set volume mount path so docker-compose.yml resolves correctly
+    if (teamContextPath) {
+      lines.push(`TEAM_CONTEXT_TEAM_CONTEXT_PATH=${teamContextPath}`);
+    }
+    fs.writeFileSync(envPath, lines.join('\n') + '\n', 'utf8');
+    console.log('  .env — created (fill in ANTHROPIC_API_KEY)');
+    if (ghToken) {
       console.log('  GITHUB_TOKEN — auto-detected from gh CLI');
     }
+  } else {
+    console.log('  .env — already exists, skipping');
+  }
+
+  // Ensure deploy/.env is gitignored if we're in a repo
+  if (teamContextPath) {
+    const gitignorePath = path.join(teamContextPath, '.gitignore');
+    const gitignoreEntry = 'deploy/.env';
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      if (!content.includes(gitignoreEntry)) {
+        fs.appendFileSync(gitignorePath, `\n${gitignoreEntry}\n`);
+        console.log('  .gitignore — added deploy/.env');
+      }
+    }
   }
 
   console.log('');
   console.log('Next steps:');
-  console.log(`  1. Fill in ${deployDir}/.env with your tokens`);
+  console.log(`  1. Set ANTHROPIC_API_KEY in ${deployDir}/.env`);
   console.log(`  2. cd "${deployDir}" && docker compose up -d`);
   console.log(`  3. Verify: curl http://localhost:${assignedPort}/healthz`);
   console.log('');
+  console.log('See .env.example for optional config (Slack, embeddings, signals, schedules).');
   console.log(`Tip: run "wayfind deploy list" to see all running team containers.`);
 
   telemetry.capture('deploy_team_init', { teamId }, CLI_USER);
@@ -3904,7 +3977,7 @@ function deployList() {
   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');
+    console.log('Start one with: wayfind deploy --team <teamId>');
     return;
   }
 
@@ -4146,8 +4219,10 @@ async function runStart() {
 
   // Validate required env vars before proceeding
   const missing = [];
-  if (!process.env.SLACK_BOT_TOKEN) missing.push('SLACK_BOT_TOKEN');
-  if (!process.env.SLACK_APP_TOKEN) missing.push('SLACK_APP_TOKEN');
+  // Slack tokens are only required for modes that run the bot
+  const needsSlack = ['bot', 'all-in-one'].includes(mode) && !process.env.TEAM_CONTEXT_NO_SLACK;
+  if (needsSlack && !process.env.SLACK_BOT_TOKEN) missing.push('SLACK_BOT_TOKEN');
+  if (needsSlack && !process.env.SLACK_APP_TOKEN) missing.push('SLACK_APP_TOKEN');
   if (!process.env.ANTHROPIC_API_KEY) missing.push('ANTHROPIC_API_KEY');
   if (missing.length > 0) {
     console.error('');
@@ -4157,6 +4232,8 @@ async function runStart() {
     console.error('  cp deploy/.env.example deploy/.env');
     console.error('  # Fill in your tokens, then: docker compose up -d');
     console.error('');
+    console.error('Tip: set TEAM_CONTEXT_NO_SLACK=1 to run without Slack integration.');
+    console.error('');
     process.exit(1);
   }
 
@@ -5000,6 +5077,52 @@ async function runContainerDoctor() {
   }
 }
 
+// ── Store management ────────────────────────────────────────────────────────
+
+async function runStoreTrim(args) {
+  const ctxConfig = readContextConfig();
+  const teamId = args[0] || readRepoTeamBinding() || ctxConfig.default;
+  if (!teamId) {
+    console.error('No team ID resolved. Usage: wayfind store trim [team-id]');
+    process.exit(1);
+  }
+  const team = ctxConfig.teams && ctxConfig.teams[teamId];
+  if (!team) {
+    console.error(`Team "${teamId}" not found.`);
+    process.exit(1);
+  }
+  const allowedPatterns = team.bound_repos;
+  if (!allowedPatterns || allowedPatterns.length === 0) {
+    console.error(`Team "${teamId}" has no bound_repos in context.json. Configure them first.`);
+    process.exit(1);
+  }
+  const storePath = contentStore.resolveStorePath(teamId);
+  console.log(`Team:     ${team.name} (${teamId})`);
+  console.log(`Store:    ${storePath}`);
+  console.log(`Patterns: ${allowedPatterns.join(', ')}`);
+  console.log('');
+  const stats = await contentStore.trimStore(storePath, allowedPatterns);
+  console.log(`Kept:    ${stats.kept}`);
+  console.log(`Removed: ${stats.removed}`);
+  if (stats.removedRepos.length > 0) {
+    console.log(`Repos removed:`);
+    stats.removedRepos.forEach(r => console.log(`  ${r}`));
+  }
+}
+
+async function runStore(args) {
+  const [sub, ...subArgs] = args;
+  switch (sub) {
+    case 'trim':
+      await runStoreTrim(subArgs);
+      break;
+    default:
+      console.error(`Unknown store subcommand: ${sub || ''}`);
+      console.error('Available: trim');
+      process.exit(1);
+  }
+}
+
 // ── Command registry ────────────────────────────────────────────────────────
 
 const COMMANDS = {
@@ -5111,13 +5234,13 @@ const COMMANDS = {
             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');
+              // Check team repo paths from context.json first
+              const updateConfig = readContextConfig();
+              if (updateConfig.teams) {
+                for (const [tid, entry] of Object.entries(updateConfig.teams)) {
+                  if (!entry.path) continue;
+                  const candidate = path.join(entry.path, '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)) {
@@ -5127,6 +5250,23 @@ const COMMANDS = {
                   }
                 }
               }
+              // Fallback: check store-adjacent deploy dirs
+              if (!composeDir) {
+                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'))) {
+                      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')];
@@ -5274,6 +5414,10 @@ const COMMANDS = {
     desc: 'Scaffold Docker deployment in your team context repo',
     run: (args) => runDeploy(args),
   },
+  store: {
+    desc: 'Manage content store (trim)',
+    run: (args) => runStore(args),
+  },
   onboard: {
     desc: 'Generate an onboarding context pack for a repo',
     run: (args) => runOnboard(args),

package/package.json

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

package/templates/deploy/.env.example

@@ -1,14 +1,11 @@
 # Wayfind — Docker environment configuration
 # Copy to .env and fill in your values: cp .env.example .env
+#
+# Only ANTHROPIC_API_KEY and GITHUB_TOKEN are required.
+# Everything else is optional — add as needed.
 
 # ── Required ──────────────────────────────────────────────────────────────────
 
-# Slack bot tokens — from the Slack app you created using slack-app-manifest.json.
-# Go to api.slack.com/apps → your Wayfind app → OAuth & Permissions for the bot token,
-# and Basic Information → App-Level Tokens for the app token.
-SLACK_BOT_TOKEN=xoxb-your-bot-token
-SLACK_APP_TOKEN=xapp-your-app-token
-
 # Anthropic API key (for digests and bot answers)
 # Get one at console.anthropic.com
 ANTHROPIC_API_KEY=sk-ant-your-key
@@ -18,73 +15,33 @@ ANTHROPIC_API_KEY=sk-ant-your-key
 # Needs read access to the team-context repo.
 GITHUB_TOKEN=
 
-# ── Digest delivery ───────────────────────────────────────────────────────────
-# Primary: bot token + channel. The bot posts digests via chat.postMessage,
-# which enables reaction tracking and threaded feedback.
-# Fallback: webhook. Used only if bot delivery fails.
+# ── Slack (for digest delivery and bot) ──────────────────────────────────────
+# Without these, set TEAM_CONTEXT_NO_SLACK=1 and the container runs in
+# scheduler/worker-only mode (no digest posting, no bot answers).
 
-# Slack channel for digest delivery (channel ID, not name)
-# Right-click channel in Slack → View channel details → copy the ID at bottom
+# SLACK_BOT_TOKEN=xoxb-your-bot-token
+# SLACK_APP_TOKEN=xapp-your-app-token
 # SLACK_DIGEST_CHANNEL=C0123456789
-
-# Slack webhook — fallback for digest delivery if bot token is unavailable
 # TEAM_CONTEXT_SLACK_WEBHOOK=https://hooks.slack.com/services/T.../B.../...
 
-# ── Optional ──────────────────────────────────────────────────────────────────
-
-# Tenant identifier (prefixes storage paths)
-# TEAM_CONTEXT_TENANT_ID=my-team
-
-# Team repo allowlist — only journals from these repos appear in digests and queries.
-# Supports org/* wildcards. This is the recommended way to scope a container to one team.
-# TEAM_CONTEXT_INCLUDE_REPOS=MyOrg/*,MyOrg-Libs/*
-
-# DEPRECATED: Blocklist approach. Use INCLUDE_REPOS instead.
-# TEAM_CONTEXT_EXCLUDE_REPOS=wayfind,personal-project
-
-# Encryption key — generate with: openssl rand -base64 32
-# TEAM_CONTEXT_ENCRYPTION_KEY=
-
-# Author slug for CLI telemetry attribution
-# TEAM_CONTEXT_AUTHOR=greg
-
-# ── LLM models ───────────────────────────────────────────────────────────────
-
-# Model for digest generation and onboarding packs (default: claude-sonnet-4-5-20250929)
-# TEAM_CONTEXT_LLM_MODEL=claude-sonnet-4-5-20250929
-
-# Model for conversation transcript extraction (default: claude-sonnet-4-5-20250929)
-# TEAM_CONTEXT_EXTRACTION_MODEL=claude-sonnet-4-5-20250929
-
-# ── Embeddings (without these, bot uses keyword search only) ─────────────────
+# ── Embeddings (for semantic search — falls back to keyword search without) ──
 # Option A: OpenAI
 # OPENAI_API_KEY=sk-your-openai-key
-# Option B: Azure OpenAI (if you have an AOAI deployment)
+# Option B: Azure OpenAI
 # AZURE_OPENAI_EMBEDDING_ENDPOINT=https://your-resource.openai.azure.com/
 # AZURE_OPENAI_EMBEDDING_KEY=your-key
 # AZURE_OPENAI_EMBEDDING_DEPLOYMENT=text-embedding-3-small
 
-# ── Path overrides ───────────────────────────────────────────────────────────
-
-# Override content store path (default: ~/.claude/team-context/content-store)
-# TEAM_CONTEXT_STORE_PATH=/data/content-store
-
-# Override signals directory (default: ~/.claude/team-context/signals)
-# TEAM_CONTEXT_SIGNALS_DIR=/data/signals
+# ── Team scoping ─────────────────────────────────────────────────────────────
 
-# Override conversations directory (default: ~/.claude/projects)
-# TEAM_CONTEXT_CONVERSATIONS_DIR=/data/conversations
-
-# ── Schedules ────────────────────────────────────────────────────────────────
-
-# Digest schedule (cron, default: daily 12pm UTC / 7am ET)
-# TEAM_CONTEXT_DIGEST_SCHEDULE=0 12 * * *
+# Tenant identifier (prefixes storage paths)
+# TEAM_CONTEXT_TENANT_ID=my-team
 
-# Signal pull schedule (cron, default: daily 6am UTC)
-# TEAM_CONTEXT_SIGNAL_SCHEDULE=0 6 * * *
+# Team repo allowlist — only journals from these repos appear in digests/queries.
+# TEAM_CONTEXT_INCLUDE_REPOS=MyOrg/*,MyOrg-Libs/*
 
-# Reindex schedule (cron, default: hourly)
-# TEAM_CONTEXT_REINDEX_SCHEDULE=0 * * * *
+# Author slug for telemetry attribution
+# TEAM_CONTEXT_AUTHOR=greg
 
 # ── Signal sources ───────────────────────────────────────────────────────────
 
@@ -93,21 +50,28 @@ GITHUB_TOKEN=
 
 # Intercom API token for support signal ingestion
 # INTERCOM_TOKEN=your-intercom-token
-
-# Filter Intercom conversations by tags (comma-separated)
 # TEAM_CONTEXT_INTERCOM_TAGS=bug,feature-request
 
 # Notion integration token for page/database signal ingestion
-# Create at: https://www.notion.so/my-integrations
 # NOTION_TOKEN=ntn_your-integration-token
-
-# Specific Notion database IDs to monitor (comma-separated, or blank for all shared pages)
 # TEAM_CONTEXT_NOTION_DATABASES=db_id1,db_id2
 
-# ── Monitoring ───────────────────────────────────────────────────────────────
+# ── Schedules ────────────────────────────────────────────────────────────────
 
-# Health check port (default: 3141)
-# TEAM_CONTEXT_HEALTH_PORT=3141
+# TEAM_CONTEXT_DIGEST_SCHEDULE=0 12 * * *
+# TEAM_CONTEXT_SIGNAL_SCHEDULE=0 6 * * *
+# TEAM_CONTEXT_REINDEX_SCHEDULE=0 * * * *
 
-# Telemetry — opt-in anonymous usage data to help improve Wayfind
+# ── Advanced ─────────────────────────────────────────────────────────────────
+
+# Set to 1 to run without Slack (scheduler + worker only, no bot)
+# TEAM_CONTEXT_NO_SLACK=1
+
+# TEAM_CONTEXT_LLM_MODEL=claude-sonnet-4-5-20250929
+# TEAM_CONTEXT_EXTRACTION_MODEL=claude-sonnet-4-5-20250929
+# TEAM_CONTEXT_ENCRYPTION_KEY=
+# TEAM_CONTEXT_HEALTH_PORT=3141
 # TEAM_CONTEXT_TELEMETRY=true
+# TEAM_CONTEXT_STORE_PATH=/data/content-store
+# TEAM_CONTEXT_SIGNALS_DIR=/data/signals
+# TEAM_CONTEXT_CONVERSATIONS_DIR=/data/conversations

package/templates/deploy/docker-compose.yml

@@ -7,52 +7,9 @@ services:
     image: ghcr.io/usewayfind/wayfind:latest
     container_name: wayfind
     restart: unless-stopped
+    env_file: .env
     environment:
       TEAM_CONTEXT_MODE: all-in-one
-      TEAM_CONTEXT_TENANT_ID: ${TEAM_CONTEXT_TENANT_ID:-my-team}
-      TEAM_CONTEXT_AUTHOR: ${TEAM_CONTEXT_AUTHOR:-}
-
-      # Slack
-      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
-      SLACK_APP_TOKEN: ${SLACK_APP_TOKEN}
-      SLACK_DIGEST_CHANNEL: ${SLACK_DIGEST_CHANNEL:-}
-      TEAM_CONTEXT_SLACK_WEBHOOK: ${TEAM_CONTEXT_SLACK_WEBHOOK:-}
-
-      # Team repo allowlist (recommended over EXCLUDE_REPOS)
-      TEAM_CONTEXT_INCLUDE_REPOS: ${TEAM_CONTEXT_INCLUDE_REPOS:-}
-      # DEPRECATED: Blocklist approach — use INCLUDE_REPOS instead
-      TEAM_CONTEXT_EXCLUDE_REPOS: ${TEAM_CONTEXT_EXCLUDE_REPOS:-}
-
-      # Telemetry (opt-in, sends anonymous usage data to improve Wayfind)
-      TEAM_CONTEXT_TELEMETRY: ${TEAM_CONTEXT_TELEMETRY:-false}
-
-      # GitHub signals
-      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
-
-      # Intercom signals
-      INTERCOM_TOKEN: ${INTERCOM_TOKEN:-}
-      TEAM_CONTEXT_INTERCOM_TAGS: ${TEAM_CONTEXT_INTERCOM_TAGS:-}
-
-      # LLM
-      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
-      TEAM_CONTEXT_LLM_MODEL: ${TEAM_CONTEXT_LLM_MODEL:-claude-sonnet-4-5-20250929}
-
-      # Embeddings (for semantic search — falls back to keyword search without these)
-      # Option A: OpenAI
-      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
-      # Option B: Azure OpenAI
-      AZURE_OPENAI_EMBEDDING_ENDPOINT: ${AZURE_OPENAI_EMBEDDING_ENDPOINT:-}
-      AZURE_OPENAI_EMBEDDING_KEY: ${AZURE_OPENAI_EMBEDDING_KEY:-}
-      AZURE_OPENAI_EMBEDDING_DEPLOYMENT: ${AZURE_OPENAI_EMBEDDING_DEPLOYMENT:-text-embedding-3-small}
-
-      # Encryption — generate with: openssl rand -base64 32
-      TEAM_CONTEXT_ENCRYPTION_KEY: ${TEAM_CONTEXT_ENCRYPTION_KEY:-}
-
-      # Scheduling
-      TEAM_CONTEXT_DIGEST_SCHEDULE: ${TEAM_CONTEXT_DIGEST_SCHEDULE:-0 8 * * 1}
-      TEAM_CONTEXT_SIGNAL_SCHEDULE: ${TEAM_CONTEXT_SIGNAL_SCHEDULE:-0 6 * * *}
-
-      # Team context repo (mounted at /data/team-context for git pull)
       TEAM_CONTEXT_TEAM_CONTEXT_DIR: /data/team-context
       TEAM_CONTEXT_JOURNALS_DIR: /data/team-context/journals
     volumes: