chati-dev 3.3.2 → 4.0.0

package/README.md

@@ -266,7 +266,7 @@ Three systems operate transparently behind the pipeline:
 
 | System | What it does |
 |--------|-------------|
-| **Context Engine (PRISM)** | Injects the right context at the right time. 5 layers of context (from system-wide rules down to specific task details). Tracks how much context space remains and adapts automatically. |
+| **Context Engine (PRISM)** | Injects the right context at the right time. 6 layers of context (from constitution rules down to keyword-matched domain rules). Uses Progressive Reinforcement: as context degrades, injection budgets INCREASE (1.5% to 5.0% of provider context window). Provider-aware for Claude (200K), Gemini (1M), and Codex (128K). |
 | **Memory System (RECALL)** | Remembers decisions, gotchas, and lessons across sessions. Organized into 4 sectors: what happened (episodic), what we know (semantic), how we do things (procedural), and what we learned (reflective). |
 | **Decision Engine (COMPASS)** | Before creating something new, checks if a similar component already exists. Decides whether to reuse, adapt, or create from scratch. Keeps a registry of all project entities. |
 
@@ -390,8 +390,8 @@ your-project/
 │   │   ├── quality/              # QA-Planning, QA-Implementation
 │   │   ├── build/                # Dev
 │   │   └── deploy/               # DevOps
-│   ├── workflows/                # 6 workflow blueprints
-│   ├── templates/                # 6 artifact templates
+│   ├── workflows/                # 7 workflow blueprints
+│   ├── templates/                # 10 artifact templates
 │   ├── schemas/                  # 5 JSON schemas
 │   ├── intelligence/             # PRISM, RECALL, COMPASS specs
 │   ├── domains/                  # Per-agent and per-workflow configs
@@ -454,5 +454,5 @@ For security concerns, see our [Security Policy](.github/SECURITY.md).
 
 <p align="center">
   <sub>Built with structure, validated by agents, governed by constitution.</sub><br>
-  <sub>Chati.dev &copy; 2026</sub>
+  <sub>Chati.dev v4.0 "Pegasus" &copy; 2026</sub>
 </p>

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "3.3.2"
+version: "4.0.0"
 installed_at: "2026-02-07T10:00:00Z"
-updated_at: "2026-03-03T00:00:00Z"
-installer_version: "3.3.2"
+updated_at: "2026-03-17T00:00:00Z"
+installer_version: "4.0.0"
 project_type: greenfield
 language: en
 ides: [claude-code]
@@ -28,6 +28,21 @@ providers:
 #     provider: gemini
 #     model: pro
 
+# Feature flags — toggle new capabilities (v4.0 Pegasus)
+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
+
 # Telemetry — opt-in anonymous usage tracking
 telemetry:
   enabled: true

package/framework/constitution.md

@@ -32,13 +32,13 @@ Chati.dev is a planning-first AI-assisted orchestration system that coordinates
 
 ### Exclusion List
 
-The following items from source projects are explicitly excluded from Chati.dev:
-- CI/CD pipelines, release scripts, publish scripts from source projects
+The following items are explicitly out of scope for Chati.dev:
+- CI/CD pipelines, release scripts, publish scripts (contributor tooling)
 - Husky/lint-staged configs (contributor tooling)
 - npm package configs (.npmignore, .npmrc)
 - Dashboard web UI (separate product)
 - Monitor Server (separate product)
-- Source project installer packages
+- Standalone installer packages (CLI handles installation)
 - execution-n8n skill (removed — code-only focus)
 - Generic tasks redundant with agent self-validation protocols
 - Duplicate checklists already covered by agent self-validation
@@ -270,7 +270,8 @@ The pipeline operates in three execution modes that control agent permissions. M
 1. The orchestrator SHALL calculate the context bracket (FRESH, MODERATE, DEPLETED, CRITICAL) before every agent interaction.
 
 2. Context injection layers SHALL be reduced according to bracket level:
