0xray 4.0.22 → 4.0.24

package/dist/mcps/governance.server.js

@@ -196,8 +196,19 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             return false;
         }
     }
+    /** Boot stays flag-gated. A required external call starts the client on demand. */
+    async armRequiredDynamo(requireExternal) {
+        if (!requireExternal)
+            return;
+        const integration = await initializeGovernanceIntegration();
+        if (!integration.isAvailable()) {
+            await integration.ensureDynamoClient();
+        }
+    }
     async handleGovernProposals(args) {
         const service = getGovernanceService();
+        const requireExternal = this.resolveRequireExternal(args.options?.require_external);
+        await this.armRequiredDynamo(requireExternal);
         const request = {
             proposals: args.proposals.map((p, i) => ({
                 id: p.id || `prop-${Date.now()}-${i}`,
@@ -210,7 +221,7 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             })),
             context: args.context || {},
             options: {
-                requireExternalDynamo: this.resolveRequireExternal(args.options?.require_external),
+                requireExternalDynamo: requireExternal,
             },
         };
         frameworkLogger.log("governance-mcp", "delegating-to-governance-service", "info", {

package/dist/mcps/researcher-confidence.d.ts

@@ -1,10 +1,14 @@
-import type { MemoryRoutingContext, MemoryTaskConfidence } from '../memory-routing/types.js';
+import { type MemoryRoutingContext, type MemorySignalLessons, type MemoryTaskConfidence } from '../memory-routing/types.js';
 export interface ResearcherMemoryContext {
     providerId: string;
     confidence: MemoryTaskConfidence;
     matchedSignals: string[];
     recommendedAgent: string | null;
     triggeredBy: 'trap-language' | 'high-confidence-primitives';
+    /** Graded lines for signals this task already matched. */
+    lessons?: MemorySignalLessons[];
+    /** Proposal text used to recall at most one pipeline plate. */
+    proposalText?: string;
 }
 export declare function shouldQueryRepertoireConfidence(description: string, proposalType?: string): boolean;
 export declare function hasHighConfidencePrimitiveMatch(routingContext: MemoryRoutingContext, minConfidence?: number): boolean;

package/dist/mcps/researcher-confidence.js

@@ -1,5 +1,7 @@
 import { frameworkLogger } from '../core/framework-logger.js';
 import { getMemoryRoutingProvider } from '../memory-routing/index.js';
+import { recallPlate } from '../memory-routing/plates.js';
+import { LESSON_TEXT_CAP, } from '../memory-routing/types.js';
 const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
 const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
 export function shouldQueryRepertoireConfidence(description, proposalType = '') {
@@ -40,12 +42,15 @@ export async function resolveResearcherMemoryContext(input) {
     const matchedSignals = confidence.matchedSignals.length > 0
         ? confidence.matchedSignals
         : routingContext.matchedSignals;
+    const lessons = lessonsForMatchedSignals(routingContext.lessons, matchedSignals);
     const context = {
         providerId: provider.id,
         confidence,
         matchedSignals,
         recommendedAgent: confidence.recommendedAgent,
         triggeredBy: trapLanguageDetected ? 'trap-language' : 'high-confidence-primitives',
+        proposalText: taskText,
+        ...(lessons.length > 0 ? { lessons } : {}),
     };
     if (confidence.highConfidenceTrapPresent) {
         frameworkLogger.log('mcps/researcher', 'repertoire-trap-detected', 'info', {
@@ -73,6 +78,10 @@ export function buildMemoryRoutingEvidence(context) {
     if (recommendedAgent) {
         lines.push(`Recommended agent for trap handling: ${recommendedAgent}`);
     }
+    for (const line of lessonSpeechLines(context.lessons, matchedSignals)) {
+        lines.push(`Lesson: ${line}`);
+    }
+    appendRecalledPlate(lines, context.proposalText);
     return lines;
 }
 export function formatMemoryRoutingBlock(context) {
@@ -88,5 +97,33 @@ export function formatMemoryRoutingBlock(context) {
     if (recommendedAgent) {
         lines.push(`  recommendedAgent: ${recommendedAgent}`);
     }
+    for (const line of lessonSpeechLines(context.lessons, matchedSignals)) {
+        lines.push(`  lesson: ${line}`);
+    }
+    appendRecalledPlate(lines, context.proposalText);
     return lines.join('\n');
 }
+function appendRecalledPlate(lines, proposalText) {
+    const plate = recallPlate(proposalText);
+    if (!plate)
+        return;
+    lines.push(`Plate: ${plate.id}`);
+    lines.push(plate.body);
+}
+function lessonsForMatchedSignals(lessons, matchedSignals) {
+    const matched = new Set(matchedSignals);
+    return (lessons ?? []).filter((lesson) => matched.has(lesson.name));
+}
+/** Stored lesson text for signals this task matched. Empty text is omitted. */
+function lessonSpeechLines(lessons, matchedSignals) {
+    const speech = [];
+    for (const lesson of lessonsForMatchedSignals(lessons, matchedSignals)) {
+        for (const line of lesson.lines) {
+            const text = line.text.trim().slice(0, LESSON_TEXT_CAP);
+            if (text.length === 0)
+                continue;
+            speech.push(`${lesson.name}: ${text}`);
+        }
+    }
+    return speech;
+}

package/dist/mcps/researcher.server.js

@@ -388,7 +388,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
             proposalType,
         });
         const enrichedEvidence = [...(evidence || [])];
-        if (memoryContext?.confidence.highConfidenceTrapPresent) {
+        if (memoryContext) {
             enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
         }
         const vote = (await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", enrichedEvidence, proposalType || "")) ??
@@ -398,7 +398,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
                 highConfidenceTrapPresent: memoryContext?.confidence.highConfidenceTrapPresent,
                 recommendedAgent: memoryContext?.recommendedAgent,
             });
-        const memoryRoutingBlock = memoryContext?.confidence.highConfidenceTrapPresent
+        const memoryRoutingBlock = memoryContext
             ? `\n${formatMemoryRoutingBlock(memoryContext)}`
             : "";
         return {

package/dist/memory-routing/index.d.ts

@@ -1,5 +1,5 @@
 export type { MemoryRoutingProvider, MemoryRoutingContext, MemoryInheritedContext, MemoryAgentCapability, MemoryOrchestrationTask, MemoryThinDispatchResult, MemoryRoutingConfig, OrchestratorFeedbackEntry, } from './types.js';
-export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
+export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, ensureMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
 export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/index.js

@@ -1,4 +1,4 @@
-export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
+export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, ensureMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
 export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
 export { loadMemoryRoutingProvider, isLeftoverMemoryRoutingOff, isExplicitMemoryRoutingOptOut, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/lesson-pickup.d.ts

@@ -0,0 +1,2 @@
+/** Refresh the Station lessons section from dest. Leaves the rest of the card alone. */
+export declare function writeLessonPickup(projectRoot: string): void;

package/dist/memory-routing/lesson-pickup.js

@@ -0,0 +1,57 @@
+import * as fs from "fs";
+import * as path from "path";
+const START = "<!-- lessons -->";
+const END = "<!-- /lessons -->";
+const DEST = path.join(".xray", "state", "repertoire", "curated_signals.json");
+const FLOOR = 0.55;
+function aboveFloor(value) {
+    return typeof value === "number" && value > FLOOR && Math.abs(value - FLOOR) > 1e-4;
+}
+function lessonBlock(signals) {
+    const lines = ["## Lessons"];
+    const graded = signals.filter((signal) => typeof signal.name === "string"
+        && aboveFloor(signal.observation_stats?.avg_confidence)
+        && (signal.lessons?.length ?? 0) > 0);
+    if (graded.length === 0) {
+        lines.push("No graded lines above the floor.");
+        return lines.join("\n");
+    }
+    for (const signal of graded) {
+        lines.push(`### ${signal.name}`);
+        if (typeof signal.definition === "string" && signal.definition.length > 0) {
+            lines.push(signal.definition);
+        }
+        for (const lesson of signal.lessons ?? []) {
+            const text = lesson.text.length > 0 ? lesson.text : "graded";
+            lines.push(`- ${lesson.decision} \`${lesson.taskId}\` — ${text}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Refresh the Station lessons section from dest. Leaves the rest of the card alone. */
+export function writeLessonPickup(projectRoot) {
+    const stationPath = path.join(projectRoot, ".xray", "state", "STATION.md");
+    if (!fs.existsSync(stationPath))
+        return;
+    const destPath = path.join(projectRoot, DEST);
+    let signals = [];
+    if (fs.existsSync(destPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(destPath, "utf-8"));
+            if (parsed && typeof parsed === "object" && "signals" in parsed && Array.isArray(parsed.signals)) {
+                signals = parsed.signals;
+            }
+        }
+        catch {
+            signals = [];
+        }
+    }
+    const section = `${START}\n${lessonBlock(signals)}\n${END}`;
+    const current = fs.readFileSync(stationPath, "utf-8");
+    const pattern = /<!-- lessons -->[\s\S]*?<!-- \/lessons -->/;
+    const next = pattern.test(current)
+        ? current.replace(pattern, section)
+        : `${current.trimEnd()}\n\n${section}\n`;
+    if (next !== current)
+        fs.writeFileSync(stationPath, next);
+}

package/dist/memory-routing/plates.d.ts

@@ -0,0 +1,16 @@
+export declare const PLATE_IDS: readonly ["routing", "governance", "boot", "orchestration", "processor", "reporting", "memory-recall"];
+export type PlateId = (typeof PLATE_IDS)[number];
+export interface PlateStamp {
+    id: PlateId;
+    body: string;
+    sourcePath: string;
+}
+export interface PlateStampResult {
+    id: PlateId;
+    path: string;
+    written: boolean;
+}
+export declare function loadPlate(id: PlateId): PlateStamp;
+export declare function recallPlate(intent: string | null | undefined): PlateStamp | null;
+export declare function stampPlateIfMissing(projectRoot: string, id: PlateId): PlateStampResult;
+export declare function plateStockLine(intent: string | null | undefined): string | null;

package/dist/memory-routing/plates.js

@@ -0,0 +1,71 @@
+/**
+ * Typed plate API. The runtime reader is plates.cjs so Station and the
+ * Cursor preCompact hook share one implementation.
+ */
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PLATE_IDS = [
+    'routing',
+    'governance',
+    'boot',
+    'orchestration',
+    'processor',
+    'reporting',
+    'memory-recall',
+];
+function isPlateId(value) {
+    return PLATE_IDS.includes(value);
+}
+function isRuntime(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return (typeof row.loadPlate === 'function'
+        && typeof row.recallPlate === 'function'
+        && typeof row.stampPlateIfMissing === 'function'
+        && typeof row.plateStockLine === 'function'
+        && Array.isArray(row.PLATE_IDS));
+}
+function loadRuntime() {
+    const require = createRequire(import.meta.url);
+    const runtimePath = join(dirname(fileURLToPath(import.meta.url)), '../integrations/hooks/plates.cjs');
+    const loaded = require(runtimePath);
+    if (!isRuntime(loaded)) {
+        throw new Error('plate runtime missing');
+    }
+    return loaded;
+}
+const runtime = loadRuntime();
+function asStamp(value) {
+    if (!value)
+        return null;
+    if (!isPlateId(value.id) || typeof value.body !== 'string') {
+        throw new Error('plate runtime returned an unknown stamp');
+    }
+    return value;
+}
+export function loadPlate(id) {
+    const stamp = asStamp(runtime.loadPlate(id));
+    if (!stamp)
+        throw new Error(`plate missing: ${id}`);
+    return stamp;
+}
+export function recallPlate(intent) {
+    return asStamp(runtime.recallPlate(intent));
+}
+export function stampPlateIfMissing(projectRoot, id) {
+    const result = runtime.stampPlateIfMissing(projectRoot, id);
+    if (!isPlateId(result.id) || typeof result.path !== 'string' || typeof result.written !== 'boolean') {
+        throw new Error('plate runtime returned an unknown stamp result');
+    }
+    return result;
+}
+export function plateStockLine(intent) {
+    const line = runtime.plateStockLine(intent);
+    if (line === null || line === undefined)
+        return null;
+    if (typeof line !== 'string')
+        throw new Error('plate stock line was not text');
+    return line;
+}

package/dist/memory-routing/provider-loader.d.ts

@@ -5,4 +5,9 @@ export declare function isExplicitMemoryRoutingOptOut(config: MemoryRoutingConfi
  *  Explicit opt-out is enabled: false + provider: repertoire. */
 export declare function isLeftoverMemoryRoutingOff(config: MemoryRoutingConfig): boolean;
 export declare function resolveLeftoverEnabledConfig(config: MemoryRoutingConfig, cwd: string): MemoryRoutingConfig | null;
+/**
+ * First route cannot wait on the async import. Node loads this ESM with require.
+ * Returns null when routing is off or the module cannot be constructed.
+ */
+export declare function loadMemoryRoutingProviderSync(config: MemoryRoutingConfig, cwd?: string): MemoryRoutingProvider | null;
 export declare function loadMemoryRoutingProvider(config: MemoryRoutingConfig, cwd?: string): Promise<MemoryRoutingProvider>;

package/dist/memory-routing/provider-loader.js

@@ -1,4 +1,5 @@
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { resolve, dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { frameworkLogger } from '../core/framework-logger.js';
@@ -19,6 +20,7 @@ function resolveUnavailableReason(provider) {
         return null;
     }
 }
+const require = createRequire(import.meta.url);
 const REPERTOIRE_CANDIDATE_PATHS = [
     'node_modules/@0xray/repertoire/dist/provider/memory-routing-provider.js',
     'vendor/@0xray/repertoire/dist/provider/memory-routing-provider.js',
@@ -99,6 +101,50 @@ export function resolveLeftoverEnabledConfig(config, cwd) {
         enabled.config = config.config;
     return enabled;
 }
+function providerFromModule(mod, modulePath, effective) {
+    const factory = mod.createMemoryRoutingProvider ?? mod.default?.createMemoryRoutingProvider;
+    if (typeof factory !== 'function') {
+        throw new Error(`Module ${modulePath} must export createMemoryRoutingProvider()`);
+    }
+    const provider = factory((effective.config ?? {}));
+    if (!provider?.id || typeof provider.isAvailable !== 'function') {
+        throw new Error(`Invalid memory routing provider from ${modulePath}`);
+    }
+    return provider;
+}
+function resolveEffectiveProvider(config, cwd) {
+    const validation = validateMemoryRoutingConfig(config);
+    if (!validation.valid)
+        return null;
+    const leftover = resolveLeftoverEnabledConfig(validation.normalized, cwd);
+    const effective = leftover ?? validation.normalized;
+    if (!effective.enabled || effective.provider === 'null')
+        return null;
+    const modulePath = resolveModulePath(effective.module_path, cwd) ??
+        defaultPathForProvider(effective.provider, cwd);
+    if (!modulePath)
+        return null;
+    return { effective, modulePath };
+}
+/**
+ * First route cannot wait on the async import. Node loads this ESM with require.
+ * Returns null when routing is off or the module cannot be constructed.
+ */
+export function loadMemoryRoutingProviderSync(config, cwd = process.cwd()) {
+    const resolved = resolveEffectiveProvider(config, cwd);
+    if (!resolved)
+        return null;
+    try {
+        const mod = require(resolved.modulePath);
+        const provider = providerFromModule(mod, resolved.modulePath, resolved.effective);
+        if (!provider.isAvailable())
+            return null;
+        return provider;
+    }
+    catch {
+        return null;
+    }
+}
 export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
     const validation = validateMemoryRoutingConfig(config);
     if (!validation.valid) {

package/dist/memory-routing/provider-registry.d.ts

@@ -1,8 +1,13 @@
 import type { MemoryRoutingConfig, MemoryRoutingProvider } from './types.js';
 export declare function getMemoryRoutingConfig(): MemoryRoutingConfig;
 export declare function getMemoryRoutingProvider(forceReload?: boolean): Promise<MemoryRoutingProvider>;
-/** Synchronous accessor — returns shared null singleton until async load completes. */
+/** Synchronous accessor — returns shared null singleton until a load completes. */
 export declare function getMemoryRoutingProviderSync(): MemoryRoutingProvider;
+/**
+ * The first scoreAndRoute call loads the organ before it routes.
+ * A later sync read sees the same provider. Off or a missing module stays null.
+ */
+export declare function ensureMemoryRoutingProviderSync(): MemoryRoutingProvider;
 export declare function resetMemoryRoutingProvider(): void;
-/** Kick off background load at module init. */
+/** Kick off load at module init. Sync require first so a later route does not require() an ESM module while its dynamic import is still in flight. */
 export declare function initializeMemoryRouting(): void;

package/dist/memory-routing/provider-registry.js

@@ -1,6 +1,6 @@
 import { featuresConfigLoader } from '../core/features-config.js';
 import { NullMemoryRoutingProvider } from './null-provider.js';
-import { loadMemoryRoutingProvider, resolveLeftoverEnabledConfig } from './provider-loader.js';
+import { loadMemoryRoutingProvider, loadMemoryRoutingProviderSync, resolveLeftoverEnabledConfig, } from './provider-loader.js';
 import { validateMemoryRoutingConfig } from './validate-config.js';
 let cachedProvider = null;
 let loadPromise = null;
@@ -12,30 +12,50 @@ export function getMemoryRoutingConfig() {
         validation.normalized);
 }
 export async function getMemoryRoutingProvider(forceReload = false) {
-    if (!forceReload && cachedProvider)
+    if (!forceReload && cachedProvider && cachedProvider.id !== 'null')
         return cachedProvider;
     if (!forceReload && loadPromise)
         return loadPromise;
     const config = getMemoryRoutingConfig();
     loadPromise = loadMemoryRoutingProvider(config).then((provider) => {
+        if (provider.id === 'null' && cachedProvider && cachedProvider.id !== 'null') {
+            loadPromise = null;
+            return cachedProvider;
+        }
         cachedProvider = provider;
         loadPromise = null;
         return provider;
     });
     return loadPromise;
 }
-/** Synchronous accessor — returns shared null singleton until async load completes. */
+/** Synchronous accessor — returns shared null singleton until a load completes. */
 export function getMemoryRoutingProviderSync() {
     return cachedProvider ?? nullProviderSingleton;
 }
+/**
+ * The first scoreAndRoute call loads the organ before it routes.
+ * A later sync read sees the same provider. Off or a missing module stays null.
+ */
+export function ensureMemoryRoutingProviderSync() {
+    if (cachedProvider && cachedProvider.id !== 'null')
+        return cachedProvider;
+    const config = getMemoryRoutingConfig();
+    if (!config.enabled)
+        return cachedProvider ?? nullProviderSingleton;
+    const loaded = loadMemoryRoutingProviderSync(config);
+    if (!loaded || loaded.id === 'null')
+        return cachedProvider ?? nullProviderSingleton;
+    cachedProvider = loaded;
+    return loaded;
+}
 export function resetMemoryRoutingProvider() {
     cachedProvider = null;
     loadPromise = null;
 }
-/** Kick off background load at module init. */
+/** Kick off load at module init. Sync require first so a later route does not require() an ESM module while its dynamic import is still in flight. */
 export function initializeMemoryRouting() {
-    const config = getMemoryRoutingConfig();
-    if (config.enabled) {
+    const loaded = ensureMemoryRoutingProviderSync();
+    if (loaded.id === 'null' && getMemoryRoutingConfig().enabled) {
         void getMemoryRoutingProvider();
     }
 }

package/dist/memory-routing/record-lesson.d.ts

@@ -0,0 +1,16 @@
+export interface LessonInput {
+    operation: string;
+    success: boolean;
+    taskId: string;
+    assignedAgent: string;
+    sessionId: string;
+    /** Signals the finished task already named. When set, text matching is not used. */
+    signals?: string[];
+    /** Approaches, solutions, or the wrong turn from the sessions that named the law. */
+    lesson?: string;
+}
+/**
+ * A finished task names the signals its text actually matched and says
+ * whether the outcome was good. That is the one-tenth step. No match, no write.
+ */
+export declare function recordLesson(input: LessonInput): string[];

package/dist/memory-routing/record-lesson.js

@@ -0,0 +1,26 @@
+import { ensureMemoryRoutingProviderSync } from "./provider-registry.js";
+/**
+ * A finished task names the signals its text actually matched and says
+ * whether the outcome was good. That is the one-tenth step. No match, no write.
+ */
+export function recordLesson(input) {
+    const provider = ensureMemoryRoutingProviderSync();
+    if (provider.id === "null" || !provider.ingestFeedback)
+        return [];
+    const named = input.signals ?? provider.buildRoutingContext(input.operation).matchedSignals;
+    const names = [...new Set(named.filter((name) => name.length > 0))];
+    if (names.length === 0)
+        return [];
+    provider.ingestFeedback({
+        timestamp: new Date().toISOString(),
+        sessionId: input.sessionId,
+        taskId: input.taskId,
+        assignedAgent: input.assignedAgent,
+        memorySignals: names,
+        complexity: 0,
+        success: input.success,
+        durationMs: 0,
+        lesson: input.lesson ?? "",
+    });
+    return names;
+}

package/dist/memory-routing/types.d.ts

@@ -33,6 +33,19 @@ export interface MemoryTaskConfidence {
     complexityBoost: number;
     recommendedAgent: string | null;
 }
+/** Characters kept on one graded lesson line. lessonTrace stores with this cap. */
+export declare const LESSON_TEXT_CAP = 400;
+export interface MemoryLessonLine {
+    taskId: string;
+    decision: 'success' | 'failure';
+    text: string;
+    at: string;
+}
+export interface MemorySignalLessons {
+    name: string;
+    definition: string;
+    lines: MemoryLessonLine[];
+}
 export interface MemoryRoutingContext {
     providerId: string;
     matchedSignals: string[];
@@ -41,6 +54,8 @@ export interface MemoryRoutingContext {
     synthesisAvailable: boolean;
     signalConfidences?: Record<string, number>;
     avgMatchConfidence?: number;
+    /** Laws above the floor, with the graded lines a wake reads. */
+    lessons?: MemorySignalLessons[];
 }
 export interface MemoryInheritedContext {
     providerId: string;
@@ -67,6 +82,8 @@ export interface OrchestratorFeedbackEntry {
     success: boolean;
     durationMs: number;
     dynamoResult?: Record<string, unknown>;
+    /** Approaches, solutions, or the wrong turn from the sessions that named the law. */
+    lesson?: string;
 }
 export interface MemoryRoutingProviderConfig {
     [key: string]: unknown;

package/dist/memory-routing/types.js

@@ -4,4 +4,5 @@
  * Repertoire is one implementation. Any provider exposing createMemoryRoutingProvider()
  * can be loaded via features.json memory_routing.module_path.
  */
-export {};
+/** Characters kept on one graded lesson line. lessonTrace stores with this cap. */
+export const LESSON_TEXT_CAP = 400;

package/dist/nucleus/thin-dispatch.d.ts

@@ -7,6 +7,7 @@
  * Import from here or from delegation/index.ts (which re-exports these).
  */
 import { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds } from "../delegation/complexity-core.js";
+import type { MemorySignalLessons } from "../memory-routing/types.js";
 export type { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds };
 export declare const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
 /**
@@ -29,5 +30,6 @@ export declare function scoreAndRoute(operation: string, context: unknown, thres
         providerId: string;
         adjustedScore: number;
         signals: string[];
+        lessons?: MemorySignalLessons[];
     };
 };

package/dist/nucleus/thin-dispatch.js

@@ -9,7 +9,7 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getLevelFromScore, getAgentForTier, getAgentCountForLevel, getStrategyForLevel, levelToTier, } from "../delegation/complexity-core.js";
 import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
-import { getMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
+import { ensureMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
 initializeMemoryRouting();
 export const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
 /**
@@ -58,7 +58,7 @@ export function routeToAgent(scoreOrLevel, level) {
 export function scoreAndRoute(operation, context, thresholds) {
     const score = scoreComplexity(operation, context, thresholds);
     let agent = routeToAgent(score);
-    const provider = getMemoryRoutingProviderSync();
+    const provider = ensureMemoryRoutingProviderSync();
     let memoryRouting;
     if (provider.id !== "null") {
         const resolved = provider.resolveThinDispatch(agent, operation, score.score);
@@ -67,6 +67,7 @@ export function scoreAndRoute(operation, context, thresholds) {
             providerId: resolved.context.providerId,
             adjustedScore: resolved.adjustedScore,
             signals: resolved.context.matchedSignals,
+            ...(resolved.context.lessons ? { lessons: resolved.context.lessons } : {}),
         };
         const adjustedLevel = getLevelFromScore(resolved.adjustedScore, thresholds);
         frameworkLogger.log("nucleus-thin-dispatch", "memory-routing", "info", {

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -33,4 +33,9 @@ export declare class InferenceImprovementProcessor extends PostProcessor {
     private generateCodeReviewerPrompt;
     private generateEnforcerPrompt;
     private triggerAgentWorkflow;
+    /**
+     * The operation is finished once its prompt result text is on disk.
+     * One session per operation id. Empty speech writes nothing.
+     */
+    private captureFinishedOperationSpeech;
 }