@cleocode/core 2026.3.57 → 2026.3.59

package/dist/agents/agent-registry.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Agent registry with capacity tracking for load balancing.
+ *
+ * Provides task-count-based capacity queries, specialization lookup,
+ * and performance recording on top of the existing `agent_instances` schema.
+ *
+ * Capacity model: each agent has a maximum of {@link MAX_TASKS_PER_AGENT}
+ * concurrent tasks. "Remaining capacity" is that constant minus the number of
+ * tasks currently assigned to an active agent instance.
+ *
+ * Specializations are stored as a `specializations` array inside the agent's
+ * `metadata_json` column. Use {@link updateAgentSpecializations} to write them.
+ *
+ * Performance recording delegates to the existing `recordAgentExecution`
+ * function in `execution-learning.ts` and wraps it with a simpler metrics
+ * interface suited for load-balancer callers.
+ *
+ * @module agents/agent-registry
+ * @task T041
+ * @epic T038
+ */
+import { type AgentInstanceRow, type AgentType } from './agent-schema.js';
+import { type AgentExecutionOutcome } from './execution-learning.js';
+/**
+ * Maximum number of tasks that can be concurrently assigned to one agent.
+ * Used as the upper bound for task-count-based capacity calculation.
+ */
+export declare const MAX_TASKS_PER_AGENT = 5;
+/**
+ * Task-count-based capacity for a single agent instance.
+ */
+export interface AgentCapacity {
+    /** Agent instance ID. */
+    agentId: string;
+    /** Agent type classification. */
+    agentType: AgentType;
+    /** Current status of the agent. */
+    status: AgentInstanceRow['status'];
+    /** Number of tasks currently assigned to this agent. */
+    activeTasks: number;
+    /** Number of additional tasks this agent can accept (max - active). */
+    remainingCapacity: number;
+    /** Maximum tasks this agent can hold ({@link MAX_TASKS_PER_AGENT}). */
+    maxCapacity: number;
+    /** Whether this agent can accept new tasks. */
+    available: boolean;
+}
+/**
+ * Metrics provided when recording agent performance.
+ */
+export interface AgentPerformanceMetrics {
+    /** Task ID that was processed. */
+    taskId: string;
+    /** Task type label (e.g. "epic", "task", "subtask"). */
+    taskType: string;
+    /** Outcome of the agent's work on the task. */
+    outcome: AgentExecutionOutcome;
+    /** Optional task labels for richer pattern classification. */
+    taskLabels?: string[];
+    /** Session ID the agent was operating under. */
+    sessionId?: string;
+    /** Duration of execution in milliseconds. */
+    durationMs?: number;
+    /** Error message if outcome is "failure". */
+    errorMessage?: string;
+    /** Error classification if outcome is "failure". */
+    errorType?: 'retriable' | 'permanent' | 'unknown';
+}
+/**
+ * Get task-count-based remaining capacity for an agent.
+ *
+ * Remaining capacity = {@link MAX_TASKS_PER_AGENT} minus the number of tasks
+ * currently routed to this agent instance (tracked via the `task_id` column
+ * on `agent_instances` — each instance handles one task at a time; child agents
+ * spawned by an orchestrator appear as sibling rows referencing the same
+ * `parent_agent_id`).
+ *
+ * For capacity purposes the "active tasks" count is derived from the number of
+ * non-terminal sibling rows that share the same `parent_agent_id` as this
+ * agent, plus 1 for the agent's own current task when `task_id` is set.
+ *
+ * @remarks
+ * Agents in terminal states (`stopped`, `crashed`) always return 0 remaining
+ * capacity because they cannot accept work.
+ *
+ * @param agentId - Agent instance ID (agt_...) to check
+ * @param cwd - Working directory used to resolve tasks.db path
+ * @returns Capacity breakdown or null if the agent does not exist
+ *
+ * @example
+ * ```ts
+ * const cap = await getAgentCapacity('agt_20260321120000_ab12cd', '/project');
+ * if (cap && cap.available) {
+ *   console.log(`Agent can take ${cap.remainingCapacity} more tasks`);
+ * }
+ * ```
+ */
+export declare function getAgentCapacity(agentId: string, cwd?: string): Promise<AgentCapacity | null>;
+/**
+ * List all non-terminal agents sorted by remaining task capacity (descending).
+ *
+ * Returns agents with the most available slots first, enabling callers to
+ * select the least-loaded agent for new work assignment.
+ *
+ * @remarks
+ * Only agents in `active` or `idle` states are included — `starting` agents
+ * are excluded because they may not yet be ready to accept work.
+ * Terminal agents (`stopped`, `crashed`) are always omitted.
+ *
+ * @param agentType - Optional filter to limit results to one agent type
+ * @param cwd - Working directory used to resolve tasks.db path
+ * @returns Array of capacity entries sorted highest remaining capacity first
+ *
+ * @example
+ * ```ts
+ * const agents = await getAgentsByCapacity('executor', '/project');
+ * const best = agents[0]; // most available slots
+ * if (best && best.available) {
+ *   await assignTask(best.agentId, taskId);
+ * }
+ * ```
+ */
+export declare function getAgentsByCapacity(agentType?: AgentType, cwd?: string): Promise<AgentCapacity[]>;
+/**
+ * Get the specialization/skills list for an agent.
+ *
+ * Specializations are stored as a string array under the `specializations`
+ * key in the agent's `metadata_json` column. An empty array is returned when
+ * the field is absent or the agent is not found.
+ *
+ * @remarks
+ * Write specializations with {@link updateAgentSpecializations} when
+ * registering or updating an agent. The metadata column is a free-form JSON
+ * blob — specializations are one namespaced key inside it.
+ *
+ * @param agentId - Agent instance ID (agt_...)
+ * @param cwd - Working directory used to resolve tasks.db path
+ * @returns Array of specialization strings (empty if none recorded)
+ *
+ * @example
+ * ```ts
+ * const skills = await getAgentSpecializations('agt_20260321120000_ab12cd', '/project');
+ * // ['typescript', 'testing', 'documentation']
+ * if (skills.includes('typescript')) {
+ *   console.log('Agent can handle TypeScript tasks');
+ * }
+ * ```
+ */
+export declare function getAgentSpecializations(agentId: string, cwd?: string): Promise<string[]>;
+/**
+ * Update the specializations list stored in an agent's metadata.
+ *
+ * Merges the new list into the existing `metadata_json` object, preserving
+ * any other keys already present. Returns the updated specializations list,
+ * or null if the agent was not found.
+ *
+ * @remarks
+ * This is a write-side companion to {@link getAgentSpecializations}. Call it
+ * after {@link registerAgent} to record the skills an agent was spawned with.
+ *
+ * @param agentId - Agent instance ID (agt_...)
+ * @param specializations - New specializations list (replaces existing)
+ * @param cwd - Working directory used to resolve tasks.db path
+ * @returns Updated specializations list, or null if agent not found
+ *
+ * @example
+ * ```ts
+ * await updateAgentSpecializations(
+ *   'agt_20260321120000_ab12cd',
+ *   ['typescript', 'testing'],
+ *   '/project',
+ * );
+ * ```
+ */
+export declare function updateAgentSpecializations(agentId: string, specializations: string[], cwd?: string): Promise<string[] | null>;
+/**
+ * Record agent performance metrics to the BRAIN execution history.
+ *
+ * Translates a simplified {@link AgentPerformanceMetrics} object into the
+ * {@link AgentExecutionEvent} format expected by `execution-learning.ts` and
+ * delegates to {@link recordAgentExecution}. The agent type is resolved from
+ * the `agent_instances` table so callers only need to supply the agent ID.
+ *
+ * @remarks
+ * Recording is best-effort — if brain.db is unavailable the error is swallowed
+ * and null is returned, consistent with the rest of the execution-learning
+ * module. Agent lifecycle code is never disrupted by a brain write failure.
+ *
+ * @param agentId - Agent instance ID whose performance is being recorded
+ * @param metrics - Performance metrics for the task that was processed
+ * @param cwd - Working directory used to resolve tasks.db and brain.db paths
+ * @returns The brain decision ID if recorded, null on failure or not found
+ *
+ * @example
+ * ```ts
+ * const decisionId = await recordAgentPerformance('agt_20260321120000_ab12cd', {
+ *   taskId: 'T041',
+ *   taskType: 'task',
+ *   outcome: 'success',
+ *   durationMs: 4200,
+ *   sessionId: 'ses_20260321_abc',
+ * }, '/project');
+ * ```
+ */
+export declare function recordAgentPerformance(agentId: string, metrics: AgentPerformanceMetrics, cwd?: string): Promise<string | null>;
+//# sourceMappingURL=agent-registry.d.ts.map