-   - FRESH/MODERATE: All 5 layers (L0-L4)
+   - FRESH: All 6 layers (L0-L5)
+   - MODERATE: L0 + L1 + L2 + L3 + L5 (skip L4 task detail)
    - DEPLETED: L0 (Constitution) + L1 (Mode) + L2 (Agent) only
    - CRITICAL: L0 (Constitution) + L1 (Mode) only
 
@@ -280,11 +281,12 @@ The pipeline operates in three execution modes that control agent permissions. M
 
 4. The Constitution (L0) and Mode governance (L1) are NON-NEGOTIABLE and SHALL be injected in ALL brackets, including CRITICAL.
 
-5. Token budgets per bracket:
-   - FRESH: 2500 tokens maximum
-   - MODERATE: 2000 tokens maximum
-   - DEPLETED: 1500 tokens maximum
-   - CRITICAL: 800 tokens maximum
+5. Token budgets per bracket (Progressive Reinforcement Model — as context degrades, reinforcement increases):
+   - Budgets are expressed as a percentage of the provider's context window
+   - FRESH: 1.5% of context window (Claude: 3000, Gemini: 15000, Codex: 1920)
+   - MODERATE: 2.5% of context window (Claude: 5000, Gemini: 25000, Codex: 3200)
+   - DEPLETED: 4.0% of context window (Claude: 8000, Gemini: 40000, Codex: 5120)
+   - CRITICAL: 5.0% of context window (Claude: 10000, Gemini: 50000, Codex: 6400)
 
 6. Autonomous spawn capability varies by IDE:
    - Full autonomy: Claude Code, AntiGravity, Gemini CLI
@@ -472,5 +474,5 @@ When multiple CLI providers are enabled, the system SHALL coordinate agent execu
 
 ---
 
-*Chati.dev Constitution v3.3.0 — 19 Articles + Preamble*
+*Chati.dev Constitution v4.0.0 — 19 Articles + Preamble*
 *All agents are bound by this Constitution. Violations are enforced per article.*

package/framework/context/governance.md

@@ -10,6 +10,8 @@ Extracted from `chati.dev/constitution.md` (19 Articles). Read the full constitu
 ## Context Bracket (Article XII)
 - 4 brackets: FRESH, MODERATE, DEPLETED, CRITICAL
 - CRITICAL = Constitution + Global layers only (no agent/task context)
+- Progressive Reinforcement: budget INCREASES as context degrades (1.5% → 2.5% → 4.0% → 5.0% of provider context window)
+- Provider-aware: budgets scale proportionally to context window size (Claude 200K, Gemini 1M, Codex 128K)
 - Handoff before bracket drops below 15%
 
 ## Memory (Article XIII)

package/framework/context/root.md

@@ -1,7 +1,7 @@
 # Chati.dev System Context
 
 ## Framework
-- **Version**: 3.3.0
+- **Version**: 4.0.0
 - **Agents**: 13 (12 specialized + orchestrator)
 - **Constitution**: 19 Articles + Preamble
 - **Quality**: 5 pipeline gates + 3-tier verdicts (APPROVED / NEEDS_REVISION / BLOCKED)

package/framework/intelligence/context-engine.md

@@ -2,7 +2,7 @@
 
 ## Purpose
 
-The Context Engine monitors context window usage and adapts what information is injected into each agent's prompt. As the context fills, fewer layers are injected to preserve quality for critical operations.
+The Context Engine monitors context window usage and adapts what information is injected into each agent's prompt. As the context fills, fewer layers are injected to maintain focus, while per-layer reinforcement INCREASES to compensate for the model forgetting initial instructions (Progressive Reinforcement Model).
 
 ---
 
@@ -12,16 +12,16 @@ Four brackets define behavior based on remaining context:
 
 | Bracket | Context Remaining | Behavior |
 |---------|-------------------|----------|
