@massu/core 0.1.2 → 0.4.0

package/src/server.ts

@@ -11,10 +11,24 @@
  * Tool names are configurable via massu.config.yaml toolPrefix.
  */
 
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { getCodeGraphDb, getDataDb } from './db.ts';
 import { getConfig } from './config.ts';
 import { getToolDefinitions, handleToolCall } from './tools.ts';
 import { getMemoryDb, pruneOldConversationTurns, pruneOldObservations } from './memory-db.ts';
+import { getCurrentTier } from './license.ts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
+    return pkg.version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
 
 interface JsonRpcRequest {
   jsonrpc: '2.0';
@@ -40,7 +54,7 @@ function getDb() {
   return { codegraphDb, dataDb: dataDb };
 }
 
-function handleRequest(request: JsonRpcRequest): JsonRpcResponse {
+async function handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse> {
   const { method, params, id } = request;
 
   switch (method) {
@@ -54,8 +68,8 @@ function handleRequest(request: JsonRpcRequest): JsonRpcResponse {
             tools: {},
           },
           serverInfo: {
-            name: 'massu',
-            version: '1.0.0',
+            name: getConfig().toolPrefix || 'massu',
+            version: PKG_VERSION,
           },
         },
       };
@@ -80,7 +94,7 @@ function handleRequest(request: JsonRpcRequest): JsonRpcResponse {
       const toolArgs = (params as { arguments?: Record<string, unknown> })?.arguments ?? {};
 
       const { codegraphDb: cgDb, dataDb: lDb } = getDb();
-      const result = handleToolCall(toolName, toolArgs, lDb, cgDb);
+      const result = await handleToolCall(toolName, toolArgs, lDb, cgDb);
 
       return {
         jsonrpc: '2.0',
@@ -133,12 +147,21 @@ function pruneMemoryOnStartup(): void {
 
 pruneMemoryOnStartup();
 
+// === License init: pre-cache tier status ===
+getCurrentTier().then(tier => {
+  process.stderr.write(`massu: License tier: ${tier}\n`);
+}).catch(error => {
+  process.stderr.write(
+    `massu: License check failed (non-fatal): ${error instanceof Error ? error.message : String(error)}\n`
+  );
+});
+
 // === stdio JSON-RPC transport ===
 
 let buffer = '';
 
 process.stdin.setEncoding('utf-8');
-process.stdin.on('data', (chunk: string) => {
+process.stdin.on('data', async (chunk: string) => {
   buffer += chunk;
 
   // Process complete messages (newline-delimited JSON-RPC)
@@ -151,7 +174,7 @@ process.stdin.on('data', (chunk: string) => {
 
     try {
       const request = JSON.parse(line) as JsonRpcRequest;
-      const response = handleRequest(request);
+      const response = await handleRequest(request);
 
       // Don't send responses for notifications (no id)
       if (request.id !== undefined) {

package/src/session-archiver.ts

@@ -5,14 +5,12 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from '
 import { resolve, dirname } from 'path';
 import type Database from 'better-sqlite3';
 import { generateCurrentMd } from './session-state-generator.ts';
-import { getProjectRoot } from './config.ts';
+import { getResolvedPaths } from './config.ts';
 
 // ============================================================
 // P5-002: Session Archiver
 // ============================================================
 
-const PROJECT_ROOT = getProjectRoot();
-
 /**
  * Archive the current CURRENT.md and generate a new one from memory DB.
  */
@@ -21,8 +19,9 @@ export function archiveAndRegenerate(db: Database.Database, sessionId: string):
   archivePath?: string;
   newContent: string;
 } {
-  const currentMdPath = resolve(PROJECT_ROOT, '.claude/session-state/CURRENT.md');
-  const archiveDir = resolve(PROJECT_ROOT, '.claude/session-state/archive');
+  const resolved = getResolvedPaths();
+  const currentMdPath = resolved.sessionStatePath;
+  const archiveDir = resolved.sessionArchivePath;
   let archived = false;
   let archivePath: string | undefined;
 

package/src/tools.ts

@@ -2,7 +2,8 @@
 // Licensed under BSL 1.1 - see LICENSE file for details.
 
 import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
+import { resolve, basename } from 'path';
+import { ensureWithinRoot } from './security-utils.ts';
 import type Database from 'better-sqlite3';
 import { matchRules } from './rules.ts';
 import { buildImportIndex } from './import-resolver.ts';
@@ -11,7 +12,12 @@ import { buildPageDeps, findAffectedPages } from './page-deps.ts';
 import { buildMiddlewareTree, isInMiddlewareTree, getMiddlewareTree } from './middleware-tree.ts';
 import { classifyFile, classifyRouter, findCrossDomainImports, getFilesInDomain } from './domains.ts';
 import { parsePrismaSchema, detectMismatches, findColumnUsageInRouters } from './schema-mapper.ts';
-import { isDataStale, updateBuildTimestamp } from './db.ts';
+import { isDataStale, updateBuildTimestamp, isPythonDataStale, updatePythonBuildTimestamp } from './db.ts';
+import { buildPythonImportIndex } from './python/import-resolver.ts';
+import { buildPythonRouteIndex } from './python/route-indexer.ts';
+import { buildPythonModelIndex } from './python/model-indexer.ts';
+import { buildPythonMigrationIndex } from './python/migration-indexer.ts';
+import { buildPythonCouplingIndex } from './python/coupling-detector.ts';
 import { getMemoryToolDefinitions, handleMemoryToolCall } from './memory-tools.ts';
 import { getMemoryDb } from './memory-db.ts';
 import { getDocsToolDefinitions, handleDocsToolCall } from './docs-tools.ts';
@@ -28,12 +34,17 @@ import { getSecurityToolDefinitions, isSecurityTool, handleSecurityToolCall } fr
 import { getDependencyToolDefinitions, isDependencyTool, handleDependencyToolCall } from './dependency-scorer.ts';
 import { getTeamToolDefinitions, isTeamTool, handleTeamToolCall } from './team-knowledge.ts';
 import { getRegressionToolDefinitions, isRegressionTool, handleRegressionToolCall } from './regression-detector.ts';
-import { getConfig, getProjectRoot } from './config.ts';
+import { getKnowledgeToolDefinitions, isKnowledgeTool, handleKnowledgeToolCall } from './knowledge-tools.ts';
+import { getKnowledgeDb } from './knowledge-db.ts';
+import { getPythonToolDefinitions, isPythonTool, handlePythonToolCall } from './python-tools.ts';
+import { getConfig, getProjectRoot, getResolvedPaths } from './config.ts';
+import { getCurrentTier, getToolTier, isToolAllowed, annotateToolDefinitions, getLicenseToolDefinitions, isLicenseTool, handleLicenseToolCall } from './license.ts';
 
 export interface ToolDefinition {
   name: string;
   description: string;
   inputSchema: Record<string, unknown>;
+  tier?: 'free' | 'pro' | 'team' | 'enterprise';
 }
 
 export interface ToolResult {
@@ -67,31 +78,58 @@ function stripPrefix(name: string): string {
  * Lazy initialization: only rebuilds if stale.
  */
 function ensureIndexes(dataDb: Database.Database, codegraphDb: Database.Database, force: boolean = false): string {
-  if (!force && !isDataStale(dataDb, codegraphDb)) {
-    return 'Indexes are up-to-date.';
-  }
-
   const results: string[] = [];
+  const config = getConfig();
 
-  const importCount = buildImportIndex(dataDb, codegraphDb);
-  results.push(`Import edges: ${importCount}`);
+  // JS indexes
+  if (force || isDataStale(dataDb, codegraphDb)) {
+    const importCount = buildImportIndex(dataDb, codegraphDb);
+    results.push(`Import edges: ${importCount}`);
 
-  const config = getConfig();
+    if (config.framework.router === 'trpc') {
+      const trpcStats = buildTrpcIndex(dataDb);
+      results.push(`tRPC procedures: ${trpcStats.totalProcedures} (${trpcStats.withCallers} with UI, ${trpcStats.withoutCallers} without)`);
+    }
+
+    const pageCount = buildPageDeps(dataDb, codegraphDb);
+    results.push(`Page deps: ${pageCount} pages`);
 
-  if (config.framework.router === 'trpc') {
-    const trpcStats = buildTrpcIndex(dataDb);
-    results.push(`tRPC procedures: ${trpcStats.totalProcedures} (${trpcStats.withCallers} with UI, ${trpcStats.withoutCallers} without)`);
+    if (config.paths.middleware) {
+      const middlewareCount = buildMiddlewareTree(dataDb);
+      results.push(`Middleware tree: ${middlewareCount} files`);
+    }
+
+    updateBuildTimestamp(dataDb);
   }
 
-  const pageCount = buildPageDeps(dataDb, codegraphDb);
-  results.push(`Page deps: ${pageCount} pages`);
+  // Python indexes — independent of JS staleness
+  if (config.python?.root) {
+    const pythonRoot = config.python.root;
+    const excludeDirs = config.python.exclude_dirs || ['__pycache__', '.venv', 'venv', '.mypy_cache', '.pytest_cache'];
+
+    if (force || isPythonDataStale(dataDb, resolve(getProjectRoot(), pythonRoot))) {
+      const pyImports = buildPythonImportIndex(dataDb, pythonRoot, excludeDirs);
+      results.push(`Python imports: ${pyImports}`);
 
-  if (config.paths.middleware) {
-    const middlewareCount = buildMiddlewareTree(dataDb);
-    results.push(`Middleware tree: ${middlewareCount} files`);
+      const pyRoutes = buildPythonRouteIndex(dataDb, pythonRoot, excludeDirs);
+      results.push(`Python routes: ${pyRoutes}`);
+
+      const pyModels = buildPythonModelIndex(dataDb, pythonRoot, excludeDirs);
+      results.push(`Python models: ${pyModels}`);
+
+      if (config.python.alembic_dir) {
+        const pyMigrations = buildPythonMigrationIndex(dataDb, config.python.alembic_dir);
+        results.push(`Python migrations: ${pyMigrations}`);
+      }
+
+      const pyCoupling = buildPythonCouplingIndex(dataDb);
+      results.push(`Python coupling: ${pyCoupling}`);
+
+      updatePythonBuildTimestamp(dataDb);
+    }
   }
 
-  updateBuildTimestamp(dataDb);
+  if (results.length === 0) return 'Indexes are up-to-date.';
   return `Indexes rebuilt:\n${results.join('\n')}`;
 }
 
@@ -101,7 +139,7 @@ function ensureIndexes(dataDb: Database.Database, codegraphDb: Database.Database
 export function getToolDefinitions(): ToolDefinition[] {
   const config = getConfig();
 
-  return [
+  return annotateToolDefinitions([
     // Memory tools
     ...getMemoryToolDefinitions(),
     // Observability tools
@@ -121,9 +159,15 @@ export function getToolDefinitions(): ToolDefinition[] {
     // Security layer (security scoring, dependency risk)
     ...getSecurityToolDefinitions(),
     ...getDependencyToolDefinitions(),
-    // Enterprise layer (team knowledge — cloud-only; regression detection — always)
-    ...(config.cloud?.enabled ? getTeamToolDefinitions() : []),
+    // Enterprise layer (team knowledge, regression detection)
+    ...getTeamToolDefinitions(),
     ...getRegressionToolDefinitions(),
+    // Knowledge layer (indexed .claude/ knowledge — rules, patterns, incidents)
+    ...getKnowledgeToolDefinitions(),
+    // Python code intelligence tools
+    ...getPythonToolDefinitions(),
+    // License tools (always available)
+    ...getLicenseToolDefinitions(),
     // Core tools
     {
       name: p('sync'),
@@ -212,18 +256,25 @@ export function getToolDefinitions(): ToolDefinition[] {
         required: [],
       },
     }] : []),
-  ];
+  ]);
 }
 
 /**
  * Handle a tool call and return the result.
  */
-export function handleToolCall(
+export async function handleToolCall(
   name: string,
   args: Record<string, unknown>,
   dataDb: Database.Database,
   codegraphDb: Database.Database
-): ToolResult {
+): Promise<ToolResult> {
+  // P3-017: Tier gate — check before any routing
+  const userTier = await getCurrentTier();
+  const requiredTier = getToolTier(name);
+  if (!isToolAllowed(name, userTier)) {
+    return text(`This tool requires ${requiredTier} tier. Current tier: ${userTier}. Upgrade at https://massu.ai/pricing`);
+  }
+
   // Ensure indexes are built before any tool call
   const syncMessage = ensureIndexes(dataDb, codegraphDb);
   const pfx = prefix();
@@ -305,11 +356,8 @@ export function handleToolCall(
       finally { memDb.close(); }
     }
 
-    // Route enterprise layer tools (team tools require cloud sync)
+    // Route enterprise layer tools
     if (isTeamTool(name)) {
-      if (!getConfig().cloud?.enabled) {
-        return text('This tool requires Cloud Team or Enterprise. Configure cloud sync to enable.');
-      }
       const memDb = getMemoryDb();
       try { return handleTeamToolCall(name, args, memDb); }
       finally { memDb.close(); }
@@ -320,6 +368,25 @@ export function handleToolCall(
       finally { memDb.close(); }
     }
 
+    // Route knowledge layer tools
+    if (isKnowledgeTool(name)) {
+      const knowledgeDb = getKnowledgeDb();
+      try { return handleKnowledgeToolCall(name, args, knowledgeDb); }
+      finally { knowledgeDb.close(); }
+    }
+
+    // Route Python tools (uses dataDb, not memDb)
+    if (isPythonTool(name)) {
+      return handlePythonToolCall(name, args, dataDb);
+    }
+
+    // Route license tools
+    if (isLicenseTool(name)) {
+      const memDb = getMemoryDb();
+      try { return await handleLicenseToolCall(name, args, memDb); }
+      finally { memDb.close(); }
+    }
+
     // Match core tools by base name
     const baseName = stripPrefix(name);
     switch (baseName) {
@@ -341,7 +408,10 @@ export function handleToolCall(
         return text(`Unknown tool: ${name}`);
     }
   } catch (error) {
-    return text(`Error in ${name}: ${error instanceof Error ? error.message : String(error)}`);
+    const msg = error instanceof Error ? error.message : String(error);
+    // Strip file paths and stack traces from error messages exposed to clients
+    const safeMsg = msg.split('\n')[0].replace(/\/(Users|home|var|tmp)\/[^\s:]+/g, '<path>');
+    return text(`Error in ${name}: ${safeMsg}`);
   }
 }
 
@@ -438,6 +508,187 @@ function handleContext(file: string, dataDb: Database.Database, codegraphDb: Dat
     lines.push('');
   }
 
+  // 7. Knowledge context (relevant CRs, schema warnings, incidents, corrections)
+  try {
+    const knowledgeDb = getKnowledgeDb();
+    try {
+      const docCount = (knowledgeDb.prepare('SELECT COUNT(*) as cnt FROM knowledge_documents').get() as { cnt: number })?.cnt ?? 0;
+      if (docCount > 0) {
+        // Schema mismatch warnings: check if file references any known-mismatch tables
+        const mismatches = knowledgeDb.prepare('SELECT table_name, wrong_column, correct_column FROM knowledge_schema_mismatches').all() as {
+          table_name: string; wrong_column: string; correct_column: string;
+        }[];
+
+        if (mismatches.length > 0) {
+          if (file.includes('router') || file.includes('server/api')) {
+            lines.push('## Schema Mismatch Warnings');
+            lines.push('Known column name traps (from CLAUDE.md):');
+            for (const m of mismatches.slice(0, 5)) {
+              lines.push(`- \`${m.table_name}.${m.wrong_column}\` → use \`${m.correct_column}\` instead`);
+            }
+            lines.push('');
+          }
+        }
+
+        // Dynamic rule matching — combine file-type defaults with content-based FTS
+        const fileType = file.includes('router') || file.includes('server/api') ? 'router'
+          : file.includes('components') || file.includes('app/') ? 'component'
+          : file.includes('middleware') ? 'middleware'
+          : file.includes('migration') ? 'migration'
+          : 'other';
+
+        const domainDefaultCRs: Record<string, string[]> = {
+          router: ['CR-2', 'CR-6'],
+          component: ['CR-8', 'CR-12'],
+          middleware: ['CR-16', 'CR-19'],
+          migration: ['CR-2', 'CR-36'],
+        };
+
+        const defaultCRs = domainDefaultCRs[fileType] || [];
+
+        // Extract keywords from file content for FTS matching
+        let ftsRuleIds: string[] = [];
+        try {
+          const resolvedPaths = getResolvedPaths();
+          const root = getProjectRoot();
+          const absFilePath = ensureWithinRoot(resolve(resolvedPaths.srcDir, '..', file), root);
+          if (existsSync(absFilePath)) {
+            const fileContent = readFileSync(absFilePath, 'utf-8').slice(0, 3000);
+            const keywords: string[] = [];
+            if (fileContent.includes('ctx.db')) keywords.push('database', 'schema');
+            if (fileContent.includes('BigInt') || fileContent.includes('Decimal')) keywords.push('BigInt', 'serialization');
+            if (fileContent.includes('protectedProcedure') || fileContent.includes('publicProcedure')) keywords.push('procedure', 'mutation');
+            if (fileContent.includes('Select') || fileContent.includes('value=')) keywords.push('Select', 'value');
+            if (fileContent.includes('include:')) keywords.push('include', 'relation');
+            if (fileContent.includes('migration') || fileContent.includes('ALTER TABLE')) keywords.push('migration', 'schema');
+            if (fileContent.includes('RLS') || fileContent.includes('policy')) keywords.push('RLS', 'policy');
+            if (fileContent.includes('onPointerDown') || fileContent.includes('onClick')) keywords.push('stylus', 'pointer');
+
+            if (keywords.length > 0) {
+              const ftsQuery = keywords.slice(0, 5).map(k => `"${k}"`).join(' OR ');
+              try {
+                const ftsResults = knowledgeDb.prepare(`
+                  SELECT DISTINCT kc.heading as rule_id
+                  FROM knowledge_fts kf
+                  JOIN knowledge_chunks kc ON kc.id = kf.rowid
+                  WHERE kf.content MATCH ? AND kc.chunk_type = 'rule'
+                  LIMIT 8
+                `).all(ftsQuery) as { rule_id: string }[];
+                ftsRuleIds = ftsResults.map(r => r.rule_id).filter(id => id.startsWith('CR-'));
+              } catch { /* FTS syntax error — fall back to defaults */ }
+            }
+          }
+        } catch { /* File read error — fall back to defaults */ }
+
+        // Combine: defaults + FTS-discovered, deduplicated
+        const relevantCRs = [...new Set([...defaultCRs, ...ftsRuleIds])].slice(0, 10);
+
+        if (relevantCRs.length > 0) {
+          const placeholders = relevantCRs.map(() => '?').join(',');
+          const crRules = knowledgeDb.prepare(
+            `SELECT rule_id, rule_text, vr_type FROM knowledge_rules WHERE rule_id IN (${placeholders})`
+          ).all(...relevantCRs) as { rule_id: string; rule_text: string; vr_type: string }[];
+
+          if (crRules.length > 0) {
+            lines.push('## Relevant Canonical Rules');
+            for (const cr of crRules) {
+              lines.push(`- **${cr.rule_id}**: ${cr.rule_text} (${cr.vr_type})`);
+            }
+            lines.push('');
+          }
+        }
+
+        // Relevant incidents based on file type
+        const domainKeywords: Record<string, string[]> = {
+          router: ['Schema', 'Migration', 'Database', 'API'],
+          component: ['UI', 'Render', 'Component', 'UX'],
+          middleware: ['Auth', 'Edge', 'Build'],
+          migration: ['Schema', 'Migration', 'Database'],
+        };
+        const incidentKeywords = domainKeywords[fileType] || [];
+        if (incidentKeywords.length > 0) {
+          const kwPlaceholders = incidentKeywords.map(() => '?').join(' OR type LIKE ');
+          const kwParams = incidentKeywords.map(k => `%${k}%`);
+          const incidents = knowledgeDb.prepare(
+            `SELECT incident_num, date, type, gap_found, prevention FROM knowledge_incidents WHERE type LIKE ${kwPlaceholders} ORDER BY incident_num DESC LIMIT 5`
+          ).all(...kwParams) as { incident_num: number; date: string; type: string; gap_found: string; prevention: string }[];
+
+          if (incidents.length > 0) {
+            lines.push('## Related Incidents');
+            for (const inc of incidents) {
+              lines.push(`- **#${inc.incident_num}** (${inc.type}): ${inc.gap_found}`);
+            }
+            lines.push('');
+          }
+        }
+
+        // Active corrections (behavioral learning)
+        try {
+          const corrections = knowledgeDb.prepare(`
+            SELECT heading, content FROM knowledge_chunks
+            WHERE metadata LIKE '%"is_correction":true%'
+            ORDER BY CAST(json_extract(metadata, '$.date') AS TEXT) DESC
+            LIMIT 3
+          `).all() as { heading: string; content: string }[];
+
+          if (corrections.length > 0) {
+            lines.push('## Active Corrections');
+            for (const c of corrections) {
+              const ruleLine = c.content.split('\n').find(l => l.startsWith('Rule:')) || c.content.split('\n')[0];
+              lines.push(`- ${c.heading}: ${ruleLine}`);
+            }
+            lines.push('');
+          }
+        } catch { /* corrections query failed — graceful degradation */ }
+      }
+    } finally {
+      knowledgeDb.close();
+    }
+  } catch {
+    // Knowledge DB not available — graceful degradation
+  }
+
+  // 8. Memory context — past bugs/fixes for this file
+  let memDb: Database.Database | null = null;
+  try {
+    memDb = getMemoryDb();
+    const fileObservations = memDb.prepare(`
+      SELECT o.type, o.title, o.cr_rule, o.importance, o.created_at
+      FROM observations o
+      WHERE o.files_involved LIKE ?
+      ORDER BY o.importance DESC, o.created_at_epoch DESC
+      LIMIT 5
+    `).all(`%${basename(file)}%`) as { type: string; title: string; cr_rule: string | null; importance: number; created_at: string }[];
+
+    if (fileObservations.length > 0) {
+      lines.push('## Past Observations (This File)');
+      for (const obs of fileObservations) {
+        const crTag = obs.cr_rule ? ` [${obs.cr_rule}]` : '';
+        const impTag = obs.importance >= 4 ? ' **HIGH**' : '';
+        lines.push(`- [${obs.type}] ${obs.title}${crTag}${impTag} (${obs.created_at})`);
+      }
+      lines.push('');
+    }
+
+    // Also check for failed attempts on this file
+    const failures = memDb.prepare(`
+      SELECT title, detail
+      FROM observations
+      WHERE type = 'failed_attempt' AND files_involved LIKE ?
+      ORDER BY recurrence_count DESC
+      LIMIT 3
+    `).all(`%${basename(file)}%`) as { title: string; detail: string }[];
+
+    if (failures.length > 0) {
+      lines.push('## Failed Attempts (DO NOT RETRY)');
+      for (const f of failures) {
+        lines.push(`- ${f.title}`);
+      }
+      lines.push('');
+    }
+  } catch { /* Memory DB not available — graceful degradation */ }
+  finally { memDb?.close(); }
+
   return text(lines.join('\n') || 'No context available for this file.');
 }
 
@@ -796,7 +1047,8 @@ function handleSchema(args: Record<string, unknown>): ToolResult {
     lines.push('Checking all column references against Prisma schema...');
     lines.push('');
 
-    const absPath = resolve(getProjectRoot(), file);
+    const projectRoot = getProjectRoot();
+    const absPath = ensureWithinRoot(resolve(projectRoot, file), projectRoot);
 
     if (!existsSync(absPath)) {
       return text(`File not found: ${file}`);

package/README.md

@@ -1,40 +0,0 @@
-# @massu/core
-
-AI Engineering Governance MCP Server — session memory, feature registry, code intelligence, and rule enforcement for AI coding assistants.
-
-## Quick Start
-
-```bash
-npx massu init
-```
-
-This sets up the MCP server, configuration, and lifecycle hooks in one command.
-
-## What is Massu?
-
-Massu is a source-available [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that adds governance capabilities to AI coding assistants like Claude Code. It provides:
-
-- **51 MCP Tools** — quality analytics, cost tracking, security scoring, dependency analysis, and more
-- **11 Lifecycle Hooks** — pre-commit gates, security scanning, intent suggestion, and session management
-- **3-Database Architecture** — code graph (read-only), data (imports/mappings), and memory (sessions/analytics)
-- **Config-Driven** — all project-specific data lives in `massu.config.yaml`
-
-## Usage
-
-After `npx massu init`, your AI assistant gains access to all governance tools automatically via the MCP protocol.
-
-```bash
-# Health check
-npx massu doctor
-
-# Validate configuration
-npx massu validate-config
-```
-
-## Documentation
-
-Full documentation at [massu.ai](https://massu.ai).
-
-## License
-
-[BSL 1.1](https://github.com/massu-ai/massu/blob/main/LICENSE) — source-available. Free to use, modify, and distribute. See LICENSE for full terms.