chati-dev 2.1.2 → 3.0.1

package/src/gates/gate-base.js

@@ -8,6 +8,33 @@
 
 import { evaluateGate, getGateThreshold, resolveGateAction } from '../autonomy/autonomous-gate.js';
 
+/**
+ * Gate verdict constants (v3.0.0).
+ * APPROVED: Score >= threshold — proceed to next pipeline stage.
+ * NEEDS_REVISION: Score within 5 points below threshold — return to agent for fixes.
+ * BLOCKED: Score significantly below threshold or critical blocker — halt pipeline.
+ */
+export const GateVerdict = {
+  APPROVED: 'approved',
+  NEEDS_REVISION: 'needs_revision',
+  BLOCKED: 'blocked',
+};
+
+/**
+ * Determine the gate verdict from a score and threshold.
+ *
+ * @param {number} score - Gate evaluation score (0-100)
+ * @param {number} threshold - Minimum score to pass
+ * @param {boolean} [hasCriticalBlocker=false] - Whether a critical blocker exists
+ * @returns {string} One of GateVerdict values
+ */
+export function determineVerdict(score, threshold, hasCriticalBlocker = false) {
+  if (hasCriticalBlocker) return GateVerdict.BLOCKED;
+  if (score >= threshold) return GateVerdict.APPROVED;
+  if (score >= threshold - 5) return GateVerdict.NEEDS_REVISION;
+  return GateVerdict.BLOCKED;
+}
+
 /**
  * Abstract base class for quality gates.
  *
@@ -70,14 +97,19 @@ export class GateBase {
 
       const action = resolveGateAction(gateResult.result, mode);
 
+      const threshold = getGateThreshold(this.agent);
+      const hasCriticalBlocker = warnings.some(w => w.toLowerCase().includes('critical'));
+      const verdict = determineVerdict(gateResult.score, threshold, hasCriticalBlocker);
+
       return {
         gateId: this.id,
         gateName: this.name,
         result: gateResult.result,
+        verdict,
         score: gateResult.score,
         evidence,
         recommendation: action.action,
-        canProceed: gateResult.canProceed,
+        canProceed: verdict === GateVerdict.APPROVED,
         details: gateResult.details,
         warnings,
       };

package/src/health/engine.js

@@ -0,0 +1,245 @@
+/**
+ * @fileoverview Health check engine for chati.dev.
+ *
+ * Validates framework integrity, CLI availability, session state,
+ * hook health, dependencies, and provider authentication.
+ * Constitution Article XIV — Framework Registry Governance.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { isCommandAvailable, parseProviderConfig } from '../utils/config-parser.js';
+
+// ---------------------------------------------------------------------------
+// Check Result Types
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} CheckResult
+ * @property {string} name - Check name
+ * @property {'pass'|'warn'|'fail'} status - Check status
+ * @property {string} message - Human-readable result
+ * @property {number} duration - Execution time in ms
+ */
+
+/**
+ * @typedef {object} HealthReport
+ * @property {number} score - Overall score (0-100)
+ * @property {number} total - Total checks run
+ * @property {number} passed - Checks passed
+ * @property {number} warned - Checks with warnings
+ * @property {number} failed - Checks failed
+ * @property {CheckResult[]} checks - Individual check results
+ * @property {string} timestamp - ISO timestamp
+ */
+
+// ---------------------------------------------------------------------------
+// Individual Checks
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if configured CLI providers are available on the system.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkCliAvailability(projectDir) {
+  const start = Date.now();
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+
+  if (!existsSync(configPath)) {
+    return { name: 'cli-availability', status: 'warn', message: 'No config.yaml found', duration: Date.now() - start };
+  }
+
+  const { enabled } = parseProviderConfig(projectDir);
+  const missing = [];
+
+  for (const provider of enabled) {
+    const available = await isCommandAvailable(provider);
+    if (!available) {
+      missing.push(provider);
+    }
+  }
+
+  if (missing.length > 0) {
+    return { name: 'cli-availability', status: 'warn', message: `Missing CLIs: ${missing.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'cli-availability', status: 'pass', message: 'All enabled CLIs available', duration: Date.now() - start };
+}
+
+/**
+ * Validate framework file integrity against entity registry.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkFrameworkIntegrity(projectDir) {
+  const start = Date.now();
+  const registryPath = join(projectDir, 'chati.dev', 'data', 'entity-registry.yaml');
+
+  if (!existsSync(registryPath)) {
+    return { name: 'framework-integrity', status: 'warn', message: 'No entity registry found', duration: Date.now() - start };
+  }
+
+  const raw = readFileSync(registryPath, 'utf-8');
+  const pathMatches = raw.match(/path:\s*["']?([^\s"']+)["']?/gm) || [];
+  let missing = 0;
+
+  for (const match of pathMatches) {
+    const filePath = match.replace(/path:\s*["']?/, '').replace(/["']?$/, '');
+    if (!existsSync(join(projectDir, filePath))) {
+      missing++;
+    }
+  }
+
+  if (missing > 0) {
+    return { name: 'framework-integrity', status: 'warn', message: `${missing} registered entities missing from filesystem`, duration: Date.now() - start };
+  }
+
+  return { name: 'framework-integrity', status: 'pass', message: 'All registered entities exist', duration: Date.now() - start };
+}
+
+/**
+ * Validate session.yaml structure.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkSessionState(projectDir) {
+  const start = Date.now();
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+
+  if (!existsSync(sessionPath)) {
+    return { name: 'session-state', status: 'pass', message: 'No active session (expected for new projects)', duration: Date.now() - start };
+  }
+
+  const raw = readFileSync(sessionPath, 'utf-8');
+  const requiredFields = ['project', 'language'];
+  const missingFields = requiredFields.filter((f) => !raw.includes(`${f}:`));
+
+  if (missingFields.length > 0) {
+    return { name: 'session-state', status: 'warn', message: `Session missing fields: ${missingFields.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'session-state', status: 'pass', message: 'Session state valid', duration: Date.now() - start };
+}
+
+/**
+ * Verify that hooks are functional.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkHooksHealth(projectDir) {
+  const start = Date.now();
+  const hooksDir = join(projectDir, 'chati.dev', 'hooks');
+
+  if (!existsSync(hooksDir)) {
+    return { name: 'hooks-health', status: 'fail', message: 'Hooks directory not found', duration: Date.now() - start };
+  }
+
+  const expectedHooks = ['prism-engine.js', 'model-governance.js', 'mode-governance.js', 'constitution-guard.js', 'read-protection.js', 'session-digest.js'];
+  const missing = expectedHooks.filter((h) => !existsSync(join(hooksDir, h)));
+
+  if (missing.length > 0) {
+    return { name: 'hooks-health', status: 'fail', message: `Missing hooks: ${missing.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'hooks-health', status: 'pass', message: 'All 6 hooks present', duration: Date.now() - start };
+}
+
+/**
+ * Verify system dependencies.
+ *
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkDependencies() {
+  const start = Date.now();
+  const issues = [];
+
+  const { execSync } = await import('child_process');
+
+  // Check Node.js version
+  try {
+    const nodeVersion = execSync('node --version', { encoding: 'utf-8' }).trim();
+    const major = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
+    if (major < 20) {
+      issues.push(`Node.js ${nodeVersion} < required v20`);
+    }
+  } catch {
+    issues.push('Node.js not found');
+  }
+
+  // Check git
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+  } catch {
+    issues.push('git not found');
+  }
+
+  if (issues.length > 0) {
+    return { name: 'dependencies', status: 'fail', message: issues.join('; '), duration: Date.now() - start };
+  }
+
+  return { name: 'dependencies', status: 'pass', message: 'All dependencies satisfied', duration: Date.now() - start };
+}
+
+/**
+ * Check git repository status.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkGitStatus(projectDir) {
+  const start = Date.now();
+
+  if (!existsSync(join(projectDir, '.git'))) {
+    return { name: 'git-status', status: 'warn', message: 'Not a git repository', duration: Date.now() - start };
+  }
+
+  return { name: 'git-status', status: 'pass', message: 'Git repository detected', duration: Date.now() - start };
+}
+
+// ---------------------------------------------------------------------------
+// Health Engine
+// ---------------------------------------------------------------------------
+
+/**
+ * Run all health checks and produce a report.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {Promise<HealthReport>}
+ */
+export async function runHealthChecks(projectDir) {
+  const checks = [
+    checkCliAvailability(projectDir),
+    checkFrameworkIntegrity(projectDir),
+    checkSessionState(projectDir),
+    checkHooksHealth(projectDir),
+    checkDependencies(),
+    checkGitStatus(projectDir),
+  ];
+
+  const results = await Promise.allSettled(checks);
+  const checkResults = results.map((r) => {
+    if (r.status === 'fulfilled') return r.value;
+    return { name: 'unknown', status: 'fail', message: r.reason?.message || 'Check failed', duration: 0 };
+  });
+
+  const passed = checkResults.filter((c) => c.status === 'pass').length;
+  const warned = checkResults.filter((c) => c.status === 'warn').length;
+  const failed = checkResults.filter((c) => c.status === 'fail').length;
+  const total = checkResults.length;
+  const score = Math.round((passed / total) * 100);
+
+  return {
+    score,
+    total,
+    passed,
+    warned,
+    failed,
+    checks: checkResults,
+    timestamp: new Date().toISOString(),
+  };
+}

package/src/installer/core.js

@@ -3,7 +3,8 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
-import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd } from './templates.js';
+import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd, generateGeminiRouter, generateCopilotAgent } from './templates.js';
+import { generateContextFiles } from '../config/context-file-generator.js';
 import { verifyManifest } from './manifest.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -18,7 +19,7 @@ const FRAMEWORK_SOURCE = existsSync(BUNDLED_SOURCE) ? BUNDLED_SOURCE : MONOREPO_
  * Install Chati.dev framework into target directory
  */
 export async function installFramework(config) {
-  const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version } = config;
+  const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version, llmProvider } = config;
 
   // 0. Verify framework signature (supply chain protection)
   const manifestPath = join(FRAMEWORK_SOURCE, 'manifest.json');
