@cleocode/core 2026.3.42 → 2026.3.44

package/dist/init.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Core init logic - project initialization and maintenance.
+ *
+ * Single source of truth for all init operations. Both CLI and MCP
+ * delegate here (shared-core pattern).
+ *
+ * Handles:
+ *   1. .cleo/ directory structure creation
+ *   2. Core data files (config.json, tasks.db)
+ *   3. Schema file installation (~/.cleo/schemas/)
+ *   4. Sequence counter (SQLite schema_meta)
+ *   5. Project info (.cleo/project-info.json)
+ *   6. CAAMP injection into agent instruction files (AGENTS.md hub pattern)
+ *   7. MCP server installation to detected providers
+ *   8. Agent definition installation (cleo-subagent)
+ *   9. Core skill installation via CAAMP
+ *  10. NEXUS project registration
+ *  11. Project type detection (--detect)
+ *  12. Injection refresh (--update-docs)
+ *  13. Git hook installation (commit-msg, pre-commit)
+ *  14. GitHub issue/PR templates (.github/ directory)
+ *
+ * @task T4681
+ * @task T4682
+ * @task T4684
+ * @task T4685
+ * @task T4686
+ * @task T4687
+ * @task T4689
+ * @task T4706
+ * @task T4707
+ * @epic T4663
+ */
+/** Options for the init operation. */
+export interface InitOptions {
+    /** Project name override. */
+    name?: string;
+    /** Overwrite existing files. */
+    force?: boolean;
+    /** Auto-detect project configuration. */
+    detect?: boolean;
+    /** Update agent documentation injections only. */
+    updateDocs?: boolean;
+    /** Run codebase analysis and store findings to brain.db. */
+    mapCodebase?: boolean;
+}
+/** Result of the init operation. */
+export interface InitResult {
+    initialized: boolean;
+    directory: string;
+    created: string[];
+    skipped: string[];
+    warnings: string[];
+    updateDocsOnly?: boolean;
+}
+/**
+ * Install cleo-subagent agent definition to ~/.agents/agents/.
+ * @task T4685
+ */
+export declare function initAgentDefinition(created: string[], warnings: string[]): Promise<void>;
+/**
+ * Install MCP server config to all detected providers via CAAMP.
+ * @task T4706
+ */
+export declare function initMcpServer(projectRoot: string, created: string[], warnings: string[]): Promise<void>;
+/**
+ * Install CLEO core skills to the canonical skills directory via CAAMP.
+ * @task T4707
+ * @task T4689
+ */
+export declare function initCoreSkills(created: string[], warnings: string[]): Promise<void>;
+/**
+ * Register/reconcile project with NEXUS.
+ * Uses nexusReconcile for idempotent handshake — auto-registers if new,
+ * updates path if moved, confirms identity if unchanged.
+ * @task T4684
+ * @task T5368
+ */
+export declare function initNexusRegistration(projectRoot: string, created: string[], warnings: string[]): Promise<void>;
+/**
+ * Install GitHub issue and PR templates to .github/ if a git repo exists
+ * but .github/ISSUE_TEMPLATE/ is not yet present.
+ *
+ * Idempotent: skips files that already exist. Never overwrites existing
+ * templates — the project owner's customisations take precedence.
+ *
+ * @param projectRoot  Absolute path to the project root.
+ * @param created      Array to push "created: ..." log entries into.
+ * @param skipped      Array to push "skipped: ..." log entries into.
+ */
+export declare function installGitHubTemplates(projectRoot: string, created: string[], skipped: string[]): Promise<void>;
+/**
+ * Run update-docs only: refresh all injections without reinitializing.
+ * Re-injects CLEO-INJECTION.md into all detected agent instruction files.
+ *
+ * @task T4686
+ */
+export declare function updateDocs(): Promise<InitResult>;
+/**
+ * Run full project initialization.
+ *
+ * Creates the .cleo/ directory structure, installs schemas, templates,
+ * agent definitions, MCP server configs, skills, and registers with NEXUS.
+ *
+ * @task T4681
+ * @task T4682
+ * @task T4684
+ * @task T4685
+ * @task T4686
+ * @task T4687
+ * @task T4689
+ * @task T4706
+ * @task T4707
+ */
+export declare function initProject(opts?: InitOptions): Promise<InitResult>;
+/**
+ * Check if auto-init is enabled via environment variable.
+ * @task T4789
+ */
+export declare function isAutoInitEnabled(): boolean;
+/**
+ * Check if a project is initialized and auto-init if configured.
+ * Returns { initialized: true } if ready, throws otherwise.
+ * @task T4789
+ */
+export declare function ensureInitialized(projectRoot?: string): Promise<{
+    initialized: boolean;
+}>;
+/**
+ * Get the current CLEO/project version.
+ * Checks VERSION file, then package.json.
+ * @task T4789
+ */
+export declare function getVersion(projectRoot?: string): Promise<{
+    version: string;
+}>;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AA6BH,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yCAAyC;IACzC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,oCAAoC;AACpC,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAID;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA0C9F;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,IAAI,CAAC,CA0Cf;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAgFzF;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,IAAI,CAAC,CAuBf;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CAiDf;AAID;;;;;GAKG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,CAwBtD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,WAAW,CAAC,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAgS7E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC,CAiB/F;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAyBnF"}

