limen-ai 1.0.0

package/dist/learning/applicator/technique_applicator.js

@@ -0,0 +1,200 @@
+/**
+ * Limen — TechniqueApplicator Implementation
+ * Phase 4E-2c: Learning System Application Mechanics
+ *
+ * Implements the TechniqueApplicator interface from learning_types.ts.
+ * Retrieves active techniques at inference time and records applications.
+ *
+ * S ref: S29.4 (application mechanics), S29.2 (applicationCount, lastApplied),
+ *        S29.6 (retirement depends on applicationCount/lastApplied),
+ *        I-03 (audit), I-07 (agent isolation)
+ *
+ * Engineering decisions:
+ *   DEC-4E2C-001: Token estimation via chars/4 (no tokenizer, I-01)
+ *   DEC-4E2C-002: Greedy fill with skip (not stop-at-overflow)
+ *   DEC-4E2C-003: Ordering tiebreaker: created_at ASC, id ASC
+ *   DEC-4E2C-004: No FK validation on recordApplications (R-07)
+ *   DEC-4E2C-005: recordApplications synchronous, single transaction
+ */
+import { randomUUID } from 'node:crypto';
+function rowToTechnique(row) {
+    return {
+        id: row.id,
+        tenantId: row.tenant_id,
+        agentId: row.agent_id,
+        type: row.type,
+        content: row.content,
+        sourceMemoryIds: JSON.parse(row.source_memory_ids),
+        confidence: row.confidence,
+        successRate: row.success_rate,
+        applicationCount: row.application_count,
+        lastApplied: row.last_applied,
+        lastUpdated: row.last_updated,
+        status: row.status,
+        createdAt: row.created_at,
+    };
+}
+// ─── Token Estimation ───
+/**
+ * Estimate token count from content length.
+ *
+ * DEC-4E2C-001: Uses chars/4 approximation because:
+ *   (1) Contract tests use Math.ceil(content.length / 4)
+ *   (2) No tokenizer dependency permitted (I-01: single production dependency)
+ *   (3) Caller controls maxTokenBudget — overestimation is safe (conservative)
+ *
+ * Risk-if-wrong: Non-ASCII content (CJK, emoji) has higher tokens/char ratio,
+ * causing underestimation. Mitigated by conservative maxTokenBudget from caller
+ * and by the 20% ceiling being a safety margin, not a precision target.
+ */
+export function estimateTokens(content) {
+    return Math.ceil(content.length / 4);
+}
+// ─── Audit Helpers ───
+function actorType(ctx) {
+    if (ctx.userId)
+        return 'user';
+    if (ctx.agentId)
+        return 'agent';
+    return 'system';
+}
+function actorId(ctx) {
+    return (ctx.userId ?? ctx.agentId ?? 'system');
+}
+// ─── Factory ───
+/**
+ * Create a TechniqueApplicator implementation.
+ * Follows the Limen factory pattern: factory → Object.freeze.
+ *
+ * @param deps - Learning system dependencies (audit, events, etc.)
+ * @param store - TechniqueStore for R-06 applicationCount/lastApplied updates
+ */
+export function createTechniqueApplicator(deps, store) {
+    // ─── getActiveByType (shared query logic) ───
+    /**
+     * Query active techniques of a specific type for an agent.
+     * Results ordered by confidence DESC, created_at ASC, id ASC.
+     *
+     * DEC-4E2C-003: Tiebreaker rationale:
+     *   - confidence DESC: spec requirement (S29.4)
+     *   - created_at ASC: older techniques survived more evaluation cycles
+     *   - id ASC: absolute determinism for identical confidence + timestamp
+     */
+    function getActiveByType(conn, agentId, tenantId, type) {
+        const rows = conn.query(`SELECT * FROM learning_techniques
+       WHERE agent_id = ? AND tenant_id = ? AND status = 'active' AND type = ?
+       ORDER BY confidence DESC, created_at ASC, id ASC`, [agentId, tenantId, type]);
+        return rows.map(rowToTechnique);
+    }
+    // ─── getActivePromptFragments ───
+    /**
+     * Retrieve active prompt fragments within token budget.
+     *
+     * DEC-4E2C-002: Greedy fill in confidence order.
+     * Processes techniques in confidence-descending order. Includes each technique
+     * if its estimated tokens fit within remaining budget. Skips techniques that
+     * don't fit and continues to try the next (a smaller one may still fit).
+     *
+     * The returned list preserves confidence-descending order because we iterate
+     * in that order and only append (never reorder).
+     *
+     * Alternatives rejected:
+     *   - Stop-at-overflow: stops at first technique that doesn't fit. Disadvantage:
+     *     a single oversized technique blocks all subsequent smaller techniques.
+     *   - Partial inclusion: truncate individual technique content. Violates technique
+     *     content integrity — a partial prompt fragment is semantically broken.
+     */
+    function getActivePromptFragments(conn, agentId, tenantId, maxTokenBudget) {
+        const techniques = getActiveByType(conn, agentId, tenantId, 'prompt_fragment');
+        const result = [];
+        let usedTokens = 0;
+        for (const technique of techniques) {
+            const tokens = estimateTokens(technique.content);
+            if (usedTokens + tokens <= maxTokenBudget) {
+                result.push(technique);
+                usedTokens += tokens;
+            }
+        }
+        return { ok: true, value: result };
+    }
+    // ─── getActiveDecisionRules ───
+    function getActiveDecisionRules(conn, agentId, tenantId) {
+        return { ok: true, value: getActiveByType(conn, agentId, tenantId, 'decision_rule') };
+    }
+    // ─── getActiveRagPatterns ───
+    function getActiveRagPatterns(conn, agentId, tenantId) {
+        return { ok: true, value: getActiveByType(conn, agentId, tenantId, 'rag_pattern') };
+    }
+    // ─── recordApplications ───
+    /**
+     * Record technique applications and update technique statistics.
+     *
+     * Two side effects (R-06, BINDING from Principal Architect):
+     * 1. Increment applicationCount on techniques where applied=true
+     * 2. Update lastApplied timestamp on techniques where applied=true
+     *
+     * These updates enable retirement evaluation (S29.6):
+     *   - "over 50+ applications" uses applicationCount
+     *   - "not applied in 90 days" uses lastApplied
+     *
+     * DEC-4E2C-004: No FK validation. Application records written for phantom
+     * technique IDs (R-07). store.get() gracefully returns TECHNIQUE_NOT_FOUND
+     * for non-existent techniques; the update is skipped but the log record persists.
+     *
+     * DEC-4E2C-005: Synchronous, single transaction. All INSERTs and technique
+     * updates are atomic. If any fails, the entire batch rolls back. This is
+     * acceptable because: (a) SQLite single-writer makes contention impossible,
+     * (b) the batch is typically small (techniques applied to one interaction),
+     * (c) atomicity prevents partial state (some records written, some not).
+     */
+    function recordApplications(conn, ctx, applications) {
+        if (applications.length === 0) {
+            return { ok: true, value: undefined };
+        }
+        const firstApp = applications[0];
+        const batchTenantId = ctx.tenantId ?? firstApp.tenantId;
+        conn.transaction(() => {
+            for (const app of applications) {
+                // Write application record (append-only log)
+                conn.run(`INSERT INTO learning_applications (id, technique_id, interaction_id, tenant_id, timestamp, applied)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+                    randomUUID(),
+                    app.techniqueId,
+                    app.interactionId,
+                    app.tenantId,
+                    app.timestamp,
+                    app.applied ? 1 : 0,
+                ]);
+                // R-06: Update technique statistics for applied techniques
+                if (app.applied && ctx.agentId) {
+                    const getResult = store.get(conn, app.techniqueId, app.tenantId, ctx.agentId);
+                    if (getResult.ok) {
+                        store.update(conn, ctx, app.techniqueId, app.tenantId, {
+                            applicationCount: getResult.value.applicationCount + 1,
+                            lastApplied: app.timestamp,
+                        });
+                    }
+                    // Phantom IDs: store.get returns TECHNIQUE_NOT_FOUND — skip silently (R-07)
+                }
+            }
+            // Audit entry for the batch (I-03)
+            deps.audit.append(conn, {
+                tenantId: batchTenantId,
+                actorType: actorType(ctx),
+                actorId: actorId(ctx),
+                operation: 'technique.record_applications',
+                resourceType: 'technique_application',
+                resourceId: `batch-${applications.length}`,
+            });
+        });
+        return { ok: true, value: undefined };
+    }
+    // ─── Return frozen applicator ───
+    return Object.freeze({
+        getActivePromptFragments,
+        getActiveDecisionRules,
+        getActiveRagPatterns,
+        recordApplications,
+    });
+}
+//# sourceMappingURL=technique_applicator.js.map

package/dist/learning/applicator/technique_applicator.js.map

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

package/dist/learning/cold_start/cold_start_manager.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Limen — ColdStartManager Implementation
+ * Phase 4E-2e: Learning System Convergence Subsystems
+ *
+ * Implements the ColdStartManager interface from learning_types.ts.
+ * Pre-built technique templates for new agents. Confidence 0.6.
+ *
+ * S ref: S29.9 (cold-start templates), BRK-S29-001 (template versioning)
+ *
+ * Engineering decisions:
+ *   D1: Templates are hardcoded in-memory. Spec defines 5 templates (customer-support,
+ *       document-qa, code-assistant, claims-processor, research-analyst). Additional
+ *       templates (e.g., sales-default) are included for domain coverage.
+ *   D2: Cold-start provenance: sourceMemoryIds = ['cold-start:template:<templateId>'].
+ *       store.create() enforces non-empty sourceMemoryIds (S29.3 Step 4). Cold-start
+ *       techniques don't originate from memories — the template IS the provenance source.
+ *       This satisfies the validation while correctly representing origin.
+ *   D3: getAvailableTemplates() takes no parameters (no conn needed). Templates are
+ *       in-memory constants, not database-backed.
+ *   D4: applyTemplate() creates ALL techniques atomically. If any create fails, the
+ *       entire operation fails. store.create() handles per-technique audit internally.
+ *   D5: Idempotent application. Applying the same template twice returns the existing
+ *       techniques instead of creating duplicates. Checked via getBySourceMemory with
+ *       the cold-start provenance pattern, filtered by agentId. BRK-IMPL-004.
+ */
+import type { ColdStartManager, TechniqueStore } from '../interfaces/index.js';
+/**
+ * Create a ColdStartManager implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * S29.9: Pre-built technique templates. Confidence 0.6.
+ * BRK-S29-001: Templates must have version >= 1.
+ */
+export declare function createColdStartManager(store: TechniqueStore): ColdStartManager;
+//# sourceMappingURL=cold_start_manager.d.ts.map

package/dist/learning/cold_start/cold_start_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cold_start_manager.d.ts","sourceRoot":"","sources":["../../../src/learning/cold_start/cold_start_manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACf,MAAM,wBAAwB,CAAC;AAyEhC;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAgE9E"}

package/dist/learning/cold_start/cold_start_manager.js

@@ -0,0 +1,146 @@
+/**
+ * Limen — ColdStartManager Implementation
+ * Phase 4E-2e: Learning System Convergence Subsystems
+ *
+ * Implements the ColdStartManager interface from learning_types.ts.
+ * Pre-built technique templates for new agents. Confidence 0.6.
+ *
+ * S ref: S29.9 (cold-start templates), BRK-S29-001 (template versioning)
+ *
+ * Engineering decisions:
+ *   D1: Templates are hardcoded in-memory. Spec defines 5 templates (customer-support,
+ *       document-qa, code-assistant, claims-processor, research-analyst). Additional
+ *       templates (e.g., sales-default) are included for domain coverage.
+ *   D2: Cold-start provenance: sourceMemoryIds = ['cold-start:template:<templateId>'].
+ *       store.create() enforces non-empty sourceMemoryIds (S29.3 Step 4). Cold-start
+ *       techniques don't originate from memories — the template IS the provenance source.
+ *       This satisfies the validation while correctly representing origin.
+ *   D3: getAvailableTemplates() takes no parameters (no conn needed). Templates are
+ *       in-memory constants, not database-backed.
+ *   D4: applyTemplate() creates ALL techniques atomically. If any create fails, the
+ *       entire operation fails. store.create() handles per-technique audit internally.
+ *   D5: Idempotent application. Applying the same template twice returns the existing
+ *       techniques instead of creating duplicates. Checked via getBySourceMemory with
+ *       the cold-start provenance pattern, filtered by agentId. BRK-IMPL-004.
+ */
+import { INITIAL_CONFIDENCE_COLD_START } from '../interfaces/index.js';
+// ─── Template Definitions (§29.9) ───
+const TEMPLATES = Object.freeze([
+    {
+        templateId: 'customer-support',
+        name: 'Customer Support',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'Acknowledge the customer\'s frustration before offering solutions.' },
+            { type: 'decision_rule', content: 'If customer has waited >24h for a response, escalate to priority queue.' },
+            { type: 'rag_pattern', content: 'Retrieve customer\'s recent ticket history before composing a response.' },
+        ]),
+    },
+    {
+        templateId: 'document-qa',
+        name: 'Document Q&A',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'Quote the relevant document section before providing an answer.' },
+            { type: 'decision_rule', content: 'If the answer is not in the provided documents, say so explicitly rather than guessing.' },
+            { type: 'rag_pattern', content: 'Retrieve the top 3 most relevant document sections by semantic similarity.' },
+        ]),
+    },
+    {
+        templateId: 'code-assistant',
+        name: 'Code Assistant',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'Include the programming language and version context in every code suggestion.' },
+            { type: 'decision_rule', content: 'If code has security implications, flag them explicitly before providing the solution.' },
+            { type: 'rag_pattern', content: 'Retrieve the project\'s existing code patterns before suggesting new implementations.' },
+        ]),
+    },
+    {
+        templateId: 'claims-processor',
+        name: 'Claims Processor',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'State the claim ID and status at the beginning of every response.' },
+            { type: 'decision_rule', content: 'If claim amount exceeds threshold, require supervisor approval before proceeding.' },
+            { type: 'rag_pattern', content: 'Retrieve similar past claims and their resolutions for reference.' },
+        ]),
+    },
+    {
+        templateId: 'research-analyst',
+        name: 'Research Analyst',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'Cite sources with author, date, and publication for every factual claim.' },
+            { type: 'decision_rule', content: 'If sources conflict, present both perspectives with confidence assessment.' },
+            { type: 'rag_pattern', content: 'Retrieve the most recent publications first, then expand to historical sources.' },
+        ]),
+    },
+    {
+        templateId: 'sales-default',
+        name: 'Sales Default',
+        version: 1,
+        techniques: Object.freeze([
+            { type: 'prompt_fragment', content: 'When discussing pricing, always mention the annual discount option first.' },
+            { type: 'decision_rule', content: 'If customer mentions budget constraints, offer a tiered pricing breakdown.' },
+            { type: 'rag_pattern', content: 'Retrieve product comparison data when customer asks about alternatives.' },
+        ]),
+    },
+]);
+// ─── Factory ───
+/**
+ * Create a ColdStartManager implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * S29.9: Pre-built technique templates. Confidence 0.6.
+ * BRK-S29-001: Templates must have version >= 1.
+ */
+export function createColdStartManager(store) {
+    // D3: getAvailableTemplates takes no parameters — templates are in-memory
+    function getAvailableTemplates() {
+        return { ok: true, value: TEMPLATES };
+    }
+    // D4: Creates ALL template techniques via store.create()
+    function applyTemplate(conn, ctx, agentId, tenantId, templateId) {
+        const template = TEMPLATES.find(t => t.templateId === templateId);
+        if (!template) {
+            return {
+                ok: false,
+                error: {
+                    code: 'TEMPLATE_NOT_FOUND',
+                    message: `Cold-start template '${templateId}' not found`,
+                    spec: 'S29.9',
+                },
+            };
+        }
+        // D5: Idempotency check — if template already applied to this agent, return existing
+        const provenanceId = `cold-start:template:${templateId}`;
+        const existingResult = store.getBySourceMemory(conn, provenanceId, tenantId);
+        if (existingResult.ok) {
+            const agentTechniques = existingResult.value.filter(t => t.agentId === agentId);
+            if (agentTechniques.length > 0) {
+                return { ok: true, value: agentTechniques };
+            }
+        }
+        const techniques = [];
+        // D2: Provenance = template reference (store.create requires non-empty sourceMemoryIds)
+        const sourceMemoryIds = [provenanceId];
+        for (const entry of template.techniques) {
+            const createResult = store.create(conn, ctx, {
+                tenantId,
+                agentId,
+                type: entry.type,
+                content: entry.content,
+                sourceMemoryIds,
+                initialConfidence: INITIAL_CONFIDENCE_COLD_START, // 0.6 per S29.9
+            });
+            if (!createResult.ok) {
+                return createResult;
+            }
+            techniques.push(createResult.value);
+        }
+        return { ok: true, value: techniques };
+    }
+    return Object.freeze({ applyTemplate, getAvailableTemplates });
+}
+//# sourceMappingURL=cold_start_manager.js.map

package/dist/learning/cold_start/cold_start_manager.js.map

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

package/dist/learning/cycle/learning_cycle_orchestrator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Limen — LearningCycleOrchestrator Implementation
+ * Phase 4E-2f: Final Learning System Sub-Phase
+ *
+ * Implements the LearningCycleOrchestrator interface from learning_types.ts.
+ * Orchestrates the §29.3 extraction pipeline:
+ *   collect → extract (per candidate) → confidence update → retirement sweep → specialization check
+ *
+ * S ref: S29.3 (learning cycle), S29.5 (confidence tracking), S29.6 (retirement),
+ *        S29.10 (over-specialization), DEC-4E-003 (HITL confidence 1.0)
+ *
+ * Engineering decisions:
+ *   D1: Pipeline order: collect → extract → confidence update (all active) → retirement sweep
+ *       → specialization check. Per §29.3 interface comment: "collect -> extract -> dedup -> store
+ *       -> track -> retire -> check specialization." Extract internally handles dedup + store.
+ *       Track = updateConfidence for all active techniques with recorded outcomes.
+ *   D2: HITL mechanism: when trigger === 'hitl_correction', after extractAndStore creates a novel
+ *       technique (non-null return), call store.update() to override confidence to HITL_CONFIDENCE
+ *       (1.0). The extractor creates at INITIAL_CONFIDENCE_EXTRACTED (0.5) — the orchestrator
+ *       applies the HITL override because the trigger context is only visible here.
+ *   D3: Cycle state: in-memory Map<string, string> keyed by agentId:tenantId. Limen is a library
+ *       (SEC-004), not a server. State lives as long as the LearningSystem instance. Set AFTER
+ *       cycle completes successfully (not before — failed cycles don't update timestamp).
+ *   D4: Error handling: best-effort per candidate. collectCandidates failure aborts cycle (no
+ *       candidates = no pipeline). Per-candidate extractAndStore failure is logged and skipped.
+ *       LearningCycleResult has count fields → design intent is partial results.
+ *   D5: Event emission: §29.3 interface comment says "Emits learning.cycle.completed event on
+ *       completion." Guarded: only emits if deps.events.emit is a function. Test stubs use
+ *       {} as EventBus — calling emit on stub would throw TypeError. Event is best-effort;
+ *       cycle success does not depend on event delivery.
+ *   D6: Confidence update scope: updateConfidence for all active techniques. With no outcomes,
+ *       tracker returns current confidence unchanged (no DB write). Safe to call for all.
+ *   D7: tenantId: extracted from ctx.tenantId. runCycle's interface takes agentId directly;
+ *       tenantId comes from the OperationContext (same pattern as all Limen operations).
+ */
+import type { LearningCycleOrchestrator, TechniqueStore, TechniqueExtractor, EffectivenessTracker, RetirementEvaluator, OverSpecializationDetector, LearningDeps } from '../interfaces/index.js';
+/**
+ * Create a LearningCycleOrchestrator implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * §29.3: Orchestrates the full learning cycle pipeline.
+ * All subsystems are injected — the orchestrator has no direct DB access.
+ */
+export declare function createLearningCycleOrchestrator(deps: LearningDeps, store: TechniqueStore, extractor: TechniqueExtractor, tracker: EffectivenessTracker, retirement: RetirementEvaluator, specialization: OverSpecializationDetector): LearningCycleOrchestrator;
+//# sourceMappingURL=learning_cycle_orchestrator.d.ts.map

package/dist/learning/cycle/learning_cycle_orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning_cycle_orchestrator.d.ts","sourceRoot":"","sources":["../../../src/learning/cycle/learning_cycle_orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EAAE,kBAAkB,EAAE,oBAAoB,EACxD,mBAAmB,EAAE,0BAA0B,EAC/C,YAAY,EACb,MAAM,wBAAwB,CAAC;AAShC;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,mBAAmB,EAC/B,cAAc,EAAE,0BAA0B,GACzC,yBAAyB,CAkJ3B"}

package/dist/learning/cycle/learning_cycle_orchestrator.js

@@ -0,0 +1,165 @@
+/**
+ * Limen — LearningCycleOrchestrator Implementation
+ * Phase 4E-2f: Final Learning System Sub-Phase
+ *
+ * Implements the LearningCycleOrchestrator interface from learning_types.ts.
+ * Orchestrates the §29.3 extraction pipeline:
+ *   collect → extract (per candidate) → confidence update → retirement sweep → specialization check
+ *
+ * S ref: S29.3 (learning cycle), S29.5 (confidence tracking), S29.6 (retirement),
+ *        S29.10 (over-specialization), DEC-4E-003 (HITL confidence 1.0)
+ *
+ * Engineering decisions:
+ *   D1: Pipeline order: collect → extract → confidence update (all active) → retirement sweep
+ *       → specialization check. Per §29.3 interface comment: "collect -> extract -> dedup -> store
+ *       -> track -> retire -> check specialization." Extract internally handles dedup + store.
+ *       Track = updateConfidence for all active techniques with recorded outcomes.
+ *   D2: HITL mechanism: when trigger === 'hitl_correction', after extractAndStore creates a novel
+ *       technique (non-null return), call store.update() to override confidence to HITL_CONFIDENCE
+ *       (1.0). The extractor creates at INITIAL_CONFIDENCE_EXTRACTED (0.5) — the orchestrator
+ *       applies the HITL override because the trigger context is only visible here.
+ *   D3: Cycle state: in-memory Map<string, string> keyed by agentId:tenantId. Limen is a library
+ *       (SEC-004), not a server. State lives as long as the LearningSystem instance. Set AFTER
+ *       cycle completes successfully (not before — failed cycles don't update timestamp).
+ *   D4: Error handling: best-effort per candidate. collectCandidates failure aborts cycle (no
+ *       candidates = no pipeline). Per-candidate extractAndStore failure is logged and skipped.
+ *       LearningCycleResult has count fields → design intent is partial results.
+ *   D5: Event emission: §29.3 interface comment says "Emits learning.cycle.completed event on
+ *       completion." Guarded: only emits if deps.events.emit is a function. Test stubs use
+ *       {} as EventBus — calling emit on stub would throw TypeError. Event is best-effort;
+ *       cycle success does not depend on event delivery.
+ *   D6: Confidence update scope: updateConfidence for all active techniques. With no outcomes,
+ *       tracker returns current confidence unchanged (no DB write). Safe to call for all.
+ *   D7: tenantId: extracted from ctx.tenantId. runCycle's interface takes agentId directly;
+ *       tenantId comes from the OperationContext (same pattern as all Limen operations).
+ */
+import { randomUUID } from 'node:crypto';
+import { HITL_CONFIDENCE } from '../interfaces/index.js';
+// ─── Factory ───
+/**
+ * Create a LearningCycleOrchestrator implementation.
+ * Follows the Limen store pattern: factory → Object.freeze.
+ *
+ * §29.3: Orchestrates the full learning cycle pipeline.
+ * All subsystems are injected — the orchestrator has no direct DB access.
+ */
+export function createLearningCycleOrchestrator(deps, store, extractor, tracker, retirement, specialization) {
+    // D3: In-memory cycle time tracking (per agent+tenant instance)
+    const lastCycleTimes = new Map();
+    function cycleKey(agentId, tenantId) {
+        return `${agentId}:${tenantId}`;
+    }
+    // ─── runCycle ───
+    async function runCycle(conn, ctx, agentId, trigger) {
+        const tenantId = ctx.tenantId;
+        const cycleId = randomUUID();
+        const now = deps.time.nowISO();
+        // Determine since-timestamp for candidate collection
+        const lastTime = lastCycleTimes.get(cycleKey(agentId, tenantId)) ?? '1970-01-01T00:00:00.000Z';
+        // ── Step 1: Collect candidates (§29.3 Step 1) ──
+        const candidatesResult = extractor.collectCandidates(conn, ctx, agentId, lastTime);
+        if (!candidatesResult.ok) {
+            return candidatesResult;
+        }
+        const candidates = candidatesResult.value;
+        let techniquesExtracted = 0;
+        let duplicatesReinforced = 0;
+        // ── Step 2: Extract and store each candidate (§29.3 Steps 2-4) ──
+        // D4: Best-effort per candidate — LLM failure for one doesn't abort cycle
+        for (const candidate of candidates) {
+            const extractResult = await extractor.extractAndStore(conn, ctx, candidate);
+            if (!extractResult.ok) {
+                // Per-candidate failure: skip, continue with remaining candidates
+                continue;
+            }
+            if (extractResult.value !== null) {
+                // Novel technique created
+                techniquesExtracted++;
+                // D2: HITL override — set confidence to 1.0 for HITL-triggered cycles
+                if (trigger === 'hitl_correction') {
+                    store.update(conn, ctx, extractResult.value.id, tenantId, {
+                        confidence: HITL_CONFIDENCE, // 1.0 per DEC-4E-003
+                    });
+                }
+            }
+            else {
+                // Duplicate reinforced (EMA applied by extractor)
+                duplicatesReinforced++;
+            }
+        }
+        // ── Step 3: Confidence update for all active techniques (§29.5 "track") ──
+        // D6: updateConfidence is a no-op when no outcomes exist — safe to call for all
+        const activeTechniques = store.getByAgent(conn, agentId, tenantId, 'active');
+        if (activeTechniques.ok) {
+            for (const technique of activeTechniques.value) {
+                tracker.updateConfidence(conn, ctx, technique.id, tenantId);
+                // Errors ignored per D4 — confidence update is best-effort within cycle
+            }
+        }
+        // ── Step 4: Retirement sweep (§29.6) ──
+        let techniquesRetired = 0;
+        const retirementResult = retirement.evaluateAll(conn, agentId, tenantId);
+        if (retirementResult.ok) {
+            for (const decision of retirementResult.value) {
+                if (decision.shouldRetire && decision.reason !== null) {
+                    const retireResult = store.retire(conn, ctx, decision.techniqueId, tenantId, decision.reason);
+                    if (retireResult.ok) {
+                        techniquesRetired++;
+                    }
+                }
+            }
+        }
+        // ── Step 5: Over-specialization check (§29.10) ──
+        const specResult = specialization.analyze(conn, agentId, tenantId);
+        const overSpecializationDetected = specResult.ok ? specResult.value.overSpecialized : false;
+        // Build result
+        const cycleResult = {
+            cycleId,
+            agentId,
+            tenantId,
+            trigger,
+            candidatesEvaluated: candidates.length,
+            techniquesExtracted,
+            duplicatesReinforced,
+            techniquesRetired,
+            overSpecializationDetected,
+            timestamp: now,
+        };
+        // D3: Record cycle time AFTER successful completion
+        lastCycleTimes.set(cycleKey(agentId, tenantId), now);
+        // D5: Emit event (best-effort — guarded against stub EventBus)
+        if (typeof deps.events?.emit === 'function') {
+            try {
+                deps.events.emit(conn, ctx, {
+                    type: 'learning.cycle.completed',
+                    scope: 'system',
+                    payload: {
+                        cycleId,
+                        agentId,
+                        tenantId,
+                        trigger,
+                        techniquesExtracted,
+                        duplicatesReinforced,
+                        techniquesRetired,
+                        overSpecializationDetected,
+                    },
+                    propagation: 'local',
+                });
+            }
+            catch {
+                // Event emission failure does not fail the cycle
+            }
+        }
+        return { ok: true, value: cycleResult };
+    }
+    // ─── getLastCycleTime ───
+    function getLastCycleTime(_conn, agentId, tenantId) {
+        const key = cycleKey(agentId, tenantId);
+        return {
+            ok: true,
+            value: lastCycleTimes.get(key) ?? null,
+        };
+    }
+    return Object.freeze({ runCycle, getLastCycleTime });
+}
+//# sourceMappingURL=learning_cycle_orchestrator.js.map

package/dist/learning/cycle/learning_cycle_orchestrator.js.map

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