@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/hooks/session-end.js

@@ -291,6 +291,31 @@ async function recordSessionEnd() {
       return { skipped: true, reason: 'No session_id' };
     }
 
+    // Stop session watcher — write stop file (primary) + SIGTERM (secondary)
+    try {
+      // Write stop file — watcher checks this on its liveness interval
+      await fs.writeFile(path.join(cwd, '.mindmeld', 'watcher.stop'), '').catch(() => {});
+
+      const pidPath = path.join(cwd, '.mindmeld', 'watcher.pid');
+      const pidContent = await fs.readFile(pidPath, 'utf-8');
+      const watcherPid = parseInt(pidContent.trim(), 10);
+      if (watcherPid && !isNaN(watcherPid)) {
+        try {
+          process.kill(watcherPid, 'SIGTERM');
+          console.error(`[MindMeld] Stopped session watcher (PID: ${watcherPid})`);
+        } catch (killErr) {
+          if (killErr.code !== 'ESRCH') {
+            console.error(`[MindMeld] Watcher kill failed: ${killErr.message}`);
+          }
+        }
+      }
+      await fs.unlink(pidPath).catch(() => {});
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error(`[MindMeld] Watcher cleanup error (non-fatal): ${err.message}`);
+      }
+    }
+
     // Load auth and config in parallel
     const [authToken, apiConfig, projectId, duration, gitBranch] = await Promise.all([
       loadAuthToken(),

package/hooks/session-start.js

@@ -101,6 +101,80 @@ async function detectGitRemote() {
   }
 }
 
+/**
+ * Detect git HEAD SHA and branch for project identity (Spec §6.5)
+ * @returns {Promise<{commitSha: string|null, gitBranch: string|null}>}
+ */
+async function detectGitMetadata() {
+  const { execSync } = require('child_process');
+  const opts = { cwd: process.cwd(), encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] };
+  let commitSha = null;
+  let gitBranch = null;
+  try {
+    commitSha = execSync('git rev-parse HEAD', opts).trim() || null;
+  } catch (_) { /* not a git repo */ }
+  try {
+    gitBranch = execSync('git branch --show-current', opts).trim() || null;
+  } catch (_) { /* detached HEAD or not a git repo */ }
+  return { commitSha, gitBranch };
+}
+
+/**
+ * Read Claude Code memory files for drift detection (Spec §5.2)
+ * Reads MEMORY.md index + all referenced .md files from the project memory dir
+ * @returns {Promise<string|null>} Concatenated memory content or null
+ */
+async function readClaudeMemory() {
+  const os = require('os');
+  const encodedCwd = process.cwd().replace(/\//g, '-');
+  const memoryDir = path.join(os.homedir(), '.claude', 'projects', encodedCwd, 'memory');
+
+  try {
+    await fs.access(memoryDir);
+  } catch (_) {
+    return null;
+  }
+
+  try {
+    const files = await fs.readdir(memoryDir);
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+    if (mdFiles.length === 0) return null;
+
+    const contents = [];
+    // Read MEMORY.md first if it exists (it's the index)
+    if (mdFiles.includes('MEMORY.md')) {
+      const content = await fs.readFile(path.join(memoryDir, 'MEMORY.md'), 'utf-8');
+      contents.push(`--- MEMORY.md ---\n${content}`);
+    }
+    for (const file of mdFiles) {
+      if (file === 'MEMORY.md') continue;
+      try {
+        const content = await fs.readFile(path.join(memoryDir, file), 'utf-8');
+        contents.push(`--- ${file} ---\n${content}`);
+      } catch (_) { /* skip unreadable files */ }
+    }
+    return contents.join('\n\n');
+  } catch (err) {
+    console.error('[MindMeld] Memory read failed (non-fatal):', err.message);
+    return null;
+  }
+}
+
+/**
+ * Read CLAUDE.md files for drift detection
+ * Reads project-level CLAUDE.md and any parent CLAUDE.md files
+ * @returns {Promise<string|null>} Concatenated CLAUDE.md content or null
+ */
+async function readClaudeMd() {
+  try {
+    const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+    const content = await fs.readFile(claudeMdPath, 'utf-8');
+    return content || null;
+  } catch (_) {
+    return null;
+  }
+}
+
 /**
  * Get project name from git remote URL or directory name
  * @param {string|null} gitRemote - Git remote URL
@@ -628,6 +702,81 @@ async function fetchRelevantStandardsFromAPI(apiUrl, authToken, characteristics,
   });
 }
 
+/**
+ * Call mindmeld_init_session via JSON-RPC to get banded injection (Band A/B/C).
+ * This converges the hook injection path with the MCP tool path — one deterministic
+ * banded output regardless of whether the MCP tool also fires during the session.
+ */
+async function callBandedInitSession(apiUrl, authToken, params) {
+  if (!authToken) {
+    throw new Error('No auth token available');
+  }
+
+  const https = require('https');
+  const url = require('url');
+
+  const jsonRpcPayload = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'tools/call',
+    params: {
+      name: 'mindmeld_init_session',
+      arguments: params
+    }
+  });
+
+  const parsedUrl = url.parse(`${apiUrl}/api/mcp/mindmeld`);
+
+  const options = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || 443,
+    path: parsedUrl.path,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${authToken}`,
+      'Content-Length': Buffer.byteLength(jsonRpcPayload)
+    },
+    timeout: 8000
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const rpcResponse = JSON.parse(data);
+          if (rpcResponse.error) {
+            const err = new Error(rpcResponse.error.message || 'JSON-RPC error');
+            err.statusCode = res.statusCode;
+            reject(err);
+            return;
+          }
+          const content = rpcResponse.result?.content;
+          if (!content || !content[0] || content[0].type !== 'text') {
+            reject(new Error('Unexpected init_session response shape'));
+            return;
+          }
+          const initResult = JSON.parse(content[0].text);
+          resolve(initResult);
+        } catch (e) {
+          reject(new Error('Invalid banded init_session response'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Banded init_session timeout'));
+    });
+
+    req.write(jsonRpcPayload);
+    req.end();
+  });
+}
+
 /**
  * Fetch weekly splash data from API
  * Returns splash summary with stats, or null if already acknowledged
@@ -744,11 +893,14 @@ async function injectContext() {
     }
 
     // 1. Parallel local reads (no network, no DB)
-    const [fingerprintConfig, authToken, apiConfig, preferences] = await Promise.all([
+    const [fingerprintConfig, authToken, apiConfig, preferences, gitMetadata, memoryContent, claudeMdContent] = await Promise.all([
       loadFingerprintConfig(),
       loadAuthToken(),
       loadApiConfig(),
-      loadStandardsPreferences()
+      loadStandardsPreferences(),
+      detectGitMetadata(),
+      readClaudeMemory(),
+      readClaudeMd()
     ]);
 
     // 2. Initialize MindmeldClient (used for project detection, session tracking, team context)
@@ -771,13 +923,33 @@ async function injectContext() {
     // 3b. Persist session context for pre-compact hook
     // Pre-compact creates a new MindmeldClient and needs project context
     try {
+      // Derive transcript path for watcher breadcrumb
+      const encodedCwd = process.cwd().replace(/\//g, '-');
+      const claudeProjectDir = path.join(require('os').homedir(), '.claude', 'projects', encodedCwd);
+      let transcriptPath = null;
+      try {
+        const dirFiles = await fs.readdir(claudeProjectDir);
+        const jsonlFiles = dirFiles.filter(f => f.endsWith('.jsonl'));
+        let newestMtime = 0;
+        for (const f of jsonlFiles) {
+          const fp = path.join(claudeProjectDir, f);
+          const s = await fs.stat(fp);
+          if (s.mtimeMs > newestMtime) { newestMtime = s.mtimeMs; transcriptPath = fp; }
+        }
+      } catch (err) {
+        // Claude project dir may not exist yet
+      }
+
       const sessionContext = {
         sessionId: sessionId,
         projectId: context.projectId,
         projectName: context.projectName,
         companyId: context.companyId,
         userEmail: context.userEmail,
-        startedAt: new Date().toISOString()
+        startedAt: new Date().toISOString(),
+        transcriptPath: transcriptPath,
+        commitSha: gitMetadata.commitSha,
+        gitBranch: gitMetadata.gitBranch,
       };
       const mindmeldDir = path.join(process.cwd(), '.mindmeld');
       await fs.mkdir(mindmeldDir, { recursive: true });
@@ -789,89 +961,101 @@ async function injectContext() {
       console.error('[MindMeld] Could not persist session context (non-fatal):', err.message);
     }
 
-    // 4. Detect project characteristics locally (file system only, no DB)
-    const characteristics = await mindmeld.relevanceDetector.detectProjectCharacteristics();
-
-    // 5. Parallel API calls: standards + team context + splash
-    const [standardsResult, projectContextResult, splashResult] = await Promise.allSettled([
-      fetchRelevantStandardsFromAPI(apiConfig.apiUrl, authToken, characteristics, context.projectId, preferences),
-      mindmeld.loadProjectContext(context.projectId),
-      fetchSplashData(apiConfig.apiUrl, authToken)
-    ]);
-
-    // 6. Resolve standards: API → file-based fallback (only for network errors, not subscription blocks)
-    let relevantStandards = [];
-    if (standardsResult.status === 'fulfilled' && standardsResult.value.length > 0) {
-      relevantStandards = standardsResult.value;
-      console.error(`[MindMeld] ${relevantStandards.length} standards from API`);
-    } else if (standardsResult.status === 'rejected' &&
-               standardsResult.reason.message.includes('subscription required')) {
-      // Subscription enforcement — do NOT fall through to file-based injection
-      console.error('[MindMeld] Active subscription required. Subscribe at app.mindmeld.dev');
-      return '';
-    } else if (standardsResult.status === 'rejected' &&
-               (standardsResult.reason.statusCode === 401 || standardsResult.reason.message === 'Unauthorized')) {
-      // Auth token expired or invalid — trigger re-auth and use file-based fallback
-      console.error('[MindMeld] Auth token expired. Triggering re-authentication...');
-      spawnBackgroundLogin();
-      const categories = mindmeld.relevanceDetector.mapCharacteristicsToCategories(characteristics);
-      relevantStandards = await mindmeld.relevanceDetector.loadStandardsFromFiles(categories, characteristics);
-      console.error(`[MindMeld] ${relevantStandards.length} standards from file fallback (scored)`);
-    } else {
-      if (standardsResult.status === 'rejected') {
-        console.error(`[MindMeld] API fallback: ${standardsResult.reason.message}`);
+    // 3c. Spawn background session watcher for continuous pattern harvesting
+    // (covers 1M context sessions where pre-compact may never fire)
+    // Watcher survives /clear — if already alive, it picks up the new transcript via breadcrumb
+    try {
+      const pidPath = path.join(process.cwd(), '.mindmeld', 'watcher.pid');
+      let watcherAlive = false;
+      try {
+        const existingPid = parseInt(await fs.readFile(pidPath, 'utf-8'), 10);
+        if (existingPid && !isNaN(existingPid)) {
+          process.kill(existingPid, 0); // Check if alive
+          watcherAlive = true;
+          console.error(`[MindMeld] Existing watcher alive (PID: ${existingPid}), will pick up new transcript via breadcrumb`);
+        }
+      } catch (err) {
+        // No PID file or process gone — spawn a new one
       }
-      const categories = mindmeld.relevanceDetector.mapCharacteristicsToCategories(characteristics);
-      relevantStandards = await mindmeld.relevanceDetector.loadStandardsFromFiles(categories, characteristics);
-      console.error(`[MindMeld] ${relevantStandards.length} standards from file fallback (scored)`);
-    }
 
-    // 7. Filter by project preferences
-    if (preferences) {
-      relevantStandards = filterStandardsByPreferences(relevantStandards, preferences);
-      console.error(`[MindMeld] Filtered to ${relevantStandards.length} standards by preferences`);
+      if (!watcherAlive) {
+        const { spawn } = require('child_process');
+        const watcherScript = path.resolve(__dirname, 'session-watcher.js');
+        await fs.access(watcherScript);
+        const parentPid = process.ppid || process.pid;
+        const watcher = spawn(process.execPath, [watcherScript, process.cwd(), String(parentPid)], {
+          detached: true,
+          stdio: ['ignore', 'ignore', 'ignore'],
+          cwd: process.cwd(),
+          env: { ...process.env }
+        });
+        watcher.unref();
+        console.error(`[MindMeld] Session watcher spawned (PID: ${watcher.pid})`);
+      }
+    } catch (err) {
+      console.error(`[MindMeld] Watcher spawn failed (non-fatal): ${err.message}`);
     }
 
-    // Take top 10 most relevant after filtering
-    relevantStandards = relevantStandards.slice(0, 10);
-
-    // 8. Record standards shown (fire-and-forget, non-blocking)
-    mindmeld.recordStandardsShown(sessionId, relevantStandards, context.projectId, context.userEmail);
+    // 4. Banded injection path (converged with MCP init_session)
+    // Band B content gated on resolved companyId — null scope would mis-match snapshots
+    const bandBGated = !!context.companyId;
+    const initParams = {
+      project_path: process.cwd(),
+      commit_sha: gitMetadata.commitSha || undefined,
+      git_branch: gitMetadata.gitBranch || undefined,
+      git_root: gitMetadata.gitRoot || undefined,
+      memory_content: bandBGated ? (memoryContent || undefined) : undefined,
+      claude_md_content: bandBGated ? (claudeMdContent || undefined) : undefined
+    };
 
-    // 9. Resolve team context from parallel API call
-    const projectContext = projectContextResult.status === 'fulfilled' ? projectContextResult.value : null;
-    const teamPatterns = projectContext && projectContext.patterns
-      ? projectContext.patterns.filter(p => p.confidence > 0.7)
-      : [];
-    const recentLearning = projectContext && projectContext.recentLearning
-      ? projectContext.recentLearning
-      : [];
+    const [bandedResult, splashResult] = await Promise.allSettled([
+      callBandedInitSession(apiConfig.apiUrl, authToken, initParams),
+      fetchSplashData(apiConfig.apiUrl, authToken)
+    ]);
 
-    // 10. Resolve splash data
     const splashData = splashResult.status === 'fulfilled' ? splashResult.value : null;
-
-    // Auto-acknowledge splash (fire-and-forget) so it doesn't show again this week
-    if (splashData && splashData.show_splash && splashData.summary) {
+    if (splashData?.show_splash && splashData?.summary) {
       acknowledgeSplash(apiConfig.apiUrl, authToken, splashData.summary.week_start);
     }
 
-    // 11. Build context injection with fingerprint
-    const injection = formatContextInjection({
-      project: context.projectName,
-      sessionId: sessionId,
-      collaborators: context.collaborators,
-      relevantStandards: relevantStandards,
-      teamPatterns: teamPatterns,
-      recentLearning: recentLearning,
-      fingerprint: fingerprintConfig,
-      splash: splashData
-    });
+    // 6. Resolve injection: banded → flat fallback
+    let injection;
+    if (bandedResult.status === 'fulfilled' && bandedResult.value.formatted_injection) {
+      const initResponse = bandedResult.value;
+      const summary = initResponse.injection_summary || {};
+      console.error(`[MindMeld] Banded injection: A=${summary.band_a_tokens || 0}t B=${summary.band_b_tokens || 0}t C=${summary.band_c_tokens || 0}t / ${summary.budget_tokens || 400}t budget`);
+
+      injection = formatConvergedInjection({
+        bandedMarkdown: initResponse.formatted_injection,
+        collaborators: context.collaborators,
+        splash: splashData
+      });
 
-    // 12. Cache condensed context for subagent injection
-    try {
-      await cacheSubagentContext(relevantStandards, teamPatterns, context.projectName);
-    } catch (cacheError) {
-      console.error('[MindMeld] Subagent context cache failed (non-fatal):', cacheError.message);
+      try {
+        const standardsForCache = (initResponse.injected_rules || []).map(r => ({
+          pattern_id: r.rule_id, element: r.standard, rule: r.text,
+          maturity: r.maturity, relevance_score: r.relevance_score
+        }));
+        await cacheSubagentContext(standardsForCache, [], context.projectName);
+      } catch (cacheError) {
+        console.error('[MindMeld] Subagent context cache failed (non-fatal):', cacheError.message);
+      }
+    } else {
+      const bandedError = bandedResult.status === 'rejected' ? bandedResult.reason : null;
+      if (bandedError) {
+        if (bandedError.message.includes('subscription required')) {
+          console.error('[MindMeld] Active subscription required. Subscribe at app.mindmeld.dev');
+          return '';
+        }
+        if (bandedError.statusCode === 401 || bandedError.message === 'Unauthorized') {
+          console.error('[MindMeld] Auth token expired. Triggering re-authentication...');
+          spawnBackgroundLogin();
+        }
+        console.error(`[MindMeld] API unavailable: ${bandedError.message}`);
+      } else {
+        console.error('[MindMeld] API returned empty injection');
+      }
+      injection = '<!-- MindMeld: API unavailable — this session is proceeding without governance injection. Standards were not loaded. -->';
     }
 
     const elapsed = Date.now() - startTime;
@@ -880,9 +1064,8 @@ async function injectContext() {
     return injection;
 
   } catch (error) {
-    // Graceful degradation - never block Claude Code session
     console.error('[MindMeld] Hook error (non-fatal):', error.message);
-    return '';
+    return '<!-- MindMeld: hook error — this session is proceeding without governance injection. Standards were not loaded. -->';
   }
 }
 
@@ -903,6 +1086,27 @@ async function checkMindmeldConfiguration() {
   }
 }
 
+/**
+ * Validate that a standard has enough content to be useful when injected.
+ * Mirrors StandardsIngestion.isViableStandard() for the output path.
+ */
+function isViableForInjection(standard) {
+  const el = (standard.element || '').trim();
+  const rl = (standard.rule || '').trim();
+
+  if (!el || !rl) return false;
+  if (/^(USE|ALWAYS|NEVER|PREFER|AVOID|DO|DON'T|SET|ADD|RUN|CALL)$/i.test(el)) return false;
+  if (/^(Standard Pattern|Core Principle)$/i.test(el) && rl.length < 30) return false;
+  if (/^(ALWAYS|NEVER|USE|PREFER|AVOID)[:\s]*$/i.test(rl)) return false;
+  if (rl.length < 15) return false;
+
+  // Word-count guard: element must have >=2 words or be a compound term (>=8 chars)
+  const wordCount = el.split(/[\s.]+/).filter(w => w.length > 0).length;
+  if (wordCount < 2 && el.length < 8) return false;
+
+  return true;
+}
+
 /**
  * Cache condensed context for subagent injection
  * Subagents don't get session-start hooks, so we cache the essentials
@@ -922,25 +1126,55 @@ async function cacheSubagentContext(standards, teamPatterns, projectName) {
   sections.push('Follow these standards when writing or modifying code:');
   sections.push('');
 
-  // Include standards as compact rules (no examples/anti-patterns to save tokens)
+  let injectedCount = 0;
+  let skippedCount = 0;
+
   if (standards && standards.length > 0) {
     for (const s of standards) {
-      sections.push(`- **${s.element}** [${s.category}]: ${s.rule}`);
+      if (!isViableForInjection(s)) {
+        skippedCount++;
+        continue;
+      }
+
+      const maturity = s.maturity_tier || s.maturity || 'validated';
+      const prefix = maturity === 'reinforced' ? '[MUST]' :
+                     maturity === 'enforced' ? '[MUST]' :
+                     maturity === 'solidified' ? '[SHOULD]' : '[CONSIDER]';
+
+      sections.push(`### ${prefix} ${s.element}`);
+      sections.push(`**Category**: ${s.category}`);
+      sections.push(`**Rule**: ${s.rule}`);
+
+      // Include first anti-pattern if available — high signal-to-token ratio
+      if (s.anti_patterns && s.anti_patterns.length > 0) {
+        const ap = s.anti_patterns[0];
+        const desc = typeof ap === 'string' ? ap : (ap.description || '');
+        if (desc) {
+          sections.push(`**Avoid**: ${desc}`);
+        }
+      }
+
+      sections.push('');
+      injectedCount++;
     }
