@monoes/monomindcli 1.12.0 → 1.14.0

package/.claude/helpers/metrics-db.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * metrics-db.mjs — Lightweight metrics aggregation helper.
+ * Reads .monomind/metrics/*.json files and produces summary output.
+ *
+ * Commands:
+ *   sync    — aggregate metrics files → JSON summary (default)
+ *   status  — print current metrics status as JSON
+ *   export  — export metrics to timestamped file
+ *   (other) — print usage hint, exit 0
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const METRICS_DIR = path.join(CWD, '.monomind', 'metrics');
+
+function safeRead(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function aggregate() {
+  const recentEdits = safeRead(path.join(METRICS_DIR, 'recent-edits.json'));
+  const toolCalls = safeRead(path.join(METRICS_DIR, 'tool-calls.json'));
+  const hookLatency = safeRead(path.join(METRICS_DIR, 'hook-latency.json'));
+  const tokenSummary = safeRead(path.join(METRICS_DIR, 'token-summary.json'));
+
+  return {
+    aggregatedAt: new Date().toISOString(),
+    recentEdits: recentEdits ? (recentEdits.edits || []).length : 0,
+    toolCalls: toolCalls ? Object.keys(toolCalls.calls || {}).length : 0,
+    hookLatency: hookLatency ? Object.keys(hookLatency).filter(k => k !== 'lastUpdated').length : 0,
+    tokenSummary: tokenSummary ? { todayCost: tokenSummary.todayCost, monthCost: tokenSummary.monthCost } : null,
+  };
+}
+
+function cmdSync() {
+  const summary = aggregate();
+  process.stdout.write(JSON.stringify(summary) + '\n');
+  process.exit(0);
+}
+
+function cmdStatus() {
+  const summary = aggregate();
+  process.stdout.write(JSON.stringify({ status: 'ok', metrics: summary }) + '\n');
+  process.exit(0);
+}
+
+function cmdExport() {
+  const summary = aggregate();
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const exportPath = path.join(METRICS_DIR, `export-${ts}.json`);
+  try {
+    fs.mkdirSync(METRICS_DIR, { recursive: true });
+    fs.writeFileSync(exportPath, JSON.stringify(summary, null, 2));
+    process.stdout.write(`Exported metrics to ${exportPath}\n`);
+  } catch (e) {
+    process.stdout.write(`Exported metrics (in-memory only): ${JSON.stringify(summary)}\n`);
+  }
+  process.exit(0);
+}
+
+function cmdUsage(unknownCmd) {
+  process.stdout.write(
+    `Usage: metrics-db.mjs [sync|status|export]\n` +
+    (unknownCmd ? `  Unknown command: ${unknownCmd}\n` : '')
+  );
+  process.exit(0);
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+const cmd = process.argv[2] || 'sync';
+
+switch (cmd) {
+  case 'sync':    cmdSync();   break;
+  case 'status':  cmdStatus(); break;
+  case 'export':  cmdExport(); break;
+  default:        cmdUsage(cmd); break;
+}

package/.claude/helpers/router.cjs

@@ -2,62 +2,234 @@
 /**
  * Keyword-based task router for hook-handler.cjs
  * Returns: { agent, agentSlug, confidence, reason, semanticRouting, specificAgents, skillMatches, extrasMatches }
+ *
+ * Exports:
+ *   routeTask(prompt)           → routing result object
+ *   routeTaskSemantic(prompt)   → alias for routeTask
+ *   matchSkills(prompt, topN)   → array of { skill, invoke, score }
+ *   matchExtras(prompt, topN)   → array of { slug, name, category, score }
+ *   buildCategoryList()         → array of { name, count, examples }
+ *   getAgentsInCategory(cat)    → array of { slug, name }
+ *   AGENT_CAPABILITIES          → { [slug]: string[] }
+ *   TASK_PATTERNS               → { [agentSlug]: RegExp }
  */
 