-| **FRESH** | 60-100% | All protocols active. Minimal injection — context is plentiful. |
-| **MODERATE** | 40-60% | Normal protocols. Summarize long outputs. Standard memory retrieval. |
-| **DEPLETED** | 25-40% | Reinforce Constitution + Agent scope. Skip optional patterns. Recover context via memory. |
-| **CRITICAL** | <25% | Constitution + Agent scope only. Trigger handoff to new session. Full memory dump for continuity. |
+| **FRESH** | 60-100% | All 6 layers active. Minimal reinforcement (1.5%) — context is plentiful. No memory injection. |
+| **MODERATE** | 40-60% | 5 layers (skip L4). Growing reinforcement (2.5%) — model starting to forget. Metadata memory. |
+| **DEPLETED** | 25-40% | 3 layers (L0-L2). Heavy reinforcement (4.0%) — significant context loss. Chunk memory recovery. |
+| **CRITICAL** | <25% | 2 layers (L0-L1). Maximum reinforcement (5.0%) — last interactions before handoff. Full memory dump. |
 
 ---
 
 ## Layered Context Injection
 
-The orchestrator injects context through 5 hierarchical layers:
+The orchestrator injects context through 6 hierarchical layers:
 
 | Layer | Name | Source | When Active |
 |-------|------|--------|-------------|
@@ -30,15 +30,18 @@ The orchestrator injects context through 5 hierarchical layers:
 | **L2** | Agent Scope | `chati.dev/agents/{agent}/` — mission, inputs, outputs, criteria | When agent is active |
 | **L3** | Pipeline State | `.chati/session.yaml` — pipeline position, scores, backlog | When session is active |
 | **L4** | Task Context | Active artifact + previous agent's handoff | When task is active |
+| **L5** | Keywords | `chati.dev/domains/keywords/` — dynamic rules from user prompt | FRESH + MODERATE only |
 
 ### Layer Activation by Bracket
 
-| Bracket | Active Layers | Approx. Token Budget |
-|---------|--------------|---------------------|
-| FRESH | L0, L1, L2, L3, L4 | ~2500 tokens |
-| MODERATE | L0, L1, L2, L3, L4 | ~2000 tokens |
-| DEPLETED | L0, L1, L2 | ~1500 tokens |
-| CRITICAL | L0, L1 | ~800 tokens |
+| Bracket | Active Layers | Budget Ratio | Claude (200K) | Gemini (1M) | Codex (128K) |
+|---------|--------------|-------------|---------------|-------------|--------------|
+| FRESH | L0, L1, L2, L3, L4, L5 | 1.5% | 3,000 | 15,000 | 1,920 |
+| MODERATE | L0, L1, L2, L3, L5 | 2.5% | 5,000 | 25,000 | 3,200 |
+| DEPLETED | L0, L1, L2 | 4.0% | 8,000 | 40,000 | 5,120 |
+| CRITICAL | L0, L1 | 5.0% | 10,000 | 50,000 | 6,400 |
+
+Budgets are proportional to the provider's context window. As context degrades, fewer layers are active (focus) but each active layer receives MORE reinforcement tokens (strength).
 
 ---
 
@@ -145,12 +148,14 @@ If Smart Continuation is insufficient, the orchestrator spawns a new session:
 
 ## Integration with Memory Layer
 
+Memory injection follows the same progressive reinforcement principle: as context degrades, memory becomes MORE important.
+
 | Bracket | Memory Level | Behavior |
 |---------|-------------|----------|
-| FRESH | None | Context is sufficient — no memory injection |
-| MODERATE | L1 Metadata | Light reminder of relevant memories (~50 tokens) |
-| DEPLETED | L2 Chunks | Context recovery via memory summaries (~200 tokens) |
-| CRITICAL | L3 Full | Full memory dump for session handoff (~1000+ tokens) |
+| FRESH | none | Context is sufficient — no memory injection needed |
+| MODERATE | metadata | Light reminder of relevant memories (~50 tokens) |
+| DEPLETED | chunks | Context recovery via memory summaries (~200 tokens) |
+| CRITICAL | full | Full memory dump for session handoff (~1000+ tokens) |
 
 ---
 
