tsunami-memory 1.0.0

package/server/mcp.ts

@@ -0,0 +1,221 @@
+#!/usr/bin/env bun
+/**
+ * TSUNAMI MCP Server — Model Context Protocol
+ *
+ * Any MCP-compatible agent (Claude Code, Cursor, Windsurf, Codex, Hermes) can connect.
+ * Example config (~/.claude/mcp.json):
+ *   { "tsunami": { "command": "bun", "args": ["run", "server/mcp.ts"] } }
+ *
+ * Exposes 8 MCP tools: tsunami_add, tsunami_search, tsunami_recall, tsunami_storm,
+ *   tsunami_status, tsunami_timeline, tsunami_diary, tsunami_wings
+ */
+
+const HOME = process.env.TSUNAMI_HOME || '.tsunami';
+
+// ── JSON-RPC 2.0 over stdio ────────────────────────────────
+async function readStdin(): Promise<any> {
+  const buf = await Bun.stdin.stream().getReader().read();
+  if (!buf.value) return null;
+  const text = new TextDecoder().decode(buf.value);
+  if (!text.trim()) return null;
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+function writeStdout(data: any): void {
+  process.stdout.write(JSON.stringify(data) + '\n');
+}
+
+function ok(id: number, result: any) {
+  writeStdout({ jsonrpc: '2.0', id, result });
+}
+
+function err(id: number, code: number, message: string) {
+  writeStdout({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+// ── Tool Definitions ───────────────────────────────────────
+const TOOLS = [
+  {
+    name: 'tsunami_add',
+    description: 'Add a memory to TSUNAMI. Returns confirmation with the stored content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Memory content to store' },
+        wing: { type: 'string', description: 'Memory wing/basin (default: general)', default: 'general' },
+        room: { type: 'string', description: 'Room/topic within the wing (default: inbox)', default: 'inbox' },
+        energy: { type: 'number', description: 'Energy/importance level 1-5 (default: 3)', default: 3 },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name: 'tsunami_search',
+    description: 'Full-text search across TSUNAMI memories. Returns ranked results.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        wing: { type: 'string', description: 'Filter by wing/basin' },
+        limit: { type: 'number', description: 'Max results (default: 5)', default: 5 },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'tsunami_recall',
+    description: 'Recall recent memories from a specific wing or room. Context-aware retrieval.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        wing: { type: 'string', description: 'Memory wing/basin to recall from' },
+        room: { type: 'string', description: 'Specific room/topic' },
+        limit: { type: 'number', description: 'Max results (default: 10)', default: 10 },
+      },
+    },
+  },
+  {
+    name: 'tsunami_storm',
+    description: 'Get the TSUNAMI storm center — active signals, memory flow, execution budget, and storm mode. Use this to understand current context.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectDir: { type: 'string', description: 'Project directory for context' },
+        query: { type: 'string', description: 'Current task/query for relevance' },
+      },
+    },
+  },
+  {
+    name: 'tsunami_status',
+    description: 'Get TSUNAMI system status — storage size, memory counts per wing, graph stats.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'tsunami_timeline',
+    description: 'Get a timeline of recent memories.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max entries (default: 20)', default: 20 },
+      },
+    },
+  },
+  {
+    name: 'tsunami_diary',
+    description: 'Write a diary entry to TSUNAMI. Automatically timestamped.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        entry: { type: 'string', description: 'Diary entry content' },
+        agent: { type: 'string', description: 'Agent name (default: external)', default: 'external' },
+        wing: { type: 'string', description: 'Memory wing (default: diary)', default: 'diary' },
+      },
+      required: ['entry'],
+    },
+  },
+  {
+    name: 'tsunami_wings',
+    description: 'List all available memory wings/basins and their memory counts.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+];
+
+// ── Tool Handlers ──────────────────────────────────────────
+async function handleTool(name: string, args: Record<string, any>): Promise<any> {
+  // Dynamic import to defer heavy module loading
+  const client = await import('../src/tsunami_client');
+  const storm = await import('../src/tsunami_storm_center');
+
+  switch (name) {
+    case 'tsunami_add':
+      return { result: await client.tsunamiAdd(args.wing || 'general', args.room || 'inbox', args.content, args.energy || 3) };
+
+    case 'tsunami_search':
+      return { result: await client.tsunamiSearch(args.query, args.wing, undefined, args.limit || 5) };
+
+    case 'tsunami_recall':
+      return { result: await client.tsunamiRecall(args.wing, args.room, args.limit || 10) };
+
+    case 'tsunami_storm': {
+      const center = storm.buildTsunamiStormCenter({
+        projectDir: args.projectDir || process.cwd(),
+        query: args.query || '',
+        refreshGraph: false,
+      });
+      return {
+        flow: center.flow,
+        stormMode: center.stormMode,
+        stormPressure: center.stormPressure,
+        stormGate: center.stormGate,
+        stormBudget: center.stormBudget,
+        stormAction: center.stormAction,
+        summary: storm.formatTsunamiStormCenterText(center),
+      };
+    }
+
+    case 'tsunami_status': {
+      const s = await client.tsunamiStatus();
+      return { ...s };
+    }
+
+    case 'tsunami_timeline':
+      return { timeline: await client.tsunamiTimeline(args.limit || 20) };
+
+    case 'tsunami_diary':
+      return { result: await client.tsunamiDiary(args.entry, args.agent || 'external', args.wing || 'diary', 3) };
+
+    case 'tsunami_wings': {
+      const wings = await client.tsunamiListWings();
+      return { wings };
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// ── Main Loop ──────────────────────────────────────────────
+async function main() {
+  // MCP initialization handshake
+  const initReq = await readStdin();
+  if (!initReq || initReq.method !== 'initialize') {
+    err(initReq?.id || 0, -32600, 'Expected initialize request');
+    process.exit(1);
+  }
+  ok(initReq.id, {
+    protocolVersion: '2024-11-05',
+    serverInfo: { name: 'tsunami-memory', version: '1.0.0' },
+    capabilities: { tools: {} },
+  });
+
+  // Main loop: handle tools/list and tools/call
+  while (true) {
+    const req = await readStdin();
+    if (!req) break; // stdin closed
+
+    try {
+      switch (req.method) {
+        case 'tools/list':
+          ok(req.id, { tools: TOOLS });
+          break;
+
+        case 'tools/call': {
+          const result = await handleTool(req.params?.name, req.params?.arguments || {});
+          ok(req.id, { content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result, null, 2) }] });
+          break;
+        }
+
+        case 'notifications/initialized':
+          // Acknowledge silently — no response needed per MCP spec
+          break;
+
+        default:
+          err(req.id, -32601, `Method not found: ${req.method}`);
+      }
+    } catch (e: any) {
+      err(req.id, -32000, e?.message || String(e));
+    }
+  }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/src/bun_memory_store.ts

@@ -0,0 +1,340 @@
+/**
+ * TSUNAMI Bun Memory Store — SQLite-backed persistent memory
+ *
+ * Stores memories as "drawers" organized by wing/room, with importance scoring
+ * and content fingerprinting for deduplication. Schema managed by migration runner.
+ */
+
+import { Database } from 'bun:sqlite';
+import { existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { BUN_MEMORY_DB_PATH } from './tsunami_storage_paths';
+import { runMigrations, getMigrations } from './migration';
+export { BUN_MEMORY_DB_PATH };
+
+// ── Database initialization ──────────────────────────────────
+
+function ensureDbDir(): void {
+  const dir = dirname(BUN_MEMORY_DB_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+let _db: Database | null = null;
+
+function getDb(): Database {
+  if (_db) return _db;
+  ensureDbDir();
+  _db = new Database(BUN_MEMORY_DB_PATH);
+  _db.run('PRAGMA journal_mode = WAL');
+  const applied = runMigrations(_db, getMigrations());
+  if (applied > 0) {
+    // First-run or upgrade — log for observability
+    const v = (_db.prepare('SELECT MAX(version) as v FROM schema_version').get() as any)?.v ?? 0;
+    console.log(`[TSUNAMI] migrations applied: ${applied}, now at v${v}`);
+  }
+  return _db;
+}
+
+// ── ID Generation ────────────────────────────────────────────
+
+function generateId(): string {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `bunmem_${ts}_${rand}`;
+}
+
+// ── Query Result Type ────────────────────────────────────────
+
+export interface BunMemoryRow {
+  id: string;
+  wing: string;
+  room: string;
+  content: string;
+  importance: number;
+  source: string;
+  session_id: string | null;
+  project_dir: string | null;
+  fingerprint: string | null;
+  created_at: number;
+  updated_at: number;
+}
+
+export interface BunMemoryInsertEntry {
+  wing?: string;
+  room?: string;
+  content: string;
+  importance?: number;
+  source?: string;
+  sessionId?: string;
+  projectDir?: string;
+  fingerprint?: string;
+}
+
+export interface BunMemorySearchOpts {
+  query: string;
+  wing?: string;
+  room?: string;
+  limit?: number;
+}
+
+export interface BunMemoryRecallOpts {
+  wing?: string;
+  room?: string;
+  limit?: number;
+}
+
+export interface BunMemoryWakeOpts {
+  wing?: string;
+  limit?: number;
+}
+
+export interface BunMemoryTaxonomyEntry {
+  wing: string;
+  rooms: Record<string, number>;
+}
+
+// ── Public API ───────────────────────────────────────────────
+
+export function insertBunMemoryEntry(entry: BunMemoryInsertEntry): string {
+  const db = getDb();
+  const id = generateId();
+  const now = Date.now();
+
+  const stmt = db.prepare(`
+    INSERT INTO memory_entries (id, wing, room, content, importance, source, session_id, project_dir, fingerprint, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  stmt.run(
+    id,
+    entry.wing || 'general',
+    entry.room || 'inbox',
+    entry.content,
+    entry.importance ?? 3,
+    entry.source || 'direct',
+    entry.sessionId || null,
+    entry.projectDir || null,
+    entry.fingerprint || null,
+    now,
+    now,
+  );
+
+  return id;
+}
+
+export function searchBunMemoryRows(opts: BunMemorySearchOpts): BunMemoryRow[] {
+  const db = getDb();
+  const query = String(opts.query ?? '').trim();
+
+  if (!query) {
+    // Fall back to recall-style query if no search query provided
+    return recallBunMemoryRows({ wing: opts.wing, room: opts.room, limit: opts.limit });
+  }
+
+  // Use FTS5 for full-text search
+  const ftsQuery = query.replace(/[^\w\s\u4e00-\u9fa5]/g, ' ').trim();
+  if (!ftsQuery) return [];
+
+  const limit = Math.max(1, Math.min(100, Number(opts.limit ?? 5)));
+
+  const sql = `
+    SELECT m.*
+    FROM memory_entries m
+    JOIN memory_fts fts ON m.rowid = fts.rowid
+    WHERE memory_fts MATCH ?
+      ${opts.wing ? 'AND m.wing = ?' : ''}
+      ${opts.room ? 'AND m.room = ?' : ''}
+    ORDER BY rank
+    LIMIT ?
+  `;
+
+  const params: any[] = [ftsQuery];
+  if (opts.wing) params.push(opts.wing);
+  if (opts.room) params.push(opts.room);
+  params.push(limit);
+
+  const stmt = db.prepare(sql);
+  return stmt.all(...params) as BunMemoryRow[];
+}
+
+export function recallBunMemoryRows(opts: BunMemoryRecallOpts): BunMemoryRow[] {
+  const db = getDb();
+  const limit = Math.max(1, Math.min(100, Number(opts.limit ?? 10)));
+
+  let sql = `
+    SELECT * FROM memory_entries
+    WHERE 1=1
+      ${opts.wing ? 'AND wing = ?' : ''}
+      ${opts.room ? 'AND room = ?' : ''}
+    ORDER BY importance DESC, created_at DESC
+    LIMIT ?
+  `;
+
+  const params: any[] = [];
+  if (opts.wing) params.push(opts.wing);
+  if (opts.room) params.push(opts.room);
+  params.push(limit);
+
+  const stmt = db.prepare(sql);
+  return stmt.all(...params) as BunMemoryRow[];
+}
+
+export function wakeBunMemoryRows(opts: BunMemoryWakeOpts): BunMemoryRow[] {
+  const db = getDb();
+  const limit = Math.max(1, Math.min(50, Number(opts.limit ?? 10)));
+
+  let sql = `
+    SELECT * FROM memory_entries
+    WHERE 1=1
+      ${opts.wing ? 'AND wing = ?' : ''}
+    ORDER BY importance DESC, created_at DESC
+    LIMIT ?
+  `;
+
+  const params: any[] = [];
+  if (opts.wing) params.push(opts.wing);
+  params.push(limit);
+
+  const stmt = db.prepare(sql);
+  return stmt.all(...params) as BunMemoryRow[];
+}
+
+export function listBunMemoryTimeline(limit?: number): BunMemoryRow[] {
+  const db = getDb();
+  const max = Math.max(1, Math.min(200, Number(limit ?? 20)));
+
+  const stmt = db.prepare(`
+    SELECT * FROM memory_entries
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+
+  return stmt.all(max) as BunMemoryRow[];
+}
+
+export function countBunMemoryEntries(wing?: string): number {
+  const db = getDb();
+
+  if (wing) {
+    const stmt = db.prepare('SELECT COUNT(*) as count FROM memory_entries WHERE wing = ?');
+    const row = stmt.get(wing) as { count: number };
+    return row.count;
+  }
+
+  const stmt = db.prepare('SELECT COUNT(*) as count FROM memory_entries');
+  const row = stmt.get() as { count: number };
+  return row.count;
+}
+
+export function getBunMemoryStatus(): Record<string, unknown> {
+  const db = getDb();
+
+  const total = (db.prepare('SELECT COUNT(*) as count FROM memory_entries').get() as { count: number }).count;
+  const wings = (db.prepare('SELECT COUNT(DISTINCT wing) as count FROM memory_entries').get() as { count: number }).count;
+  const totalSize = (db.prepare("SELECT COUNT(*) as count FROM memory_entries WHERE length(content) > 0").get() as { count: number }).count;
+
+  return {
+    total,
+    wings,
+    total_drawers: total,
+    backend: 'bun_native',
+    db_path: BUN_MEMORY_DB_PATH,
+    totalSize,
+  };
+}
+
+export function listBunMemoryWingCounts(): Record<string, number> {
+  const db = getDb();
+  const rows = db.prepare('SELECT wing, COUNT(*) as count FROM memory_entries GROUP BY wing ORDER BY count DESC').all() as Array<{ wing: string; count: number }>;
+
+  const result: Record<string, number> = {};
+  for (const row of rows) {
+    result[row.wing] = row.count;
+  }
+  return result;
+}
+
+export function listBunMemoryRoomCounts(wing?: string): Record<string, number> {
+  const db = getDb();
+
+  let rows: Array<{ room: string; count: number }>;
+  if (wing) {
+    rows = db.prepare('SELECT room, COUNT(*) as count FROM memory_entries WHERE wing = ? GROUP BY room ORDER BY count DESC').all(wing) as Array<{ room: string; count: number }>;
+  } else {
+    rows = db.prepare('SELECT room, COUNT(*) as count FROM memory_entries GROUP BY room ORDER BY count DESC').all() as Array<{ room: string; count: number }>;
+  }
+
+  const result: Record<string, number> = {};
+  for (const row of rows) {
+    result[row.room] = row.count;
+  }
+  return result;
+}
+
+export function getBunMemoryTaxonomy(): BunMemoryTaxonomyEntry[] {
+  const db = getDb();
+  const wings = db.prepare('SELECT DISTINCT wing FROM memory_entries ORDER BY wing').all() as Array<{ wing: string }>;
+
+  return wings.map((w) => {
+    const rooms = db.prepare('SELECT room, COUNT(*) as count FROM memory_entries WHERE wing = ? GROUP BY room ORDER BY count DESC').all(w.wing) as Array<{ room: string; count: number }>;
+    const roomCounts: Record<string, number> = {};
+    for (const r of rooms) {
+      roomCounts[r.room] = r.count;
+    }
+    return { wing: w.wing, rooms: roomCounts };
+  });
+}
+
+export function checkBunMemoryDuplicate(
+  content: string,
+  threshold = 0.9,
+): { is_duplicate: boolean; matches: Array<{ id: string; wing: string; room: string; similarity: number; content: string }> } {
+  const query = String(content ?? '').trim();
+  if (!query) return { is_duplicate: false, matches: [] };
+
+  // Tokenize the query content for comparison
+  const qTokens = new Set(tokenize(query));
+
+  const db = getDb();
+  const rows = db.prepare('SELECT id, wing, room, content FROM memory_entries ORDER BY created_at DESC LIMIT 500').all() as BunMemoryRow[];
+
+  const matches: Array<{ id: string; wing: string; room: string; similarity: number; content: string }> = [];
+
+  for (const row of rows) {
+    const dTokens = new Set(tokenize(row.content));
+    const inter = [...qTokens].filter((t) => dTokens.has(t)).length;
+    const union = new Set([...qTokens, ...dTokens]).size || 1;
+    const sim = inter / union;
+
+    if (sim >= threshold) {
+      matches.push({
+        id: row.id,
+        wing: row.wing,
+        room: row.room,
+        similarity: Number(sim.toFixed(3)),
+        content: row.content.slice(0, 200),
+      });
+    }
+  }
+
+  matches.sort((a, b) => b.similarity - a.similarity);
+  return { is_duplicate: matches.length > 0, matches: matches.slice(0, 5) };
+}
+
+export function deleteBunMemoryEntry(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM memory_entries WHERE id = ?').run(id);
+  return result.changes > 0;
+}
+
+export function buildBunMemoryPreview(row: BunMemoryRow, maxLen: number): string {
+  const text = String(row.content ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
+}
+
+// ── Internal Helpers ─────────────────────────────────────────
+
+function tokenize(text: string): string[] {
+  return (text.toLowerCase().match(/[\u4e00-\u9fa5a-z0-9_]+/g) ?? []).filter(Boolean);
+}

package/src/classifier_keywords.ts

@@ -0,0 +1,115 @@
+/**
+ * TSUNAMI Classifier Keywords — wing/room keyword data
+ *
+ * Extracted from classifier logic for maintainability.
+ * Each keyword maps to a weight in the range [1.0, 4.0]:
+ *   1.0–1.5  — weak signal (common words, low specificity)
+ *   2.0–2.5  — moderate signal
+ *   3.0–3.5  — strong signal (domain-specific terms)
+ *   4.0       — definitive signal (reserved for exact-match terms)
+ */
+
+export type KeywordPair = readonly [string, number];
+
+/** Wing-level keywords — determines which basin a memory belongs to. */
+export const WING_KEYWORDS: Record<string, KeywordPair[]> = {
+  identity: [
+    ['identity', 3.0], ['whoami', 3.0], ['name', 2.0], ['role', 3.0],
+    ['personality', 3.0], ['character', 2.5], ['behavior', 2.0],
+    ['preference', 2.0], ['style', 2.0], ['tone', 2.0],
+    ['principle', 3.0], ['rule', 2.5], ['iron_law', 3.5], ['red_line', 3.5],
+    ['communication', 2.0], ['speech', 2.0],
+  ],
+  brain: [
+    ['brain', 2.5], ['model', 2.0],
+    ['provider', 2.5], ['engine', 2.0],
+    ['port', 2.0], ['config', 2.0],
+    ['start', 1.5], ['stop', 1.5], ['restart', 1.5], ['shutdown', 1.5],
+    ['tool', 2.0], ['loader', 3.0],
+    ['register', 2.0], ['executor', 2.5],
+    ['tts', 3.0], ['voice', 2.0], ['synthesis', 2.0], ['audio', 1.5],
+    ['architecture', 2.0], ['module', 2.0],
+    ['directory', 1.5], ['path', 1.5], ['file', 1.0],
+    ['code', 1.5], ['implementation', 1.5], ['bug', 2.0], ['fix', 1.5],
+  ],
+  decision: [
+    ['decision', 3.0], ['decision_making', 3.0], ['chose', 2.5],
+    ['approach', 2.5], ['tech_selection', 3.0], ['adopted', 2.0],
+    ['abandoned', 2.0], ['conclusion', 2.0], ['final_approach', 3.0],
+    ['decided', 3.0], ['finalized', 2.5], ['selected', 2.0],
+    ['architecture', 2.5], ['tech_stack', 3.0], ['framework', 2.0],
+    ['feature', 1.5], ['requirement', 1.5],
+  ],
+  memory: [
+    ['memory', 3.0], ['graphmemory', 3.0], ['knowledge_graph', 3.0],
+    ['relationship', 2.0], ['recall', 2.5], ['search', 1.5],
+    ['chromadb', 2.5], ['vector', 2.5], ['embedding', 2.5],
+    ['semantic_search', 3.0], ['semantic', 2.0],
+    ['recollection', 2.0], ['remember', 1.5], ['forget', 1.5], ['archive', 2.0],
+    ['session', 2.0], ['context', 1.5],
+    ['compress', 2.0],
+    ['wrapper', 2.5], ['long_term_memory', 3.0], ['memory_fabric', 2.5], ['tsunami', 2.5],
+  ],
+  task: [
+    ['task', 2.0], ['todo', 2.0], ['project', 1.5],
+    ['feature', 1.5], ['implement', 2.0], ['development', 1.5],
+    ['bug', 2.0], ['fix', 1.5], ['testing', 1.5],
+    ['deploy', 1.5], ['deployment', 1.5], ['done', 1.5],
+    ['in_progress', 2.0], ['plan', 1.5],
+    ['daily', 2.0], ['routine', 2.0],
+    ['core_task', 3.0], ['phase_task', 2.5], ['phase_1', 2.5],
+    ['heartbeat_check', 3.0], ['scheduled_check', 2.5], ['verify', 2.5],
+    ['check', 1.5],
+  ],
+  people: [
+    ['user', 3.0], ['boss', 3.0],
+    ['partner', 3.0],
+    ['team', 1.5], ['colleague', 1.5],
+  ],
+};
+
+/** Room-level keywords — refines the current within a wing. */
+export const ROOM_KEYWORDS: Record<string, Record<string, KeywordPair[]>> = {
+  identity: {
+    core: [
+      ['identity', 3.0], ['whoami', 3.0], ['name', 2.5], ['role_positioning', 3.0],
+      ['core_identity', 3.0], ['deputy', 3.0], ['platform', 1.0],
+    ],
+    personality: [
+      ['personality', 3.0], ['assertive', 3.0],
+      ['speech_style', 3.0], ['tone', 2.5], ['communication', 2.0],
+      ['elite', 2.0], ['professional', 2.0],
+    ],
+    rules: [
+      ['rule', 3.0], ['principle', 3.0], ['hard_line', 3.0],
+      ['red_line', 3.0], ['iron_law', 3.0], ['ban', 3.0],
+    ],
+  },
+  brain: {
+    model: [['brain', 3.0], ['model', 2.5], ['provider', 2.5], ['engine', 2.5], ['intent', 2.0]],
+    tts: [['tts', 3.0], ['voice', 3.0], ['synthesis', 3.0], ['audio', 2.0], ['read_aloud', 2.0]],
+    tools: [['tool', 3.0], ['register', 2.5]],
+    architecture: [['architecture', 3.0], ['module', 2.5], ['design', 2.0], ['structure', 2.0], ['directory', 2.0], ['path', 1.5], ['file', 1.5], ['backend', 2.5], ['execution_loop', 2.5], ['context', 1.5]],
+    config: [['config', 3.0], ['port', 2.5], ['setting', 2.0]],
+    control: [['control_plane', 2.5], ['restart', 1.5]],
+  },
+  decision: {
+    strategy: [['tech_selection', 3.0], ['approach', 2.5], ['architecture', 2.5], ['tech_stack', 3.0], ['framework', 2.0], ['language', 2.0]],
+    product: [['product', 3.0], ['direction', 2.5], ['feature', 2.5], ['requirement', 2.5]],
+    direction: [['strategy', 3.0], ['direction', 2.5], ['priority', 2.5]],
+  },
+  memory: {
+    tsunami: [['compress', 2.5], ['embedding', 2.0], ['integration', 2.0], ['long_term_memory', 3.0], ['memory_fabric', 2.5], ['tsunami', 2.5]],
+    graph: [['graphmemory', 3.0], ['knowledge_graph', 3.0], ['relationship', 2.0], ['timeline', 2.5]],
+    context: [['context', 2.5], ['history', 2.0], ['message', 1.5]],
+  },
+  task: {
+    project: [['project', 3.0], ['feature', 2.5], ['implement', 2.5], ['development', 2.0], ['phase', 2.5], ['integration', 1.5], ['task', 1.5], ['core_task', 3.0], ['phase_task', 2.5], ['phase_1', 3.0]],
+    routine: [['daily', 3.0], ['routine', 3.0], ['scheduled', 2.5], ['heartbeat', 3.0], ['verify', 2.0], ['check', 1.5], ['heartbeat_check', 3.5], ['scheduled_check', 3.0]],
+  },
+  people: {
+    user: [['user', 3.0], ['boss', 3.0]],
+    partner: [['partner', 3.0]],
+    team: [['team', 2.0], ['colleague', 2.0]],
+  },
+};