agentic-qe 3.10.2 → 3.10.4

package/dist/kernel/unified-memory.js

@@ -46,70 +46,14 @@ import { createCRDTStore, } from '../memory/crdt/index.js';
 // ============================================================================
 // Project Root Detection
 // ============================================================================
-/** Module-level cache for findProjectRoot result. */
-let _cachedProjectRoot = null;
-/**
- * Clear the cached project root. Useful for testing or when the
- * environment changes at runtime.
- */
-export function clearProjectRootCache() {
-    _cachedProjectRoot = null;
-}
-/**
- * Find the project root by walking up the directory tree.
- *
- * Priority order:
- * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for .agentic-qe directory (existing AQE project)
- * 3. Walk up looking for .git directory (git repo root)
- * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
- * 5. Fallback to current working directory
- *
- * Optimized: single upward walk checks all markers in one pass,
- * and the result is cached at module level for subsequent calls.
- */
-export function findProjectRoot(startDir = process.cwd()) {
-    if (_cachedProjectRoot) {
-        return _cachedProjectRoot;
-    }
-    if (process.env.AQE_PROJECT_ROOT) {
-        _cachedProjectRoot = process.env.AQE_PROJECT_ROOT;
-        return _cachedProjectRoot;
-    }
-    const dir = startDir;
-    const root = path.parse(dir).root;
-    let checkDir = dir;
-    let topmostAqeDir = null;
-    let lowestGitDir = null;
-    let topmostPackageJson = null;
-    while (checkDir !== root) {
-        if (fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
-            topmostAqeDir = checkDir;
-        }
-        if (fs.existsSync(path.join(checkDir, '.git'))) {
-            if (lowestGitDir === null) {
-                lowestGitDir = checkDir;
-            }
-        }
-        if (fs.existsSync(path.join(checkDir, 'package.json'))) {
-            topmostPackageJson = checkDir;
-        }
-        checkDir = path.dirname(checkDir);
-    }
-    if (topmostAqeDir) {
-        _cachedProjectRoot = topmostAqeDir;
-    }
-    else if (lowestGitDir) {
-        _cachedProjectRoot = lowestGitDir;
-    }
-    else if (topmostPackageJson) {
-        _cachedProjectRoot = topmostPackageJson;
-    }
-    else {
-        _cachedProjectRoot = process.cwd();
-    }
-    return _cachedProjectRoot;
-}
+// Issue #516: findProjectRoot / clearProjectRootCache live in a lightweight,
+// sqlite-free module so RVF hot paths can import them statically without
+// pulling in this sqlite-heavy module. Re-exported here for backward compat —
+// existing `import { findProjectRoot } from '.../unified-memory.js'` sites keep
+// working unchanged. Imported (not bare re-exported) so internal callers below
+// have a usable local binding.
+import { findProjectRoot, clearProjectRootCache } from './project-root.js';
+export { findProjectRoot, clearProjectRootCache };
 /**
  * Get the default database path using project root detection.
  * Always resolves to {project_root}/.agentic-qe/memory.db

package/dist/learning/experience-capture.js

@@ -418,7 +418,7 @@ export class ExperienceCaptureService {
      * plus new { consolidated, archived } fields.
      */
     async cleanup() {
-        let consolidated = 0;
+        const consolidated = 0;
         let archived = 0;
         for (const domain of this.stats.byDomain.keys()) {
             const count = this.stats.byDomain.get(domain) || 0;

package/dist/learning/local-judge-client.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Agentic QE v3 - Local LLM Judge Client
+ *
+ * Scores QE patterns for coherence, specificity, and reusability using a
+ * locally running Ollama-compatible LLM (OpenAI chat completions API).
+ *
+ * Reward blending: final_reward = 0.7 * outcome_reward + 0.3 * judge_score
+ * Escalation: score in [0.4, 0.6] → logged for human review (ambiguous zone)
+ *
+ * Env vars (all optional — client is disabled if none set):
+ *   NAGUAL_JUDGE_URL    — base URL of Ollama server (default: http://localhost:11434)
+ *   NAGUAL_JUDGE_MODEL  — model to use (default: qwen3:8b)
+ *
+ * Supported models (in preference order for M-series Macs):
+ *   gemma4:12b-mlx  — 10GB, MLX-optimised, best quality on Apple Silicon
+ *   qwen3:8b        — 5.2GB, strong reasoning, already installed
+ *   qwen3:30b-a3b   — 18GB, highest quality, use only if RAM permits
+ */
+/** Output of a judge evaluation. */
+export interface JudgeResult {
+    /** Quality score in [0, 1]. */
+    score: number;
+    /** One-sentence reasoning from the model. */
+    reason: string;
+    /** Model that produced the score. */
+    model: string;
+    /** True if score falls in the ambiguous zone [0.4, 0.6]. */
+    needsReview: boolean;
+}
+/**
+ * Blend an outcome reward with a judge score.
+ * final = 0.7 * outcomeReward + 0.3 * judgeScore
+ * Falls back to outcomeReward if judgeResult is null (judge unavailable).
+ */
+export declare function blendReward(outcomeReward: number, judgeResult: JudgeResult | null): number;
+/**
+ * Local LLM judge using OpenAI-compatible chat completions.
+ * Disabled automatically when NAGUAL_JUDGE_URL and NAGUAL_JUDGE_MODEL are both unset.
+ */
+export declare class LocalJudgeClient {
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly enabled: boolean;
+    constructor(opts?: {
+        url?: string;
+        model?: string;
+    });
+    /**
+     * Score a piece of text (pattern problem+solution) for QE quality.
+     * Returns null if judge is disabled or unavailable — callers use outcomeReward as-is.
+     */
+    score(text: string): Promise<JudgeResult | null>;
+}
+export declare function getLocalJudgeClient(): LocalJudgeClient;
+//# sourceMappingURL=local-judge-client.d.ts.map

package/dist/learning/local-judge-client.js

@@ -0,0 +1,127 @@
+/**
+ * Agentic QE v3 - Local LLM Judge Client
+ *
+ * Scores QE patterns for coherence, specificity, and reusability using a
+ * locally running Ollama-compatible LLM (OpenAI chat completions API).
+ *
+ * Reward blending: final_reward = 0.7 * outcome_reward + 0.3 * judge_score
+ * Escalation: score in [0.4, 0.6] → logged for human review (ambiguous zone)
+ *
+ * Env vars (all optional — client is disabled if none set):
+ *   NAGUAL_JUDGE_URL    — base URL of Ollama server (default: http://localhost:11434)
+ *   NAGUAL_JUDGE_MODEL  — model to use (default: qwen3:8b)
+ *
+ * Supported models (in preference order for M-series Macs):
+ *   gemma4:12b-mlx  — 10GB, MLX-optimised, best quality on Apple Silicon
+ *   qwen3:8b        — 5.2GB, strong reasoning, already installed
+ *   qwen3:30b-a3b   — 18GB, highest quality, use only if RAM permits
+ */
+import { LoggerFactory } from '../logging/index.js';
+const logger = LoggerFactory.create('local-judge');
+const DEFAULT_URL = 'http://localhost:11434';
+const DEFAULT_MODEL = 'qwen3:8b';
+const JUDGE_TIMEOUT_MS = 30_000;
+const MAX_TEXT_LENGTH = 600;
+// Thinking models (gemma4, qwen3) need extra tokens to finish reasoning before output
+const MAX_TOKENS = 600;
+/** Score in this range is ambiguous — flagged for human review. */
+const AMBIGUOUS_LOW = 0.4;
+const AMBIGUOUS_HIGH = 0.6;
+/**
+ * Blend an outcome reward with a judge score.
+ * final = 0.7 * outcomeReward + 0.3 * judgeScore
+ * Falls back to outcomeReward if judgeResult is null (judge unavailable).
+ */
+export function blendReward(outcomeReward, judgeResult) {
+    if (judgeResult === null)
+        return outcomeReward;
+    return 0.7 * outcomeReward + 0.3 * judgeResult.score;
+}
+/**
+ * Local LLM judge using OpenAI-compatible chat completions.
+ * Disabled automatically when NAGUAL_JUDGE_URL and NAGUAL_JUDGE_MODEL are both unset.
+ */
+export class LocalJudgeClient {
+    baseUrl;
+    model;
+    enabled;
+    constructor(opts) {
+        this.baseUrl = opts?.url ?? process.env['NAGUAL_JUDGE_URL'] ?? DEFAULT_URL;
+        this.model = opts?.model ?? process.env['NAGUAL_JUDGE_MODEL'] ?? DEFAULT_MODEL;
+        // Only active when explicitly configured via env or constructor options
+        this.enabled = Boolean(opts?.url ?? opts?.model ??
+            process.env['NAGUAL_JUDGE_URL'] ??
+            process.env['NAGUAL_JUDGE_MODEL']);
+    }
+    /**
+     * Score a piece of text (pattern problem+solution) for QE quality.
+     * Returns null if judge is disabled or unavailable — callers use outcomeReward as-is.
+     */
+    async score(text) {
+        if (!this.enabled)
+            return null;
+        const truncated = text.slice(0, MAX_TEXT_LENGTH);
+        const prompt = [
+            'You are a QE pattern quality judge.',
+            'Rate the following pattern for: coherence, specificity, and reusability in a software quality engineering context.',
+            'Reply with valid JSON only, no other text: {"score": <float 0.0-1.0>, "reason": "<one sentence>"}',
+            '',
+            `Pattern:\n${truncated}`,
+        ].join('\n');
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [{ role: 'user', content: prompt }],
+                    temperature: 0.1,
+                    max_tokens: MAX_TOKENS,
+                }),
+                signal: AbortSignal.timeout(JUDGE_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                logger.debug('judge request failed', { status: response.status, model: this.model });
+                return null;
+            }
+            const data = await response.json();
+            const msg = data.choices?.[0]?.message;
+            // Thinking models (gemma4, qwen3) emit final answer in content; reasoning
+            // holds the internal chain-of-thought. Fall back to reasoning if content empty.
+            const rawText = (msg?.content ?? '') || (msg?.reasoning ?? '');
+            // Strip markdown code fences before parsing
+            const cleaned = rawText.replace(/```[\w]*\n?/g, '').replace(/```/g, '');
+            // Extract first JSON object — handles multiline values via [\s\S] inside quotes
+            const jsonMatch = cleaned.match(/\{[\s\S]*?"score"[\s\S]*?\}/);
+            if (!jsonMatch) {
+                logger.debug('judge response had no JSON', { rawText: rawText.slice(0, 150) });
+                return null;
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (typeof parsed.score !== 'number')
+                return null;
+            const score = Math.max(0, Math.min(1, parsed.score));
+            const reason = typeof parsed.reason === 'string' ? parsed.reason : '';
+            const needsReview = score >= AMBIGUOUS_LOW && score <= AMBIGUOUS_HIGH;
+            if (needsReview) {
+                logger.info('[SurpriseReview] ambiguous judge score — flag for human review', {
+                    score,
+                    reason,
+                    model: this.model,
+                });
+            }
+            return { score, reason, model: this.model, needsReview };
+        }
+        catch (err) {
+            logger.debug('judge unavailable (non-fatal)', { err, model: this.model });
+            return null;
+        }
+    }
+}
+let _instance;
+export function getLocalJudgeClient() {
+    if (!_instance)
+        _instance = new LocalJudgeClient();
+    return _instance;
+}
+//# sourceMappingURL=local-judge-client.js.map

package/dist/learning/nagual-client.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Agentic QE v3 - Nagual Client
+ *
+ * REST client for a nagual self-learning pattern hub.
+ * Defaults to a locally running nagual serve instance.
+ *
+ * Setup: run your own nagual instance from
+ *   https://github.com/proffesor-for-testing/nagual-qe
+ * then: nagual serve --port 3333
+ *
+ * Env vars:
+ *   NAGUAL_URL          — base URL of your nagual instance (default: http://localhost:3333)
+ *   NAGUAL_API_TOKEN    — API token if your instance requires one
+ *   NAGUAL_CLOUD_KEY    — alias for NAGUAL_API_TOKEN, loaded from ~/.nagual/cloud-hooks.env
+ */
+export interface NagualPattern {
+    id: string;
+    problem: string;
+    solution: string;
+    domain: string;
+    reward: number;
+    tags: string[];
+    use_count?: number;
+    success_rate?: number;
+    embedding_method?: string;
+}
+export type NagualOutcomeType = 'success' | 'partial_success' | 'failure';
+export interface NagualOutcome {
+    outcome: NagualOutcomeType;
+    reward: number;
+    feedback?: string;
+}
+export interface NagualPromotePayload {
+    problem: string;
+    solution: string;
+    domain: string;
+    reward: number;
+    tags?: string[];
+    source_project?: string;
+}
+/** Map AQE TestOutcome → nagual outcome + reward. */
+export declare function mapTestOutcomeToNagual(testOutcome: string): {
+    outcome: NagualOutcomeType;
+    reward: number;
+};
+/**
+ * Thin REST client for the nagual pattern hub.
+ * All methods are fire-and-forget safe — they never throw.
+ */
+export declare class NagualClient {
+    private readonly baseUrl;
+    private readonly token;
+    readonly enabled: boolean;
+    constructor();
+    /**
+     * Search nagual for patterns relevant to a task.
+     * Returns empty array on any error — callers must not depend on results.
+     */
+    search(query: string, domain?: string, limit?: number): Promise<NagualPattern[]>;
+    /**
+     * Record an outcome for a nagual pattern that was used in a task.
+     * Fire-and-forget — never awaited by callers in the hot path.
+     */
+    recordOutcome(patternId: string, outcome: NagualOutcome): Promise<void>;
+    /**
+     * Promote an AQE long-term pattern up to nagual as the cross-project hub.
+     * Applies 0.8 confidence decay on the reward before storing.
+     */
+    promotePattern(payload: NagualPromotePayload): Promise<void>;
+    private headers;
+}
+export declare function getNagualClient(): NagualClient;
+//# sourceMappingURL=nagual-client.d.ts.map

package/dist/learning/nagual-client.js

@@ -0,0 +1,150 @@
+/**
+ * Agentic QE v3 - Nagual Client
+ *
+ * REST client for a nagual self-learning pattern hub.
+ * Defaults to a locally running nagual serve instance.
+ *
+ * Setup: run your own nagual instance from
+ *   https://github.com/proffesor-for-testing/nagual-qe
+ * then: nagual serve --port 3333
+ *
+ * Env vars:
+ *   NAGUAL_URL          — base URL of your nagual instance (default: http://localhost:3333)
+ *   NAGUAL_API_TOKEN    — API token if your instance requires one
+ *   NAGUAL_CLOUD_KEY    — alias for NAGUAL_API_TOKEN, loaded from ~/.nagual/cloud-hooks.env
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { LoggerFactory } from '../logging/index.js';
+const logger = LoggerFactory.create('nagual-client');
+/** Load NAGUAL_CLOUD_KEY from ~/.nagual/cloud-hooks.env when not in process.env. */
+function loadCloudKeyFromFile() {
+    try {
+        const envFile = readFileSync(`${homedir()}/.nagual/cloud-hooks.env`, 'utf8');
+        for (const line of envFile.split('\n')) {
+            const m = line.match(/^(?:export\s+)?NAGUAL_CLOUD_KEY=(.+)/);
+            if (m)
+                return m[1].trim().replace(/^['"]|['"]$/g, '');
+        }
+    }
+    catch { /* file may not exist */ }
+    return undefined;
+}
+const DEFAULT_URL = 'http://localhost:3333';
+const REQUEST_TIMEOUT_MS = 3000;
+const PROMOTE_TIMEOUT_MS = 5000;
+/** Map AQE TestOutcome → nagual outcome + reward. */
+export function mapTestOutcomeToNagual(testOutcome) {
+    switch (testOutcome) {
+        case 'catches-bug': return { outcome: 'success', reward: 0.9 };
+        case 'new-coverage': return { outcome: 'partial_success', reward: 0.7 };
+        case 'neutral': return { outcome: 'partial_success', reward: 0.5 };
+        case 'redundant': return { outcome: 'partial_success', reward: 0.3 };
+        case 'code-smell': return { outcome: 'failure', reward: 0.2 };
+        case 'flaky': return { outcome: 'failure', reward: 0.2 };
+        case 'false-positive': return { outcome: 'failure', reward: 0.1 };
+        default: return { outcome: 'partial_success', reward: 0.5 };
+    }
+}
+/**
+ * Thin REST client for the nagual pattern hub.
+ * All methods are fire-and-forget safe — they never throw.
+ */
+export class NagualClient {
+    baseUrl;
+    token;
+    enabled;
+    constructor() {
+        this.baseUrl = process.env['NAGUAL_URL'] ?? DEFAULT_URL;
+        this.token =
+            process.env['NAGUAL_CLOUD_KEY'] ??
+                process.env['NAGUAL_API_TOKEN'] ??
+                loadCloudKeyFromFile();
+        this.enabled = true; // always attempt; errors are swallowed
+    }
+    /**
+     * Search nagual for patterns relevant to a task.
+     * Returns empty array on any error — callers must not depend on results.
+     */
+    async search(query, domain, limit = 5) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/patterns/search`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify({ query, domain, limit }),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            return data.patterns ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Record an outcome for a nagual pattern that was used in a task.
+     * Fire-and-forget — never awaited by callers in the hot path.
+     */
+    async recordOutcome(patternId, outcome) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/patterns/${encodeURIComponent(patternId)}/outcome`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(outcome),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                logger.debug('nagual recordOutcome non-OK', { patternId, status: response.status });
+            }
+        }
+        catch (err) {
+            logger.debug('nagual recordOutcome failed (non-fatal)', { patternId, err });
+        }
+    }
+    /**
+     * Promote an AQE long-term pattern up to nagual as the cross-project hub.
+     * Applies 0.8 confidence decay on the reward before storing.
+     */
+    async promotePattern(payload) {
+        const body = {
+            problem: payload.problem,
+            solution: payload.solution,
+            domain: payload.domain,
+            reward: payload.reward * 0.8, // cross-domain confidence decay
+            tags: [
+                ...(payload.tags ?? []),
+                'source:aqe',
+                payload.source_project ? `project:${payload.source_project}` : null,
+            ].filter((t) => t !== null),
+        };
+        try {
+            const response = await fetch(`${this.baseUrl}/api/patterns`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(PROMOTE_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                logger.debug('nagual promotePattern non-OK', { status: response.status });
+            }
+        }
+        catch (err) {
+            logger.debug('nagual promotePattern failed (non-fatal)', { err });
+        }
+    }
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        if (this.token)
+            h['Authorization'] = `Bearer ${this.token}`;
+        return h;
+    }
+}
+let _instance;
+export function getNagualClient() {
+    if (!_instance)
+        _instance = new NagualClient();
+    return _instance;
+}
+//# sourceMappingURL=nagual-client.js.map

package/dist/learning/pattern-store.js

@@ -6,6 +6,9 @@
  * O(log n) approximate nearest neighbor search.
  */
 import { v4 as uuidv4 } from 'uuid';
+// Issue #516: lightweight, sqlite-free project-root resolver (static import so it
+// resolves under the test runner; avoids pulling unified-memory's sqlite graph).
+import { findProjectRoot } from '../kernel/project-root.js';
 import { ok, err } from '../shared/types/index.js';
 import { RvfPatternStore } from './rvf-pattern-store.js';
 import { createRvfStore as _createRvfStore, isRvfNativeAvailable } from '../integrations/ruvector/rvf-native-adapter.js';
@@ -1364,10 +1367,14 @@ export function createPatternStore(memory, config) {
     try {
         const flags = getRuVectorFeatureFlags();
         if (flags.useRVFPatternStore && isRvfNativeAvailable()) {
-            // Only use RVF if the data directory exists (created by kernel init)
+            // Only use RVF if the data directory exists (created by kernel init).
+            // Issue #516: anchor to the project root so a subfolder cwd reads/writes
+            // the project's own .agentic-qe/ rather than a cwd-relative stray store.
             const { existsSync } = require('fs');
-            const rvfPath = '.agentic-qe/patterns.rvf';
-            const rvfDir = require('path').dirname(rvfPath);
+            const { join: joinPath } = require('path');
+            const projectRoot = process.env.AQE_PROJECT_ROOT ?? findProjectRoot();
+            const rvfDir = joinPath(projectRoot, '.agentic-qe');
+            const rvfPath = joinPath(rvfDir, 'patterns.rvf');
             if (existsSync(rvfDir)) {
                 const mergedConfig = { ...DEFAULT_PATTERN_STORE_CONFIG, ...config };
                 // FIX: Route through getSharedRvfAdapter() singleton to avoid

package/dist/learning/qe-reasoning-bank.js

@@ -132,10 +132,18 @@ export class QEReasoningBank {
             logger.warn('Failed to wire SQLitePatternStore into PatternStore', { error: toErrorMessage(e) });
         }
         signal?.throwIfAborted();
+        // Mark initialized BEFORE seeding patterns. Pattern seeding goes through
+        // storePattern(), which ensure-inits via `if (!this.initialized) await
+        // this.initialize()`. The core stores (patternStore + SQLite) are already up
+        // at this point, so the bank is functionally ready — setting the flag here
+        // stops storePattern() from recursively re-entering initialize(). With the
+        // flag set only AFTER seeding, that re-entry recursed without bound and hung
+        // every MCP domain tool on a fresh install the first time patterns were
+        // seeded (CPU spin via async self-recursion).
+        this.initialized = true;
         // Load any pre-trained patterns
         await this.loadPretrainedPatterns(signal);
         signal?.throwIfAborted();
-        this.initialized = true;
         // Run cross-domain transfer ONCE per DB lifetime (not every init)
         // IMPORTANT: Set the flag BEFORE the transfer so that even if the transfer
         // times out (hooks.ts has a 10s timeout on initialize()), the flag persists

package/dist/learning/qe-unified-memory.js

@@ -378,7 +378,7 @@ export class QEUnifiedMemory {
         let totalEntries = 0;
         let totalVectors = 0;
         let totalIndexSize = 0;
-        let hnswHealthy = true;
+        const hnswHealthy = true;
         for (const domain of QE_MEMORY_DOMAINS) {
             let vectorCount = 0;
             let indexSize = 0;
@@ -469,7 +469,7 @@ export class QEUnifiedMemory {
             };
         }
         let itemsMigrated = 0;
-        let itemsSkipped = 0;
+        const itemsSkipped = 0;
         const errors = [];
         try {
             switch (config.source) {
@@ -576,10 +576,12 @@ export class QEUnifiedMemory {
     extractRiskScore(domain, metadata) {
         switch (domain) {
             case 'defects':
-                const defectMeta = metadata;
-                // Map severity to risk score
-                const severityMap = { critical: 1, high: 0.75, medium: 0.5, low: 0.25 };
-                return severityMap[defectMeta.severity] * defectMeta.confidence;
+                {
+                    const defectMeta = metadata;
+                    // Map severity to risk score
+                    const severityMap = { critical: 1, high: 0.75, medium: 0.5, low: 0.25 };
+                    return severityMap[defectMeta.severity] * defectMeta.confidence;
+                }
             case 'quality':
                 return 1 - metadata.qualityScore;
             case 'learning':