chati-dev 4.3.1 → 4.4.1

package/src/utils/constitution-meta.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Single source of truth for constitution metadata used by
+ * integrity checks.
+ *
+ * Every check that counts `## Article` headings (doctor, registry health,
+ * installer validator, stale-scan check 13) compares against THIS constant,
+ * so adding a constitutional article is a one-line bump here. The stale-scan
+ * asserts the canonical constitution.md actually contains this many articles,
+ * which keeps the constant honest.
+ */
+
+export const EXPECTED_ARTICLE_COUNT = 25;

package/src/utils/feature-flags.js

@@ -14,21 +14,45 @@ import { resolveFrameworkDir } from './framework-dir.js';
 
 /**
  * All known feature flags with their default values.
- * New features start as false (opt-in).
+ * New features start as false (opt-in). Defaults describe the state when
+ * config.yaml is absent; installed projects get their real values written by
+ * generateConfigYaml, and parseFeaturesSection only honors keys listed here,
+ * so EVERY boolean flag documented in config.yaml must appear in this map or
+ * the user's toggle is silently ignored (which froze 11 flags until 4.4.1).
+ * The numeric team_* and build_wave_size keys are intentionally absent: the
+ * parser is boolean-only and those values are read directly from config.yaml
+ * by their consumers.
  */
 const DEFAULTS = {
+  // Core framework flags
   hybrid_budget: false,
   anti_dash: false,
   rate_limiter_integration: false,
   l5_keywords: false,
   prompt_size_guard: false,
-  ids_decision_engine: false,
   surface_criteria: false,
   parallel_fallback: false,
   tool_mesh: false,
   tech_presets: false,
   doctor_autofix: false,
   brandbook: false,
+  // Intelligence upgrade flags
+  undercover_mode: false,
+  memory_extraction: false,
+  memory_consolidation: false,
+  daily_digest: false,
+  structured_session_memory: false,
+  static_prism_boundary: false,
+  token_bracket_estimation: false,
+  model_fallback: false,
+  frustration_detection: false,
+  bash_security_checks: false,
+  // Agent Teams (Article XXI). NOTE: isAgentTeamsEnabled in cli.js keeps its
+  // own reader with Claude-provider defaulting; this entry exists so a config
+  // toggle is at least visible through the generic API.
+  agent_teams: false,
+  // Execution Kinds (Article XXV)
+  execution_kinds: false,
 };
 
 /**

package/src/utils/flatten-entities.js

@@ -1,46 +1,10 @@
 /**
- * @fileoverview Shared entity-flattening utilities.
+ * @fileoverview Shared entity-flattening utility.
  *
- * Two variants exist because the registry YAML stores entities in two different
- * shapes depending on who reads it:
- *
- * - flattenEntitiesFromRegistry: receives the full registry object
- *   (i.e. the result of yaml.load()), where each category's value is an Array.
- *   Used by decision/analyzer.js and decision/engine.js.
- *
- * - flattenEntitiesMap: receives only the `registry.entities` map,
- *   where each category's value is a nested object keyed by entity name.
- *   Used by intelligence/registry-manager.js.
- *
- * Keep both functions here so there is a single canonical implementation.
- */
-
-/**
- * Flatten a full entity registry (as returned by yaml.load) into a flat array.
- *
- * Each category value must be an Array of entity objects.
- * The `type` field is inferred from the category key.
- *
- * @param {object} registry - Full registry object with a top-level `entities` key.
- * @returns {object[]} Flat array of entity objects, each with a `type` field added.
+ * flattenEntitiesMap receives the `registry.entities` map, where each category's
+ * value is a nested object keyed by entity name. Used by
+ * intelligence/registry-manager.js.
  */
