chati-dev 1.2.0 → 1.3.0

package/src/installer/core.js

@@ -1,7 +1,6 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import yaml from 'js-yaml';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
 import { generateSessionYaml, generateConfigYaml, generateClaudeMd } from './templates.js';
@@ -38,7 +37,7 @@ export async function installFramework(config) {
     'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
     'templates', 'workflows', 'quality-gates',
     'schemas', 'frameworks', 'intelligence', 'patterns',
-    'i18n', 'migrations',
+    'i18n', 'migrations', 'data',
     'artifacts/0-WU', 'artifacts/1-Brief', 'artifacts/2-PRD',
     'artifacts/3-Architecture', 'artifacts/4-UX', 'artifacts/5-Phases',
     'artifacts/6-Tasks', 'artifacts/7-QA-Planning', 'artifacts/8-Validation',
@@ -49,6 +48,27 @@ export async function installFramework(config) {
     createDir(join(frameworkDir, dir));
   }
 
+  // Create .chati/memories/ directory tree for Memory Layer
+  const memoriesBase = join(targetDir, '.chati', 'memories');
+  const memoryDirs = [
+    'shared/durable', 'shared/daily', 'shared/session',
+    'greenfield-wu/durable', 'greenfield-wu/daily',
+    'brownfield-wu/durable', 'brownfield-wu/daily',
+    'brief/durable', 'brief/daily',
+    'detail/durable', 'detail/daily',
+    'architect/durable', 'architect/daily',
+    'ux/durable', 'ux/daily',
+    'phases/durable', 'phases/daily',
+    'tasks/durable', 'tasks/daily',
+    'qa-planning/durable', 'qa-planning/daily',
+    'qa-implementation/durable', 'qa-implementation/daily',
+    'dev/durable', 'dev/daily',
+    'devops/durable', 'devops/daily',
+  ];
+  for (const dir of memoryDirs) {
+    createDir(join(memoriesBase, dir));
+  }
+
   // Copy framework files from source
   copyFrameworkFiles(frameworkDir);
 
@@ -115,6 +135,8 @@ function copyFrameworkFiles(destDir) {
     'schemas/session.schema.json',
     'schemas/config.schema.json',
     'schemas/task.schema.json',
+    'schemas/context.schema.json',
+    'schemas/memory.schema.json',
     // Frameworks
     'frameworks/quality-dimensions.yaml',
     'frameworks/decision-heuristics.yaml',
@@ -122,6 +144,9 @@ function copyFrameworkFiles(destDir) {
     'intelligence/gotchas.yaml',
     'intelligence/patterns.yaml',
     'intelligence/confidence.yaml',
+    'intelligence/context-engine.md',
+    'intelligence/memory-layer.md',
+    'intelligence/decision-engine.md',
     // Patterns
     'patterns/elicitation.md',
     // i18n
@@ -131,6 +156,8 @@ function copyFrameworkFiles(destDir) {
     'i18n/fr.yaml',
     // Migrations
     'migrations/v1.0-to-v1.1.yaml',
+    // Data
+    'data/entity-registry.yaml',
   ];
 
   for (const file of filesToCopy) {
@@ -182,11 +209,11 @@ This is a thin router. All logic lives in the orchestrator.
     }
   } else {
     // For other IDEs, create a rules file pointing to chati.dev/
-    const rulesContent = `# chati.dev Framework Rules
+    const rulesContent = `# chati.dev System Rules
 # This file configures ${config.name} to work with chati.dev
 
-## Framework Location
-All framework content is in the \`chati.dev/\` directory.
+## System Location
+All system content is in the \`chati.dev/\` directory.
 
 ## Session State
 Runtime session state is in \`.chati/session.yaml\` (IDE-agnostic).

package/src/installer/templates.js

@@ -80,6 +80,13 @@ export function generateClaudeMd(config) {
 ## Quick Start
 Type \`/chati\` to activate the orchestrator. It will guide you through the entire process.
 
+## Session Lock
+**Status: INACTIVE** — Type \`/chati\` to activate.
+
+When active, ALL messages are routed through the chati.dev orchestrator. The user stays inside the system until they explicitly exit with \`/chati exit\`.
+
+<!-- SESSION-LOCK:INACTIVE -->
+
 ## Key Files
 - **Session**: \`.chati/session.yaml\` (runtime state)
 - **Constitution**: \`chati.dev/constitution.md\` (governance)

package/src/installer/validator.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
 /**
@@ -13,6 +13,9 @@ export async function validateInstallation(targetDir) {
     schemas: { pass: false, details: [] },
     workflows: { pass: false, details: [] },
     templates: { pass: false, details: [] },
+    intelligence: { pass: false, details: [] },
+    registry: { pass: false, details: [] },
+    memories: { pass: false, details: [] },
     total: 0,
     passed: 0,
   };
@@ -56,7 +59,7 @@ export async function validateInstallation(targetDir) {
   if (existsSync(constitutionPath)) {
     const content = readFileSync(constitutionPath, 'utf-8');
     const articleCount = (content.match(/^## Article/gm) || []).length;
-    results.constitution.pass = articleCount >= 10;
+    results.constitution.pass = articleCount >= 15;
     results.constitution.details.push({ articleCount });
   }
   results.total += 1;
@@ -68,15 +71,18 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.session.pass) results.passed += 1;
 
-  // Check schemas
-  const schemaFiles = ['session.schema.json', 'config.schema.json', 'task.schema.json'];
+  // Check schemas (5 total: session, config, task, context, memory)
+  const schemaFiles = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
   let schemaCount = 0;
   for (const file of schemaFiles) {
     if (existsSync(join(targetDir, 'chati.dev', 'schemas', file))) {
       schemaCount++;
     }
   }
-  results.schemas.pass = schemaCount === 3;
+  results.schemas.pass = schemaCount === 5;
   results.total += 1;
   if (results.schemas.pass) results.passed += 1;
 
@@ -110,5 +116,38 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.templates.pass) results.passed += 1;
 
+  // Check intelligence files (6: 3 specs + 3 yaml)
+  const intelligenceFiles = [
+    'intelligence/context-engine.md',
+    'intelligence/memory-layer.md',
+    'intelligence/decision-engine.md',
+    'intelligence/gotchas.yaml',
+    'intelligence/patterns.yaml',
+    'intelligence/confidence.yaml',
+  ];
+  let intelCount = 0;
+  for (const file of intelligenceFiles) {
+    if (existsSync(join(targetDir, 'chati.dev', file))) {
+      intelCount++;
+    }
+  }
+  results.intelligence.pass = intelCount === 6;
+  results.intelligence.details.push({ found: intelCount, expected: 6 });
+  results.total += 1;
+  if (results.intelligence.pass) results.passed += 1;
+
+  // Check entity registry
+  const registryPath = join(targetDir, 'chati.dev', 'data', 'entity-registry.yaml');
+  results.registry.pass = existsSync(registryPath);
+  results.total += 1;
+  if (results.registry.pass) results.passed += 1;
+
+  // Check .chati/memories/ directory tree
+  const memoriesPath = join(targetDir, '.chati', 'memories');
+  const memoriesShared = join(memoriesPath, 'shared', 'durable');
+  results.memories.pass = existsSync(memoriesPath) && existsSync(memoriesShared);
+  results.total += 1;
+  if (results.memories.pass) results.passed += 1;
+
   return results;
 }

package/src/intelligence/context-status.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const BRACKETS = [
+  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 2500 },
+  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 2000 },
+  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             budget: 1500 },
+  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                   budget: 800 },
+];
+
+/**
+ * Get context status based on session state
+ * (Advisory — actual bracket is calculated at runtime by the orchestrator)
+ */
+export function getContextStatus(targetDir) {
+  const sessionPath = join(targetDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) {
+    return {
+      bracket: 'FRESH',
+      activeLayers: BRACKETS[0].layers,
+      tokenBudget: BRACKETS[0].budget,
+      memoryLevel: 'none',
+      advisory: 'No active session — default FRESH bracket',
+    };
+  }
+
+  // Read session to determine pipeline state
+  const sessionContent = readFileSync(sessionPath, 'utf-8');
+  const currentAgent = extractYamlValue(sessionContent, 'current_agent');
+  const state = extractYamlValue(sessionContent, 'state');
+
+  // Count completed agents as a rough proxy for context usage
+  const completedCount = (sessionContent.match(/status: completed/g) || []).length;
+  const inProgressCount = (sessionContent.match(/status: in_progress/g) || []).length;
+
+  // Estimate context usage based on pipeline progress
+  // More agents completed = more context consumed
+  const estimatedUsage = Math.min(95, completedCount * 8 + inProgressCount * 5);
+  const remainingPercent = 100 - estimatedUsage;
+
+  const bracket = BRACKETS.find(b => remainingPercent >= b.min && remainingPercent <= b.max) || BRACKETS[0];
+
+  const memoryLevels = { FRESH: 'none', MODERATE: 'metadata', DEPLETED: 'chunks', CRITICAL: 'full' };
+
+  return {
+    bracket: bracket.name,
+    activeLayers: bracket.layers,
+    tokenBudget: bracket.budget,
+    memoryLevel: memoryLevels[bracket.name],
+    remainingPercent,
+    estimatedUsage,
+    currentAgent: currentAgent || 'none',
+    pipelineState: state || 'unknown',
+    completedAgents: completedCount,
+    advisory: `Estimated bracket based on pipeline progress (${completedCount} agents completed)`,
+  };
+}
+
+/**
+ * Estimate context usage for display purposes
+ */
+export function estimateContextUsage(targetDir) {
+  const status = getContextStatus(targetDir);
+  return {
+    bracket: status.bracket,
+    remainingPercent: status.remainingPercent,
+    tokenBudget: status.tokenBudget,
+    layers: status.activeLayers,
+  };
+}
+
+/**
+ * Simple YAML value extractor (avoids js-yaml dependency)
+ */
+function extractYamlValue(content, key) {
+  const regex = new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm');
+  const match = content.match(regex);
+  if (!match) return null;
+  return match[1].trim().replace(/^["']|["']$/g, '');
+}

package/src/intelligence/memory-manager.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join, relative } from 'path';
+
+const MEMORIES_DIR = '.chati/memories';
+
+/**
+ * List memories with optional filters
+ */
+export function listMemories(targetDir, options = {}) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return [];
+
+  const memories = [];
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) return;
+
+    if (options.agent && meta.agent !== options.agent) return;
+    if (options.sector && meta.sector !== options.sector) return;
+    if (options.tier && meta.tier !== options.tier) return;
+
+    memories.push({
+      ...meta,
+      path: relative(memoriesPath, filePath),
+    });
+  });
+
+  return memories;
+}
+
+/**
+ * Search memories by query (matches tags and content)
+ */
+export function searchMemories(targetDir, query) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return [];
+
+  const queryLower = query.toLowerCase();
+  const results = [];
+
+  walkMemories(memoriesPath, (filePath) => {
+    const content = readFileSync(filePath, 'utf-8');
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) return;
+
+    const tagMatch = meta.tags && meta.tags.some(t => t.toLowerCase().includes(queryLower));
+    const contentMatch = content.toLowerCase().includes(queryLower);
+
+    if (tagMatch || contentMatch) {
+      results.push({
+        ...meta,
+        path: relative(memoriesPath, filePath),
+        matchType: tagMatch ? 'tag' : 'content',
+      });
+    }
+  });
+
+  return results;
+}
+
+/**
+ * Clean expired or cold memories
+ */
+export function cleanMemories(targetDir, options = {}) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return { cleaned: 0, skipped: 0 };
+
+  let cleaned = 0;
+  let skipped = 0;
+
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) { skipped++; return; }
+
+    // Clean session-tier memories (they should be cleaned on new session start)
+    const isSessionTier = filePath.includes('/session/');
+
+    // Clean expired memories
+    const isExpired = meta.expires_at && new Date(meta.expires_at) < new Date();
+
+    if (isSessionTier || isExpired) {
+      if (!options.dryRun) {
+        unlinkSync(filePath);
+      }
+      cleaned++;
+    } else {
+      skipped++;
+    }
+  });
+
+  return { cleaned, skipped, dryRun: !!options.dryRun };
+}
+
+/**
+ * Get memory statistics
+ */
+export function getMemoryStats(targetDir) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) {
+    return { total: 0, byAgent: {}, bySector: {}, byTier: {}, diskUsage: 0 };
+  }
+
+  const stats = {
+    total: 0,
+    byAgent: {},
+    bySector: {},
+    byTier: { hot: 0, warm: 0, cold: 0 },
+    diskUsage: 0,
+  };
+
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    const fileStats = statSync(filePath);
+    stats.diskUsage += fileStats.size;
+
+    if (!meta) return;
+    stats.total++;
+
+    if (meta.agent) {
+      stats.byAgent[meta.agent] = (stats.byAgent[meta.agent] || 0) + 1;
+    }
+    if (meta.sector) {
+      stats.bySector[meta.sector] = (stats.bySector[meta.sector] || 0) + 1;
+    }
+    if (meta.tier && stats.byTier[meta.tier] !== undefined) {
+      stats.byTier[meta.tier]++;
+    }
+  });
+
+  return stats;
+}
+
+/**
+ * Walk memory files recursively
+ */
+export function walkMemories(dir, callback) {
+  if (!existsSync(dir)) return;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkMemories(fullPath, callback);
+    } else if (entry.name.endsWith('.md')) {
+      callback(fullPath);
+    }
+  }
+}
+
+/**
+ * Parse YAML frontmatter from a memory file
+ */
+export function parseMemoryFrontmatter(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+
+    // Simple YAML parsing for frontmatter (no dependency on js-yaml)
+    const lines = fmMatch[1].split('\n');
+    const meta = {};
+    for (const line of lines) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx === -1) continue;
+      const key = line.slice(0, colonIdx).trim();
+      let value = line.slice(colonIdx + 1).trim();
+
+      // Handle arrays [a, b, c]
+      if (value.startsWith('[') && value.endsWith(']')) {
+        value = value.slice(1, -1).split(',').map(s => s.trim());
+      }
+      // Handle numbers
+      else if (!isNaN(value) && value !== '') {
+        value = parseFloat(value);
+      }
+      // Handle quoted strings
+      else if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      meta[key] = value;
+    }
+
+    return meta;
+  } catch {
+    return null;
+  }
+}

package/src/intelligence/registry-manager.js

@@ -0,0 +1,202 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+const REGISTRY_PATH = 'chati.dev/data/entity-registry.yaml';
+
+/**
+ * Check registry integrity against filesystem
+ */
+export function checkRegistry(targetDir) {
+  const registryPath = join(targetDir, REGISTRY_PATH);
+  if (!existsSync(registryPath)) {
+    return { valid: false, error: 'Entity registry not found', missing: [], orphaned: [] };
+  }
+
+  const registry = loadRegistry(registryPath);
+  if (!registry) {
+    return { valid: false, error: 'Failed to parse entity registry', missing: [], orphaned: [] };
+  }
+
+  const missing = [];
+  const found = [];
+
+  // Check each registered entity exists on disk
+  const entities = flattenEntities(registry.entities);
+  for (const entity of entities) {
+    const filePath = join(targetDir, entity.path);
+    if (existsSync(filePath)) {
+      found.push(entity);
+    } else {
+      missing.push(entity);
+    }
+  }
+
+  return {
+    valid: missing.length === 0,
+    totalEntities: entities.length,
+    found: found.length,
+    missing,
+  };
+}
+
+/**
+ * Get registry statistics
+ */
+export function getRegistryStats(targetDir) {
+  const registryPath = join(targetDir, REGISTRY_PATH);
+  if (!existsSync(registryPath)) {
+    return { exists: false, totalEntities: 0, byType: {} };
+  }
+
+  const registry = loadRegistry(registryPath);
+  if (!registry) {
+    return { exists: true, totalEntities: 0, byType: {}, error: 'Parse error' };
+  }
+
+  const entities = flattenEntities(registry.entities);
+  const byType = {};
+  for (const entity of entities) {
+    const type = entity.type || 'unknown';
+    byType[type] = (byType[type] || 0) + 1;
+  }
+
+  return {
+    exists: true,
+    version: registry.metadata?.version || 'unknown',
+    totalEntities: entities.length,
+    declaredCount: registry.metadata?.entity_count || 0,
+    countMatch: entities.length === (registry.metadata?.entity_count || 0),
+    byType,
+  };
+}
+
+/**
+ * Validate all entities exist on disk
+ */
+export function validateEntities(targetDir) {
+  const result = checkRegistry(targetDir);
+  return {
+    valid: result.valid,
+    total: result.totalEntities || 0,
+    found: result.found || 0,
+    missing: (result.missing || []).map(e => e.path),
+  };
+}
+
+/**
+ * Run comprehensive health check
+ */
+export function runHealthCheck(targetDir) {
+  const checks = {
+    registry: { pass: false, details: '' },
+    schemas: { pass: false, details: '' },
+    constitution: { pass: false, details: '' },
+    agents: { pass: false, details: '' },
+    entities: { pass: false, details: '' },
+    overall: 'UNHEALTHY',
+  };
+
+  // 1. Registry check
+  const registryStats = getRegistryStats(targetDir);
+  if (registryStats.exists && registryStats.totalEntities > 0) {
+    checks.registry.pass = true;
+    checks.registry.details = `${registryStats.totalEntities} entities registered (v${registryStats.version})`;
+  } else {
+    checks.registry.details = registryStats.exists ? 'Registry empty or invalid' : 'Registry not found';
+  }
+
+  // 2. Schema validation
+  const schemaFiles = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
+  let validSchemas = 0;
+  for (const file of schemaFiles) {
+    const schemaPath = join(targetDir, 'chati.dev', 'schemas', file);
+    if (existsSync(schemaPath)) {
+      try {
+        JSON.parse(readFileSync(schemaPath, 'utf-8'));
+        validSchemas++;
+      } catch {
+        // Invalid JSON
+      }
+    }
+  }
+  checks.schemas.pass = validSchemas === schemaFiles.length;
+  checks.schemas.details = `${validSchemas}/${schemaFiles.length} valid`;
+
+  // 3. Constitution check
+  const constitutionPath = join(targetDir, 'chati.dev', 'constitution.md');
+  if (existsSync(constitutionPath)) {
+    const content = readFileSync(constitutionPath, 'utf-8');
+    const articleCount = (content.match(/^## Article/gm) || []).length;
+    checks.constitution.pass = articleCount >= 15;
+    checks.constitution.details = `${articleCount}/15 articles`;
+  } else {
+    checks.constitution.details = 'Not found';
+  }
+
+  // 4. Agent check
+  const agentPaths = [
+    'orchestrator/chati.md',
+    'agents/clarity/greenfield-wu.md', 'agents/clarity/brownfield-wu.md',
+    'agents/clarity/brief.md', 'agents/clarity/detail.md',
+    'agents/clarity/architect.md', 'agents/clarity/ux.md',
+    'agents/clarity/phases.md', 'agents/clarity/tasks.md',
+    'agents/quality/qa-planning.md', 'agents/quality/qa-implementation.md',
+    'agents/build/dev.md', 'agents/deploy/devops.md',
+  ];
+  let foundAgents = 0;
+  for (const p of agentPaths) {
+    if (existsSync(join(targetDir, 'chati.dev', p))) foundAgents++;
+  }
+  checks.agents.pass = foundAgents === 13;
+  checks.agents.details = `${foundAgents}/13 present`;
+
+  // 5. Entity validation (registry vs filesystem)
+  const entityResult = validateEntities(targetDir);
+  checks.entities.pass = entityResult.valid;
+  checks.entities.details = `${entityResult.found}/${entityResult.total} present`;
+
+  // Overall
+  const passCount = Object.values(checks).filter(c => c && c.pass).length;
+  const totalChecks = 5;
+  checks.overall = passCount === totalChecks ? 'HEALTHY' : passCount >= 3 ? 'DEGRADED' : 'UNHEALTHY';
+  checks.passCount = passCount;
+  checks.totalChecks = totalChecks;
+
+  return checks;
+}
+
+/**
+ * Load and parse registry YAML
+ */
+function loadRegistry(registryPath) {
+  try {
+    const content = readFileSync(registryPath, 'utf-8');
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Flatten nested entity categories into flat array
+ */
+function flattenEntities(entities) {
+  if (!entities) return [];
+  const flat = [];
+
+  for (const [, items] of Object.entries(entities)) {
+    if (typeof items === 'object' && items !== null) {
+      for (const [name, entity] of Object.entries(items)) {
+        if (entity && entity.path) {
+          flat.push({ name, ...entity });
+        }
+      }
+    }
+  }
+
+  return flat;
+}

package/src/upgrade/backup.js

@@ -28,6 +28,8 @@ export function createBackup(targetDir, currentVersion) {
     'i18n',
     'patterns',
     'migrations',
+    'intelligence',
+    'data',
   ];
 
   const filesToBackup = [

package/src/upgrade/migrator.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
 import semver from 'semver';

package/src/utils/logger.js

@@ -26,7 +26,7 @@ export function logBanner(logoText, version) {
     console.log(brand(line));
   }
   console.log(brand(`chati.dev v${version}`));
-  console.log(dim('AI-Powered Multi-Agent Development Framework'));
+  console.log(dim('AI-Powered Multi-Agent Orchestration System'));
   console.log(dim('═'.repeat(55)));
   console.log();
 }