-    sections.push('');
   }
 
-  // Include team patterns as compact rules
+  // Include team patterns with validation
   if (teamPatterns && teamPatterns.length > 0) {
     sections.push('## Team Patterns');
     for (const p of teamPatterns) {
+      if (!isViableForInjection(p)) {
+        skippedCount++;
+        continue;
+      }
       sections.push(`- **${p.element}** (${(p.correlation * 100).toFixed(0)}% correlation): ${p.rule}`);
+      injectedCount++;
     }
     sections.push('');
   }
 
   await fs.writeFile(cachePath, sections.join('\n'));
-  console.error(`[MindMeld] Cached subagent context (${sections.length} lines)`);
+  console.error(`[MindMeld] Cached subagent context (${injectedCount} standards, ${skippedCount} skipped as non-viable)`);
 }
 
 /**
@@ -958,7 +1192,53 @@ function getMaturityPrefix(maturityTier) {
 }
 
 /**
- * Format context injection for Claude Code
+ * Wrap banded init_session output with hook-only sections (splash, team).
+ * The banded markdown is self-contained (header, copyright, bands A/B/C, footer).
+ * Hook-only content is inserted between the copyright block and the first band heading.
+ */
+function formatConvergedInjection({ bandedMarkdown, collaborators, splash }) {
+  const extraSections = [];
+
+  if (splash && splash.show_splash) {
+    if (splash.is_greenfield && splash.tips && splash.tips.length > 0) {
+      extraSections.push('## Getting Started with MindMeld');
+      for (const tip of splash.tips) extraSections.push(`- ${tip}`);
+      extraSections.push('');
+    } else if (splash.summary) {
+      const s = splash.summary;
+      const formatDate = (dateStr) => {
+        const d = new Date(dateStr + 'T00:00:00Z');
+        return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone: 'UTC' });
+      };
+      const hours = Math.floor(s.total_duration_minutes / 60);
+      const mins = s.total_duration_minutes % 60;
+      const duration = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+      extraSections.push(`## Weekly Recap (${formatDate(s.week_start)} - ${formatDate(s.week_end)})`);
+      extraSections.push(`${s.sessions_count} sessions | ${duration} total | ${s.active_projects} project${s.active_projects !== 1 ? 's' : ''}`);
+      extraSections.push(`${s.standards_injected} standards injected, ${s.standards_followed} followed, ${s.violations_detected} violation${s.violations_detected !== 1 ? 's' : ''}`);
+      if (s.patterns_harvested > 0) extraSections.push(`${s.patterns_harvested} patterns harvested`);
+      extraSections.push('');
+    }
+  }
+
+  if (collaborators && collaborators.length > 0) {
+    extraSections.push('## Team');
+    extraSections.push(collaborators.map(c => `- ${c.name} (${c.email})`).join('\n'));
+    extraSections.push('');
+  }
+
+  if (extraSections.length === 0) return bandedMarkdown;
+
+  const firstBandHeading = bandedMarkdown.indexOf('\n## ');
+  if (firstBandHeading === -1) return bandedMarkdown;
+
+  return bandedMarkdown.slice(0, firstBandHeading + 1) +
+    extraSections.join('\n') + '\n' +
+    bandedMarkdown.slice(firstBandHeading + 1);
+}
+
+/**
+ * Format flat context injection for Claude Code (fallback when banded path unavailable)
  * @param {object} data - Context data to inject
  * @param {object} data.fingerprint - Fingerprint config {userId, companyId, tier}
  */