chati-dev 1.2.0 → 1.3.0

package/framework/orchestrator/chati.md

@@ -1,6 +1,6 @@
 # /chati — Orchestrator
 
-You are the **chati.dev Orchestrator**, the single entry point for the chati.dev framework. You route requests, manage sessions, handle deviations, track backlog, and guide users through the development pipeline.
+You are the **chati.dev Orchestrator**, the single entry point for the chati.dev system. You route requests, manage sessions, handle deviations, track backlog, and guide users through the development pipeline.
 
 ---
 
@@ -9,7 +9,7 @@ You are the **chati.dev Orchestrator**, the single entry point for the chati.dev
 - **Name**: Chati
 - **Role**: Orchestrator & Router
 - **Position**: Entry point (always first contact)
-- **Scope**: Framework-wide routing, session management, deviation handling, backlog
+- **Scope**: System-wide routing, session management, deviation handling, backlog
 
 ---
 
@@ -26,19 +26,50 @@ When the user invokes `/chati`, execute this sequence:
 5. Detect language from session.yaml -> respond in that language
 ```
 
-### Step 2: Determine State
+### Step 2: Check Subcommands
+
+Before determining state, check if the user passed a subcommand:
+
+```
+/chati exit | /chati stop | /chati quit:
+  -> Execute Exit Protocol (see Session Lock Protocol section)
+  -> Do NOT proceed further
+
+/chati status:
+  -> Display status dashboard (see /chati status section)
+  -> Stay locked, do NOT exit
+
+/chati resume:
+  -> Load continuation from .chati/continuation/latest.md (if exists)
+  -> Resume session with full context recovery
+  -> Re-activate session lock
+
+/chati help:
+  -> Display available commands:
+     /chati              Start or resume session
+     /chati status       Show project dashboard
+     /chati resume       Resume from continuation file
+     /chati exit         Save and exit session
+     /chati help         Show this help
+  -> Stay locked
+
+(no subcommand or unrecognized):
+  -> Continue to Step 3 (Determine State)
+```
+
+### Step 3: Determine State
 
 **If session.yaml is empty or project.name is empty:**
 ```
--> First run. Go to Step 3 (New Project Setup)
+-> First run. Go to Step 4 (New Project Setup)
 ```
 
 **If session.yaml has active project:**
 ```
--> Resume session. Go to Step 4 (Session Resume)
+-> Resume session. Go to Step 5 (Session Resume)
 ```
 
-### Step 3: New Project Setup
+### Step 4: New Project Setup
 
 #### 3a. Detect Project Type
 ```
@@ -78,7 +109,7 @@ If greenfield -> Read chati.dev/agents/clarity/greenfield-wu.md -> Activate
 If brownfield -> Read chati.dev/agents/clarity/brownfield-wu.md -> Activate
 ```
 
-### Step 4: Session Resume
+### Step 5: Session Resume
 ```
 1. Read session.yaml -> identify current_agent, project.state, last_handoff
 2. Read latest handoff from chati.dev/artifacts/handoffs/
@@ -412,10 +443,125 @@ To activate autonomous mode:
 
 ---
 