@@ -160,7 +165,7 @@ If Smart Continuation is insufficient, the orchestrator spawns a new session:
 
 ---
 
-*Context Engine v1.0 — Chati.dev Intelligence Layer*
+*Context Engine v2.0 — Chati.dev Intelligence Layer (Progressive Reinforcement Model)*
 
 ---
 

package/package.json

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

package/scripts/doctor/checks/agents.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Doctor check: Agent definition files.
+ *
+ * Validates that all 13 agent definition files exist with valid structure.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const EXPECTED_AGENTS = {
+  'discover/greenfield-wu.md': 'greenfield-wu',
+  'discover/brownfield-wu.md': 'brownfield-wu',
+  'discover/brief.md': 'brief',
+  'plan/detail.md': 'detail',
+  'plan/architect.md': 'architect',
+  'plan/ux.md': 'ux',
+  'plan/phases.md': 'phases',
+  'plan/tasks.md': 'tasks',
+  'quality/qa-planning.md': 'qa-planning',
+  'quality/qa-implementation.md': 'qa-implementation',
+  'build/dev.md': 'dev',
+  'deploy/devops.md': 'devops',
+};
+
+/**
+ * Run agents check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkAgents(frameworkDir) {
+  const agentsDir = join(frameworkDir, 'agents');
+  const orchestratorDir = join(frameworkDir, 'orchestrator');
+
+  const missing = [];
+  const invalid = [];
+
+  for (const [relPath, name] of Object.entries(EXPECTED_AGENTS)) {
+    const fullPath = join(agentsDir, relPath);
+    if (!existsSync(fullPath)) {
+      missing.push(name);
+      continue;
+    }
+    try {
+      const content = readFileSync(fullPath, 'utf8');
+      if (!content.includes('## Identity') && !content.includes('## Mission')) {
+        invalid.push(name);
+      }
+    } catch {
+      invalid.push(name);
+    }
+  }
+
+  // Check orchestrator
+  const orchPath = join(orchestratorDir, 'chati.md');
+  if (!existsSync(orchPath)) {
+    missing.push('orchestrator');
+  }
+
+  const total = Object.keys(EXPECTED_AGENTS).length + 1;
+  const found = total - missing.length;
+
+  if (missing.length > 0 || invalid.length > 0) {
+    const issues = [];
+    if (missing.length) issues.push(`missing: ${missing.join(', ')}`);
+    if (invalid.length) issues.push(`invalid: ${invalid.join(', ')}`);
+    return {
+      pass: false,
+      details: `${found}/${total} agents found; ${issues.join('; ')}`,
+      severity: missing.length > 0 ? 'critical' : 'warning',
+      fixable: false,
+      fixId: null,
+    };
+  }
+
+  return { pass: true, details: `${found}/${total} agents present`, severity: 'info', fixable: false, fixId: null };
+}

package/scripts/doctor/checks/constitution.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Doctor check: Constitution integrity.
+ *
+ * Validates constitution.md exists and contains the expected number of articles.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Run constitution integrity check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkConstitution(frameworkDir) {
+  const constPath = join(frameworkDir, 'constitution.md');
+  if (!existsSync(constPath)) {
+    return { pass: false, details: 'constitution.md not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  try {
+    const content = readFileSync(constPath, 'utf8');
+    const articleMatches = content.match(/^## Article [IVXLCDM]+/gm) || [];
+    const articleCount = articleMatches.length;
+
+    if (articleCount < 10) {
+      return {
+        pass: false,
+        details: `Only ${articleCount} articles found (expected 10+)`,
+        severity: 'warning',
+        fixable: false,
+        fixId: null,
+      };
+    }
+
+    return { pass: true, details: `${articleCount} articles found`, severity: 'info', fixable: false, fixId: null };
+  } catch (err) {
+    return { pass: false, details: `Failed to read: ${err.message}`, severity: 'critical', fixable: false, fixId: null };
+  }
+}

package/scripts/doctor/checks/domain-alignment.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Doctor check: Domain-Agent alignment.
+ *
+ * Validates that each agent domain YAML has a corresponding agent .md file.
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+
+/**
+ * Run domain-agent alignment check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkDomainAlignment(frameworkDir) {
+  const domainsDir = join(frameworkDir, 'domains', 'agents');
+  if (!existsSync(domainsDir)) {
+    return { pass: false, details: 'domains/agents/ directory not found', severity: 'warning', fixable: false, fixId: null };
+  }
+
+  const domainFiles = readdirSync(domainsDir).filter(f => f.endsWith('.yaml'));
+  const mismatches = [];
+
+  for (const file of domainFiles) {
+    const agentName = basename(file, '.yaml');
+
+    // Orchestrator has a different path
+    if (agentName === 'orchestrator') {
+      if (!existsSync(join(frameworkDir, 'orchestrator', 'chati.md'))) {
+        mismatches.push('orchestrator');
+      }
+      continue;
+    }
+
+    // Other agents: check all category dirs
+    const agentDirs = ['agents/discover', 'agents/plan', 'agents/quality', 'agents/build', 'agents/deploy'];
+    const found = agentDirs.some(dir =>
+      existsSync(join(frameworkDir, dir, `${agentName}.md`))
+    );
+
+    if (!found) {
+      mismatches.push(agentName);
+    }
+  }
+
+  if (mismatches.length > 0) {
+    return {
+      pass: false,
+      details: `Mismatched agents: ${mismatches.join(', ')}`,
+      severity: 'warning',
+      fixable: false,
+      fixId: null,
+    };
+  }
+
+  return { pass: true, details: `${domainFiles.length} domain-agent pairs aligned`, severity: 'info', fixable: false, fixId: null };
+}

package/scripts/doctor/checks/prism-layers.js

@@ -0,0 +1,84 @@
+/**
+ * @fileoverview Doctor check: PRISM Layer integrity.
+ *
+ * Validates that all 6 PRISM layers (L0-L5) have the required
+ * domain files and configuration in place.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Run PRISM layers integrity check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkPrismLayers(frameworkDir) {
+  const domainsDir = join(frameworkDir, 'domains');
+  if (!existsSync(domainsDir)) {
+    return { pass: false, details: 'domains/ directory not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  const issues = [];
+
+  // L0: Constitution domain
+  const constitutionDomain = join(domainsDir, 'constitution.yaml');
+  if (!existsSync(constitutionDomain)) {
+    issues.push('L0: constitution.yaml missing');
+  }
+
+  // L1: Global domain
+  const globalDomain = join(domainsDir, 'global.yaml');
+  if (!existsSync(globalDomain)) {
+    issues.push('L1: global.yaml missing');
+  }
+
+  // L2: Agent domains
+  const agentsDir = join(domainsDir, 'agents');
+  if (!existsSync(agentsDir)) {
+    issues.push('L2: agents/ directory missing');
+  } else {
+    const agentDomains = readdirSync(agentsDir).filter(f => f.endsWith('.yaml'));
+    if (agentDomains.length < 12) {
+      issues.push(`L2: only ${agentDomains.length}/12 agent domains found`);
+    }
+  }
+
+  // L3: Workflow domains
+  const workflowsDir = join(domainsDir, 'workflows');
+  if (!existsSync(workflowsDir)) {
+    issues.push('L3: workflows/ directory missing');
+  }
+
+  // L4: Task context (checked via task domain files or inline)
+  // L4 is dynamic (loaded from handoff data), so we check that the task
+  // processing layer module exists
+  const l4Module = join(frameworkDir, '..', 'src', 'context', 'layers', 'l4-task.js');
+  if (!existsSync(l4Module)) {
+    issues.push('L4: l4-task.js module missing');
+  }
+
+  // L5: Keywords domains
+  const keywordsDir = join(domainsDir, 'keywords');
+  if (!existsSync(keywordsDir)) {
+    issues.push('L5: keywords/ directory missing');
+  } else {
+    const keywordFiles = readdirSync(keywordsDir).filter(f => f.endsWith('.yaml'));
+    if (keywordFiles.length === 0) {
+      issues.push('L5: no keyword domain files found');
+    }
+  }
+
+  if (issues.length > 0) {
+    return {
+      pass: false,
+      details: issues.join('; '),
+      severity: issues.some(i => i.includes('L0') || i.includes('L1')) ? 'critical' : 'warning',
+      fixable: false,
+      fixId: null,
+    };
+  }
+
+  return { pass: true, details: 'All 6 PRISM layers (L0-L5) validated', severity: 'info', fixable: false, fixId: null };
+}

package/scripts/doctor/checks/registry.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Doctor check: Entity Registry integrity.
+ *
+ * Validates entity-registry.yaml exists, parses correctly,
+ * entity count matches metadata, and all entity paths exist.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Run entity registry integrity check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkRegistry(frameworkDir) {
+  const regPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+  if (!existsSync(regPath)) {
+    return { pass: false, details: 'entity-registry.yaml not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  try {
+    const content = readFileSync(regPath, 'utf8');
+    const registry = yaml.load(content);
+
+    if (!registry || !registry.entities) {
+      return { pass: false, details: 'entity-registry.yaml has no entities section', severity: 'critical', fixable: false, fixId: null };
+    }
+
+    // Count all entities across all categories
+    let entityCount = 0;
+    for (const category of Object.values(registry.entities)) {
+      if (typeof category === 'object' && category !== null) {
+        entityCount += Object.keys(category).length;
+      }
+    }
+
+    const declaredCount = registry.metadata?.entity_count || 0;
+    if (declaredCount > 0 && entityCount !== declaredCount) {
+      return {
+        pass: false,
+        details: `Entity count mismatch: declared ${declaredCount}, actual ${entityCount}`,
+        severity: 'warning',
+        fixable: true,
+        fixId: 'registry-count',
+      };
+    }
+
+    return { pass: true, details: `${entityCount} entities registered`, severity: 'info', fixable: false, fixId: null };
+  } catch (err) {
+    return { pass: false, details: `Failed to parse: ${err.message}`, severity: 'critical', fixable: false, fixId: null };
+  }
+}

package/scripts/doctor/checks/schemas.js

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Doctor check: JSON Schema validation.
+ *
+ * Validates that all expected schema files exist and contain valid JSON.
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const EXPECTED_SCHEMAS = [
+  'session.schema.json',
+  'config.schema.json',
+  'context.schema.json',
+  'memory.schema.json',
+  'task.schema.json',
+];
+
+/**
+ * Run schema validation check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkSchemas(frameworkDir) {
+  const schemasDir = join(frameworkDir, 'schemas');
+  if (!existsSync(schemasDir)) {
+    return { pass: false, details: 'schemas/ directory not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  const missing = [];
+  const invalid = [];
+
+  for (const schema of EXPECTED_SCHEMAS) {
+    const schemaPath = join(schemasDir, schema);
+    if (!existsSync(schemaPath)) {
+      missing.push(schema);
+      continue;
+    }
+    try {
+      JSON.parse(readFileSync(schemaPath, 'utf8'));
+    } catch {
+      invalid.push(schema);
+    }
+  }
+
+  if (missing.length > 0 || invalid.length > 0) {
+    const issues = [];
+    if (missing.length) issues.push(`missing: ${missing.join(', ')}`);
+    if (invalid.length) issues.push(`invalid JSON: ${invalid.join(', ')}`);
+    return {
+      pass: false,
+      details: issues.join('; '),
+      severity: missing.length > 0 ? 'critical' : 'warning',
+      fixable: false,
+      fixId: null,
+    };
+  }
+
+  const actualSchemas = readdirSync(schemasDir).filter(f => f.endsWith('.json'));
+  return { pass: true, details: `${actualSchemas.length} schemas valid`, severity: 'info', fixable: false, fixId: null };
+}