package/dist/inject/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Task injection core module.
+ *
+ * Selects and formats tasks for injection into external systems.
+ *
+ * ARCHITECTURE NOTE: Instruction injection is a CAAMP domain responsibility.
+ * Once @cleocode/caamp is available as a dependency, the injection formatting
+ * and template resolution should delegate to CAAMP's injection provider.
+ * CLEO's role here is task selection and filtering (what to inject),
+ * while CAAMP handles the injection format (how to inject).
+ *
+ * @task T4539
+ * @epic T4454
+ */
+import type { DataAccessor } from '../store/data-accessor.js';
+/** Inject tasks for external consumption. */
+export declare function injectTasks(opts: {
+    maxTasks?: number;
+    focusedOnly?: boolean;
+    phase?: string;
+    output?: string;
+    saveState?: boolean;
+    dryRun?: boolean;
+    cwd?: string;
+}, accessor?: DataAccessor): Promise<Record<string, unknown>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/inject/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/inject/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AA4D9D,6CAA6C;AAC7C,wBAAsB,WAAW,CAC/B,IAAI,EAAE;IACJ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,EACD,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAsBlC"}

package/dist/injection.d.ts

@@ -0,0 +1,69 @@
+/**
+ * CAAMP injection management — manages agent instruction file injection.
+ *
+ * Extracted from init.ts to enable shared use across init, upgrade, and doctor.
+ *
+ * Handles:
+ *   1. Injecting @AGENTS.md into provider instruction files (CLAUDE.md, GEMINI.md, etc.)
+ *   2. Injecting CLEO protocol content into AGENTS.md itself
+ *   3. Installing CLEO-INJECTION.md to global templates directory
+ *   4. Creating global ~/.agents/AGENTS.md hub
+ *   5. Stripping legacy CLEO blocks and removing deprecated files
+ *   6. Checking injection health (CAAMP markers, @ reference resolution)
+ *
+ * @task T4682
+ */
+export interface ScaffoldResult {
+    action: 'created' | 'repaired' | 'skipped';
+    path: string;
+    details?: string;
+}
+export interface InjectionCheckResult {
+    id: string;
+    category: string;
+    status: 'passed' | 'failed' | 'warning' | 'info';
+    message: string;
+    details: Record<string, unknown>;
+    fix: string | null;
+}
+/**
+ * Get the CLEO-INJECTION.md template content from the package templates/ directory.
+ * Returns null if the template file is not found.
+ */
+export declare function getInjectionTemplateContent(): string | null;
+/**
+ * Full injection refresh: strip legacy blocks, inject CAAMP content,
+ * install global template, create hub.
+ *
+ * Replaces initInjection from init.ts with a ScaffoldResult return type.
+ *
+ * Target architecture:
+ *   CLAUDE.md/GEMINI.md -> @AGENTS.md (via injectAll)
+ *   AGENTS.md -> @~/.cleo/templates/CLEO-INJECTION.md + @.cleo/project-context.json
+ *
+ * @task T4682
+ */
+export declare function ensureInjection(projectRoot: string): Promise<ScaffoldResult>;
+/**
+ * Build a smart, contextual contributor block for AGENTS.md injection.
+ * Returns null if this is not a contributor project.
+ *
+ * The block is INFORMATIONAL, not prescriptive. It tells agents:
+ *   - This is the CLEO source repo (contributor project)
+ *   - cleo-dev is available (or not, with reason)
+ *   - Prefer cleo-dev for unreleased features, but fall back to cleo if
+ *     the dev build is broken or unavailable
+ *
+ * This avoids the trap where a hardcoded "ALWAYS use cleo-dev" instruction
+ * sends agents into a loop when the dev build has compile errors.
+ */
+export declare function buildContributorInjectionBlock(projectRoot: string): string | null;
+/**
+ * Verify injection health: AGENTS.md exists, has CAAMP markers,
+ * markers are balanced, and @ references resolve.
+ *
+ * Combines logic from doctor/checks.ts checkAgentsMdHub,
+ * checkCaampMarkerIntegrity, and checkAtReferenceTargetExists.
+ */
+export declare function checkInjection(projectRoot: string): InjectionCheckResult;
+//# sourceMappingURL=injection.d.ts.map