+## Session Lock Protocol
+
+Once `/chati` is invoked and a session is active, the orchestrator LOCKS the session. ALL subsequent user messages are routed through the orchestrator and the active agent. The user never "falls out" of the chati.dev system.
+
+### Lock Activation
+
+```
+When /chati is invoked:
+  1. Load session state (Step 1-2 above)
+  2. SET session lock = ACTIVE
+  3. Update CLAUDE.md with Session Lock block (see template below)
+  4. ALL subsequent messages are intercepted by the orchestrator
+  5. Messages are routed to current_agent
+```
+
+### Session Lock Block (CLAUDE.md)
+
+When the session is active, CLAUDE.md MUST contain this block:
+
+```markdown
+## ⚠️ Session Lock — ACTIVE
+
+**chati.dev session is ACTIVE.** You MUST follow these rules for EVERY message:
+
+1. Read `chati.dev/orchestrator/chati.md` and follow its routing logic
+2. Route ALL user messages through the current agent: `{current_agent}`
+3. NEVER respond outside of the chati.dev system
+4. NEVER act as generic Claude — you ARE the chati.dev orchestrator
+5. If the user asks something unrelated to the current agent's scope,
+   handle it via the Deviation Protocol (Section 5.7), do NOT exit the system
+6. The ONLY way to exit is via explicit exit commands (see below)
+```
+
+This block is injected into CLAUDE.md when the session starts and removed when the user exits.
+
+### Message Routing (while locked)
+
+```
+User sends message:
+  │
+  ├─ Is it an exit command? (see Exit Commands below)
+  │   YES -> Execute Exit Protocol
+  │   NO  -> Continue
+  │
+  ├─ Is it a /chati subcommand? (/chati status, /chati help, etc.)
+  │   YES -> Execute subcommand, stay locked
+  │   NO  -> Continue
+  │
+  ├─ Is it relevant to current agent's scope?
+  │   YES -> Route to current agent
+  │   NO  -> Handle via Deviation Protocol (5.7)
+  │         -> Orchestrator re-routes to appropriate agent
+  │         -> Stay locked
+  │
+  └─ NEVER drop to raw/generic mode
+```
+
+### Exit Commands
+
+The session lock is ONLY released by explicit user intent:
+
+```
+Explicit commands (any language):
+  /chati exit
+  /chati stop
+  /chati quit
+
+Natural language (detected by orchestrator):
+  EN: "exit chati", "stop chati", "I want to leave", "quit the system"
+  PT: "sair do chati", "quero sair", "parar o chati"
+  ES: "salir de chati", "quiero salir", "parar el chati"
+  FR: "quitter chati", "je veux sortir", "arrêter chati"
+
+NOT exit triggers (stay locked):
+  - "stop" (without "chati" — could mean stop current task)
+  - "wait" / "pause" (temporary, not exit)
+  - "go back" / "voltar" (navigation within pipeline)
+  - "cancel" (cancel current action, not exit system)
+  - Closing the IDE (session persists in session.yaml for resume)
+```
+
+### Exit Protocol
+
+```
+When exit is triggered:
+  1. Save current agent state to session.yaml
+  2. Generate session digest (for Memory Layer):
+     - Decisions made this session
+     - Current progress and partial work
+     - Pending items
+  3. Update CLAUDE.md:
+     - REMOVE Session Lock block
+     - UPDATE project status with current state
+     - ADD resume instructions:
+       "Session paused at {agent}. Type /chati to resume."
+  4. Confirm to user in their language:
+     EN: "Session saved. Type /chati anytime to resume."
+     PT: "Sessão salva. Digite /chati para retomar."
+     ES: "Sesión guardada. Escribe /chati para reanudar."
+     FR: "Session sauvée. Tapez /chati pour reprendre."
+  5. Session data PERSISTS — nothing is lost
+```
+
+### Resume After Exit
+
+```
+When user types /chati after a previous exit:
+  -> Normal Step 5 (Session Resume) flow
+  -> Session Lock is RE-ACTIVATED
+  -> CLAUDE.md lock block is RE-INJECTED
+  -> User is back in the system seamlessly
+```
+
+---
+
 ## Constitution Enforcement
 
 The orchestrator enforces the Constitution (chati.dev/constitution.md):
-- **BLOCK** enforcement: Halt agent on violation (Articles I, II, III, IV, VII, VIII, X, XI)
+- **BLOCK** enforcement: Halt agent on violation (Articles I, II, III, IV, VII, VIII, X, XI, XV)
 - **GUIDE** enforcement: Correct behavior without halting (Articles V, IX)
 - **WARN** enforcement: Generate warning in QA (Article VI)
 

