chati-dev 4.1.6 → 4.2.1

package/framework/templates/team-build-tasks.yaml

@@ -0,0 +1,56 @@
+# Team Build Tasks Template (Article XXI)
+# Used by orchestrator when forming a Build Team (BUILD phase)
+# QA reviews EACH task as Dev completes it (per-task review, not batch)
+
+team_type: build
+phase: build
+mission: "Implement all tasks with per-task QA review and evidence-based quality gates"
+
+# NOTE: Tasks are dynamically populated from tasks.md at team formation time.
+# This template defines the PATTERN, not the actual tasks.
+# The orchestrator reads tasks.md and generates TT-BLD-{NNN} entries per task.
+
+task_pattern:
+  dev_task:
+    id_format: "TT-BLD-{NNN}-DEV"
+    assigned_to: dev
+    status: pending
+    score: null
+    blocker: null
+    threshold: 95
+    on_complete:
+      notify: qa-implementation
+      message_type: task_ready_for_review
+      include: [task_id, commit_hash, score, artifacts, self_critique_findings]
+
+  qa_review:
+    id_format: "TT-BLD-{NNN}-QA"
+    assigned_to: qa-implementation
+    status: pending
+    score: null
+    blocker: null
+    depends_on: ["TT-BLD-{NNN}-DEV"]
+    threshold: 95
+    protocol:
+      - "Run Evidence Gate (Phase 4c): lint, typecheck, test output required"
+      - "Classify fault origin (Phase 4d): INTENT | SPEC | CODE | DEFER"
+      - "Check Decision Trail for known-bad states before review"
+      - "Issue per-task verdict: pass | warn | block"
+    on_block:
+      action: notify_dev
+      message_type: task_review_findings
+      include: [task_id, verdict, findings, evidence, fault_origin]
+
+# Example of dynamically generated tasks (orchestrator produces these):
+#
+# tasks:
+#   - id: TT-BLD-001-DEV
+#     title: "T1.1: Initialize Next.js + App Router"
+#     assigned_to: dev
+#     source_task: T1.1
+#     ...
+#   - id: TT-BLD-001-QA
+#     title: "T1.1: Review + approve"
+#     assigned_to: qa-implementation
+#     depends_on: [TT-BLD-001-DEV]
+#     ...

package/framework/templates/team-planning-tasks.yaml

@@ -0,0 +1,73 @@
+# Team Planning Tasks Template (Article XXI)
+# Used by orchestrator when forming a Planning Team (post-Brief)
+# Cross-review assignments form a circular review: Detail -> Architect -> UX -> Detail
+
+team_type: planning
+phase: plan
+mission: "Co-design PRD, architecture, and UX specification with cross-validated alignment"
+
+tasks:
+  - id: TT-PLN-001
+    title: "Expand Brief into PRD with acceptance criteria"
+    assigned_to: detail
+    status: pending
+    score: null
+    blocker: null
+    depends_on: []
+    cross_review:
+      target: architect
+      questions:
+        - "Do PRD entities align with the data architecture constraints you anticipate?"
+        - "Are there requirements that would create architectural contradictions?"
+        - "Are scope decisions in Section 4 likely to conflict with your design?"
+    artifacts_produced:
+      - prd.md
+    threshold: 90
+
+  - id: TT-PLN-002
+    title: "Design system architecture and data architecture"
+    assigned_to: architect
+    status: pending
+    score: null
+    blocker: null
+    depends_on: []
+    cross_review:
+      target: ux
+      questions:
+        - "Does the responsive strategy conflict with deployment architecture constraints?"
+        - "Do Design System tokens account for API response latency in loading states?"
+        - "Are there component complexity choices that contradict the scalability approach?"
+    artifacts_produced:
+      - architecture.md
+    threshold: 90
+
+  - id: TT-PLN-003
+    title: "Design UX specification with brandbook, user flows, and components"
+    assigned_to: ux
+    status: pending
+    score: null
+    blocker: null
+    depends_on: []
+    cross_review:
+      target: detail
+      questions:
+        - "Do any PRD requirements conflict with the selected visual direction?"
+        - "Are there user flows implying requirements not captured in the PRD?"
+        - "Is the target user profile consistent with UX research findings?"
+    artifacts_produced:
+      - ux-specification.md
+      - brandbook.md
+      - brandbook.html
+    threshold: 90
+
+  - id: TT-PLN-004
+    title: "Cross-validate alignment: PRD entities = DB tables = UI components"
+    assigned_to: null
+    status: pending
+    score: null
+    blocker: null
+    depends_on: [TT-PLN-001, TT-PLN-002, TT-PLN-003]
+    cross_review: null
+    artifacts_produced: []
+    threshold: 95
+    notes: "Assigned by Team Lead after individual tasks complete. All 3 members participate."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "4.1.6",
+  "version": "4.2.1",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {

package/scripts/validate-package.js

@@ -166,6 +166,114 @@ function checkBinExists(packageRoot, results) {
   }
 }
 