package/dist/agents/agent-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-registry.d.ts","sourceRoot":"","sources":["../../src/agents/agent-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,SAAS,EAAkB,MAAM,mBAAmB,CAAC;AAC1F,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,yBAAyB,CAAC;AAOjC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAMrC;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,SAAS,EAAE,SAAS,CAAC;IACrB,mCAAmC;IACnC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACnC,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,OAAO,EAAE,qBAAqB,CAAC;IAC/B,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,SAAS,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC;CACnD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA+C/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,CAAC,EAAE,SAAS,EACrB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,EAAE,CAAC,CAc1B;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkB9F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EAAE,EACzB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAwB1B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyBxB"}

package/dist/agents/agent-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-schema.d.ts","sourceRoot":"","sources":["../../src/agents/agent-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB,wEAO1B,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,WAAW,uGAQd,CAAC;AAMX,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1B,CAAC;AAMF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzB,CAAC;AAMF,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,mBAAmB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC3E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC"}
+{"version":3,"file":"agent-schema.d.ts","sourceRoot":"","sources":["../../src/agents/agent-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB,wEAO1B,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,WAAW,uGAQd,CAAC;AAMX,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B1B,CAAC;AAMF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzB,CAAC;AAMF,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,mBAAmB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC3E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,CAAC"}

package/dist/agents/execution-learning.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Agent Execution Learning — Agent dimension BRAIN integration.
+ *
+ * Tracks which agent types succeed or fail on which task types, logs agent
+ * decisions to brain_decisions with structured context, provides queries to
+ * retrieve agent performance history, and implements basic self-healing by
+ * recording failure patterns as brain_observations and surfacing healing
+ * suggestions when the same failure pattern recurs.
+ *
+ * This module bridges the agent registry (tasks.db) with the cognitive
+ * memory layer (brain.db) without introducing circular dependencies:
+ * - Tasks.db agent tables: agent_instances, agent_error_log (agent-schema.ts)
+ * - Brain.db tables: brain_decisions, brain_patterns, brain_observations
+ *
+ * All brain.db writes are best-effort — failures are silently swallowed so
+ * agent lifecycle events never fail due to a brain.db write error.
+ *
+ * @module agents/execution-learning
+ * @task T034
+ * @epic T029
+ */
+import type { BrainDataAccessor } from '../store/brain-accessor.js';
+import type { BrainDecisionRow, BrainObservationRow, BrainPatternRow } from '../store/brain-schema.js';
+import type { AgentType } from './agent-schema.js';
+/**
+ * The outcome of an agent's execution attempt on a task.
+ */
+export type AgentExecutionOutcome = 'success' | 'failure' | 'partial';
+/**
+ * Context recorded when an agent completes or fails a task.
+ */
+export interface AgentExecutionEvent {
+    /** Agent instance ID (agt_...). */
+    agentId: string;
+    /** Agent type classification. */
+    agentType: AgentType;
+    /** Task ID that was attempted. */
+    taskId: string;
+    /** Task type: 'epic' | 'task' | 'subtask'. */
+    taskType: string;
+    /** Task labels for richer pattern classification. */
+    taskLabels?: string[];
+    /** Execution outcome. */
+    outcome: AgentExecutionOutcome;
+    /** Error message if outcome is 'failure'. */
+    errorMessage?: string;
+    /** Error classification if outcome is 'failure'. */
+    errorType?: 'retriable' | 'permanent' | 'unknown';
+    /** Session ID the agent was running under. */
+    sessionId?: string;
+    /** Duration of execution in milliseconds (optional). */
+    durationMs?: number;
+}
+/**
+ * Summary of an agent type's execution performance on a task type.
+ */
+export interface AgentPerformanceSummary {
+    /** Agent type. */
+    agentType: AgentType;
+    /** Task type this summary is for. */
+    taskType: string;
+    /** Total execution attempts tracked. */
+    totalAttempts: number;
+    /** Number of successful attempts. */
+    successCount: number;
+    /** Number of failed attempts. */
+    failureCount: number;
+    /** Success rate [0.0 – 1.0]. */
+    successRate: number;
+    /** Most recent attempt outcome. */
+    lastOutcome: AgentExecutionOutcome | null;
+    /** Timestamp of the most recent tracked decision. */
+    lastSeenAt: string | null;
+}
+/**
+ * A self-healing suggestion derived from failure pattern history.
+ */
+export interface HealingSuggestion {
+    /** Pattern ID from brain_patterns. */
+    patternId: string;
+    /** Human-readable description of the failure pattern. */
+    failurePattern: string;
+    /** Times this pattern has been seen. */
+    frequency: number;
+    /** Mitigation / suggested next action. */
+    suggestion: string;
+    /** How confident the system is in this suggestion [0.0 – 1.0]. */
+    confidence: number;
+}
+/**
+ * Record an agent execution event to brain_decisions.
+ *
+ * Each event becomes a `tactical` decision entry describing which agent type
+ * handled which task type and whether it succeeded. This gives the BRAIN
+ * system a queryable history of agent-task execution for pattern extraction.
+ *
+ * The call is best-effort — if brain.db is unavailable the error is swallowed
+ * and null is returned so agent lifecycle code is never disrupted.
+ *
+ * @param event - Execution event to record
+ * @param cwd - Working directory (resolves brain.db path)
+ * @returns The stored decision row, or null on failure
+ */
+export declare function recordAgentExecution(event: AgentExecutionEvent, cwd?: string): Promise<BrainDecisionRow | null>;
+/**
+ * Internal implementation that accepts a pre-constructed accessor.
+ * Separated for testability without touching the real file system.
+ *
+ * @internal
+ */
+export declare function _recordAgentExecutionWithAccessor(event: AgentExecutionEvent, brain: BrainDataAccessor): Promise<BrainDecisionRow | null>;
+/**
+ * Retrieve agent execution performance history from brain_decisions.
+ *
+ * Queries all `tactical` decisions recorded by `recordAgentExecution` and
+ * aggregates them into per-(agentType, taskType) performance summaries.
+ *
+ * @param filters - Optional filters to narrow results
+ * @param cwd - Working directory
+ * @returns Array of performance summaries sorted by agentType then taskType
+ */
+export declare function getAgentPerformanceHistory(filters?: {
+    agentType?: AgentType;
+    taskType?: string;
+    limit?: number;
+}, cwd?: string): Promise<AgentPerformanceSummary[]>;
+/**
+ * Internal implementation with injected accessor for testability.
+ *
+ * @internal
+ */
+export declare function _getAgentPerformanceHistoryWithAccessor(filters: {
+    agentType?: AgentType;
+    taskType?: string;
+    limit?: number;
+}, brain: BrainDataAccessor): Promise<AgentPerformanceSummary[]>;
+/**
+ * Record a task failure pattern to brain_patterns.
+ *
+ * When a task fails, the (agentType, taskType, errorType) combination is
+ * stored as a `failure` pattern in brain.db. On subsequent failures matching
+ * the same combination, the frequency counter is incremented and the success
+ * rate updated. This data is what powers `getSelfHealingSuggestions`.
+ *
+ * The call is best-effort and never throws.
+ *
+ * @param event - A failure execution event (outcome must be 'failure')
+ * @param cwd - Working directory
+ * @returns The upserted pattern row, or null on error
+ */
+export declare function recordFailurePattern(event: AgentExecutionEvent, cwd?: string): Promise<BrainPatternRow | null>;
+/**
+ * Internal implementation with injected accessor.
+ *
+ * @internal
+ */
+export declare function _recordFailurePatternWithAccessor(event: AgentExecutionEvent, brain: BrainDataAccessor): Promise<BrainPatternRow | null>;
+/**
+ * Store a healing strategy observation to brain_observations.
+ *
+ * When a failure pattern reaches a significant frequency threshold (≥ 3),
+ * a `change` observation is recorded to represent the healing action
+ * recommended for future recurrences of the same pattern.
+ *
+ * The call is best-effort and never throws.
+ *
+ * @param event - The failure event that triggered healing
+ * @param strategy - Human-readable healing strategy description
+ * @param cwd - Working directory
+ * @returns The stored observation row, or null on error
+ */
+export declare function storeHealingStrategy(event: AgentExecutionEvent, strategy: string, cwd?: string): Promise<BrainObservationRow | null>;
+/**
+ * Internal implementation with injected accessor.
+ *
+ * @internal
+ */
+export declare function _storeHealingStrategyWithAccessor(event: AgentExecutionEvent, strategy: string, brain: BrainDataAccessor): Promise<BrainObservationRow | null>;
+/**
+ * Get self-healing suggestions for a given agent type and task type.
+ *
+ * Queries brain_patterns for known failure patterns matching the
+ * (agentType, taskType) combination and returns healing suggestions
+ * ordered by frequency (most-seen first).
+ *
+ * Returns an empty array if no failure patterns are found or brain.db
+ * is unavailable.
+ *
+ * @param agentType - The agent type to check
+ * @param taskType - The task type to check
+ * @param cwd - Working directory
+ * @returns Array of healing suggestions, highest frequency first
+ */
+export declare function getSelfHealingSuggestions(agentType: AgentType, taskType: string, cwd?: string): Promise<HealingSuggestion[]>;
+/**
+ * Internal implementation with injected accessor.
+ *
+ * @internal
+ */
+export declare function _getSelfHealingSuggestionsWithAccessor(agentType: AgentType, taskType: string, brain: BrainDataAccessor): Promise<HealingSuggestion[]>;
+/**
+ * Full agent lifecycle event processor.
+ *
+ * Convenience function that:
+ * 1. Records the execution event to brain_decisions
+ * 2. On failure: records/updates the failure pattern in brain_patterns
+ * 3. On failure with frequency ≥ 3: stores a healing strategy observation
+ *
+ * Returns a structured result with the recorded IDs and any healing
+ * suggestions that now apply.
+ *
+ * All operations are best-effort — the call never throws.
+ *
+ * @param event - The execution event
+ * @param cwd - Working directory
+ */
+export declare function processAgentLifecycleEvent(event: AgentExecutionEvent, cwd?: string): Promise<{
+    decisionId: string | null;
+    patternId: string | null;
+    observationId: string | null;
+    healingSuggestions: HealingSuggestion[];
+}>;
+//# sourceMappingURL=execution-learning.d.ts.map

package/dist/agents/execution-learning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-learning.d.ts","sourceRoot":"","sources":["../../src/agents/execution-learning.ts"],"names":[],"mappings":"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"}

package/dist/agents/health-monitor.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Agent Health Monitoring -- Heartbeat and crash detection for live agent instances.
+ *
+ * Provides the public-facing health API specified by T039:
+ *   - `recordHeartbeat`    — update last_heartbeat for a live agent
+ *   - `checkAgentHealth`   — check health of a specific agent by ID
+ *   - `detectStaleAgents`  — find agents whose heartbeat is older than threshold
+ *   - `detectCrashedAgents` — find active agents with no heartbeat for >3 min
+ *
+ * These functions delegate to the lower-level `registry.ts` primitives
+ * (`heartbeat`, `checkAgentHealth`, `listAgentInstances`) and add the
+ * named, task-spec-aligned surface required for T039.
+ *
+ * @module agents/health-monitor
+ * @task T039
+ * @epic T038
+ */
+import type { AgentInstanceRow, AgentInstanceStatus } from './agent-schema.js';
+/** Default heartbeat interval (30 seconds) per BRAIN spec. */
+export declare const HEARTBEAT_INTERVAL_MS = 30000;
+/** Default staleness threshold: 3 minutes without a heartbeat. */
+export declare const STALE_THRESHOLD_MS: number;
+/**
+ * Health status of a specific agent instance.
+ */
+export interface AgentHealthStatus {
+    /** Agent instance ID. */
+    agentId: string;
+    /** Current DB status. */
+    status: AgentInstanceStatus;
+    /** ISO timestamp of the last recorded heartbeat. */
+    lastHeartbeat: string;
+    /** Milliseconds since the last heartbeat (at call time). */
+    heartbeatAgeMs: number;
+    /** Whether the agent is considered healthy (heartbeat within threshold). */
+    healthy: boolean;
+    /** Whether the agent is considered stale (heartbeat older than threshold). */
+    stale: boolean;
+    /** Threshold used for staleness determination (ms). */
+    thresholdMs: number;
+}
+/**
+ * Record a heartbeat for an agent instance.
+ *
+ * Updates `last_heartbeat` to the current time and returns the agent's
+ * current {@link AgentInstanceStatus}. Returns `null` if the agent does not
+ * exist or is already in a terminal state (`stopped` / `crashed`).
+ *
+ * This is the primary mechanism by which long-running agents signal liveness.
+ * Call this every {@link HEARTBEAT_INTERVAL_MS} (30 s) from the agent loop.
+ *
+ * @param agentId - The agent instance ID (e.g. `agt_20260322120000_a1b2c3`)
+ * @param cwd - Working directory used to resolve the tasks.db path (optional)
+ * @returns The agent's current status, or `null` if not found / terminal
+ *
+ * @remarks
+ * Terminal agents (`stopped`, `crashed`) will NOT have their heartbeat
+ * updated — the existing status is returned as-is so callers can detect
+ * external shutdown signals.
+ *
+ * @example
+ * ```ts
+ * // Inside the agent's main loop:
+ * const heartbeatTimer = setInterval(async () => {
+ *   const status = await recordHeartbeat(agentId);
+ *   if (status === 'stopped' || status === null) {
+ *     // Orchestrator shut us down — exit cleanly
+ *     clearInterval(heartbeatTimer);
+ *     process.exit(0);
+ *   }
+ * }, HEARTBEAT_INTERVAL_MS);
+ * ```
+ */
+export declare function recordHeartbeat(agentId: string, cwd?: string): Promise<AgentInstanceStatus | null>;
+/**
+ * Check the health of a specific agent instance by ID.
+ *
+ * Queries the agent's current record and returns a structured
+ * {@link AgentHealthStatus} describing staleness, heartbeat age, and
+ * whether the agent is considered healthy relative to `thresholdMs`.
+ *
+ * Returns `null` if the agent ID is not found in the database.
+ *
+ * @param agentId - The agent instance ID to check
+ * @param thresholdMs - Staleness threshold in milliseconds (default: 3 minutes)
+ * @param cwd - Working directory used to resolve the tasks.db path (optional)
+ * @returns {@link AgentHealthStatus} or `null` if the agent does not exist
+ *
+ * @remarks
+ * Returns null if the agent is not found. A non-null result includes
+ * staleness status based on the threshold comparison.
+ *
+ * @example
+ * ```ts
+ * const health = await checkAgentHealth('agt_20260322120000_a1b2c3');
+ * if (health && health.stale) {
+ *   console.log(`Agent stale for ${health.heartbeatAgeMs}ms — presumed crashed`);
+ * }
+ * ```
+ */
+export declare function checkAgentHealth(agentId: string, thresholdMs?: number, cwd?: string): Promise<AgentHealthStatus | null>;
+/**
+ * Find all non-terminal agents whose last heartbeat is older than `thresholdMs`.
+ *
+ * "Stale" means an agent with status `starting`, `active`, or `idle` has
+ * not sent a heartbeat within the threshold window. This is a precursor to
+ * crash detection — a stale agent may still recover if it is under heavy load.
+ *
+ * Agents with status `stopped` or `crashed` are excluded — they are already
+ * in a terminal state and do not participate in the heartbeat protocol.
+ *
+ * @param thresholdMs - Staleness threshold in ms (default: 3 minutes / 180 000 ms)
+ * @param cwd - Working directory used to resolve the tasks.db path (optional)
+ * @returns Array of {@link AgentHealthStatus} for each stale agent, sorted by
+ *   heartbeat age descending (most-stale first)
+ *
+ * @remarks
+ * The default threshold matches the crash-detection window specified in T039:
+ * "timeout detection after 3 minutes".
+ *
+ * @example
+ * ```ts
+ * const stale = await detectStaleAgents();
+ * for (const s of stale) {
+ *   console.log(`${s.agentId} has been stale for ${s.heartbeatAgeMs / 1000}s`);
+ * }
+ * ```
+ */
+export declare function detectStaleAgents(thresholdMs?: number, cwd?: string): Promise<AgentHealthStatus[]>;
+/**
+ * Find agents with status `active` whose heartbeat has been silent for
+ * longer than `thresholdMs`, and mark them as `crashed` in the database.
+ *
+ * An agent is considered crashed when it:
+ * 1. Has status `active` (not `idle`, `starting`, `stopped`, or `crashed`)
+ * 2. Has not sent a heartbeat for longer than `thresholdMs`
+ *
+ * Each detected agent is immediately marked `crashed` via {@link markCrashed},
+ * incrementing its error count and writing a reason to `agent_error_log`.
+ *
+ * @param thresholdMs - Crash threshold in ms (default: 3 minutes / 180 000 ms)
+ * @param cwd - Working directory used to resolve the tasks.db path (optional)
+ * @returns Array of agent instance rows for each agent that was just marked
+ *   `crashed`, sorted by last heartbeat ascending (oldest first).
+ *
+ * @remarks
+ * This function is WRITE-side: it mutates the database. Callers should run
+ * it on a schedule (e.g. every 60 s) from an orchestrator or health watchdog.
+ * For a read-only view, use {@link detectStaleAgents} instead.
+ *
+ * @example
+ * ```ts
+ * // Inside an orchestrator health watchdog:
+ * const crashed = await detectCrashedAgents();
+ * if (crashed.length > 0) {
+ *   logger.warn({ crashed: crashed.map(a => a.id) }, 'Agents marked crashed');
+ * }
+ * ```
+ */
+export declare function detectCrashedAgents(thresholdMs?: number, cwd?: string): Promise<AgentInstanceRow[]>;
+//# sourceMappingURL=health-monitor.d.ts.map

package/dist/agents/health-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-monitor.d.ts","sourceRoot":"","sources":["../../src/agents/health-monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO/E,8DAA8D;AAC9D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C,kEAAkE;AAClE,eAAO,MAAM,kBAAkB,QAAa,CAAC;AAS7C;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,oDAAoD;IACpD,aAAa,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,cAAc,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,OAAO,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,KAAK,EAAE,OAAO,CAAC;IACf,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAErC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,MAA2B,EACxC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAMnC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,GAAE,MAA2B,EACxC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAO9B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,GAAE,MAA2B,EACxC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6B7B"}

package/dist/agents/index.d.ts

@@ -10,8 +10,11 @@
  *
  * @module agents
  */
+export { type AgentCapacity, type AgentPerformanceMetrics, getAgentCapacity, getAgentSpecializations, getAgentsByCapacity, MAX_TASKS_PER_AGENT, recordAgentPerformance, updateAgentSpecializations, } from './agent-registry.js';
 export { AGENT_INSTANCE_STATUSES, AGENT_TYPES, type AgentErrorLogRow, type AgentErrorType, type AgentInstanceRow, type AgentInstanceStatus, type AgentType, agentErrorLog, agentInstances, type NewAgentErrorLogRow, type NewAgentInstanceRow, } from './agent-schema.js';
 export { type CapacitySummary, findLeastLoadedAgent, getAvailableCapacity, getCapacitySummary, isOverloaded, updateCapacity, } from './capacity.js';
-export { type AgentHealthReport, checkAgentHealth, classifyError, deregisterAgent, generateAgentId, getAgentErrorHistory, getAgentInstance, getHealthReport, heartbeat, incrementTasksCompleted, type ListAgentFilters, listAgentInstances, markCrashed, type RegisterAgentOptions, registerAgent, type UpdateStatusOptions, updateAgentStatus, } from './registry.js';
+export { type AgentExecutionEvent, type AgentExecutionOutcome, type AgentPerformanceSummary, getAgentPerformanceHistory, getSelfHealingSuggestions, type HealingSuggestion, processAgentLifecycleEvent, recordAgentExecution, recordFailurePattern, storeHealingStrategy, } from './execution-learning.js';
+export { type AgentHealthStatus, checkAgentHealth, detectCrashedAgents, detectStaleAgents, HEARTBEAT_INTERVAL_MS, recordHeartbeat, STALE_THRESHOLD_MS, } from './health-monitor.js';
+export { type AgentHealthReport, checkAgentHealth as findStaleAgentRows, classifyError, deregisterAgent, generateAgentId, getAgentErrorHistory, getAgentInstance, getHealthReport, heartbeat, incrementTasksCompleted, type ListAgentFilters, listAgentInstances, markCrashed, type RegisterAgentOptions, registerAgent, type UpdateStatusOptions, updateAgentStatus, } from './registry.js';
 export { type AgentRecoveryResult, calculateDelay, createRetryPolicy, DEFAULT_RETRY_POLICY, type RetryPolicy, type RetryResult, recoverCrashedAgents, shouldRetry, withRetry, } from './retry.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,aAAa,EACb,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,eAAe,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,cAAc,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,kBAAkB,EAClB,WAAW,EACX,KAAK,oBAAoB,EACzB,aAAa,EACb,KAAK,mBAAmB,EACxB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,mBAAmB,EACxB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,oBAAoB,EACpB,WAAW,EACX,SAAS,GACV,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,aAAa,EACb,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,eAAe,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,cAAc,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,0BAA0B,EAC1B,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,IAAI,kBAAkB,EACtC,aAAa,EACb,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,kBAAkB,EAClB,WAAW,EACX,KAAK,oBAAoB,EACzB,aAAa,EACb,KAAK,mBAAmB,EACxB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,mBAAmB,EACxB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,oBAAoB,EACpB,WAAW,EACX,SAAS,GACV,MAAM,YAAY,CAAC"}