@@ -38,7 +39,7 @@ export async function installFramework(config) {
   createDir(join(targetDir, '.chati'));
   writeFileSync(
     join(targetDir, '.chati', 'session.yaml'),
-    generateSessionYaml({ projectName, projectType, language, selectedIDEs, selectedMCPs }),
+    generateSessionYaml({ projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider }),
     'utf-8'
   );
 
@@ -91,7 +92,7 @@ export async function installFramework(config) {
   // Write config.yaml
   writeFileSync(
     join(frameworkDir, 'config.yaml'),
-    generateConfigYaml({ version, projectType, language, selectedIDEs }),
+    generateConfigYaml({ version, projectType, language, selectedIDEs, llmProvider }),
     'utf-8'
   );
 
@@ -101,13 +102,13 @@ export async function installFramework(config) {
   }
 
   // 4. Copy context files to .claude/rules/chati/ (auto-loaded by Claude Code)
-  const rulesDir = join(targetDir, '.claude', 'rules', 'chati');
-  createDir(rulesDir);
   const contextFiles = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
+  const claudeRulesDir = join(targetDir, '.claude', 'rules', 'chati');
+  createDir(claudeRulesDir);
   for (const file of contextFiles) {
     const src = join(FRAMEWORK_SOURCE, 'context', file);
     if (existsSync(src)) {
-      copyFileSync(src, join(rulesDir, file));
+      copyFileSync(src, join(claudeRulesDir, file));
     }
   }
 
@@ -124,6 +125,14 @@ export async function installFramework(config) {
     generateClaudeLocalMd(),
     'utf-8'
   );
+
+  // 7. Generate context files for non-Claude providers (GEMINI.md, AGENTS.md)
+  // Copilot CLI natively reads AGENTS.md + CLAUDE.md + GEMINI.md — no separate COPILOT.md needed.
+  const hasNonClaudeProvider = (llmProvider && llmProvider !== 'claude') ||
+    selectedIDEs.some(ide => ['gemini-cli', 'github-copilot'].includes(ide));
+  if (hasNonClaudeProvider) {
+    generateContextFiles(targetDir);
+  }
 }
 
 /**
@@ -157,12 +166,14 @@ function copyFrameworkFiles(destDir) {
     'templates/fullstack-architecture-tmpl.yaml',
     'templates/task-tmpl.yaml',
     'templates/qa-gate-tmpl.yaml',
+    'templates/quick-brief-tmpl.yaml',
     // Workflows
     'workflows/greenfield-fullstack.yaml',
     'workflows/brownfield-fullstack.yaml',
     'workflows/brownfield-discovery.yaml',
     'workflows/brownfield-service.yaml',
     'workflows/brownfield-ui.yaml',
+    'workflows/quick-flow.yaml',
     // Quality gates
     'quality-gates/planning-gate.md',
     'quality-gates/implementation-gate.md',
@@ -191,6 +202,7 @@ function copyFrameworkFiles(destDir) {
     'hooks/session-digest.js',
     'hooks/model-governance.js',
     'hooks/settings.json',
+    'hooks/read-protection.js',
     // Domains (PRISM Context Engine)
     'domains/constitution.yaml',
     'domains/global.yaml',
@@ -212,6 +224,7 @@ function copyFrameworkFiles(destDir) {
     'domains/workflows/brownfield-discovery.yaml',
     'domains/workflows/brownfield-service.yaml',
     'domains/workflows/brownfield-ui.yaml',
+    'domains/workflows/quick-flow.yaml',
     // i18n
     'i18n/en.yaml',
     'i18n/pt.yaml',
@@ -294,10 +307,32 @@ Pass through all context: session state, handoffs, artifacts, and user input.
         'utf-8'
       );
     }
+  } else if (ideKey === 'gemini-cli') {
+    // Gemini CLI: TOML command file (native format for /chati command)
+    writeFileSync(join(targetDir, '.gemini', 'commands', 'chati.toml'), generateGeminiRouter(), 'utf-8');
+  } else if (ideKey === 'github-copilot') {
+    // GitHub Copilot: agent file (.github/agents/chati.md) for @chati invocation
+    writeFileSync(join(targetDir, '.github', 'agents', 'chati.md'), generateCopilotAgent(), 'utf-8');
+
+    // Copilot instructions file (auto-loaded by Copilot CLI)
+    createDir(dirname(join(targetDir, config.rulesFile)));
+    writeFileSync(join(targetDir, config.rulesFile), generateProviderInstructions(config.name), 'utf-8');
   } else {
-    // For other IDEs, create a rules file pointing to chati.dev/
-    const rulesContent = `# Chati.dev System Rules
-# This file configures ${config.name} to work with Chati.dev
+    // VS Code, Cursor, AntiGravity — generic rules file
+    if (config.rulesFile) {
+      createDir(dirname(join(targetDir, config.rulesFile)));
+      writeFileSync(join(targetDir, config.rulesFile), generateProviderInstructions(config.name), 'utf-8');
+    }
+  }
+}
+
+/**
+ * Generate provider-agnostic instructions file content.
+ * Used for non-Claude IDEs (.github/copilot-instructions.md, .vscode/chati/rules.md, etc.)
+ */
+function generateProviderInstructions(providerName) {
+  return `# Chati.dev System Rules
+# This file configures ${providerName} to work with Chati.dev
 
 ## System Location
 All system content is in the \`chati.dev/\` directory.
@@ -310,7 +345,15 @@ The orchestrator is at \`chati.dev/orchestrator/chati.md\`.
 Read it to understand routing, session management, and agent activation.
 
 ## Constitution
-Governance rules are in \`chati.dev/constitution.md\` (17 Articles).
+Governance rules are in \`chati.dev/constitution.md\` (19 Articles).
+
+## Pipeline
+\`\`\`
+DISCOVER: WU -> Brief
+PLAN:     Detail -> Architect -> UX -> Phases -> Tasks -> QA-Planning
+BUILD:    Dev -> QA-Implementation
+DEPLOY:   DevOps
+\`\`\`
 
 ## Agents
 - DISCOVER: chati.dev/agents/discover/ (3 agents)
@@ -319,11 +362,6 @@ Governance rules are in \`chati.dev/constitution.md\` (17 Articles).
 - BUILD: chati.dev/agents/build/ (1 agent)
 - DEPLOY: chati.dev/agents/deploy/ (1 agent)
 `;
-    if (config.rulesFile) {
-      createDir(dirname(join(targetDir, config.rulesFile)));
-      writeFileSync(join(targetDir, config.rulesFile), rulesContent, 'utf-8');
-    }
-  }
 }
 
 /**

package/src/installer/templates.js

@@ -4,7 +4,7 @@ import yaml from 'js-yaml';
  * Generate session.yaml content
  */
 export function generateSessionYaml(config) {
-  const { projectName, projectType, language, selectedIDEs, selectedMCPs } = config;
+  const { projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider } = config;
 
   const session = {
     project: {
@@ -13,16 +13,19 @@ export function generateSessionYaml(config) {
       state: 'discover',
     },
     execution_mode: 'interactive',
+    execution_profile: 'guided',
     current_agent: '',
     language: language,
     ides: selectedIDEs,
     mcps: selectedMCPs,
+    providers_enabled: [llmProvider || 'claude'],
     user_level: 'auto',
     user_level_confidence: 0.0,
     agents: {},
     backlog: [],
     last_handoff: '',
     deviations: [],
+    profile_transitions: [],
   };
 
   // Initialize all 12 agent statuses
@@ -44,11 +47,56 @@ export function generateSessionYaml(config) {
   return yaml.dump(session, { lineWidth: -1, quotingType: '"', forceQuotes: false });
 }
 
+/**
+ * Optimal model assignments per provider.
+ * Deep reasoning agents (architect, qa, dev, detail, brownfield-wu) get the top model.
+ * Lightweight agents (brief, phases, ux, greenfield-wu, devops, orchestrator) get the fast model.
+ */
+const PROVIDER_MODEL_MAPS = {
+  claude: {
+    deep: 'opus', light: 'sonnet', minimal: 'haiku',
+    agents: {
+      orchestrator: 'sonnet', 'greenfield-wu': 'haiku', 'brownfield-wu': 'opus',
+      brief: 'sonnet', detail: 'opus', architect: 'opus', ux: 'sonnet',
+      phases: 'sonnet', tasks: 'sonnet', 'qa-planning': 'opus',
+      dev: 'opus', 'qa-implementation': 'opus', devops: 'sonnet',
+    },
+  },
+  gemini: {
+    deep: 'pro', light: 'flash', minimal: 'flash',
+    agents: {
+      orchestrator: 'flash', 'greenfield-wu': 'flash', 'brownfield-wu': 'pro',
+      brief: 'flash', detail: 'pro', architect: 'pro', ux: 'flash',
+      phases: 'flash', tasks: 'flash', 'qa-planning': 'pro',
+      dev: 'pro', 'qa-implementation': 'pro', devops: 'flash',
+    },
+  },
+  codex: {
+    deep: 'codex', light: 'mini', minimal: 'mini',
+    agents: {
+      orchestrator: 'mini', 'greenfield-wu': 'mini', 'brownfield-wu': 'codex',
+      brief: 'mini', detail: 'codex', architect: 'codex', ux: 'mini',
+      phases: 'mini', tasks: 'mini', 'qa-planning': 'codex',
+      dev: 'codex', 'qa-implementation': 'codex', devops: 'mini',
+    },
+  },
+  copilot: {
+    deep: 'claude-sonnet', light: 'claude-sonnet', minimal: 'gpt-5',
+    agents: {
+      orchestrator: 'claude-sonnet', 'greenfield-wu': 'gpt-5', 'brownfield-wu': 'claude-sonnet',
+      brief: 'claude-sonnet', detail: 'claude-sonnet', architect: 'claude-sonnet', ux: 'claude-sonnet',
+      phases: 'claude-sonnet', tasks: 'claude-sonnet', 'qa-planning': 'claude-sonnet',
+      dev: 'claude-sonnet', 'qa-implementation': 'claude-sonnet', devops: 'claude-sonnet',
+    },
+  },
+};
+
 /**
  * Generate config.yaml content
  */
 export function generateConfigYaml(config) {
-  const { version, projectType, language, selectedIDEs } = config;
+  const { version, projectType, language, selectedIDEs, llmProvider } = config;
+  const provider = llmProvider || 'claude';
 
   const configData = {
     version: version,
@@ -58,8 +106,25 @@ export function generateConfigYaml(config) {
     project_type: projectType,
     language: language,
     ides: selectedIDEs,
+    providers: {
+      claude: { enabled: true, primary: provider === 'claude' },
+      gemini: { enabled: provider === 'gemini' || selectedIDEs.includes('gemini-cli'), model_default: 'pro', primary: provider === 'gemini' },
+      codex: { enabled: provider === 'codex', model_default: 'codex', primary: provider === 'codex' },
+      copilot: { enabled: provider === 'copilot' || selectedIDEs.includes('github-copilot'), primary: provider === 'copilot' },
+    },
   };
 
+  // Add agent_overrides with optimal model map for the selected provider
+  if (provider !== 'claude') {
+    const modelMap = PROVIDER_MODEL_MAPS[provider];
+    if (modelMap) {
+      configData.agent_overrides = {};
+      for (const [agent, model] of Object.entries(modelMap.agents)) {
+        configData.agent_overrides[agent] = { provider, model };
+      }
+    }
+  }
+
   return yaml.dump(configData, { lineWidth: -1, quotingType: '"', forceQuotes: false });
 }
 
@@ -81,6 +146,70 @@ Type \`/chati\` to start.
 `;
 }
 
+/**
+ * Generate Gemini CLI TOML command (.gemini/commands/chati.toml)
+ *
+ * Gemini CLI custom commands use TOML format with `description` and `prompt` fields.
+ * Supports {{args}} for user arguments and @{file} for file injection.
+ */
+export function generateGeminiRouter() {
+  return `description = "Activate Chati.dev orchestrator"
+prompt = """
+CRITICAL — Language Override:
+Read \`.chati/session.yaml\` field \`language\` BEFORE anything else.
+ALL responses MUST be in this language (en, pt, es, fr).
+If session.yaml does not exist or has no language field, default to English.
+
+Read and execute the full orchestrator at \`chati.dev/orchestrator/chati.md\`.
+
+Context to load:
+- \`.chati/session.yaml\` (session state — includes language)
+- \`chati.dev/artifacts/handoffs/\` (latest handoff)
+- \`chati.dev/config.yaml\` (version info)
+
+User input: {{args}}
+"""
+`;
+}
+
+/**
+ * Generate GitHub Copilot agent file (.github/agents/chati.md)
+ *
+ * Copilot CLI uses .github/agents/*.md for custom agents.
+ * The user invokes with @chati in the Copilot CLI.
+ */
+export function generateCopilotAgent() {
+  return `# Chati.dev Orchestrator
+
+You are the Chati.dev orchestrator agent for GitHub Copilot CLI.
+
+## CRITICAL — Language Override
+
+Read \`.chati/session.yaml\` field \`language\` BEFORE anything else.
+ALL responses MUST be in this language. This overrides any global setting.
+
+| Value | Language |
+|-------|----------|
+| \`en\`  | English |
+| \`pt\`  | Portugues |
+| \`es\`  | Espanol |
+| \`fr\`  | Francais |
+
+If session.yaml does not exist or has no language field, default to English.
+
+## Load
+
+Read and execute the full orchestrator at \`chati.dev/orchestrator/chati.md\`.
+
+Pass through all context: session state, handoffs, artifacts, and user input.
+
+**Context to pass:**
+- \`.chati/session.yaml\` (session state — includes language)
+- \`chati.dev/artifacts/handoffs/\` (latest handoff)
+- \`chati.dev/config.yaml\` (version info)
+`;
+}
+
 /**
  * Generate CLAUDE.local.md content (runtime state — auto-gitignored, never committed)
  */

package/src/installer/validator.js

@@ -63,7 +63,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 >= 17;
+    results.constitution.pass = articleCount >= 19;
     results.constitution.details.push({ articleCount });
   }
   results.total += 1;
@@ -94,6 +94,7 @@ export async function validateInstallation(targetDir) {
   const workflowFiles = [
     'greenfield-fullstack.yaml', 'brownfield-fullstack.yaml',
     'brownfield-discovery.yaml', 'brownfield-service.yaml', 'brownfield-ui.yaml',
+    'quick-flow.yaml',
   ];
   let workflowCount = 0;
   for (const file of workflowFiles) {
@@ -101,7 +102,7 @@ export async function validateInstallation(targetDir) {
       workflowCount++;
     }
   }
-  results.workflows.pass = workflowCount === 5;
+  results.workflows.pass = workflowCount === 6;
   results.total += 1;
   if (results.workflows.pass) results.passed += 1;
 
@@ -109,6 +110,7 @@ export async function validateInstallation(targetDir) {
   const templateFiles = [
     'prd-tmpl.yaml', 'brownfield-prd-tmpl.yaml',
     'fullstack-architecture-tmpl.yaml', 'task-tmpl.yaml', 'qa-gate-tmpl.yaml',
+    'quick-brief-tmpl.yaml',
   ];
   let templateCount = 0;
   for (const file of templateFiles) {
@@ -116,7 +118,7 @@ export async function validateInstallation(targetDir) {
       templateCount++;
     }
   }
-  results.templates.pass = templateCount === 5;
+  results.templates.pass = templateCount === 6;
   results.total += 1;
   if (results.templates.pass) results.passed += 1;