package/framework/schemas/config.schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "title": "chati.dev Config",
-  "description": "Schema for chati.dev/config.yaml - framework version and installation tracking",
+  "description": "Schema for chati.dev/config.yaml - system version and installation tracking",
   "type": "object",
   "required": ["version"],
   "properties": {

package/framework/schemas/context.schema.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "chati.dev Context Block",
+  "description": "Schema for <chati-context> XML block structure injected into agent prompts",
+  "type": "object",
+  "required": ["bracket", "constitution", "mode"],
+  "properties": {
+    "bracket": {
+      "enum": ["FRESH", "MODERATE", "DEPLETED", "CRITICAL"],
+      "description": "Current context bracket based on remaining context window"
+    },
+    "constitution": {
+      "type": "string",
+      "description": "Summarized constitution content (always injected, L0 layer)"
+    },
+    "mode": {
+      "enum": ["clarity", "build", "deploy"],
+      "description": "Current execution mode from session state (L1 layer)"
+    },
+    "agent": {
+      "type": "object",
+      "description": "Active agent scope information (L2 layer, active when bracket >= DEPLETED)",
+      "required": ["name", "mission"],
+      "properties": {
+        "name": { "type": "string", "description": "Agent identifier" },
+        "mission": { "type": "string", "description": "One-line agent mission statement" },
+        "inputs": { "type": "string", "description": "Expected inputs for this agent" },
+        "outputs": { "type": "string", "description": "Expected outputs from this agent" },
+        "criteria": { "type": "string", "description": "Success criteria summary" }
+      }
+    },
+    "pipeline": {
+      "type": "string",
+      "description": "Pipeline state string showing agent progression (L3 layer, active when bracket >= MODERATE)"
+    },
+    "task": {
+      "type": "string",
+      "description": "Current task description (L4 layer, active when bracket >= MODERATE)"
+    },
+    "handoff": {
+      "type": "object",
+      "description": "Previous agent handoff summary (L4 layer, active when bracket >= MODERATE)",
+      "properties": {
+        "from": { "type": "string", "description": "Source agent name" },
+        "score": { "type": "number", "minimum": 0, "maximum": 100, "description": "Source agent final score" },
+        "summary": { "type": "string", "description": "Key context from previous agent" }
+      }
+    },
+    "memory": {
+      "type": "object",
+      "description": "Memory injection based on bracket level",
+      "properties": {
+        "bracket": {
+          "enum": ["FRESH", "MODERATE", "DEPLETED", "CRITICAL"],
+          "description": "Memory retrieval bracket (mirrors context bracket)"
+        },
+        "level": {
+          "enum": ["none", "metadata", "chunks", "full"],
+          "description": "Memory retrieval level: none (FRESH), metadata (MODERATE), chunks (DEPLETED), full (CRITICAL)"
+        },
+        "entries": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": { "type": "string", "description": "Memory entry identifier" },
+              "title": { "type": "string", "description": "Memory title" },
+              "tier": { "enum": ["hot", "warm", "cold"], "description": "Memory attention tier" },
+              "summary": { "type": "string", "description": "Memory summary (L2 chunks level)" },
+              "content": { "type": "string", "description": "Full memory content (L3 full level)" }
+            }
+          }
+        }
+      }
+    },
+    "token_budget": {
+      "type": "object",
+      "description": "Token usage estimates",
+      "properties": {
+        "estimated_used": { "type": "integer", "minimum": 0, "description": "Estimated tokens used" },
+        "max_context": { "type": "integer", "minimum": 0, "description": "Maximum context window tokens" },
+        "remaining_percent": { "type": "number", "minimum": 0, "maximum": 100, "description": "Percentage of context remaining" },
+        "injection_budget": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Token budget for context injection (FRESH: 2500, MODERATE: 2000, DEPLETED: 1500, CRITICAL: 800)"
+        }
+      }
+    },
+    "active_layers": {
+      "type": "array",
+      "items": {
+        "enum": ["L0", "L1", "L2", "L3", "L4"]
+      },
+      "description": "Currently active injection layers based on bracket"
+    }
+  }
+}