-export function flattenEntitiesFromRegistry(registry) {
-  const entities = [];
-
-  if (!registry || !registry.entities) {
-    return entities;
-  }
-
-  Object.entries(registry.entities).forEach(([type, typeEntities]) => {
-    if (Array.isArray(typeEntities)) {
-      typeEntities.forEach(entity => {
-        entities.push({ ...entity, type });
-      });
-    }
-  });
-
-  return entities;
-}
 
 /**
  * Flatten the `entities` section of the registry (a nested object map) into a flat array.

package/src/utils/schema-validator.js

@@ -177,20 +177,6 @@ export const SESSION_SCHEMA = {
   },
 };
 
-/**
- * Build state schema (build-state.json).
- */
-export const BUILD_STATE_SCHEMA = {
-  required: ['sessionId', 'status', 'checkpoints'],
-  properties: {
-    sessionId: { type: 'string', required: true },
-    status: { type: 'string', required: true, enum: ['idle', 'running', 'completed', 'failed', 'abandoned'] },
-    checkpoints: { type: 'array', required: true },
-    startedAt: { type: 'string' },
-    totalAttempts: { type: 'number', min: 0 },
-  },
-};
-
 /**
  * Config schema (config.yaml).
  */

package/src/wizard/i18n.js

@@ -39,7 +39,7 @@ const FALLBACK_EN = {
     agents_count: 'Specialized agent definitions across DISCOVER, PLAN, BUILD, DEPLOY phases',
     workflows_count: '6 workflow blueprints',
     templates_count: '6 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate, Quick Brief)',
-    constitution: 'Constitution (23 Articles + Preamble)',
+    constitution: 'Constitution (25 Articles + Preamble)',
     session_mgmt: 'Session management system',
     quality_gates: 'Quality gates (3-tier verdicts)',
     proceed: 'Proceed with installation?',
@@ -47,7 +47,7 @@ const FALLBACK_EN = {
     created_chati: 'Created .chati/ session directory',
     created_framework: 'Created chati.dev/ system directory (agents, templates, workflows)',
     created_commands: 'Created .claude/commands/ (thin router)',
-    installed_constitution: 'Installed Constitution (Articles I-XXIII)',
+    installed_constitution: 'Installed Constitution (Articles I-XXV)',
     created_session: 'Created session.yaml schema',
     created_claude_md: 'Created CLAUDE.md',
     configured_mcps: 'Configured MCPs:',
@@ -55,7 +55,7 @@ const FALLBACK_EN = {
     agents_valid: 'All agents implement 8 protocols',
     handoff_ok: 'Handoff protocol: OK',
     validation_ok: 'Self-validation criteria: OK',
-    constitution_ok: 'Constitution: 23 articles verified',
+    constitution_ok: 'Constitution: 25 articles verified',
     created_memories: 'Created .chati/memories/ (Memory Layer)',
     installed_intelligence: 'Installed Intelligence Layer (Context Engine, Memory, Registry)',
     intelligence_valid: 'Intelligence: 6 spec files verified',

package/src/api/index.js

@@ -1,120 +0,0 @@
-/**
- * @fileoverview Public API surface for chati-dev.
- *
- * Re-exports stable functions from core modules, providing
- * a clean entry point for programmatic usage.
- *
- * @example
- * import { createSession, runHealthChecks, classifyIntent } from 'chati-dev/api';
- */
-
-// ---------------------------------------------------------------------------
-// Health & Diagnostics
-// ---------------------------------------------------------------------------
-
-export { runHealthChecks } from '../health/engine.js';
-
-// ---------------------------------------------------------------------------
-// Context Engine (PRISM)
-// ---------------------------------------------------------------------------
-
-export { runPrism } from '../context/engine.js';
-
-// ---------------------------------------------------------------------------
-// Orchestrator
-// ---------------------------------------------------------------------------
-
-export { classifyIntent, INTENT_TYPES } from '../orchestrator/intent-classifier.js';
-export {
-  initPipeline,
-  advancePipeline,
-  initQuickFlowPipeline,
-  initStandardFlowPipeline,
-} from '../orchestrator/pipeline-manager.js';
-export { selectAgent } from '../orchestrator/agent-selector.js';
-
-// ---------------------------------------------------------------------------
-// Session Management
-// ---------------------------------------------------------------------------
-
-import { initSession as _initSession } from '../orchestrator/session-manager.js';
-
-export {
-  initSession,
-  loadSession,
-  updateSession,
-  validateSession,
-  getSessionSummary,
-  claimSession,
-  releaseSession,
-  getSessionOwner,
-} from '../orchestrator/session-manager.js';
-
-// ---------------------------------------------------------------------------
-// Autonomy
-// ---------------------------------------------------------------------------
-
-export { runBuildLoop } from '../autonomy/build-loop.js';
-export { checkSafety, SAFETY_TRIGGERS } from '../autonomy/safety-net.js';
-
-// ---------------------------------------------------------------------------
-// Memory
-// ---------------------------------------------------------------------------
-
-export { recordError, getGotchas } from '../memory/gotchas.js';
-
-// ---------------------------------------------------------------------------
-// Quality
-// ---------------------------------------------------------------------------
-
-export { getMetricsHistory, getQualityDashboard, recordMetric } from '../quality/metrics-collector.js';
-
-// ---------------------------------------------------------------------------
-// Extensions
-// ---------------------------------------------------------------------------
-
-export {
-  registerExtension,
-  getExtensions,
-  executeExtensions,
-  clearExtensions,
-  EXTENSION_POINTS,
-} from '../extensions/registry.js';
-export { loadProjectExtensions, validateExtension } from '../extensions/loader.js';
-
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-
-export { loadCustomization, applyCustomization, validateCustomization } from '../config/agent-customizer.js';
-export { IDE_CONFIGS, getIDEChoices } from '../config/ide-configs.js';
-
-// ---------------------------------------------------------------------------
-// Convenience Wrapper
-// ---------------------------------------------------------------------------
-
-/**
- * Create and initialize a new chati.dev session.
- *
- * Convenience wrapper that initializes session state.
- *
- * @param {string} projectDir - Project root directory
- * @param {object} [options]
- * @param {string} [options.mode='discover'] - Initial pipeline mode
- * @param {boolean} [options.isGreenfield=true] - Project type
- * @param {string} [options.language='en'] - Interaction language
- * @param {string} [options.projectName=''] - Project name
- * @param {string[]} [options.ides=[]] - Selected IDEs
- * @param {string[]} [options.mcps=[]] - Selected MCPs
- * @returns {{ created: boolean, session: object, path: string }}
- */
-export function createSession(projectDir, options = {}) {
-  return _initSession(projectDir, {
-    mode: options.mode || 'discover',
-    isGreenfield: options.isGreenfield !== false,
-    language: options.language || 'en',
-    projectName: options.projectName || '',
-    ides: options.ides || [],
-    mcps: options.mcps || [],
-  });
-}

package/src/autonomy/autonomous-gate.js

@@ -1,294 +0,0 @@
-/**
- * @fileoverview Autonomous quality gate evaluation
- * Evaluates quality gates without human input using score-based heuristics
- */
-
-import { loadSession, updateSession } from '../orchestrator/session-manager.js';
-
-/**
- * Gate result types.
- */
-export const GATE_RESULTS = {
-  PASS: 'pass',
-  FAIL: 'fail',
-  REVIEW: 'review', // Borderline — pause for human review even in autonomous mode
-};
-
-// Minimum passing scores per agent (conservative: 90 default)
-const GATE_THRESHOLDS = {
-  'qa-planning': 95,        // Highest — gates planning→build transition
-  'qa-implementation': 95,  // Gates build→deploy transition
-  'qa-visual': 90,          // Visual quality gate
-  'brief': 90,              // Requirements are critical
-  'detail': 90,
-  'architect': 90,
-  'ux': 90,
-  'phases': 90,
-  'tasks': 90,
-  'dev': 90,
-  'devops': 90,
-  'greenfield-wu': 90,
-  'brownfield-wu': 90,
-  // Default for any other agent
-  '_default': 90,
-};
-
-// Review range: within 5 points of threshold triggers REVIEW
-const REVIEW_RANGE = 5;
-
-/**
- * Evaluate a quality gate autonomously.
- *
- * @param {object} gateInput
- * @param {string} gateInput.agent - Agent that produced the work
- * @param {number} gateInput.score - Self-reported quality score (0-100)
- * @param {string[]} gateInput.criteriaResults - Which criteria passed
- * @param {string[]} gateInput.allCriteria - All criteria for this gate
- * @param {number} [gateInput.confidence] - Agent's confidence (0-100)
- * @param {string[]} [gateInput.warnings] - Any warnings produced
- * @returns {{ result: string, score: number, reasoning: string, canProceed: boolean }}
- */
-export function evaluateGate(gateInput) {
-  const {
-    agent,
-    score,
-    criteriaResults = [],
-    allCriteria = [],
-    confidence = 100,
-    warnings = [],
-  } = gateInput;
-
-  // Validate inputs
-  if (typeof score !== 'number' || score < 0 || score > 100) {
-    throw new Error(`Invalid score: ${score}. Must be 0-100.`);
-  }
-
-  const threshold = getGateThreshold(agent);
-  const criteriaScore = allCriteria.length > 0
-    ? (criteriaResults.length / allCriteria.length) * 100
-    : 100;
-
-  // Combine self-reported score and criteria score
-  const weightedScore = (score * 0.6) + (criteriaScore * 0.4);
-
-  // Factor in confidence
-  const confidencePenalty = confidence < 80 ? (80 - confidence) * 0.2 : 0;
-  const finalScore = Math.max(0, weightedScore - confidencePenalty);
-
-  // Factor in warnings
-  const warningPenalty = warnings.length * 3;
-  const adjustedScore = Math.max(0, finalScore - warningPenalty);
-
-  // Determine result
-  let result;
-  const reasoning = [];
-
-  if (adjustedScore >= threshold) {
-    result = GATE_RESULTS.PASS;
-    reasoning.push(`Score ${Math.round(adjustedScore)}% meets threshold ${threshold}%`);
-  } else if (adjustedScore >= threshold - REVIEW_RANGE) {
-    result = GATE_RESULTS.REVIEW;
-    reasoning.push(`Score ${Math.round(adjustedScore)}% is borderline (threshold: ${threshold}%)`);
-    reasoning.push('Manual review recommended');
-  } else {
-    result = GATE_RESULTS.FAIL;
-    reasoning.push(`Score ${Math.round(adjustedScore)}% below threshold ${threshold}%`);
-  }
-
-  // Add details
-  reasoning.push(`Criteria: ${criteriaResults.length}/${allCriteria.length} passed`);
-
-  if (confidence < 80) {
-    reasoning.push(`Low confidence (${confidence}%) reduced score by ${Math.round(confidencePenalty)}%`);
-  }
-
-  if (warnings.length > 0) {
-    reasoning.push(`${warnings.length} warning(s) reduced score by ${warningPenalty}%`);
-  }
-
-  return {
-    result,
-    score: Math.round(adjustedScore),
-    reasoning: reasoning.join('. '),
-    canProceed: result === GATE_RESULTS.PASS,
-    details: {
-      rawScore: Math.round(score),
-      criteriaScore: Math.round(criteriaScore),
-      weightedScore: Math.round(weightedScore),
-      confidencePenalty: Math.round(confidencePenalty),
-      warningPenalty,
-      finalScore: Math.round(adjustedScore),
-      threshold,
-    },
-  };
-}
-
-/**
- * Get the minimum passing score for an agent's gate.
- * Different agents have different thresholds.
- * @param {string} agentName
- * @returns {number} Minimum score (0-100)
- */
-export function getGateThreshold(agentName) {
-  return GATE_THRESHOLDS[agentName] || GATE_THRESHOLDS._default;
-}
-
-/**
- * Check if gate result allows pipeline to continue.
- * @param {string} result - GATE_RESULTS value
- * @param {string} executionMode - 'autonomous' | 'human-in-the-loop'
- * @returns {{ proceed: boolean, action: string }}
- */
-export function resolveGateAction(result, executionMode) {
-  if (result === GATE_RESULTS.PASS) {
-    return {
-      proceed: true,
-      action: 'continue',
-    };
-  }
-
-  if (result === GATE_RESULTS.FAIL) {
-    return {
-      proceed: false,
-      action: executionMode === 'autonomous' ? 'pause_for_review' : 'wait_for_user',
-    };
-  }
-
-  // REVIEW result
-  if (executionMode === 'autonomous') {
-    return {
-      proceed: false,
-      action: 'pause_for_review',
-    };
-  }
-
-  return {
-    proceed: false,
-    action: 'wait_for_user',
-  };
-}
-
-/**
- * Get gate evaluation history.
- * @param {string} projectDir
- * @returns {object[]}
- */
-export function getGateHistory(projectDir) {
-  const result = loadSession(projectDir);
-  if (!result.loaded || !result.session) {
-    return [];
-  }
-  return result.session.gate_evaluations || [];
-}
-
-/**
- * Record a gate evaluation.
- * @param {string} projectDir
- * @param {object} evaluation
- */
-export function recordGateEvaluation(projectDir, evaluation) {
-  const result = loadSession(projectDir);
-
-  if (!result.loaded || !result.session) {
-    return;
-  }
-
-  const gate_evaluations = result.session.gate_evaluations || [];
-  gate_evaluations.push({
-    ...evaluation,
-    timestamp: new Date().toISOString(),
-  });
-
-  updateSession(projectDir, { gate_evaluations });
-}
-
-/**
- * Get gate statistics.
- * @param {string} projectDir
- * @returns {{ total: number, passed: number, failed: number, reviewed: number, passRate: number }}
- */
-export function getGateStatistics(projectDir) {
-  const history = getGateHistory(projectDir);
-
-  const stats = {
-    total: history.length,
-    passed: 0,
-    failed: 0,
-    reviewed: 0,
-  };
-
-  history.forEach(evaluation => {
-    if (evaluation.result === GATE_RESULTS.PASS) {
-      stats.passed++;
-    } else if (evaluation.result === GATE_RESULTS.FAIL) {
-      stats.failed++;
-    } else if (evaluation.result === GATE_RESULTS.REVIEW) {
-      stats.reviewed++;
-    }
-  });
-
-  stats.passRate = stats.total > 0
-    ? Math.round((stats.passed / stats.total) * 100)
-    : 0;
-
-  return stats;
-}
-
-/**
- * Get agent-specific gate statistics.
- * @param {string} projectDir
- * @param {string} agentName
- * @returns {{ total: number, passed: number, failed: number, reviewed: number, averageScore: number }}
- */
-export function getAgentGateStatistics(projectDir, agentName) {
-  const history = getGateHistory(projectDir);
-  const agentEvaluations = history.filter(e => e.agent === agentName);
-
-  const stats = {
-    total: agentEvaluations.length,
-    passed: 0,
-    failed: 0,
-    reviewed: 0,
-    averageScore: 0,
-  };
-
-  if (stats.total === 0) {
-    return stats;
-  }
-
-  let totalScore = 0;
-
-  agentEvaluations.forEach(evaluation => {
-    if (evaluation.result === GATE_RESULTS.PASS) {
-      stats.passed++;
-    } else if (evaluation.result === GATE_RESULTS.FAIL) {
-      stats.failed++;
-    } else if (evaluation.result === GATE_RESULTS.REVIEW) {
-      stats.reviewed++;
-    }
-
-    totalScore += evaluation.score || 0;
-  });
-
-  stats.averageScore = Math.round(totalScore / stats.total);
-
-  return stats;
-}
-
-/**
- * Clear gate evaluation history.
- * @param {string} projectDir
- * @returns {{ cleared: number }}
- */
-export function clearGateHistory(projectDir) {
-  const result = loadSession(projectDir);
-  if (!result.loaded || !result.session) {
-    return { cleared: 0 };
-  }
-
-  const count = result.session.gate_evaluations?.length || 0;
-
-  updateSession(projectDir, { gate_evaluations: [] });
-
-  return { cleared: count };
-}