@vascend/talos 0.1.0

package/dist/vascend/token-market.js

@@ -0,0 +1,144 @@
+// Token Market (metodo Danilov, Memory OS) -- L3: Optimization Layer.
+//
+// Il salto sopra le quote fisse del BudgetAllocator: la context window non e' un
+// insieme di cassetti a percentuale fissa, ma un MERCATO. Ogni capsula fa
+// un'offerta per lo spazio; i token vanno a chi produce piu' valore per token.
+//
+//   bid_i = (relevance + dependency + riskReduction + novelty + trust)_i
+//           / tokenCost_i
+//
+// Ogni zona ha un prezzo dinamico:
+//
+//   price_zone = congestion_zone + stalePenalty_zone - missionNeed_zone
+//
+// Una prova decisionale puo' "pagare" per entrare anche se l'evidence budget e'
+// quasi pieno, mentre una nota ripetuta viene respinta. L'esito assegna a ogni
+// capsula un LIVELLO di espansione (R0-R4) o il DROP, rispettando il budget.
+//
+// Modulo PURO e DETERMINISTICO: nessun side-effect, nessuna rete. L'asta e'
+// greedy ordinata per bid (tie-break stabile su id), quindi riproducibile.
+import { bestExpansion, tokensAtLevel, utilityAtLevel, } from "./expansion-levels.js";
+import { isStale, withExpansion, confidenceWeightOf, } from "./context-capsule.js";
+// Valore marginale di una capsula: somma dei segnali positivi. riskReduction =
+// quanto la capsula RIDUCE il rischio (decisione attiva/dipendenza forte) meno
+// il rischio che AGGIUNGE (stale). Deterministico.
+function marginalValue(c, relevance, novelty) {
+    const trust = confidenceWeightOf(c.header.confidence);
+    const dependency = c.metrics.utility >= 0.7 ? 1 : c.metrics.utility >= 0.5 ? 0.5 : 0;
+    // riskReduction: una decisione attiva o un prerequisito riduce il rischio di
+    // risposta errata; una capsula stale lo AUMENTA (riskReduction negativo).
+    let riskReduction = 0;
+    if (c.header.type === "decision" && c.header.status === "active")
+        riskReduction += 0.6;
+    if (c.metrics.utility >= 0.7)
+        riskReduction += 0.3;
+    if (isStale(c))
+        riskReduction -= 0.8;
+    riskReduction = clampSigned(riskReduction);
+    const rel = clamp01(relevance);
+    const nov = clamp01(novelty);
+    const total = rel + dependency + Math.max(0, riskReduction) + nov + trust;
+    return { relevance: rel, dependency, riskReduction, novelty: nov, trust, total };
+}
+// Calcola il bid di una capsula al suo livello DESIDERATO (bestExpansion).
+export function computeBid(c, ctx) {
+    const relevance = ctx.relevance?.get(c.header.id) ?? 0;
+    const novelty = ctx.novelty?.get(c.header.id) ?? 1;
+    const mv = marginalValue(c, relevance, novelty);
+    const desiredLevel = bestExpansion(c, { tokenBudget: ctx.tokenBudget, ...ctx.expansion });
+    const tokenCost = Math.max(1, tokensAtLevel(c, desiredLevel));
+    const bid = mv.total / tokenCost;
+    return {
+        id: c.header.id,
+        relevance: mv.relevance,
+        dependency: mv.dependency,
+        riskReduction: mv.riskReduction,
+        novelty: mv.novelty,
+        trust: mv.trust,
+        tokenCost,
+        bid,
+        desiredLevel,
+    };
+}
+// Esegue l'asta: ordina le capsule per bid decrescente e le ammette finche' il
+// budget regge, al loro livello desiderato. Se una capsula non entra al livello
+// desiderato, prova a DEGRADARLA (livello piu' basso, piu' economico) prima di
+// scartarla: e' il rate-distortion che paga il prezzo dello spazio scarso.
+// Deterministico: tie-break su id.
+export function runTokenMarket(capsules, ctx) {
+    const bids = capsules.map((c) => ({ capsule: c, bid: computeBid(c, ctx) }));
+    bids.sort((a, b) => b.bid.bid - a.bid.bid || a.bid.id.localeCompare(b.bid.id));
+    const admitted = [];
+    const dropped = [];
+    let used = 0;
+    const budget = Math.max(0, ctx.tokenBudget);
+    for (const { capsule, bid } of bids) {
+        let placed = false;
+        // Prova dal livello desiderato verso il basso (degrado): R desiderato..R0.
+        for (let lvl = bid.desiredLevel; lvl >= 0; lvl--) {
+            const level = lvl;
+            const tokens = tokensAtLevel(capsule, level);
+            if (used + tokens <= budget) {
+                admitted.push({
+                    capsule: withExpansion(capsule, level),
+                    bid,
+                    level,
+                    tokensUsed: tokens,
+                });
+                used += tokens;
+                placed = true;
+                break;
+            }
+        }
+        if (!placed) {
+            dropped.push({ capsule, bid, level: "drop", tokensUsed: 0 });
+        }
+    }
+    return { admitted, dropped, tokensUsed: used, tokenBudget: budget };
+}
+// price_zone = congestion + stalePenalty - missionNeed, clampato >= 0.
+// Una zona poco richiesta dalla mission e congestionata costa di piu' (frena gli
+// ingressi); una zona che serve alla mission costa meno (lascia entrare prove).
+export function zonePrice(input) {
+    const p = clamp01(input.congestion) + clamp01(input.stalePenalty) - clamp01(input.missionNeed);
+    return Math.max(0, round(p));
+}
+// Diagnostica dell'asta come blocco Danilov.
+export function formatMarketResult(r, opts) {
+    const top = opts?.top ?? r.admitted.length;
+    const lines = [
+        "[TOKEN_MARKET]",
+        `@asta: budget=${r.tokenBudget}tok, usati=${r.tokensUsed}tok, ammesse=${r.admitted.length}, drop=${r.dropped.length}`,
+        "--- ammesse (bid desc) ---",
+    ];
+    r.admitted.slice(0, top).forEach((a) => {
+        lines.push(`@adm[${a.bid.id}]: R${a.level} bid=${round(a.bid.bid)} (${a.tokensUsed}tok)`);
+    });
+    if (r.dropped.length) {
+        lines.push("--- drop ---");
+        r.dropped.forEach((d) => lines.push(`@drop[${d.bid.id}]: bid=${round(d.bid.bid)} (no budget)`));
+    }
+    lines.push("OUTPUT: i token vanno alle capsule con piu' valore per token.");
+    return lines.join("\n");
+}
+function clamp01(v) {
+    if (Number.isNaN(v))
+        return 0;
+    if (v < 0)
+        return 0;
+    if (v > 1)
+        return 1;
+    return v;
+}
+function clampSigned(v) {
+    if (Number.isNaN(v))
+        return 0;
+    if (v < -1)
+        return -1;
+    if (v > 1)
+        return 1;
+    return v;
+}
+function round(v) {
+    return Math.round(v * 1000) / 1000;
+}