package/framework/schemas/memory.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "chati.dev Memory Entry",
+  "description": "Schema for memory entry YAML frontmatter in .chati/memories/",
+  "type": "object",
+  "required": ["id", "type", "agent", "tags", "confidence", "sector", "tier", "created_at"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^mem-\\d{4}-\\d{2}-\\d{2}-\\d{3}$",
+      "description": "Unique memory identifier (mem-YYYY-MM-DD-NNN)"
+    },
+    "type": {
+      "enum": ["decision", "error_pattern", "resolution", "user_correction", "validated_pattern", "gotcha", "lesson"],
+      "description": "Classification of what this memory captures"
+    },
+    "agent": {
+      "type": "string",
+      "description": "Agent that created or owns this memory"
+    },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "description": "Searchable tags for similarity matching and retrieval"
+    },
+    "confidence": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "System confidence in this memory (0.0-1.0)"
+    },
+    "sector": {
+      "enum": ["episodic", "semantic", "procedural", "reflective"],
+      "description": "Cognitive sector: episodic (what happened), semantic (what we know), procedural (how to do it), reflective (what we learned)"
+    },
+    "tier": {
+      "enum": ["hot", "warm", "cold"],
+      "description": "Attention tier: hot (>0.7, auto-loaded), warm (0.3-0.7, on-demand), cold (<0.3, explicit search)"
+    },
+    "access_count": {
+      "type": "integer",
+      "minimum": 0,
+      "default": 0,
+      "description": "Number of times this memory has been accessed"
+    },
+    "evidence_count": {
+      "type": "integer",
+      "minimum": 0,
+      "default": 0,
+      "description": "Number of corroborating observations"
+    },
+    "last_accessed": {
+      "type": ["string", "null"],
+      "format": "date-time",
+      "description": "Timestamp of last access"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Timestamp of memory creation"
+    },
+    "expires_at": {
+      "type": ["string", "null"],
+      "format": "date-time",
+      "description": "Expiration timestamp (null for durable memories)"
+    },
+    "storage_tier": {
+      "enum": ["session", "daily", "durable"],
+      "default": "daily",
+      "description": "Storage persistence: session (cleaned on restart), daily (archived after 30d), durable (permanent)"
+    },
+    "scope": {
+      "enum": ["shared", "private"],
+      "default": "shared",
+      "description": "Visibility: shared (all agents) or private (owning agent only)"
+    }
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chati-dev",
-  "version": "1.2.0",
-  "description": "AI-Powered Multi-Agent Development Framework — 13 agents, 6 IDEs, 4 languages",
+  "version": "1.3.0",
+  "description": "AI-Powered Multi-Agent Orchestration System — 13 agents, 6 IDEs, 4 languages",
   "type": "module",
   "bin": {
     "chati": "bin/chati.js",
@@ -19,13 +19,15 @@
     "start": "node bin/chati.js",
     "bundle": "node scripts/bundle-framework.js",
     "prepublishOnly": "node scripts/bundle-framework.js",
-    "test": "node --test"
+    "test": "node --test test/**/*.test.js",
+    "lint": "eslint src/ bin/",
+    "lint:fix": "eslint src/ bin/ --fix"
   },
   "keywords": [
     "ai",
     "agents",
     "development",
-    "framework",
+    "system",
     "planning",
     "multi-agent",
     "cli",
@@ -46,15 +48,20 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
+    "blessed": "^0.1.81",
     "chalk": "^5.3.0",
-    "ora": "^8.0.1",
     "cli-progress": "^3.12.0",
     "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
-    "semver": "^7.6.0",
-    "blessed": "^0.1.81"
+    "ora": "^8.0.1",
+    "semver": "^7.6.0"
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.0",
+    "globals": "^17.3.0"
   }
 }

package/scripts/bundle-framework.js