-const KEYWORD_ROUTES = [
-  { pattern: /\b(bug|fix|error|exception|crash|broken|fail|regression|null pointer|undefined)\b/i, agent: 'coder', confidence: 0.85 },
-  { pattern: /\b(test|spec|coverage|vitest|jest|mocha|unit test|integration test|e2e)\b/i, agent: 'tester', confidence: 0.85 },
-  { pattern: /\b(review|audit|code quality|lint|smell|refactor|clean up|cleanup)\b/i, agent: 'reviewer', confidence: 0.82 },
-  { pattern: /\b(architect|design|system design|ADR|domain|bounded context|microservice|pattern)\b/i, agent: 'system-architect', confidence: 0.85 },
-  { pattern: /\b(security|vulnerability|CVE|injection|XSS|CSRF|auth|permissions|OWASP)\b/i, agent: 'Security Engineer', confidence: 0.90 },
-  { pattern: /\b(performance|optimiz|slow|bottleneck|profil|benchmark|latency|throughput)\b/i, agent: 'coder', confidence: 0.80 },
-  { pattern: /\b(deploy|CI\/CD|pipeline|docker|kubernetes|infra|devops|helm|terraform)\b/i, agent: 'DevOps Automator', confidence: 0.85 },
-  { pattern: /\b(document|readme|docs|api reference|jsdoc|write up)\b/i, agent: 'Technical Writer', confidence: 0.82 },
-  { pattern: /\b(feature|implement|add|build|create|develop|new)\b/i, agent: 'coder', confidence: 0.75 },
-  { pattern: /\b(research|investigate|explore|analyze|survey|compare)\b/i, agent: 'researcher', confidence: 0.78 },
-  { pattern: /\b(plan|roadmap|strategy|prioritize|breakdown|estimate)\b/i, agent: 'planner', confidence: 0.80 },
-  { pattern: /\b(memory|vector|embedding|HNSW|sqlite|database|query)\b/i, agent: 'coder', confidence: 0.82 },
-  { pattern: /\b(hook|swarm|agent|mcp|cli|routing|monomind)\b/i, agent: 'coder', confidence: 0.80 },
-  { pattern: /\b(mobile|ios|android|react native|flutter)\b/i, agent: 'mobile-dev', confidence: 0.88 },
-  { pattern: /\b(ml|machine learning|AI|model|training|inference|neural)\b/i, agent: 'AI Engineer', confidence: 0.85 },
-  { pattern: /\b(api|rest|graphql|endpoint|http|websocket|grpc)\b/i, agent: 'backend-dev', confidence: 0.80 },
-  { pattern: /\b(ui|frontend|react|vue|component|css|layout|design)\b/i, agent: 'Frontend Developer', confidence: 0.80 },
+// ── Dev patterns (slug-correct) ─────────────────────────────────────────────
+// TASK_PATTERNS: { keywords: agentSlug } — exported for introspection
+// Values are agent slugs; keys describe what keywords trigger that agent.
+
+var TASK_PATTERNS = {
+  'test|spec|coverage|vitest|jest|mocha|e2e':                  'tester',
+  'review|audit|code quality|lint|refactor|cleanup':           'reviewer',
+  'architect|system design|ADR|bounded context|architecture':  'architect',
+  'security|vulnerability|CVE|injection|XSS|CSRF|OWASP':       'security-engineer',
+  'deploy|CI/CD|docker|kubernetes|infra|devops|helm|terraform': 'devops',
+  'document|readme|docs|api reference|jsdoc':                  'technical-writer',
+  'research|investigate|explore|analyze|survey|compare':       'researcher',
+  'plan|roadmap|prioritize|breakdown|estimate':                 'planner',
+  'mobile|ios|android|react native|flutter':                   'mobile-dev',
+  'ml|machine learning|neural network|model training':          'ai-engineer',
+  'api|rest|graphql|endpoint|http|websocket|grpc|optimize':    'backend-dev',
+  'ui|frontend|react|vue|component|css|layout|style':          'frontend-dev',
+  'bug|fix|error|feature|implement|build|create|develop':      'coder',
+};
+
+// Internal routing patterns (regex per slug for routeTask)
+var _ROUTING_PATTERNS = {
+  'tester':      /\b(test|tests|spec|coverage|vitest|jest|mocha|e2e)\b/i,
+  'reviewer':    /\b(review|audit|code quality|lint|smell|refactor|clean up|cleanup)\b/i,
+  'architect':   /\b(architect|system design|ADR|domain|bounded context|microservice|architecture)\b/i,
+  'security-engineer': /\b(security|vulnerability|CVE|injection|XSS|CSRF|OWASP)\b/i,
+  'devops':      /\b(deploy|CI\/CD|docker|kubernetes|infra|devops|helm|terraform)\b/i,
+  'technical-writer': /\b(document|readme|docs|api reference|jsdoc|write up)\b/i,
+  'researcher':  /\b(research|investigate|explore|analyze|survey|compare)\b/i,
+  'planner':     /\b(plan|roadmap|prioritize|breakdown|estimate)\b/i,
+  'mobile-dev':  /\b(mobile|ios|android|react native|flutter)\b/i,
+  'ai-engineer': /\b(ml|machine learning|neural network|model training|inference)\b/i,
+  'backend-dev': /\b(api|rest|graphql|endpoint|http|websocket|grpc|optimize)\b/i,
+  'frontend-dev': /\b(ui|frontend|react|vue|component|css|layout|style)\b/i,
+  'coder':       /\b(bug|fix|error|exception|crash|broken|fail|regression|feature|implement|add|build|create|develop|new|memory|vector|embedding|hook|swarm|agent|mcp|cli|routing|monomind)\b/i,
+};
+
+var TASK_CONFIDENCES = {
+  'tester':      0.85,
+  'reviewer':    0.82,
+  'architect':   0.85,
+  'security-engineer': 0.90,
+  'devops':      0.85,
+  'technical-writer': 0.82,
+  'researcher':  0.78,
+  'planner':     0.80,
+  'mobile-dev':  0.88,
+  'ai-engineer': 0.85,
+  'backend-dev': 0.80,
+  'frontend-dev': 0.80,
+  'coder':       0.80,
+};
+
+var TASK_AGENTS = {
+  'tester':      'Tester',
+  'reviewer':    'Reviewer',
+  'architect':   'Architect',
+  'security-engineer': 'Security Engineer',
+  'devops':      'DevOps',
+  'technical-writer': 'Technical Writer',
+  'researcher':  'Researcher',
+  'planner':     'Planner',
+  'mobile-dev':  'Mobile Developer',
+  'ai-engineer': 'AI Engineer',
+  'backend-dev': 'Backend Developer',
+  'frontend-dev': 'Frontend Developer',
+  'coder':       'Coder',
+};
+
+// Priority order: higher-priority slugs checked first
+var DEV_PRIORITY = [
+  'tester', 'reviewer', 'architect', 'security-engineer', 'devops',
+  'mobile-dev', 'ai-engineer', 'frontend-dev', 'backend-dev',
+  'researcher', 'planner', 'technical-writer', 'coder',
 ];
 
-const DEFAULT_RESULT = {
-  agent: 'coder',
-  agentSlug: 'coder',
-  confidence: 0.60,
-  reason: 'Default routing — no strong keyword match',
-  semanticRouting: false,
-  specificAgents: [],
-  skillMatches: [],
-  extrasMatches: [],
+// ── AGENT_CAPABILITIES ────────────────────────────────────────────────────────
+
+var AGENT_CAPABILITIES = {
+  'coder':         ['implement', 'fix', 'build', 'develop', 'create'],
+  'tester':        ['test', 'spec', 'coverage', 'vitest', 'jest', 'e2e'],
+  'reviewer':      ['review', 'audit', 'refactor', 'code quality', 'lint'],
+  'researcher':    ['research', 'investigate', 'analyze', 'survey', 'compare'],
+  'architect':     ['design', 'architecture', 'ADR', 'domain', 'microservice'],
+  'planner':       ['plan', 'roadmap', 'strategy', 'prioritize', 'estimate'],
+  'security-engineer': ['security', 'vulnerability', 'CVE', 'XSS', 'CSRF'],
+  'backend-dev':   ['api', 'rest', 'graphql', 'endpoint', 'http', 'grpc'],
+  'frontend-dev':  ['ui', 'frontend', 'react', 'css', 'component', 'layout'],
+  'devops':        ['deploy', 'docker', 'kubernetes', 'CI/CD', 'terraform'],
+  'mobile-dev':    ['mobile', 'ios', 'android', 'react native', 'flutter'],
+  'ai-engineer':   ['ml', 'machine learning', 'model', 'neural', 'inference'],
+  'technical-writer': ['docs', 'readme', 'document', 'jsdoc', 'api reference'],
 };
 
+// ── Non-dev domain agent registry ─────────────────────────────────────────────
+
+var DOMAIN_AGENTS = [
+  // Marketing
+  { slug: 'content-strategist', name: 'Content Strategist', category: 'marketing',
+    keywords: /\b(content|brand|blogging|copywriting|content strategy)\b/i },
+  { slug: 'seo-specialist', name: 'SEO Specialist', category: 'marketing',
+    keywords: /\b(seo|search engine|keyword research|backlink|organic traffic)\b/i },
+  { slug: 'social-media-manager', name: 'Social Media Manager', category: 'marketing',
+    keywords: /\b(social media|instagram|tiktok|twitter|linkedin|facebook|campaign)\b/i },
+  { slug: 'marketing-analyst', name: 'Marketing Analyst', category: 'marketing',
+    keywords: /\b(marketing|advertising|analytics|conversion|funnel|cpm|cpa)\b/i },
+
+  // Sales
+  { slug: 'sales-strategist', name: 'Sales Strategist', category: 'sales',
+    keywords: /\b(sales|crm|lead generation|prospect|quota|sales revenue)\b/i },
+  { slug: 'account-manager', name: 'Account Manager', category: 'sales',
+    keywords: /\b(account management|client relationship|upsell|renewal|b2b)\b/i },
+
+  // Academic
+  { slug: 'academic-researcher', name: 'Academic Researcher', category: 'academic',
+    keywords: /\b(anthropolog|ethnograph|kinship|cultural ritual|qualitative study|thesis|dissertation|peer review|academic)\b/i },
+  { slug: 'data-scientist', name: 'Data Scientist', category: 'academic',
+    keywords: /\b(statistical analysis|regression|hypothesis|p-value|dataset|R studio)\b/i },
+
+  // Game development
+  { slug: 'game-developer', name: 'Game Developer', category: 'game-development',
+    keywords: /\b(unity|unreal|godot|game engine|shader|sprite|tilemap|game jam)\b/i },
+  { slug: 'game-designer', name: 'Game Designer', category: 'game-development',
+    keywords: /\b(game design|game mechanic|level design|player experience|narrative design)\b/i },
+
+  // Legal / Finance
+  { slug: 'legal-advisor', name: 'Legal Advisor', category: 'legal',
+    keywords: /\b(legal|contract|compliance|regulation|gdpr|liability|intellectual property)\b/i },
+  { slug: 'financial-analyst', name: 'Financial Analyst', category: 'finance',
+    keywords: /\b(finance|investment|portfolio|valuation|balance sheet|ROI|P&L)\b/i },
+
+  // HR / Operations
+  { slug: 'hr-specialist', name: 'HR Specialist', category: 'hr',
+    keywords: /\b(hiring|recruitment|onboarding|performance review|employee|hr|human resources)\b/i },
+];
+
+// Categories that are opt-in (only returned when keywords match)
+var OPT_IN_CATEGORIES = new Set(['academic', 'game-development', 'legal', 'finance', 'hr']);
+
+// Marketing is also opt-in — keywords must match
+var MARKETING_OPTIN = /\b(marketing|seo|social media|advertising|campaign|content strategy|tiktok|instagram|brand)\b/i;
+
+// ── Skills registry ────────────────────────────────────────────────────────────
+
+var SKILLS = [
+  { skill: 'mastermind', invoke: '/mastermind', description: 'Select swarm topology', keywords: /\b(swarm|topology|hive|mastermind|multi.agent)\b/i },
+  { skill: 'monodesign', invoke: '/monodesign', description: 'Frontend design and UI', keywords: /\b(design|ui|ux|component|visual|layout|css|theme)\b/i },
+  { skill: 'monomotion', invoke: '/monomotion', description: 'Web animations and motion', keywords: /\b(animate|animation|motion|gsap|transition|scroll)\b/i },
+  { skill: 'graphify', invoke: '/graphify', description: 'Input to knowledge graph', keywords: /\b(graph|knowledge|monograph|node|edge|visualize)\b/i },
+];
+
+// ── Utilities ─────────────────────────────────────────────────────────────────
+
 var MAX_PROMPT = 2000;
 
+// ── routeTask ─────────────────────────────────────────────────────────────────
+
 function routeTask(prompt) {
-  if (!prompt || typeof prompt !== 'string') return DEFAULT_RESULT;
+  // Empty / null → confidence 0
+  if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') {
+    return {
+      agent: 'coder',
+      agentSlug: 'coder',
+      confidence: 0,
+      reason: 'Default routing — empty input',
+      semanticRouting: false,
+      specificAgents: [],
+      skillMatches: [],
+      extrasMatches: [],
+    };
+  }
+
   var safePrompt = prompt.slice(0, MAX_PROMPT);
 
-  var best = null;
-  for (var i = 0; i < KEYWORD_ROUTES.length; i++) {
-    var rule = KEYWORD_ROUTES[i];
-    if (rule.pattern.test(safePrompt)) {
-      if (!best || rule.confidence > best.confidence) {
-        best = rule;
-      }
-    }
+  // Check non-dev domain agents first (only if opt-in keywords match)
+  var extras = matchExtras(safePrompt);
+  if (extras.length > 0) {
+    var topExtra = extras[0];
+    return {
+      agent: topExtra.name,
+      agentSlug: topExtra.slug,
+      confidence: 0.80,
+      reason: 'Domain: ' + topExtra.category,
+      semanticRouting: false,
+      specificAgents: extras,
+      skillMatches: [],
+      extrasMatches: extras,
+    };
   }
 
-  if (!best) return DEFAULT_RESULT;
+  // Check dev patterns in priority order
+  for (var i = 0; i < DEV_PRIORITY.length; i++) {
+    var slug = DEV_PRIORITY[i];
+    var pattern = _ROUTING_PATTERNS[slug];
+    if (pattern && pattern.test(safePrompt)) {
+      var confidence = TASK_CONFIDENCES[slug] || 0.75;
+      var skills = matchSkills(safePrompt);
+      return {
+        agent: TASK_AGENTS[slug],
+        agentSlug: slug,
+        confidence: confidence,
+        reason: ('Keyword match: ' + slug).slice(0, 80),
+        semanticRouting: false,
+        specificAgents: [{ slug: slug, name: TASK_AGENTS[slug], confidence: confidence }],
+        skillMatches: skills,
+        extrasMatches: [],
+      };
+    }
+  }
 
+  // No match → default
   return {
-    agent: best.agent,
-    agentSlug: best.agent.toLowerCase().replace(/\s+/g, '-'),
-    confidence: best.confidence,
-    reason: ('Keyword match: ' + best.pattern.toString()).slice(0, 80),
+    agent: 'coder',
+    agentSlug: 'coder',
+    confidence: 0.5,
+    reason: 'Default routing — no strong keyword match',
     semanticRouting: false,
     specificAgents: [],
     skillMatches: [],
@@ -65,7 +237,90 @@ function routeTask(prompt) {
   };
 }
 
+// ── matchSkills ────────────────────────────────────────────────────────────────
+
+function matchSkills(prompt, topN) {
+  if (!prompt || typeof prompt !== 'string') return [];
+  topN = topN || 5;
+  var safePrompt = prompt.slice(0, MAX_PROMPT);
+
+  var scored = [];
+  for (var i = 0; i < SKILLS.length; i++) {
+    var s = SKILLS[i];
+    if (s.keywords.test(safePrompt)) {
+      scored.push({ skill: s.skill, invoke: s.invoke, description: s.description, score: 1.0 });
+    }
+  }
+
+  scored.sort(function(a, b) { return b.score - a.score; });
+  return scored.slice(0, topN);
+}
+
+// ── matchExtras ────────────────────────────────────────────────────────────────
+
+function matchExtras(prompt, topN) {
+  if (!prompt || typeof prompt !== 'string') return [];
+  topN = topN || 8;
+  var safePrompt = prompt.slice(0, MAX_PROMPT);
+
+  var scored = [];
+  for (var i = 0; i < DOMAIN_AGENTS.length; i++) {
+    var a = DOMAIN_AGENTS[i];
+    if (!a.keywords.test(safePrompt)) continue;
+
+    // Opt-in categories: only include if keywords explicitly match
+    if (OPT_IN_CATEGORIES.has(a.category)) {
+      scored.push({ slug: a.slug, name: a.name, category: a.category, score: 1.0 });
+      continue;
+    }
+
+    // Marketing is opt-in too
+    if (a.category === 'marketing') {
+      if (MARKETING_OPTIN.test(safePrompt)) {
+        scored.push({ slug: a.slug, name: a.name, category: a.category, score: 1.0 });
+      }
+      continue;
+    }
+
+    // Sales: only include when sales keywords match
+    scored.push({ slug: a.slug, name: a.name, category: a.category, score: 1.0 });
+  }
+
+  scored.sort(function(a, b) { return b.score - a.score; });
+  return scored.slice(0, topN);
+}
+
+// ── buildCategoryList ─────────────────────────────────────────────────────────
+
+function buildCategoryList() {
+  var catMap = {};
+  for (var i = 0; i < DOMAIN_AGENTS.length; i++) {
+    var a = DOMAIN_AGENTS[i];
+    if (!catMap[a.category]) catMap[a.category] = { name: a.category, count: 0, examples: [] };
+    catMap[a.category].count++;
+    if (catMap[a.category].examples.length < 3) catMap[a.category].examples.push(a.slug);
+  }
+  return Object.values(catMap);
+}
+
+// ── getAgentsInCategory ────────────────────────────────────────────────────────
+
+function getAgentsInCategory(category) {
+  if (!category || typeof category !== 'string') return [];
+  return DOMAIN_AGENTS
+    .filter(function(a) { return a.category === category; })
+    .map(function(a) { return { slug: a.slug, name: a.name }; });
+}
+
+// ── exports ────────────────────────────────────────────────────────────────────
+
 module.exports = {
   routeTask: routeTask,
   routeTaskSemantic: routeTask,
+  matchSkills: matchSkills,
+  matchExtras: matchExtras,
+  buildCategoryList: buildCategoryList,
+  getAgentsInCategory: getAgentsInCategory,
+  AGENT_CAPABILITIES: AGENT_CAPABILITIES,
+  TASK_PATTERNS: TASK_PATTERNS,
 };

package/.claude/helpers/session.cjs

@@ -1,65 +1,140 @@
 'use strict';
 /**
  * Session state management for hook-handler.cjs
- * Persists session data to .monomind/session-state.json
+ * Persists session data to .git/monomind/sessions/current.json (branch-agnostic,
+ * shared across git worktrees). Falls back to .monomind/sessions/ if not in a git repo.
+ *
+ * API: start(), restore(), end(), status(), metric(key), update(patch)
  */
 
 const path = require('path');
 const fs = require('fs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const SESSION_FILE = path.join(CWD, '.monomind', 'session-state.json');
+
+function getMonoDir(workDir) {
+  try {
+    const gitEntry = path.join(workDir, '.git');
+    const st = fs.statSync(gitEntry);
+    if (st.isDirectory()) return path.join(gitEntry, 'monomind');
+    if (st.isFile()) {
+      const m = fs.readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
+      if (m) {
+        const worktreeDir = path.resolve(workDir, m[1].trim());
+        return path.join(path.dirname(path.dirname(worktreeDir)), 'monomind');
+      }
+    }
+  } catch {}
+  return path.join(workDir, '.monomind');
+}
+
+const SESSIONS_DIR = path.join(getMonoDir(CWD), 'sessions');
+const CURRENT_FILE = path.join(SESSIONS_DIR, 'current.json');
+
+var KNOWN_METRICS = new Set(['edits', 'commands', 'tasks', 'errors']);
 
 function ensureDir() {
-  try { fs.mkdirSync(path.dirname(SESSION_FILE), { recursive: true }); } catch (_) {}
+  try { fs.mkdirSync(SESSIONS_DIR, { recursive: true }); } catch (_) {}
 }
 
-function restore() {
+function readCurrent() {
   try {
-    if (!fs.existsSync(SESSION_FILE)) return null;
-    var st = fs.statSync(SESSION_FILE);
-    if (st.size > 1 * 1024 * 1024) return null; // 1 MiB guard
-    var raw = fs.readFileSync(SESSION_FILE, 'utf-8');
+    if (!fs.existsSync(CURRENT_FILE)) return null;
+    var st = fs.statSync(CURRENT_FILE);
+    if (st.size > 1 * 1024 * 1024) return null;
+    var raw = fs.readFileSync(CURRENT_FILE, 'utf-8');
     var data = JSON.parse(raw);
-    if (!data || !data.sessionId) return null;
-    console.log('[OK] Session restored: ' + data.sessionId);
+    if (!data || !data.id) return null;
     return data;
   } catch (_) {
     return null;
   }
 }
 
-function start() {
+function writeCurrent(data) {
   ensureDir();
-  var sessionId = 'session-' + Date.now();
-  var data = { sessionId: sessionId, startedAt: new Date().toISOString(), editCount: 0, taskCount: 0 };
   try {
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), 'utf-8');
-    console.log('[OK] Session started: ' + sessionId);
+    fs.writeFileSync(CURRENT_FILE, JSON.stringify(data, null, 2), 'utf-8');
   } catch (_) {}
-  return data;
 }
 
-function update(patch) {
-  ensureDir();
-  try {
-    var existing = restore() || start();
-    var merged = Object.assign({}, existing, patch, { updatedAt: new Date().toISOString() });
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(merged, null, 2), 'utf-8');
-    return merged;
-  } catch (_) {
-    return null;
-  }
+// ── start ──────────────────────────────────────────────────────────────────────
+
+function start() {
+  var sessionId = 'session-' + Date.now();
+  var sess = {
+    id: sessionId,
+    startedAt: new Date().toISOString(),
+    context: {},
+    metrics: { edits: 0, commands: 0, tasks: 0, errors: 0 },
+  };
+  writeCurrent(sess);
+  return sess;
 }
 
+// ── restore ────────────────────────────────────────────────────────────────────
+
+function restore() {
+  var data = readCurrent();
+  if (!data) return null;
+  data.restoredAt = new Date().toISOString();
+  writeCurrent(data);
+  return data;
+}
+
+// ── end ────────────────────────────────────────────────────────────────────────
+
 function end() {
+  var data = readCurrent();
+  if (!data) return null;
+
+  var startTs = new Date(data.startedAt).getTime();
+  var endTs = Date.now();
+  var duration = endTs - startTs;
+
+  var archived = Object.assign({}, data, {
+    endedAt: new Date(endTs).toISOString(),
+    duration: duration,
+  });
+
+  // Archive to <session-id>.json
   try {
-    var data = restore();
-    if (data) {
-      update({ endedAt: new Date().toISOString() });
-      console.log('[OK] Session ended: ' + data.sessionId);
-    }
+    var archivePath = path.join(SESSIONS_DIR, data.id + '.json');
+    fs.writeFileSync(archivePath, JSON.stringify(archived, null, 2), 'utf-8');
   } catch (_) {}
+
+  // Remove current.json
+  try { fs.unlinkSync(CURRENT_FILE); } catch (_) {}
+
+  return archived;
+}
+
+// ── status ─────────────────────────────────────────────────────────────────────
+
+function status() {
+  return readCurrent();
+}
+
+// ── metric ─────────────────────────────────────────────────────────────────────
+
+function metric(key) {
+  var data = readCurrent();
+  if (!data) return null;
+  if (!KNOWN_METRICS.has(key)) return data;
+
+  data.metrics[key] = (data.metrics[key] || 0) + 1;
+  writeCurrent(data);
+  return data;
+}
+
+// ── update ─────────────────────────────────────────────────────────────────────
+
+function update(patch) {
+  var existing = readCurrent();
+  if (!existing) return null;
+  var merged = Object.assign({}, existing, patch, { updatedAt: new Date().toISOString() });
+  writeCurrent(merged);
+  return merged;
 }
 
-module.exports = { restore, start, update, end };
+module.exports = { start, restore, end, status, metric, update };