+/**
+ * Validate that every hook referenced in hooks/settings.json exists on disk.
+ * Prevents shipping a bundle where settings.json references a hook file that
+ * was never copied.
+ */
+function checkHooksParity(packageRoot, results) {
+  results.checks++;
+  const settingsPath = join(packageRoot, 'framework', 'hooks', 'settings.json');
+  if (!existsSync(settingsPath)) {
+    results.warnings.push('framework/hooks/settings.json not found — skipping hooks parity check.');
+    results.passed++;
+    return;
+  }
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    const missing = new Set();
+    const hooksDir = join(packageRoot, 'framework', 'hooks');
+
+    // Walk all hook events and collect referenced .js files
+    for (const event of Object.keys(settings.hooks || {})) {
+      for (const matcher of settings.hooks[event] || []) {
+        for (const hook of matcher.hooks || []) {
+          if (hook.type === 'command' && typeof hook.command === 'string') {
+            // command format: "node chati.dev/hooks/foo.js"
+            const match = hook.command.match(/hooks\/([^\s]+\.js)/);
+            if (match) {
+              const hookFile = match[1];
+              if (!existsSync(join(hooksDir, hookFile))) {
+                missing.add(hookFile);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (missing.size === 0) {
+      results.passed++;
+    } else {
+      results.errors.push(`Hooks referenced in settings.json but missing from framework/hooks/: ${[...missing].join(', ')}`);
+    }
+  } catch (err) {
+    results.errors.push(`Failed to parse hooks/settings.json: ${err.message}`);
+  }
+}
+
+/**
+ * Parity check: every file in source chati.dev/ (that belongs to a copied
+ * directory) must exist in framework/. Catches bundling bugs where new files
+ * are added to the source but not included in the bundle.
+ *
+ * Only runs when the monorepo source is available (skipped inside the
+ * published package since the source is not shipped).
+ */
+function checkSourceBundleParity(packageRoot, results) {
+  results.checks++;
+  const monorepoSource = join(packageRoot, '..', '..', 'chati.dev');
+  const bundleDir = join(packageRoot, 'framework');
+
+  if (!existsSync(monorepoSource)) {
+    // Running inside the published package — skip (nothing to compare against)
+    results.passed++;
+    return;
+  }
+
+  // Collect all files in source, grouped by the top-level directory
+  const missing = [];
+  const COPIED_DIRS = [
+    'orchestrator', 'agents', 'templates', 'workflows', 'quality-gates',
+    'schemas', 'frameworks', 'intelligence', 'patterns', 'hooks',
+    'domains', 'i18n', 'migrations', 'data', 'context', 'tasks', 'presets',
+  ];
+  const COPIED_ROOT_FILES = ['constitution.md'];
+
+  function walk(srcDir, relBase) {
+    if (!existsSync(srcDir)) return;
+    for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+      const srcPath = join(srcDir, entry.name);
+      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(srcPath, relPath);
+      } else if (entry.isFile()) {
+        const bundlePath = join(bundleDir, relPath);
+        if (!existsSync(bundlePath)) missing.push(relPath);
+      }
+    }
+  }
+
+  for (const file of COPIED_ROOT_FILES) {
+    const src = join(monorepoSource, file);
+    const bundled = join(bundleDir, file);
+    if (existsSync(src) && !existsSync(bundled)) missing.push(file);
+  }
+
+  for (const dir of COPIED_DIRS) {
+    walk(join(monorepoSource, dir), dir);
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    const sample = missing.slice(0, 10).join(', ');
+    const more = missing.length > 10 ? ` (+ ${missing.length - 10} more)` : '';
+    results.errors.push(`Files in source chati.dev/ missing from framework/ bundle: ${sample}${more}`);
+  }
+}
+
 /**
  * Compare entity count in registry vs actual files in framework/.
  */
@@ -216,6 +324,8 @@ export function validatePackage(packageRoot) {
   checkExportsResolve(packageRoot, results);
   checkBinExists(packageRoot, results);
   checkEntityCount(packageRoot, results);
+  checkHooksParity(packageRoot, results);
+  checkSourceBundleParity(packageRoot, results);
 
   return results;
 }

package/src/autonomy/safety-net.js

@@ -12,6 +12,7 @@ export const SAFETY_TRIGGERS = {
   CRITICAL_RISK: 'critical_risk', // Security/data risk detected
   TIMEOUT: 'timeout', // Agent exceeded time limit
   GOTCHA_SPIKE: 'gotcha_spike', // 5+ new gotchas in current session
+  EDIT_LOOP: 'edit_loop', // Same file edited 3+ times in current task (Article XX)
 };
 
 // Critical risk keywords
@@ -98,6 +99,9 @@ export function evaluateTrigger(trigger, state) {
     case SAFETY_TRIGGERS.GOTCHA_SPIKE:
       return evaluateGotchaSpike(state);
 
+    case SAFETY_TRIGGERS.EDIT_LOOP:
+      return evaluateEditLoop(state);
+
     default:
       return {
         triggered: false,
@@ -291,6 +295,34 @@ function evaluateGotchaSpike(state) {
   };
 }
 
+/**
+ * Article XX — Detect edit loops (same file edited 3+ times in current task).
+ * state.fileEdits should be an object: { 'path/to/file.tsx': 3, ... }
+ */
+function evaluateEditLoop(state) {
+  const threshold = 3;
+  const fileEdits = state.fileEdits || {};
+  const loopedFiles = Object.entries(fileEdits)
+    .filter(([, count]) => count >= threshold);
+
+  if (loopedFiles.length > 0) {
+    const details = loopedFiles
+      .map(([path, count]) => `${path} (${count} edits)`)
+      .join(', ');
+    return {
+      triggered: true,
+      severity: 'critical',
+      details: `Edit loop detected (Article XX): ${details}. Stop and diagnose root cause before continuing.`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'No edit loops detected',
+  };
+}
+
 /**
  * Get critical risk keywords list.
  * @returns {string[]}

package/src/installer/core.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
@@ -146,144 +146,103 @@ export async function installFramework(config) {
 }
 
 /**
- * Copy framework files from the Chati.dev source directory
+ * Framework directories to copy recursively from source to target.
+ * This list controls WHICH top-level directories under chati.dev/ get copied.
+ * Everything inside each directory is copied automatically — no need to
+ * enumerate individual files.
+ *
+ * New files added to the source framework are picked up automatically.
  */
-export function copyFrameworkFiles(destDir, provider = 'claude') {
-  if (!existsSync(FRAMEWORK_SOURCE)) return;
-
-  const filesToCopy = [
-    'constitution.md',
-    'orchestrator/chati.md',
-    // DISCOVER agents
-    'agents/discover/greenfield-wu.md',
-    'agents/discover/brownfield-wu.md',
-    'agents/discover/brief.md',
-    // PLAN agents
-    'agents/plan/detail.md',
-    'agents/plan/architect.md',
-    'agents/plan/architect-system.md',
-    'agents/plan/architect-data-engineer.md',
-    'agents/plan/ux.md',
-    'agents/plan/ux-brand-architect.md',
-    'agents/plan/ux-researcher.md',
-    'agents/plan/ux-component-engineer.md',
-    'agents/plan/phases.md',
-    'agents/plan/tasks.md',
-    // Quality agents
-    'agents/quality/qa-planning.md',
-    'agents/quality/qa-implementation.md',
-    // BUILD + DEPLOY agents
-    'agents/build/dev.md',
-    'agents/deploy/devops.md',
-    // Templates
-    'templates/prd-tmpl.yaml',
-    'templates/brownfield-prd-tmpl.yaml',
-    'templates/fullstack-architecture-tmpl.yaml',
-    'templates/task-tmpl.yaml',
-    'templates/qa-gate-tmpl.yaml',
-    'templates/quick-brief-tmpl.yaml',
-    'templates/brandbook-tmpl.yaml',
-    'templates/brandbook-html-tmpl.md',
-    'templates/design-token-tmpl.yaml',
-    'templates/component-spec-tmpl.yaml',
-    'templates/icon-system-tmpl.yaml',
-    'templates/session-memory-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',
-    'workflows/standard-flow.yaml',
-    // Quality gates
-    'quality-gates/planning-gate.md',
-    'quality-gates/implementation-gate.md',
-    // Schemas
-    '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',
-    // Intelligence
-    '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',
-    'patterns/elicitation-library.yaml',
-    // Hooks
-    'hooks/prism-engine.js',
-    'hooks/mode-governance.js',
-    'hooks/constitution-guard.js',
-    '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',
-    'domains/agents/orchestrator.yaml',
-    'domains/agents/greenfield-wu.yaml',
-    'domains/agents/brownfield-wu.yaml',
-    'domains/agents/brief.yaml',
-    'domains/agents/detail.yaml',
-    'domains/agents/architect.yaml',
-    'domains/agents/ux.yaml',
-    'domains/agents/phases.yaml',
-    'domains/agents/tasks.yaml',
-    'domains/agents/qa-planning.yaml',
-    'domains/agents/qa-implementation.yaml',
-    'domains/agents/dev.yaml',
-    'domains/agents/devops.yaml',
-    'domains/workflows/greenfield-fullstack.yaml',
-    'domains/workflows/brownfield-fullstack.yaml',
-    'domains/workflows/brownfield-discovery.yaml',
-    'domains/workflows/brownfield-service.yaml',
-    'domains/workflows/brownfield-ui.yaml',
-    'domains/workflows/quick-flow.yaml',
-    'domains/workflows/standard-flow.yaml',
-    // i18n
-    'i18n/en.yaml',
-    'i18n/pt.yaml',
-    'i18n/es.yaml',
-    'i18n/fr.yaml',
-    // Migrations
-    'migrations/v1.0-to-v1.1.yaml',
-    // Data
-    'data/entity-registry.yaml',
-    // Context (@ import chain for CLAUDE.md)
-    'context/root.md',
-    'context/governance.md',
-    'context/protocols.md',
-    'context/quality.md',
-  ];
-
-  for (const file of filesToCopy) {
-    const src = join(FRAMEWORK_SOURCE, file);
-    const dest = join(destDir, file);
+const FRAMEWORK_DIRS_TO_COPY = [
+  'orchestrator',
+  'agents',
+  'templates',
+  'workflows',
+  'quality-gates',
+  'schemas',
+  'frameworks',
+  'intelligence',
+  'patterns',
+  'hooks',
+  'domains',
+  'i18n',
+  'migrations',
+  'data',
+  'context',
+  'tasks',
+  'presets',
+];
 
-    if (existsSync(src)) {
-      createDir(dirname(dest));
+/**
+ * Loose files at the root of chati.dev/ that get copied directly.
+ */
+const FRAMEWORK_ROOT_FILES = [
+  'constitution.md',
+];
 
-      if (provider !== 'claude' && ADAPTABLE_FILES.has(file)) {
+/**
+ * Recursively copy a directory from source to destination, applying provider
+ * adaptation for files listed in ADAPTABLE_FILES when the provider is not Claude.
+ */
+function copyDirRecursive(srcDir, destDir, provider, relBase = '') {
+  if (!existsSync(srcDir)) return;
+  createDir(destDir);
+
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+    const relPath = relBase ? join(relBase, entry.name) : entry.name;
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, provider, relPath);
+    } else if (entry.isFile()) {
+      if (provider !== 'claude' && ADAPTABLE_FILES.has(relPath)) {
         // Non-Claude provider: read, adapt, write
-        const content = readFileSync(src, 'utf-8');
-        writeFileSync(dest, adaptFrameworkFile(content, file, provider), 'utf-8');
+        const content = readFileSync(srcPath, 'utf-8');
+        writeFileSync(destPath, adaptFrameworkFile(content, relPath, provider), 'utf-8');
       } else {
         // Claude or non-adaptable: direct copy
-        copyFileSync(src, dest);
+        copyFileSync(srcPath, destPath);
       }
     }
   }
 }
 
+/**
+ * Copy framework files from the Chati.dev source directory.
+ *
+ * Uses recursive directory copy instead of a hardcoded file list, so that
+ * new files added to the framework source are automatically picked up.
+ *
+ * @param {string} destDir - Target framework directory (e.g., {project}/chati.dev/)
+ * @param {string} provider - Primary provider for text adaptation ('claude' | 'gemini' | 'codex')
+ */
+export function copyFrameworkFiles(destDir, provider = 'claude') {
+  if (!existsSync(FRAMEWORK_SOURCE)) return;
+
+  // Copy loose root files
+  for (const file of FRAMEWORK_ROOT_FILES) {
+    const src = join(FRAMEWORK_SOURCE, file);
+    if (!existsSync(src)) continue;
+    const dest = join(destDir, file);
+    createDir(dirname(dest));
+    if (provider !== 'claude' && ADAPTABLE_FILES.has(file)) {
+      const content = readFileSync(src, 'utf-8');
+      writeFileSync(dest, adaptFrameworkFile(content, file, provider), 'utf-8');
+    } else {
+      copyFileSync(src, dest);
+    }
+  }
+
+  // Copy each framework directory recursively
+  for (const dir of FRAMEWORK_DIRS_TO_COPY) {
+    const srcDir = join(FRAMEWORK_SOURCE, dir);
+    const destSubDir = join(destDir, dir);
+    copyDirRecursive(srcDir, destSubDir, provider, dir);
+  }
+}
+
 /**
  * Configure a specific IDE
  */

package/src/installer/templates.js

@@ -108,6 +108,40 @@ export function generateConfigYaml(config) {
     },
   };
 
+  // Feature flags (Intelligence Upgrade + Article XXI Agent Teams)
+  // Must match source chati.dev/config.yaml features block.
+  configData.features = {
+    hybrid_budget: true,
+    anti_dash: true,
+    rate_limiter_integration: true,
+    l5_keywords: true,
+    prompt_size_guard: true,
+    ids_decision_engine: true,
+    surface_criteria: true,
+    parallel_fallback: true,
+    tool_mesh: true,
+    tech_presets: true,
+    doctor_autofix: true,
+    brandbook: true,
+    // Intelligence Upgrade (v4.0.5 — Claude Code patterns)
+    undercover_mode: true,
+    memory_extraction: true,
+    memory_consolidation: true,
+    daily_digest: true,
+    structured_session_memory: true,
+    static_prism_boundary: true,
+    token_bracket_estimation: true,
+    model_fallback: true,
+    frustration_detection: true,
+    bash_security_checks: true,
+    // Agent Teams (v4.2.0 — Article XXI)
+    agent_teams: false,
+    team_planning_size: 3,
+    team_build_size: 2,
+    team_echo_threshold: 0.92,
+    team_correction_cycles_max: 2,
+  };
+
   // Add telemetry config
   configData.telemetry = {
     enabled: config.telemetryEnabled !== false,