@@ -35,7 +35,7 @@ const dirs = [
   'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
   'templates', 'workflows', 'quality-gates',
   'schemas', 'frameworks', 'intelligence', 'patterns',
-  'i18n', 'migrations',
+  'i18n', 'migrations', 'data',
 ];
 
 for (const dir of dirs) {

package/src/dashboard/data-reader.js

@@ -1,11 +1,11 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
 
 /**
  * Read all dashboard data from project directory
  */
-export function readDashboardData(targetDir) {
+export async function readDashboardData(targetDir) {
   const data = {
     session: null,
     config: null,
@@ -15,6 +15,9 @@ export function readDashboardData(targetDir) {
     recentActivity: [],
     blockers: [],
     gotchas: [],
+    memoryStats: null,
+    contextStatus: null,
+    registryStats: null,
   };
 
   // Read session.yaml
@@ -95,5 +98,27 @@ export function readDashboardData(targetDir) {
     });
   }
 
+  // Intelligence Layer data (graceful degradation)
+  try {
+    const { getMemoryStats } = await import('../intelligence/memory-manager.js');
+    data.memoryStats = getMemoryStats(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
+  try {
+    const { getContextStatus } = await import('../intelligence/context-status.js');
+    data.contextStatus = getContextStatus(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
+  try {
+    const { getRegistryStats } = await import('../intelligence/registry-manager.js');
+    data.registryStats = getRegistryStats(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
   return data;
 }

package/src/dashboard/layout.js

@@ -135,6 +135,27 @@ export function buildValidateSection(data) {
   ];
 }
 
+/**
+ * Build INTELLIGENCE section
+ */
+export function buildIntelligenceSection(data) {
+  const mem = data.memoryStats;
+  const ctx = data.contextStatus;
+  const reg = data.registryStats;
+
+  const memText = mem ? `${mem.total} total (H:${mem.byTier.hot} W:${mem.byTier.warm} C:${mem.byTier.cold})` : gray('N/A');
+  const ctxText = ctx ? `${ctx.bracket} [${ctx.activeLayers.join(',')}]` : gray('N/A');
+  const regText = reg && reg.exists ? `${reg.totalEntities} entities (${reg.countMatch ? green('match') : yellow('mismatch')})` : gray('N/A');
+
+  return [
+    brand('│') + `  ${brand('── INTELLIGENCE')} ${'─'.repeat(41)}` + brand('│'),
+    brand('│') + `  │ ${dim('Memory:')}   ${memText}` + ' '.repeat(Math.max(1, 35 - String(memText).length)) + brand('│'),
+    brand('│') + `  │ ${dim('Context:')}  ${ctxText}` + ' '.repeat(Math.max(1, 35 - String(ctxText).length)) + brand('│'),
+    brand('│') + `  │ ${dim('Registry:')} ${regText}` + ' '.repeat(Math.max(1, 35 - String(regText).length)) + brand('│'),
+    brand('│') + `  ${'─'.repeat(57)}` + brand('│'),
+  ];
+}
+
 /**
  * Build footer with recent activity, blockers, gotchas
  */

package/src/dashboard/renderer.js

@@ -5,6 +5,7 @@ import {
   buildClaritySection,
   buildBuildSection,
   buildValidateSection,
+  buildIntelligenceSection,
   buildFooter,
 } from './layout.js';
 import { dim } from '../utils/colors.js';
@@ -12,8 +13,8 @@ import { dim } from '../utils/colors.js';
 /**
  * Render dashboard once (static mode)
  */
-export function renderDashboard(targetDir) {
-  const data = readDashboardData(targetDir);
+export async function renderDashboard(targetDir) {
+  const data = await readDashboardData(targetDir);
 
   if (!data.session) {
     console.log('No chati.dev session found. Run `npx chati-dev init` first.');
@@ -30,6 +31,8 @@ export function renderDashboard(targetDir) {
     '',
     ...buildValidateSection(data),
     '',
+    ...buildIntelligenceSection(data),
+    '',
     ...buildFooter(data),
   ];
 
@@ -43,16 +46,16 @@ export function renderDashboard(targetDir) {
 /**
  * Render dashboard in watch mode (auto-refresh)
  */
-export function renderDashboardWatch(targetDir, intervalMs = 5000) {
+export async function renderDashboardWatch(targetDir, intervalMs = 5000) {
   // Initial render
   console.clear();
-  renderDashboard(targetDir);
+  await renderDashboard(targetDir);
   console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
 
   // Set up interval
-  const timer = setInterval(() => {
+  const timer = setInterval(async () => {
     console.clear();
-    renderDashboard(targetDir);
+    await renderDashboard(targetDir);
     console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
     console.log(dim(`  Last update: ${new Date().toLocaleTimeString()}`));
   }, intervalMs);
@@ -70,8 +73,8 @@ export function renderDashboardWatch(targetDir, intervalMs = 5000) {
 /**
  * Render plain text fallback (for terminals without TUI support)
  */
-export function renderPlainDashboard(targetDir) {
-  const data = readDashboardData(targetDir);
+export async function renderPlainDashboard(targetDir) {
+  const data = await readDashboardData(targetDir);
 
   if (!data.session) {
     console.log('No chati.dev session found. Run `npx chati-dev init` first.');