package/dist/injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../src/injection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAID;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,GAAG,IAAI,CAO3D;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CA8FlF;AAqBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA2CjF;AAID;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,CAiIxE"}

package/dist/intelligence/impact.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Impact analysis module - dependency-aware prediction of downstream effects.
+ *
+ * Builds on the existing dependency graph infrastructure in phases/deps.ts
+ * and orchestration/analyze.ts to provide:
+ *   - Task impact assessment (direct + transitive dependents)
+ *   - Change impact prediction (cancel, block, complete, reprioritize)
+ *   - Blast radius calculation (scope quantification)
+ *
+ * @module intelligence
+ */
+import type { DataAccessor } from '../store/data-accessor.js';
+import type { BlastRadius, ChangeImpact, ChangeType, ImpactAssessment } from './types.js';
+/**
+ * Analyze the full downstream impact of a task.
+ *
+ * Computes direct and transitive dependents, affected lifecycle pipelines,
+ * blocked work counts, critical path membership, and blast radius.
+ *
+ * @param taskId - The task to analyze
+ * @param accessor - DataAccessor instance (or auto-created from cwd)
+ * @param cwd - Working directory (used if accessor is not provided)
+ * @returns Full impact assessment
+ */
+export declare function analyzeTaskImpact(taskId: string, accessor?: DataAccessor, cwd?: string): Promise<ImpactAssessment>;
+/**
+ * Analyze the downstream effects of a specific change to a task.
+ *
+ * Predicts what happens when a task is cancelled, blocked, completed,
+ * or reprioritized, including cascading status changes.
+ *
+ * @param taskId - The task being changed
+ * @param changeType - The type of change
+ * @param accessor - DataAccessor instance (or auto-created from cwd)
+ * @param cwd - Working directory (used if accessor is not provided)
+ * @returns Predicted change impact
+ */
+export declare function analyzeChangeImpact(taskId: string, changeType: ChangeType, accessor?: DataAccessor, cwd?: string): Promise<ChangeImpact>;
+/**
+ * Calculate the blast radius for a task.
+ *
+ * Quantifies how many tasks, epics, and what percentage of the project
+ * would be impacted by changes to this task.
+ *
+ * @param taskId - The task to analyze
+ * @param accessor - DataAccessor instance (or auto-created from cwd)
+ * @param cwd - Working directory (used if accessor is not provided)
+ * @returns Blast radius metrics
+ */
+export declare function calculateBlastRadius(taskId: string, accessor?: DataAccessor, cwd?: string): Promise<BlastRadius>;
+//# sourceMappingURL=impact.d.ts.map

