@equilateral_ai/mindmeld 3.5.2 → 3.5.3

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

@@ -771,13 +771,31 @@ 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
       };
       const mindmeldDir = path.join(process.cwd(), '.mindmeld');
       await fs.mkdir(mindmeldDir, { recursive: true });
@@ -789,6 +807,41 @@ async function injectContext() {
       console.error('[MindMeld] Could not persist session context (non-fatal):', err.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
+      }
+
+      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}`);
+    }
+
     // 4. Detect project characteristics locally (file system only, no DB)
     const characteristics = await mindmeld.relevanceDetector.detectProjectCharacteristics();
 

package/hooks/session-watcher.js

@@ -0,0 +1,585 @@
+#!/usr/bin/env node
+/**
+ * MindMeld - Background Pattern Watcher
+ *
+ * Long-lived background process that monitors the JSONL session transcript
+ * and harvests patterns on resolution detection rather than a dumb timer.
+ *
+ * With 1M context windows, pre-compact may never fire. This watcher ensures
+ * patterns are harvested continuously throughout long sessions.
+ *
+ * Lifecycle:
+ *   1. SessionStart spawns watcher (or watcher detects breadcrumb update)
+ *   2. Polls transcript every 10s, buffers new content
+ *   3. Detects resolution signals (test runs, completions, task done)
+ *   4. Extracts patterns after 60s cooldown post-resolution
+ *   5. Survives /clear via breadcrumb transcript switch
+ *   6. Stops on: parent death, stop file, or 2h idle
+ *
+ * Args:
+ *   argv[2] - project cwd
+ *   argv[3] - parent PID (terminal process to monitor)
+ *
+ * @equilateral_ai/mindmeld v3.5.3
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const os = require('os');
+
+process.title = 'mindmeld-watcher';
+
+// Import harvest pipeline from pre-compact
+let harvestPatterns = null;
+try {
+  const preCompact = require('./pre-compact');
+  harvestPatterns = preCompact.harvestPatterns;
+} catch (error) {
+  console.error(`[MindMeld:Watcher] Cannot load pre-compact module: ${error.message}`);
+  process.exit(0);
+}
+
+const PROJECT_CWD = process.argv[2];
+const PARENT_PID = parseInt(process.argv[3], 10);
+
+if (!PROJECT_CWD) {
+  console.error('[MindMeld:Watcher] No project cwd provided');
+  process.exit(0);
+}
+
+// ── Timing constants ──────────────────────────────────────────────────────────
+const POLL_MS = 10 * 1000;                // 10s transcript poll
+const COOLDOWN_MS = 60 * 1000;            // 60s after resolution before extracting
+const IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000; // 2h no transcript activity → exit
+const PARENT_CHECK_MS = 10 * 1000;        // 10s parent liveness check
+const FALLBACK_HARVEST_MS = 5 * 60 * 1000; // 5 min safety net if no resolution detected
+const MIN_BUFFER_CHARS = 500;             // skip trivial buffers
+const MAX_DELTA_BYTES = 200 * 1024;       // 200KB cap per read
+const STARTUP_RETRY_MS = 10 * 1000;
+const STARTUP_MAX_RETRIES = 12;
+
+// ── Resolution signal patterns ────────────────────────────────────────────────
+// Bash tool calls that indicate work completion
+const RESOLUTION_COMMANDS = [
+  /npm\s+test/,
+  /npm\s+run\s+test/,
+  /jest/,
+  /pytest/,
+  /ruff\s+check/,
+  /eslint/,
+  /tsc\s+--noEmit/,
+  /go\s+test/,
+  /cargo\s+test/,
+  /make\s+test/,
+  /sam\s+build/,
+  /sam\s+deploy/,
+  /npm\s+run\s+build/,
+  /npm\s+run\s+deploy/,
+];
+
+// Completion phrases in assistant messages
+const COMPLETION_PHRASES = [
+  /all\s+(?:tests?\s+)?pass/i,
+  /successfully\s+(?:deployed|built|completed|created|updated)/i,
+  /changes?\s+(?:look|are)\s+good/i,
+  /(?:done|finished|completed)[.!]\s*$/im,
+  /ready\s+(?:to\s+)?(?:commit|deploy|merge|push|review)/i,
+  /implementation\s+is\s+(?:complete|done|ready)/i,
+  /that\s+(?:should\s+)?fix/i,
+];
+
+// ── State ─────────────────────────────────────────────────────────────────────
+let byteOffset = 0;
+let jsonlPath = null;
+let sessionId = null;
+let buffer = '';                           // accumulated unparsed transcript text
+let pollHandle = null;
+let parentCheckHandle = null;
+let cooldownTimer = null;
+let lastHarvestTime = Date.now();
+let lastActivityTime = Date.now();
+let resolutionDetected = false;
+
+// ── Breadcrumb ────────────────────────────────────────────────────────────────
+
+/**
+ * Path to the breadcrumb file written by session-start.
+ * Contains session_id and transcript_path, updated on /clear.
+ */
+function breadcrumbPath() {
+  return path.join(PROJECT_CWD, '.mindmeld', 'current-session.json');
+}
+
+/**
+ * Read the breadcrumb to get current session info and transcript path.
+ */
+async function readBreadcrumb() {
+  try {
+    const content = await fs.readFile(breadcrumbPath(), 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    return null;
+  }
+}
+
+// ── Transcript discovery ──────────────────────────────────────────────────────
+
+function encodeProjectDir(cwd) {
+  return cwd.replace(/\//g, '-');
+}
+
+/**
+ * Find the active JSONL session file.
+ * Priority: breadcrumb transcript_path → most recently modified .jsonl
+ */
+async function findSessionFile() {
+  // Check breadcrumb first
+  const crumb = await readBreadcrumb();
+  if (crumb?.transcriptPath) {
+    try {
+      await fs.access(crumb.transcriptPath);
+      sessionId = crumb.sessionId || sessionId;
+      return crumb.transcriptPath;
+    } catch (err) {
+      // Breadcrumb points to missing file, fall through
+    }
+  }
+
+  if (crumb?.sessionId) {
+    sessionId = crumb.sessionId;
+  }
+
+  // Fall back to most recently modified JSONL
+  const projectDir = path.join(os.homedir(), '.claude', 'projects', encodeProjectDir(PROJECT_CWD));
+  let files;
+  try {
+    files = await fs.readdir(projectDir);
+  } catch (err) {
+    return null;
+  }
+
+  const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+  if (jsonlFiles.length === 0) return null;
+
+  let newest = null;
+  let newestMtime = 0;
+  for (const file of jsonlFiles) {
+    const fullPath = path.join(projectDir, file);
+    try {
+      const stat = await fs.stat(fullPath);
+      if (stat.mtimeMs > newestMtime) {
+        newestMtime = stat.mtimeMs;
+        newest = fullPath;
+      }
+    } catch (err) {
+      // Skip
+    }
+  }
+
+  return newest;
+}
+
+// ── JSONL parsing ─────────────────────────────────────────────────────────────
+
+/**
+ * Parse JSONL entries from raw text. Returns array of parsed entry objects
+ * for resolution detection, plus accumulated transcript text.
+ */
+function parseJsonlEntries(rawText) {
+  const lines = rawText.split('\n').filter(l => l.trim());
+  const entries = [];
+  const textParts = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      entries.push(entry);
+
+      const content = entry.message?.content || entry.content;
+      if (!content) continue;
+
+      if (typeof content === 'string') {
+        textParts.push(content);
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text' && block.text) {
+            textParts.push(block.text);
+          }
+          // Also capture tool_use for resolution detection
+          if (block.type === 'tool_use' && block.input) {
+            const input = typeof block.input === 'string' ? block.input : JSON.stringify(block.input);
+            textParts.push(input);
+          }
+        }
+      }
+    } catch (e) {
+      // Skip partial lines
+    }
+  }
+
+  return { entries, transcript: textParts.join('\n\n') };
+}
+
+// ── Delta reading ─────────────────────────────────────────────────────────────
+
+async function readDelta() {
+  if (!jsonlPath) return null;
+
+  let stat;
+  try {
+    stat = await fs.stat(jsonlPath);
+  } catch (err) {
+    return null;
+  }
+
+  if (stat.size <= byteOffset) return null;
+  lastActivityTime = Date.now();
+
+  const readSize = Math.min(stat.size - byteOffset, MAX_DELTA_BYTES);
+  const buf = Buffer.alloc(readSize);
+
+  const fh = await fs.open(jsonlPath, 'r');
+  try {
+    await fh.read(buf, 0, readSize, byteOffset);
+  } finally {
+    await fh.close();
+  }
+
+  const raw = buf.toString('utf-8');
+
+  // Skip partial first line if mid-file
+  let usable = raw;
+  if (byteOffset > 0) {
+    const firstNewline = raw.indexOf('\n');
+    if (firstNewline > 0) {
+      usable = raw.substring(firstNewline + 1);
+    }
+  }
+
+  // Advance to end of last complete line
+  const lastNewline = raw.lastIndexOf('\n');
+  if (lastNewline >= 0) {
+    byteOffset += lastNewline + 1;
+  } else {
+    return null;
+  }
+
+  return usable;
+}
+
+// ── Resolution detection ──────────────────────────────────────────────────────
+
+/**
+ * Scan entries for signals that the agent just finished a unit of work.
+ */
+function detectResolution(entries, transcriptText) {
+  // Check for resolution command patterns in tool calls
+  for (const entry of entries) {
+    const content = entry.message?.content || entry.content;
+    if (!Array.isArray(content)) continue;
+
+    for (const block of content) {
+      if (block.type === 'tool_use' && block.name === 'Bash') {
+        const cmd = block.input?.command || '';
+        for (const pattern of RESOLUTION_COMMANDS) {
+          if (pattern.test(cmd)) {
+            return { type: 'command', signal: cmd.substring(0, 80) };
+          }
+        }
+      }
+      // TaskUpdate with status "completed"
+      if (block.type === 'tool_use' && block.name === 'TaskUpdate') {
+        const status = block.input?.status;
+        if (status === 'completed') {
+          return { type: 'task_complete', signal: block.input?.id || 'unknown' };
+        }
+      }
+    }
+  }
+
+  // Check for completion phrases in recent text
+  for (const phrase of COMPLETION_PHRASES) {
+    if (phrase.test(transcriptText)) {
+      return { type: 'phrase', signal: transcriptText.match(phrase)?.[0] || '' };
+    }
+  }
+
+  return null;
+}
+
+// ── Harvest ───────────────────────────────────────────────────────────────────
+
+async function extract() {
+  if (!buffer || buffer.length < MIN_BUFFER_CHARS) {
+    buffer = '';
+    resolutionDetected = false;
+    return;
+  }
+
+  const harvestText = buffer.length > MAX_DELTA_BYTES
+    ? buffer.substring(buffer.length - MAX_DELTA_BYTES)
+    : buffer;
+
+  console.error(`[MindMeld:Watcher] Extracting patterns (${harvestText.length} chars)`);
+
+  try {
+    const result = await harvestPatterns({
+      sessionId: sessionId || 'unknown',
+      transcript: harvestText,
+      source: 'watcher'
+    });
+
+    if (result && !result.skipped) {
+      console.error(`[MindMeld:Watcher] Harvest: ${result.patternsDetected || 0} patterns, ${result.violations || 0} violations, ${result.reinforced || 0} reinforced`);
+    }
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Harvest error (non-fatal): ${err.message}`);
+  }
+
+  buffer = '';
+  resolutionDetected = false;
+  lastHarvestTime = Date.now();
+}
+
+// ── Transcript switch (clear detection) ───────────────────────────────────────
+
+/**
+ * Check if the breadcrumb has been updated with a new transcript path.
+ * This happens when session-start fires again after /clear.
+ */
+async function checkTranscriptSwitch() {
+  const crumb = await readBreadcrumb();
+  if (!crumb?.transcriptPath) return false;
+
+  // No current path yet — initial setup, not a switch
+  if (!jsonlPath) return false;
+
+  // Normalize for comparison
+  const currentBasename = path.basename(jsonlPath);
+  const crumbBasename = path.basename(crumb.transcriptPath);
+
+  if (currentBasename !== crumbBasename) {
+    console.error(`[MindMeld:Watcher] Transcript switch detected: ${currentBasename} → ${crumbBasename}`);
+
+    // Flush remaining buffer from old transcript
+    if (buffer.length >= MIN_BUFFER_CHARS) {
+      console.error('[MindMeld:Watcher] Flushing buffer from previous transcript');
+      await extract();
+    }
+
+    // Reset state for new transcript
+    try {
+      await fs.access(crumb.transcriptPath);
+      jsonlPath = crumb.transcriptPath;
+      sessionId = crumb.sessionId || sessionId;
+      byteOffset = 0; // Read from start of new transcript
+      buffer = '';
+      resolutionDetected = false;
+
+      // Set offset to current size if we don't want pre-existing content
+      const stat = await fs.stat(jsonlPath);
+      byteOffset = stat.size;
+
+      console.error(`[MindMeld:Watcher] Now watching: ${path.basename(jsonlPath)}`);
+      return true;
+    } catch (err) {
+      console.error(`[MindMeld:Watcher] New transcript not accessible: ${err.message}`);
+      return false;
+    }
+  }
+
+  return false;
+}
+
+// ── Parent process liveness ───────────────────────────────────────────────────
+
+function isParentAlive() {
+  if (!PARENT_PID || isNaN(PARENT_PID)) return true; // Can't check, assume alive
+  try {
+    process.kill(PARENT_PID, 0); // Signal 0 = existence check
+    return true;
+  } catch (err) {
+    return false; // ESRCH = process gone
+  }
+}
+
+// ── Stop file detection ───────────────────────────────────────────────────────
+
+function stopFilePath() {
+  return path.join(PROJECT_CWD, '.mindmeld', 'watcher.stop');
+}
+
+async function checkStopFile() {
+  try {
+    await fs.access(stopFilePath());
+    await fs.unlink(stopFilePath()).catch(() => {});
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// ── PID file ──────────────────────────────────────────────────────────────────
+
+async function writePidFile() {
+  try {
+    const pidPath = path.join(PROJECT_CWD, '.mindmeld', 'watcher.pid');
+    await fs.writeFile(pidPath, String(process.pid));
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Could not write PID file: ${err.message}`);
+  }
+}
+
+// ── Poll tick ─────────────────────────────────────────────────────────────────
+
+async function poll() {
+  try {
+    // Check for transcript switch (breadcrumb updated by session-start after /clear)
+    await checkTranscriptSwitch();
+
+    // Read new lines from transcript
+    const delta = await readDelta();
+    if (delta) {
+      const { entries, transcript } = parseJsonlEntries(delta);
+      if (transcript) {
+        buffer += transcript + '\n\n';
+      }
+
+      // Check for resolution signals in new entries
+      if (!resolutionDetected) {
+        const resolution = detectResolution(entries, transcript);
+        if (resolution) {
+          resolutionDetected = true;
+          console.error(`[MindMeld:Watcher] Resolution detected (${resolution.type}): ${resolution.signal}`);
+
+          // Start cooldown — extract after 60s
+          if (cooldownTimer) clearTimeout(cooldownTimer);
+          cooldownTimer = setTimeout(() => {
+            cooldownTimer = null;
+            extract();
+          }, COOLDOWN_MS);
+        }
+      }
+    }
+
+    // Fallback: if no resolution detected but buffer is accumulating, harvest on timer
+    if (!resolutionDetected && !cooldownTimer && buffer.length >= MIN_BUFFER_CHARS) {
+      const sinceLastHarvest = Date.now() - lastHarvestTime;
+      if (sinceLastHarvest >= FALLBACK_HARVEST_MS) {
+        console.error('[MindMeld:Watcher] Fallback harvest (no resolution signal)');
+        await extract();
+      }
+    }
+  } catch (err) {
+    console.error(`[MindMeld:Watcher] Poll error (non-fatal): ${err.message}`);
+  }
+}
+
+/**
+ * Parent liveness + idle + stop file checks.
+ */
+async function livenessCheck() {
+  // Parent process died (terminal closed)
+  if (!isParentAlive()) {
+    console.error('[MindMeld:Watcher] Parent process gone, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+
+  // Stop file written by session-end
+  if (await checkStopFile()) {
+    console.error('[MindMeld:Watcher] Stop file detected, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+
+  // Idle timeout
+  if (Date.now() - lastActivityTime > IDLE_TIMEOUT_MS) {
+    console.error('[MindMeld:Watcher] Idle for 2h, extracting and exiting');
+    await extract();
+    cleanup();
+    return;
+  }
+}
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+
+function cleanup() {
+  if (pollHandle) {
+    clearInterval(pollHandle);
+    pollHandle = null;
+  }
+  if (parentCheckHandle) {
+    clearInterval(parentCheckHandle);
+    parentCheckHandle = null;
+  }
+  if (cooldownTimer) {
+    clearTimeout(cooldownTimer);
+    cooldownTimer = null;
+  }
+
+  // Remove PID file
+  try {
+    fsSync.unlinkSync(path.join(PROJECT_CWD, '.mindmeld', 'watcher.pid'));
+  } catch (err) {
+    // Already gone
+  }
+
+  process.exit(0);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.error(`[MindMeld:Watcher] Starting for ${path.basename(PROJECT_CWD)} (parent PID: ${PARENT_PID || 'unknown'})`);
+
+  await writePidFile();
+
+  // Find the JSONL file, retrying if it doesn't exist yet
+  for (let attempt = 0; attempt < STARTUP_MAX_RETRIES; attempt++) {
+    jsonlPath = await findSessionFile();
+    if (jsonlPath) break;
+    await new Promise(r => setTimeout(r, STARTUP_RETRY_MS));
+  }
+
+  if (!jsonlPath) {
+    console.error('[MindMeld:Watcher] Could not find session JSONL file after retries, exiting');
+    cleanup();
+    return;
+  }
+
+  // Read session ID from breadcrumb if not set
+  if (!sessionId) {
+    const crumb = await readBreadcrumb();
+    sessionId = crumb?.sessionId || 'unknown';
+  }
+
+  console.error(`[MindMeld:Watcher] Watching: ${path.basename(jsonlPath)} (session: ${sessionId})`);
+
+  // Start offset at current file size — only capture new activity
+  try {
+    const stat = await fs.stat(jsonlPath);
+    byteOffset = stat.size;
+  } catch (err) {
+    byteOffset = 0;
+  }
+
+  // Start polling
+  pollHandle = setInterval(poll, POLL_MS);
+  parentCheckHandle = setInterval(livenessCheck, PARENT_CHECK_MS);
+}
+
+process.on('SIGTERM', async () => {
+  console.error('[MindMeld:Watcher] SIGTERM received, extracting and exiting');
+  await extract();
+  cleanup();
+});
+process.on('SIGINT', cleanup);
+
+main().catch(err => {
+  console.error(`[MindMeld:Watcher] Fatal: ${err.message}`);
+  cleanup();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equilateral_ai/mindmeld",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "description": "Intelligent standards injection for AI coding sessions - context-aware, self-documenting, scales to large codebases",
   "main": "src/index.js",
   "bin": {
@@ -15,6 +15,7 @@
     "scripts/harvest.js",
     "scripts/repo-analyzer.js",
     "scripts/mcp-bridge.js",
+    "scripts/standards.js",
     "README.md"
   ],
   "publishConfig": {
@@ -80,13 +81,12 @@
   "homepage": "https://mindmeld.dev",
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.460.0",
-    "@aws-sdk/client-ssm": "^3.985.0",
+    "@aws-sdk/client-ses": "^3.985.0",
     "js-yaml": "^4.1.1",
     "pg": "^8.18.0"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.460.0",
-    "@aws-sdk/client-ses": "^3.985.0",
     "jest": "^29.7.0"
   },
   "engines": {

package/scripts/standards.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+/**
+ * MindMeld CLI - Standards Management
+ *
+ * Usage:
+ *   mindmeld standards              # Open standards picker in browser
+ *   mindmeld standards --show       # Show current preferences
+ *   mindmeld standards --sync       # Sync preferences from server
+ *   mindmeld standards --reset      # Reset to defaults
+ *
+ * @equilateral_ai/mindmeld v3.2.0
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const { AuthManager } = require('../src/core/AuthManager');
+
+const authManager = new AuthManager();
+const API_BASE = process.env.MINDMELD_API_URL || 'https://api.mindmeld.dev';
+
+/**
+ * Load local MindMeld config
+ */
+async function loadConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+      console.error('Unexpected error loading config:', error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Load authentication tokens
+ */
+async function loadAuth() {
+  try {
+    const authPath = path.join(process.env.HOME, '.mindmeld', 'auth.json');
+    const content = await fs.readFile(authPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+      console.error('Unexpected error loading auth:', error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Load local preferences
+ */
+async function loadPreferences() {
+  try {
+    const prefsPath = path.join(process.cwd(), '.mindmeld', 'preferences.json');
+    const content = await fs.readFile(prefsPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+      console.error('Unexpected error loading preferences:', error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Save local preferences
+ */
+async function savePreferences(preferences) {
+  const prefsPath = path.join(process.cwd(), '.mindmeld', 'preferences.json');
+  await fs.mkdir(path.dirname(prefsPath), { recursive: true });
+  await fs.writeFile(prefsPath, JSON.stringify(preferences, null, 2));
+}
+
+/**
+ * Fetch project standards from API
+ */
+async function fetchProjectStandards(projectId, idToken) {
+  const response = await fetch(`${API_BASE}/api/projects/standards?project_id=${encodeURIComponent(projectId)}`, {
+    headers: {
+      'Authorization': `Bearer ${idToken}`,
+      'Content-Type': 'application/json'
+    }
+  });
+
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Show current preferences
+ */
+async function showPreferences() {
+  const prefs = await loadPreferences();
+
+  if (!prefs) {
+    console.log('\nNo local preferences set. Using defaults (all standards enabled).\n');
+    console.log('Run `mindmeld standards` to configure.\n');
+    return;
+  }
+
+  console.log('\n📋 Current Standards Preferences\n');
+
+  const enabledCats = prefs.enabled_categories || {};
+  const overrides = prefs.standard_overrides || {};
+
+  console.log('Categories:');
+  for (const [cat, enabled] of Object.entries(enabledCats)) {
+    const icon = enabled ? '✅' : '❌';
+    console.log(`  ${icon} ${cat}`);
+  }
+
+  if (Object.keys(overrides).length > 0) {
+    console.log('\nIndividual Overrides:');
+    for (const [standard, enabled] of Object.entries(overrides)) {
+      const icon = enabled ? '✅' : '❌';
+      console.log(`  ${icon} ${standard}`);
+    }
+  }
+
+  if (prefs.synced_at) {
+    console.log(`\nLast synced: ${new Date(prefs.synced_at).toLocaleString()}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * Sync preferences from server
+ */
+async function syncPreferences() {
+  const config = await loadConfig();
+  const auth = await loadAuth();
+
+  if (!config) {
+    console.error('\n❌ Not a MindMeld project. Run `mindmeld init` first.\n');
+    process.exit(1);
+  }
+
+  if (!auth || !auth.id_token) {
+    console.error('\n❌ Not authenticated. Run `mindmeld login` first.\n');
+    process.exit(1);
+  }
+
+  console.log('\n🔄 Syncing preferences from server...\n');
+
+  try {
+    const result = await fetchProjectStandards(config.projectId, auth.id_token);
+
+    if (result.success && result.data) {
+      const prefs = {
+        enabled_categories: result.data.preferences?.enabled_categories || {},
+        standard_overrides: result.data.preferences?.standard_overrides || {},
+        critical_overrides: result.data.preferences?.critical_overrides || {},
+        catalog_version: result.data.catalog_version,
+        synced_at: new Date().toISOString()
+      };
+
+      await savePreferences(prefs);
+
+      console.log('✅ Preferences synced successfully!\n');
+      await showPreferences();
+    } else {
+      console.log('ℹ️  No custom preferences set. Using defaults.\n');
+    }
+  } catch (error) {
+    console.error('❌ Failed to sync:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Reset preferences to defaults
+ */
+async function resetPreferences() {
+  try {
+    const prefsPath = path.join(process.cwd(), '.mindmeld', 'preferences.json');
+    await fs.unlink(prefsPath);
+    console.log('\n✅ Preferences reset to defaults (all standards enabled).\n');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('\nℹ️  No preferences file to reset.\n');
+    } else {
+      console.error('Unexpected error resetting preferences:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Open standards picker in browser
+ */
+async function openStandardsPicker() {
+  const config = await loadConfig();
+  const auth = await loadAuth();
+
+  if (!config) {
+    console.error('\n❌ Not a MindMeld project. Run `mindmeld init` first.\n');
+    process.exit(1);
+  }
+
+  if (!auth) {
+    console.error('\n❌ Not authenticated. Run `mindmeld login` first.\n');
+    process.exit(1);
+  }
+
+  const projectId = config.projectId;
+  const baseUrl = authManager.getAppBaseUrl();
+  const url = `${baseUrl}/projects/${projectId}/standards`;
+
+  console.log('\n🌐 Opening standards picker in browser...\n');
+  console.log(`   ${url}\n`);
+
+  const opened = await authManager.openBrowser(url);
+  if (!opened) {
+    console.log('Could not open browser automatically.');
+    console.log(`Please visit: ${url}\n`);
+  }
+
+  console.log('After saving preferences in the browser, run:');
+  console.log('   mindmeld standards --sync\n');
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+MindMeld Standards - Configure which standards apply to this project
+
+Usage:
+  mindmeld standards              Open standards picker in browser
+  mindmeld standards --show       Show current preferences
+  mindmeld standards --sync       Sync preferences from server
+  mindmeld standards --reset      Reset to defaults (all enabled)
+  mindmeld standards --help       Show this help
+
+Examples:
+  mindmeld standards              # Configure in browser
+  mindmeld standards --show       # See what's enabled/disabled
+`);
+}
+
+/**
+ * Main
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--show')) {
+    await showPreferences();
+    process.exit(0);
+  }
+
+  if (args.includes('--sync')) {
+    await syncPreferences();
+    process.exit(0);
+  }
+
+  if (args.includes('--reset')) {
+    await resetPreferences();
+    process.exit(0);
+  }
+
+  // Default: open browser
+  await openStandardsPicker();
+}
+
+main().catch(error => {
+  console.error('\n❌ Error:', error.message);
+  process.exit(1);
+});
+
+module.exports = { showHelp };