package/dist/vascend/tuner-baseline-store.d.ts

@@ -0,0 +1,52 @@
+import { type TuneConfig } from "./context-autotuner.js";
+export declare const TUNER_BASELINE_SCHEMA_VERSION: 1;
+export declare const DEFAULT_BASELINE_SCOPE = "global";
+export interface TunerBaseline {
+    readonly version: 1;
+    readonly scope: string;
+    readonly config: TuneConfig;
+    readonly bestScore: number;
+    readonly lastScore: number;
+    readonly observations: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface BaselineObservation {
+    readonly config: TuneConfig;
+    readonly score: number;
+    readonly initialScore?: number;
+}
+export declare function learningRate(observations: number, gain: number): number;
+export declare function blendConfig(base: TuneConfig, obs: TuneConfig, alpha: number): TuneConfig;
+export declare function mergeObservation(baseline: TunerBaseline, obs: BaselineObservation, opts?: {
+    readonly now?: string;
+}): TunerBaseline;
+export declare const MIN_PRIOR_OBSERVATIONS = 3;
+export declare const MIN_PRIOR_SCORE = 1;
+export declare function blendPrior(baselines: readonly TunerBaseline[]): TuneConfig | null;
+export declare function initialBaseline(scope: string, opts?: {
+    readonly now?: string;
+}): TunerBaseline;
+export declare function parseBaseline(raw: unknown, scopeFallback: string, opts?: {
+    readonly now?: string;
+}): TunerBaseline;
+export declare function baselineToJSON(b: TunerBaseline): Record<string, unknown>;
+export declare function formatBaseline(b: TunerBaseline): string;
+export declare class TunerBaselineStore {
+    private readonly file;
+    private readonly dir;
+    private baselines;
+    private priorCache;
+    private constructor();
+    static open(dir: string, storeId: string): TunerBaselineStore;
+    get(scope?: string): TunerBaseline;
+    private freshBaseline;
+    private prior;
+    has(scope?: string): boolean;
+    all(): readonly TunerBaseline[];
+    startConfig(scope?: string): TuneConfig;
+    observe(scope: string, obs: BaselineObservation, opts?: {
+        readonly now?: string;
+    }): TunerBaseline;
+    private persistUnlocked;
+}

package/dist/vascend/tuner-baseline-store.js

@@ -0,0 +1,446 @@
+// Tuner Baseline Store (metodo Danilov, Memory OS) -- L4: l'apprendimento.
+//
+// L'anello di retroazione (context-feedback-loop) trova una bestConfig ottima
+// PER QUEL TURNO, ma poi la getta: il turno dopo riparte da DEFAULT_CONFIG e
+// ri-paga la convergenza da zero. Questo modulo chiude l'ultimo anello:
+// PERSISTE la configurazione appresa come BASELINE, cosi' i turni e le SESSIONI
+// successive ripartono dall'architettura gia' migliorata invece che dai default.
+//
+//   turno 1: DEFAULT -> loop -> bestConfig  -->  baseline.observe(best)
+//   turno 2: baseline.config (gia' buona) -> loop -> bestConfig' -> baseline.observe
+//   ...      la baseline converge verso la configurazione che funziona davvero
+//
+// E' apprendimento CUMULATIVO e DETERMINISTICO dell'architettura del context:
+// non genera testo, non chiama il modello, non tocca la rete. Aggiorna pesi e
+// soglie via media mobile esponenziale (EMA), pesata sulla qualita' osservata.
+//
+//   - EMA: nuova_baseline = (1-alpha)*baseline + alpha*osservata.
+//     alpha cresce con il guadagno di qualita' (un'osservazione molto migliore
+//     pesa di piu') e cala col numero di osservazioni gia' viste (stabilita').
+//   - MONOTONIA MORBIDA: una config che PEGGIORA non sposta la baseline; una
+//     che migliora la attira verso di se' in proporzione al miglioramento.
+//   - CLAMP: ogni leva resta nei range sani dell'autotuner (no divergenza).
+//   - SCOPE: una baseline per "scope" (di default il progetto), cosi' progetti
+//     diversi imparano architetture diverse senza interferire.
+//
+// Persistenza: file JSON `<storeId>.tuner.json` -> mappa { [scope]: Baseline }.
+// Stesso stile di VascendVisionStore: API immutabile, persistenza su mutazione,
+// parsing robusto (file corrotto -> si riparte dai default).
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { DEFAULT_WEIGHTS, DEFAULT_THRESHOLDS } from "./context-scorer.js";
+import { DEFAULT_CONFIG } from "./context-autotuner.js";
+import { withLockSync } from "./file-lock.js";
+// ---------------------------------------------------------------------------
+// 1. MODELLO
+// ---------------------------------------------------------------------------
+export const TUNER_BASELINE_SCHEMA_VERSION = 1;
+// Lo scope di default quando il chiamante non ne passa uno.
+export const DEFAULT_BASELINE_SCOPE = "global";
+// ---------------------------------------------------------------------------
+// 2. RANGE SANI (riallineati all'autotuner: l'apprendimento non puo' divergere)
+// ---------------------------------------------------------------------------
+const WEIGHT_BOUNDS = {
+    relevance: [0.5, 2.0],
+    dependency: [0.3, 1.5],
+    trust: [0.2, 1.2],
+    freshness: [0.1, 1.0],
+    novelty: [0.1, 1.0],
+    conflictRisk: [0.5, 2.5],
+    tokenCost: [0.05, 0.8],
+};
+const HIGH_BOUNDS = [0.6, 1.8];
+const MID_BOUNDS = [0.2, 0.9];
+// Estremi del passo di apprendimento. alpha grande = impara in fretta ma
+// instabile; piccolo = stabile ma lento. Restiamo in una banda prudente.
+const ALPHA_MIN = 0.1;
+const ALPHA_MAX = 0.5;
+function clamp(v, lo, hi) {
+    if (!Number.isFinite(v))
+        return lo;
+    return Math.max(lo, Math.min(hi, v));
+}
+function round3(v) {
+    return Math.round(v * 1000) / 1000;
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+// ---------------------------------------------------------------------------
+// 3. BLEND EMA (cuore dell'apprendimento)
+// ---------------------------------------------------------------------------
+// Calcola il tasso di apprendimento alpha per un'osservazione. Cresce col
+// guadagno di qualita' (un salto grande tira di piu' la baseline) e cala col
+// numero di osservazioni gia' viste (piu' esperienza = piu' stabilita').
+//   gainFactor in [0,1]: quanto e' migliore l'osservazione rispetto al passato.
+//   ageFactor  in (0,1]: smorzamento per esperienza accumulata.
+export function learningRate(observations, gain) {
+    // gain atteso 0..100 (delta di qualityScore). Normalizziamo su una scala di
+    // 20 punti: un guadagno >= 20 conta come "molto migliore" (gainFactor=1).
+    const gainFactor = clamp(gain / 20, 0, 1);
+    // Piu' osservazioni -> meno reattivita': 1/(1+obs) smorza nel tempo.
+    const ageFactor = 1 / (1 + Math.max(0, observations));
+    const alpha = ALPHA_MIN + (ALPHA_MAX - ALPHA_MIN) * gainFactor * Math.max(ageFactor, 0.2);
+    return clamp(alpha, ALPHA_MIN, ALPHA_MAX);
+}
+// Media mobile esponenziale di un singolo valore, clampata nel suo range.
+function emaValue(base, obs, alpha, lo, hi) {
+    return clamp(round3(base * (1 - alpha) + obs * alpha), lo, hi);
+}
+// Fonde due config con tasso alpha: ogni leva via EMA, clampata nei range sani.
+// Mantiene l'invariante di tier (mid sempre sotto high).
+export function blendConfig(base, obs, alpha) {
+    const w = (k) => emaValue(base.weights[k], obs.weights[k], alpha, WEIGHT_BOUNDS[k][0], WEIGHT_BOUNDS[k][1]);
+    const weights = {
+        relevance: w("relevance"),
+        dependency: w("dependency"),
+        trust: w("trust"),
+        freshness: w("freshness"),
+        novelty: w("novelty"),
+        conflictRisk: w("conflictRisk"),
+        tokenCost: w("tokenCost"),
+    };
+    const high = emaValue(base.thresholds.high, obs.thresholds.high, alpha, HIGH_BOUNDS[0], HIGH_BOUNDS[1]);
+    const midRaw = emaValue(base.thresholds.mid, obs.thresholds.mid, alpha, MID_BOUNDS[0], MID_BOUNDS[1]);
+    const mid = Math.min(midRaw, round3(high - 0.1));
+    return { weights, thresholds: { high, mid } };
+}
+// Incorpora un'osservazione in una baseline e ritorna la NUOVA baseline
+// (immutabile). Regola fondamentale:
+//   - se l'osservazione PEGGIORA (score < lastScore) la baseline NON si sposta:
+//     solo lastScore viene aggiornato (memoria dell'andamento) -- monotonia.
+//   - se l'osservazione MIGLIORA o pareggia, la config si fonde via EMA verso
+//     l'osservata, con alpha pesato sul guadagno.
+// PURA e deterministica.
+export function mergeObservation(baseline, obs, opts) {
+    const ts = opts?.now ?? nowIso();
+    const improving = obs.score >= baseline.lastScore;
+    if (!improving) {
+        // Peggioramento: non spostiamo la config appresa, ma registriamo l'esito.
+        return {
+            ...baseline,
+            lastScore: obs.score,
+            bestScore: Math.max(baseline.bestScore, obs.score),
+            observations: baseline.observations + 1,
+            updatedAt: ts,
+        };
+    }
+    const gain = obs.score - (obs.initialScore ?? baseline.lastScore);
+    const alpha = learningRate(baseline.observations, Math.max(0, gain));
+    const config = blendConfig(baseline.config, obs.config, alpha);
+    return {
+        version: TUNER_BASELINE_SCHEMA_VERSION,
+        scope: baseline.scope,
+        config,
+        bestScore: Math.max(baseline.bestScore, obs.score),
+        lastScore: obs.score,
+        observations: baseline.observations + 1,
+        createdAt: baseline.createdAt,
+        updatedAt: ts,
+    };
+}
+// ---------------------------------------------------------------------------
+// 3-bis. PRIOR FRA SCOPE (l'esperienza si trasferisce)
+// ---------------------------------------------------------------------------
+//
+// L'EMA fa imparare uno scope dai propri turni. Ma uno scope NUOVO nasceva
+// sempre da DEFAULT_CONFIG, e siccome un progetto tipico dura una manciata di
+// turni non arrivava mai a imparare niente: i .tuner.json reali mostrano le
+// sessioni lunghe a 100 e i progetti nuovi fermi a 46 con una osservazione.
+//
+// Il prior chiude questo buco: cio' che l'architettura del contesto ha imparato
+// ALTROVE e' il punto di partenza piu' sensato di un default scritto a mano.
+// Non e' una config nuova, e' una media pesata di configurazioni gia' validate.
+//
+// Chi entra nella media: solo baseline con abbastanza esperienza E una qualita'
+// misurata. Una baseline con una sola osservazione non e' esperienza, e una con
+// bestScore 0 non ha mai dimostrato niente — pesarle sarebbe propagare rumore.
+// Sotto queste soglie una baseline non ha ancora imparato abbastanza da poter
+// insegnare a un'altra.
+export const MIN_PRIOR_OBSERVATIONS = 3;
+export const MIN_PRIOR_SCORE = 1;
+// Quante baseline sorelle al massimo si leggono dal disco per costruire il
+// prior: un tetto tiene il costo costante anche in una cartella cresciuta.
+const MAX_PRIOR_FILES = 64;
+// Peso di una baseline nella media: l'esperienza (osservazioni) moltiplicata
+// per la qualita' raggiunta. Chi ha girato di piu' ED e' arrivato piu' in alto
+// insegna di piu'.
+function priorWeight(b) {
+    return b.observations * (b.bestScore / 100);
+}
+// Media pesata delle baseline mature. Ritorna null quando non c'e' esperienza
+// da cui attingere: in quel caso il chiamante resta ai default, che e' il
+// comportamento di prima (non-regressione).
+export function blendPrior(baselines) {
+    const mature = baselines
+        .filter((b) => b.observations >= MIN_PRIOR_OBSERVATIONS && b.bestScore >= MIN_PRIOR_SCORE)
+        // Ordine stabile: la media di float non deve dipendere da come il
+        // filesystem ha elencato i file.
+        .slice()
+        .sort((a, b) => (a.scope < b.scope ? -1 : a.scope > b.scope ? 1 : 0));
+    if (!mature.length)
+        return null;
+    const total = mature.reduce((sum, b) => sum + priorWeight(b), 0);
+    if (!(total > 0))
+        return null;
+    const mean = (pick) => mature.reduce((sum, b) => sum + pick(b) * priorWeight(b), 0) / total;
+    const w = (k) => clamp(round3(mean((b) => b.config.weights[k])), WEIGHT_BOUNDS[k][0], WEIGHT_BOUNDS[k][1]);
+    const high = clamp(round3(mean((b) => b.config.thresholds.high)), HIGH_BOUNDS[0], HIGH_BOUNDS[1]);
+    const midRaw = clamp(round3(mean((b) => b.config.thresholds.mid)), MID_BOUNDS[0], MID_BOUNDS[1]);
+    return {
+        weights: {
+            relevance: w("relevance"),
+            dependency: w("dependency"),
+            trust: w("trust"),
+            freshness: w("freshness"),
+            novelty: w("novelty"),
+            conflictRisk: w("conflictRisk"),
+            tokenCost: w("tokenCost"),
+        },
+        // Stessa invariante del blend: il tier mid non puo' raggiungere l'high.
+        thresholds: { high, mid: Math.min(midRaw, round3(high - 0.1)) },
+    };
+}
+// Baseline iniziale (default) per uno scope: parte dalla config di default.
+export function initialBaseline(scope, opts) {
+    const ts = opts?.now ?? nowIso();
+    return {
+        version: TUNER_BASELINE_SCHEMA_VERSION,
+        scope: scope.trim() || DEFAULT_BASELINE_SCOPE,
+        config: DEFAULT_CONFIG,
+        bestScore: 0,
+        lastScore: 0,
+        observations: 0,
+        createdAt: ts,
+        updatedAt: ts,
+    };
+}
+// ---------------------------------------------------------------------------
+// 4. PARSING ROBUSTO + SERIALIZZAZIONE
+// ---------------------------------------------------------------------------
+function num(v, fallback) {
+    const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+    return Number.isFinite(n) ? n : fallback;
+}
+// Normalizza pesi grezzi nei range sani, riempiendo i mancanti dai default.
+function parseWeights(raw) {
+    const o = (raw ?? {});
+    const w = (k) => clamp(round3(num(o[k], DEFAULT_WEIGHTS[k])), WEIGHT_BOUNDS[k][0], WEIGHT_BOUNDS[k][1]);
+    return {
+        relevance: w("relevance"),
+        dependency: w("dependency"),
+        trust: w("trust"),
+        freshness: w("freshness"),
+        novelty: w("novelty"),
+        conflictRisk: w("conflictRisk"),
+        tokenCost: w("tokenCost"),
+    };
+}
+function parseThresholds(raw) {
+    const o = (raw ?? {});
+    const high = clamp(round3(num(o["high"], DEFAULT_THRESHOLDS.high)), HIGH_BOUNDS[0], HIGH_BOUNDS[1]);
+    const midRaw = clamp(round3(num(o["mid"], DEFAULT_THRESHOLDS.mid)), MID_BOUNDS[0], MID_BOUNDS[1]);
+    const mid = Math.min(midRaw, round3(high - 0.1));
+    return { high, mid };
+}
+// Deserializza una singola baseline da oggetto grezzo. Mai lancia: riempie i
+// campi mancanti/invalidi dai default e clampa tutto.
+export function parseBaseline(raw, scopeFallback, opts) {
+    const o = (raw ?? {});
+    const ts = opts?.now ?? nowIso();
+    const scope = (typeof o["scope"] === "string" && o["scope"].trim()) || scopeFallback || DEFAULT_BASELINE_SCOPE;
+    return {
+        version: TUNER_BASELINE_SCHEMA_VERSION,
+        scope,
+        config: { weights: parseWeights(o["config"]?.["weights"]), thresholds: parseThresholds(o["config"]?.["thresholds"]) },
+        bestScore: clamp(num(o["bestScore"], 0), 0, 100),
+        lastScore: clamp(num(o["lastScore"], 0), 0, 100),
+        observations: Math.max(0, Math.floor(num(o["observations"], 0))),
+        createdAt: (typeof o["createdAt"] === "string" && o["createdAt"]) || ts,
+        updatedAt: (typeof o["updatedAt"] === "string" && o["updatedAt"]) || ts,
+    };
+}
+// Serializza una baseline in oggetto JSON-stabile (chiavi ordinate).
+export function baselineToJSON(b) {
+    return {
+        version: b.version,
+        scope: b.scope,
+        config: {
+            weights: {
+                relevance: b.config.weights.relevance,
+                dependency: b.config.weights.dependency,
+                trust: b.config.weights.trust,
+                freshness: b.config.weights.freshness,
+                novelty: b.config.weights.novelty,
+                conflictRisk: b.config.weights.conflictRisk,
+                tokenCost: b.config.weights.tokenCost,
+            },
+            thresholds: { high: b.config.thresholds.high, mid: b.config.thresholds.mid },
+        },
+        bestScore: b.bestScore,
+        lastScore: b.lastScore,
+        observations: b.observations,
+        createdAt: b.createdAt,
+        updatedAt: b.updatedAt,
+    };
+}
+// Blocco Danilov per log/TUI.
+export function formatBaseline(b) {
+    return [
+        `[TUNER_BASELINE:${b.scope}]`,
+        `@appreso: obs=${b.observations}, best=${b.bestScore}, last=${b.lastScore}`,
+        `@pesi: rel=${b.config.weights.relevance} dep=${b.config.weights.dependency} trust=${b.config.weights.trust} fresh=${b.config.weights.freshness} nov=${b.config.weights.novelty} conf=${b.config.weights.conflictRisk} cost=${b.config.weights.tokenCost}`,
+        `@soglie: high=${b.config.thresholds.high} mid=${b.config.thresholds.mid}`,
+        "OUTPUT: usa config come punto di partenza dell'anello (apprendimento cumulativo).",
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+// 5. STORE PERSISTENTE
+// ---------------------------------------------------------------------------
+// Store persistente delle baseline apprese: file `<storeId>.tuner.json` ->
+// mappa { [scope]: TunerBaseline }. API immutabile verso l'esterno, persistenza
+// su mutazione, robusto al file corrotto. Stesso stile di VascendVisionStore.
+export class TunerBaselineStore {
+    file;
+    dir;
+    baselines = {};
+    // undefined = prior non ancora calcolato; null = calcolato e non esiste
+    // esperienza da cui attingere. Il disco si legge una volta per store, e solo
+    // se serve davvero: nel caso comune (scope gia' appreso) non si legge affatto.
+    priorCache;
+    constructor(file, dir) {
+        this.file = file;
+        this.dir = dir;
+    }
+    // Apre lo store per uno scope di file (di norma il progetto/sessione). Il
+    // file e' separato dagli store di sessione cosi' la baseline VIVE FRA SESSIONI.
+    static open(dir, storeId) {
+        const store = new TunerBaselineStore(join(dir, `${storeId}.tuner.json`), dir);
+        store.baselines = readBaselineFile(store.file);
+        return store;
+    }
+    // Ritorna la baseline dello scope. Se lo scope e' nuovo parte dal PRIOR
+    // appreso sugli altri progetti invece che dai default: un progetto nuovo non
+    // deve ripagare da zero una convergenza gia' pagata altrove.
+    // Non persiste: e' una lettura pura.
+    get(scope = DEFAULT_BASELINE_SCOPE) {
+        const key = (scope || DEFAULT_BASELINE_SCOPE).trim() || DEFAULT_BASELINE_SCOPE;
+        return this.baselines[key] ?? this.freshBaseline(key);
+    }
+    // La baseline di partenza per uno scope mai visto: default piu' il prior, se
+    // c'e'. bestScore e observations restano a zero — il prior offre un punto di
+    // partenza, non un merito che questo scope non ha ancora guadagnato.
+    freshBaseline(scope, opts) {
+        const base = initialBaseline(scope, opts);
+        const prior = this.prior();
+        return prior ? { ...base, config: prior } : base;
+    }
+    // Il prior appreso dalle baseline sorelle nella stessa cartella (gli altri
+    // progetti e sessioni). Memoizzato: vale per la vita dello store.
+    prior() {
+        if (this.priorCache !== undefined)
+            return this.priorCache;
+        this.priorCache = blendPrior(readSiblingBaselines(this.dir, this.file));
+        return this.priorCache;
+    }
+    has(scope = DEFAULT_BASELINE_SCOPE) {
+        return Boolean(this.baselines[(scope || DEFAULT_BASELINE_SCOPE).trim()]);
+    }
+    all() {
+        return Object.values(this.baselines);
+    }
+    // La config da usare come PUNTO DI PARTENZA dell'anello per uno scope. Se non
+    // c'e' ancora apprendimento, ritorna i default.
+    startConfig(scope = DEFAULT_BASELINE_SCOPE) {
+        return this.get(scope).config;
+    }
+    // Incorpora un'osservazione (config+score trovati dall'anello), aggiorna la
+    // baseline via EMA e persiste. Ritorna la nuova baseline.
+    observe(scope, obs, opts) {
+        const key = (scope || DEFAULT_BASELINE_SCOPE).trim() || DEFAULT_BASELINE_SCOPE;
+        return withLockSync(this.file, () => {
+            // Rileggi DENTRO il lock: due sessioni/vassalli aperti sulla stessa
+            // baseline non possono sovrascriversi a vicenda con snapshot stantii.
+            const disk = readBaselineFile(this.file);
+            const cur = disk[key] ?? this.baselines[key] ?? this.freshBaseline(key, opts);
+            const next = mergeObservation(cur, obs, opts);
+            this.baselines = { ...disk, [key]: next };
+            this.persistUnlocked();
+            return next;
+        });
+    }
+    persistUnlocked() {
+        mkdirSync(dirname(this.file), { recursive: true });
+        const ordered = {};
+        for (const [scope, b] of Object.entries(this.baselines)) {
+            ordered[scope] = baselineToJSON(b);
+        }
+        const temp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(temp, JSON.stringify(ordered, null, 2) + "\n", "utf8");
+        try {
+            renameSync(temp, this.file);
+        }
+        catch {
+            rmSync(this.file, { force: true });
+            renameSync(temp, this.file);
+        }
+    }
+}
+// Le baseline degli ALTRI store nella stessa cartella: e' li' che vive
+// l'esperienza degli altri progetti. Il proprio file e' escluso — un prior
+// costruito su se stessi non insegnerebbe niente.
+//
+// Best-effort in ogni passaggio: una cartella illeggibile o un file corrotto
+// fanno tornare cio' che si e' riusciti a leggere. Il prior e' un miglioramento
+// opportunistico, non una dipendenza: se manca, si resta ai default.
+function readSiblingBaselines(dir, ownFile) {
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const own = basename(ownFile);
+    const candidates = names.filter((name) => name.endsWith(".tuner.json") && name !== own);
+    // Piu' recenti prima: se la cartella e' cresciuta oltre il tetto, l'esperienza
+    // fresca conta piu' di quella vecchia.
+    const ordered = candidates
+        .map((name) => {
+        const full = join(dir, name);
+        let mtime = 0;
+        try {
+            mtime = statSync(full).mtimeMs;
+        }
+        catch {
+            mtime = 0;
+        }
+        return { full, mtime };
+    })
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, MAX_PRIOR_FILES);
+    const out = [];
+    for (const { full } of ordered) {
+        for (const baseline of Object.values(readBaselineFile(full)))
+            out.push(baseline);
+    }
+    return out;
+}
+function readBaselineFile(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        const out = {};
+        for (const [scope, value] of Object.entries(raw ?? {})) {
+            const parsed = parseBaseline(value, scope);
+            out[parsed.scope] = parsed;
+        }
+        return out;
+    }
+    catch {
+        // File corrotto: fail-open sui default. La prossima observe lo sostituisce
+        // atomicamente sotto lock con uno store valido.
+        return {};
+    }
+}