package/dist/intelligence/impact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact.d.ts","sourceRoot":"","sources":["../../src/intelligence/impact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAI9D,OAAO,KAAK,EAEV,WAAW,EAEX,YAAY,EACZ,UAAU,EACV,gBAAgB,EACjB,MAAM,YAAY,CAAC;AA6KpB;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,YAAY,EACvB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAyC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,YAAY,EACvB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,YAAY,CAAC,CAkDvB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,YAAY,EACvB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAoBtB"}

package/dist/intelligence/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CLEO Intelligence dimension — Quality Prediction and Pattern Extraction.
+ *
+ * Provides risk scoring, validation outcome prediction, automatic pattern
+ * detection, pattern matching, and pattern storage backed by the existing
+ * brain_patterns and brain_learnings tables.
+ *
+ * @task Wave3A
+ * @epic T5149
+ */
+export { analyzeChangeImpact, analyzeTaskImpact, calculateBlastRadius, } from './impact.js';
+export { extractPatternsFromHistory, matchPatterns, storeDetectedPattern, updatePatternStats, } from './patterns.js';
+export { calculateTaskRisk, gatherLearningContext, predictValidationOutcome, } from './prediction.js';
+export type { AffectedTask, BlastRadius, BlastRadiusSeverity, ChangeImpact, ChangeType, DetectedPattern, ImpactAssessment, LearningContext, PatternExtractionOptions, PatternMatch, PatternStatsUpdate, RiskAssessment, RiskFactor, ValidationPrediction, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/intelligence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/intelligence/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,oBAAoB,GACrB,MAAM,YAAY,CAAC"}

package/dist/intelligence/patterns.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Pattern Extraction module for the CLEO Intelligence dimension.
+ *
+ * Provides automatic pattern detection from brain_observations and task history,
+ * pattern matching against brain_patterns, and pattern storage/stat updates.
+ *
+ * Uses the existing brain_patterns and brain_learnings tables — no new tables.
+ *
+ * @task Wave3A
+ * @epic T5149
+ */
+import type { BrainDataAccessor } from '../store/brain-accessor.js';
+import type { BrainPatternRow } from '../store/brain-schema.js';
+import type { DataAccessor } from '../store/data-accessor.js';
+import type { DetectedPattern, PatternExtractionOptions, PatternMatch, PatternStatsUpdate } from './types.js';
+/**
+ * Analyze brain_observations and task history to find recurring patterns.
+ *
+ * Detects:
+ * - Workflow patterns: common task sequences that succeed/fail
+ * - Blocker patterns: what commonly blocks tasks
+ * - Success patterns: what correlates with successful task completion
+ * - Time patterns: recurring label/type distributions by task status
+ *
+ * @param taskAccessor - DataAccessor for tasks.db
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @param options - Extraction options (min frequency, confidence, limit)
+ * @returns Array of detected patterns sorted by frequency descending
+ */
+export declare function extractPatternsFromHistory(taskAccessor: DataAccessor, brainAccessor: BrainDataAccessor, options?: PatternExtractionOptions): Promise<DetectedPattern[]>;
+/**
+ * Find which known patterns from brain_patterns apply to a given task.
+ *
+ * Compares task attributes (labels, title, description, type, size, status)
+ * against stored patterns and returns matches with relevance scores.
+ *
+ * @param taskId - The task to match patterns against
+ * @param taskAccessor - DataAccessor for tasks.db
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @returns Array of pattern matches sorted by relevance descending
+ */
+export declare function matchPatterns(taskId: string, taskAccessor: DataAccessor, brainAccessor: BrainDataAccessor): Promise<PatternMatch[]>;
+/**
+ * Save a detected pattern to the brain_patterns table.
+ *
+ * Uses the existing brain_patterns schema: type, pattern, context, frequency,
+ * success_rate, impact, anti_pattern, mitigation, examples_json.
+ *
+ * @param detected - The pattern to store
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @returns The stored pattern row
+ */
+export declare function storeDetectedPattern(detected: DetectedPattern, brainAccessor: BrainDataAccessor): Promise<BrainPatternRow>;
+/**
+ * Update the frequency and success_rate of an existing pattern after an outcome.
+ *
+ * Increments frequency by 1 and recalculates success_rate using the running
+ * average formula: newRate = (oldRate * oldFreq + (success ? 1 : 0)) / newFreq.
+ *
+ * @param patternId - The brain_patterns ID to update
+ * @param outcome - Whether the outcome was successful
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @returns The update result or null if the pattern was not found
+ */
+export declare function updatePatternStats(patternId: string, outcome: boolean, brainAccessor: BrainDataAccessor): Promise<PatternStatsUpdate | null>;
+//# sourceMappingURL=patterns.d.ts.map

package/dist/intelligence/patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.d.ts","sourceRoot":"","sources":["../../src/intelligence/patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACxB,YAAY,EACZ,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAMpB;;;;;;;;;;;;;GAaG;AACH,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,iBAAiB,EAChC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,eAAe,EAAE,CAAC,CAiC5B;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,YAAY,EAAE,CAAC,CAiCzB;AAMD;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,eAAe,EACzB,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,eAAe,CAAC,CAiB1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAwBpC"}

package/dist/intelligence/prediction.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Quality Prediction module for the CLEO Intelligence dimension.
+ *
+ * Provides risk scoring for tasks based on complexity, historical patterns,
+ * and blocking analysis. Also predicts lifecycle gate validation outcomes
+ * using brain_patterns and brain_learnings data.
+ *
+ * Uses the existing BrainDataAccessor and DataAccessor — no new tables.
+ *
+ * @task Wave3A
+ * @epic T5149
+ */
+import type { Task } from '@cleocode/contracts';
+import type { BrainDataAccessor } from '../store/brain-accessor.js';
+import type { DataAccessor } from '../store/data-accessor.js';
+import type { LearningContext, RiskAssessment, ValidationPrediction } from './types.js';
+/**
+ * Calculate the risk score for a task based on multiple contributing factors.
+ *
+ * Factors considered:
+ * - Task complexity (size, dependency count, hierarchy depth)
+ * - Historical patterns (similar tasks' failure rates from brain_patterns)
+ * - Blocking risk (does this task block others?)
+ * - Dependency depth (how deep in the dependency chain)
+ *
+ * @param taskId - The task to assess
+ * @param taskAccessor - DataAccessor for tasks.db
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @returns A complete risk assessment with score, confidence, factors, and recommendation
+ */
+export declare function calculateTaskRisk(taskId: string, taskAccessor: DataAccessor, brainAccessor: BrainDataAccessor): Promise<RiskAssessment>;
+/**
+ * Predict the likelihood of a task passing a lifecycle validation gate.
+ *
+ * Combines:
+ * - Historical gate results for similar tasks (from brain_patterns)
+ * - Current task completion state
+ * - Applicable learnings from brain_learnings
+ *
+ * @param taskId - The task to evaluate
+ * @param stage - The lifecycle stage (e.g., "specification", "implementation")
+ * @param taskAccessor - DataAccessor for tasks.db
+ * @param brainAccessor - BrainDataAccessor for brain.db
+ * @returns Prediction with pass likelihood, blockers, and suggestions
+ */
+export declare function predictValidationOutcome(taskId: string, stage: string, taskAccessor: DataAccessor, brainAccessor: BrainDataAccessor): Promise<ValidationPrediction>;
+/**
+ * Gather applicable learnings for a task from brain_learnings.
+ */
+export declare function gatherLearningContext(task: Task, brainAccessor: BrainDataAccessor): Promise<LearningContext>;
+//# sourceMappingURL=prediction.d.ts.map

package/dist/intelligence/prediction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prediction.d.ts","sourceRoot":"","sources":["../../src/intelligence/prediction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAc,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAgCpG;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,cAAc,CAAC,CAkDzB;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CA6D/B;AAyUD;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,iBAAiB,GAC/B,OAAO,CAAC,eAAe,CAAC,CA6C1B"}

package/dist/intelligence/types.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Type definitions for the CLEO Intelligence dimension.
+ *
+ * Covers quality prediction (risk scoring, validation outcome prediction),
+ * pattern extraction (automatic detection, matching, storage), and
+ * impact analysis (blast radius, change prediction).
+ *
+ * @task Wave3A
+ * @epic T5149
+ * @module intelligence
+ */
+import type { BrainLearningRow, BrainPatternRow } from '../store/brain-schema.js';
+/**
+ * A single factor contributing to a task's overall risk score.
+ *
+ * Each factor has a weight (how much it matters) and a value (current level, 0-1).
+ * The weighted sum of all factors produces the aggregate risk score.
+ */
+export interface RiskFactor {
+    /** Human-readable factor name (e.g., "complexity", "blocking_risk"). */
+    name: string;
+    /** How much this factor contributes to the total score (0-1). */
+    weight: number;
+    /** Current measured value for this factor (0-1, where 1 = highest risk). */
+    value: number;
+    /** Explanation of why this factor has its current value. */
+    description: string;
+}
+/**
+ * Complete risk assessment for a single task.
+ *
+ * Returned by {@link calculateTaskRisk}. The `riskScore` is the weighted
+ * aggregate of all {@link RiskFactor} entries in `factors`.
+ */
+export interface RiskAssessment {
+    /** The task ID this assessment applies to. */
+    taskId: string;
+    /** Aggregate risk score (0-1, where 1 = highest risk). */
+    riskScore: number;
+    /** Confidence in the assessment (0-1). Higher when more data is available. */
+    confidence: number;
+    /** Individual risk factors that contributed to the score. */
+    factors: RiskFactor[];
+    /** Human-readable recommendation based on the risk level. */
+    recommendation: string;
+}
+/**
+ * Predicted outcome for a lifecycle validation gate.
+ *
+ * Returned by {@link predictValidationOutcome}. Combines historical
+ * pattern data with the task's current state to estimate pass likelihood.
+ */
+export interface ValidationPrediction {
+    /** The task ID being evaluated. */
+    taskId: string;
+    /** The lifecycle stage being predicted (e.g., "specification", "implementation"). */
+    stage: string;
+    /** Probability of passing the gate (0-1). */
+    passLikelihood: number;
+    /** Known blockers that may prevent passing. */
+    blockers: string[];
+    /** Actionable suggestions to improve pass likelihood. */
+    suggestions: string[];
+}
+/**
+ * A pattern automatically detected from historical brain/task data.
+ *
+ * Detected patterns may be stored in the existing brain_patterns table
+ * if they meet frequency and confidence thresholds.
+ */
+export interface DetectedPattern {
+    /** Pattern type classification. */
+    type: 'workflow' | 'blocker' | 'success' | 'failure' | 'optimization';
+    /** Human-readable pattern description. */
+    pattern: string;
+    /** Context in which the pattern was observed. */
+    context: string;
+    /** How many times this pattern was observed. */
+    frequency: number;
+    /** Success rate when this pattern appears (0-1, null if unknown). */
+    successRate: number | null;
+    /** Estimated impact level. */
+    impact: 'low' | 'medium' | 'high';
+    /** If this is an anti-pattern, describe the negative behavior. */
+    antiPattern: string | null;
+    /** Recommended mitigation for anti-patterns. */
+    mitigation: string | null;
+    /** Example task IDs or descriptions where this pattern occurred. */
+    examples: string[];
+    /** Confidence in this pattern's validity (0-1). */
+    confidence: number;
+}
+/**
+ * Result of matching a task against known patterns from brain_patterns.
+ *
+ * Includes the original pattern row and a relevance score indicating
+ * how strongly the pattern applies to the target task.
+ */
+export interface PatternMatch {
+    /** The matched brain_patterns row. */
+    pattern: BrainPatternRow;
+    /** How relevant this pattern is to the target task (0-1). */
+    relevanceScore: number;
+    /** Why this pattern was matched. */
+    matchReason: string;
+    /** Whether this is an anti-pattern match (warns about potential issues). */
+    isAntiPattern: boolean;
+}
+/**
+ * Options for pattern extraction from historical data.
+ */
+export interface PatternExtractionOptions {
+    /** Minimum number of occurrences to consider something a pattern. Default: 2. */
+    minFrequency?: number;
+    /** Minimum confidence threshold (0-1). Default: 0.3. */
+    minConfidence?: number;
+    /** Maximum number of patterns to return. Default: 50. */
+    limit?: number;
+    /** Filter by pattern type. */
+    type?: DetectedPattern['type'];
+}
+/**
+ * Result of updating pattern statistics after an outcome.
+ */
+export interface PatternStatsUpdate {
+    /** The pattern ID that was updated. */
+    patternId: string;
+    /** New frequency value. */
+    newFrequency: number;
+    /** New success rate (0-1). */
+    newSuccessRate: number | null;
+    /** Whether the outcome was successful. */
+    outcomeSuccess: boolean;
+}
+/**
+ * Summary of applicable learnings for a task, used in prediction.
+ */
+export interface LearningContext {
+    /** Learnings that apply to this task's context. */
+    applicable: BrainLearningRow[];
+    /** Average confidence of applicable learnings. */
+    averageConfidence: number;
+    /** Count of actionable learnings. */
+    actionableCount: number;
+}
+/**
+ * Full impact assessment for a task within its dependency graph.
+ *
+ * Captures direct dependents, transitive dependents, lifecycle pipeline
+ * effects, blocked work counts, and critical path membership.
+ */
+export interface ImpactAssessment {
+    /** The task being assessed. */
+    taskId: string;
+    /** Tasks that directly depend on this task. */
+    directDependents: string[];
+    /** All downstream tasks (direct + transitive). */
+    transitiveDependents: string[];
+    /** Epic IDs whose lifecycle pipelines are affected. */
+    affectedPipelines: string[];
+    /** Count of tasks that would be blocked if this task is not completed. */
+    blockedWorkCount: number;
+    /** Whether this task lies on the project's critical path. */
+    isOnCriticalPath: boolean;
+    /** Quantified scope of the impact. */
+    blastRadius: BlastRadius;
+}
+/** The type of change being analyzed. */
+export type ChangeType = 'cancel' | 'block' | 'complete' | 'reprioritize';
+/**
+ * Predicted downstream effects of a specific change to a task.
+ *
+ * Models what happens when a task is cancelled, blocked, completed,
+ * or reprioritized -- including cascading status changes and
+ * recommendations.
+ */
+export interface ChangeImpact {
+    /** The task being changed. */
+    taskId: string;
+    /** The type of change being analyzed. */
+    changeType: ChangeType;
+    /** Tasks affected by this change, with predicted new status. */
+    affectedTasks: AffectedTask[];
+    /** Maximum depth of cascading effects in the dependency graph. */
+    cascadeDepth: number;
+    /** Human-readable recommendation based on the analysis. */
+    recommendation: string;
+}
+/**
+ * A single task affected by a change, with its predicted new state.
+ */
+export interface AffectedTask {
+    /** Task ID. */
+    id: string;
+    /** Task title. */
+    title: string;
+    /** Current status before the change. */
+    currentStatus: string;
+    /** Predicted new status after the change (if it would change). */
+    newStatus?: string;
+    /** Why this task is affected. */
+    reason: string;
+}
+/** Severity classification for blast radius. */
+export type BlastRadiusSeverity = 'isolated' | 'moderate' | 'widespread' | 'critical';
+/**
+ * Quantified scope of a task's impact across the project.
+ */
+export interface BlastRadius {
+    /** Number of direct dependents. */
+    directCount: number;
+    /** Number of transitive dependents (full downstream tree). */
+    transitiveCount: number;
+    /** Number of distinct epics affected. */
+    epicCount: number;
+    /** Percentage of the total project impacted (0-100). */
+    projectPercentage: number;
+    /** Classification of impact severity. */
+    severity: BlastRadiusSeverity;
+}
+//# sourceMappingURL=types.d.ts.map