@vascend/talos 0.1.0

package/dist/vascend/budget-allocator.js

@@ -0,0 +1,79 @@
+// Budget Allocator (metodo Danilov, Memory OS).
+//
+// Regola d'oro del documento talos-context:
+//   "Mai riempire la finestra perche' c'e' spazio. Riempila solo se il prossimo
+//    token aumenta la probabilita' di risposta corretta."
+//
+// Ogni ZONA del prompt ha un budget di token (slot fissi + dinamici), con una
+// RISERVA per il recall mirato. Questo modulo calcola l'allocazione e taglia i
+// contenuti che eccedono, in modo deterministico.
+//
+// Modulo PURO: nessun side-effect, stima token ~4 char/token.
+export const DEFAULT_POLICY = {
+    system: 0.08,
+    mission: 0.07,
+    vision: 0.12,
+    memory: 0.15,
+    evidence: 0.3,
+    recall: 0.12,
+    tool: 0.13,
+    tail: 0.03,
+};
+// Calcola l'allocazione per zona. La zona "user" riceve esattamente userTokens
+// (garantita); il resto e' distribuito per percentuale sul budget rimanente.
+export function allocateBudget(input) {
+    const policy = input.policy ?? DEFAULT_POLICY;
+    const nonNegative = (value) => Number.isFinite(value) ? Math.max(0, value) : 0;
+    const total = Math.floor(nonNegative(input.totalTokens));
+    const userTokens = Math.floor(nonNegative(input.userTokens ?? 0));
+    const remaining = Math.max(0, total - userTokens);
+    const sumPct = Object.values(policy).reduce((sum, value) => sum + nonNegative(value), 0);
+    const norm = sumPct > 0 ? sumPct : 1;
+    const share = (pct) => Math.floor((remaining * nonNegative(pct)) / norm);
+    return {
+        system: share(policy.system),
+        mission: share(policy.mission),
+        vision: share(policy.vision),
+        memory: share(policy.memory),
+        evidence: share(policy.evidence),
+        recall: share(policy.recall),
+        tool: share(policy.tool),
+        tail: share(policy.tail),
+        user: userTokens,
+    };
+}
+// Stima deterministica dei token di un testo (~4 char/token).
+export function estimateTokens(text) {
+    return Math.max(0, Math.ceil(text.length / 4));
+}
+// Taglia un testo al budget di token indicato (best effort, su confine di
+// carattere). Aggiunge un marcatore se troncato.
+export function clampToBudget(text, maxTokens) {
+    const maxChars = Math.max(0, maxTokens) * 4;
+    if (text.length <= maxChars)
+        return text;
+    if (maxChars <= 0)
+        return "";
+    const marker = " …[troncato-budget]";
+    if (maxChars <= marker.length)
+        return text.slice(0, maxChars);
+    return text.slice(0, maxChars - marker.length).trimEnd() + marker;
+}
+// Packing greedy: include gli item (ordinati per priorita' desc) finche' il
+// budget regge. Deterministico. Ritorna inclusi ed esclusi.
+export function packToBudget(items, maxTokens) {
+    const sorted = [...items].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    const included = [];
+    const excluded = [];
+    let used = 0;
+    for (const item of sorted) {
+        if (used + item.tokens <= maxTokens) {
+            included.push(item.ref);
+            used += item.tokens;
+        }
+        else {
+            excluded.push(item.ref);
+        }
+    }
+    return { included, excluded, usedTokens: used };
+}

package/dist/vascend/candidate-collector.d.ts

@@ -0,0 +1,20 @@
+import { type ContextCandidate } from "./context-candidate.js";
+import { type RoomRecord } from "./room-memory.js";
+import { type CastlePlan } from "./plan-store.js";
+import { type Vision } from "./vision.js";
+import { type DecisionEvent } from "./decision-promotion.js";
+export interface CollectInput {
+    readonly sessionDir: string;
+    readonly scopeId: string;
+    readonly planScopeId?: string;
+    readonly limit?: number;
+    readonly projectScopeLimit?: number;
+    readonly projectKey?: string;
+    /** Preselected dependencies supplied by a coherent snapshot. */
+    readonly projectScopes?: readonly string[];
+}
+export declare function collectCandidates(input: CollectInput): readonly ContextCandidate[];
+export declare function candidateFromRoom(r: RoomRecord, scopeId: string): ContextCandidate;
+export declare function candidatesFromCastle(castle: CastlePlan, scopeId: string): readonly ContextCandidate[];
+export declare function candidateFromVision(v: Vision, scopeId: string): ContextCandidate;
+export declare function candidateFromDecision(event: DecisionEvent, scopeId: string): ContextCandidate;

package/dist/vascend/candidate-collector.js

@@ -0,0 +1,220 @@
+// Candidate Collector (metodo Danilov, Memory OS).
+//
+// Raccoglie i CANDIDATI di contesto dalle viste materializzate del Memory OS
+// (MemoryStore append-only, RoomMemory, PlanStore, VisionStore) e li normalizza
+// in ContextCandidate, pronti per scoring e retrieval. NON decide cosa entra
+// nel prompt: produce solo il pool grezzo (de-duplicato per id).
+//
+// Modulo di SOLA LETTURA: apre gli store e legge; nessuna scrittura. Robusto
+// agli store mancanti (safe()).
+import { candidateFromEvent, normalizeCandidate, } from "./context-candidate.js";
+import { MemoryStore, listMemoryScopes } from "./memory-store.js";
+import { RoomMemory } from "./room-memory.js";
+import { VascendPlanStore } from "./plan-store.js";
+import { VascendVisionStore } from "./vision.js";
+import { DecisionStore } from "./decision-promotion.js";
+import { listContextMemoryScopes } from "./context-fabric.js";
+// Retrieval limits apply after ranking; explicit collector limits remain supported.
+const DEFAULT_CANDIDATE_LIMIT = Number.POSITIVE_INFINITY;
+// Raccoglie e de-duplica i candidati dal Memory OS. Deterministico a parita'
+// di store su disco.
+export function collectCandidates(input) {
+    const limit = input.limit && input.limit > 0 ? input.limit : DEFAULT_CANDIDATE_LIMIT;
+    const out = new Map();
+    const add = (c) => {
+        if (!out.has(c.id))
+            out.set(c.id, c);
+    };
+    // 1) Eventi del Memory OS della sessione corrente (fonte canonica).
+    for (const e of safe(() => MemoryStore.open(input.sessionDir, input.scopeId).all(), [])) {
+        add(candidateFromEvent(e, { scopeId: input.scopeId }));
+    }
+    // Le decisioni canoniche vivono in uno store dedicato. Indicizzarle solo
+    // come RoomRecord le degradava a kind=room e rendeva inattivi anchor,
+    // supersession e proof chain orientati alle decisioni.
+    for (const decision of safe(() => DecisionStore.open(input.sessionDir, input.scopeId).all(), [])) {
+        add(candidateFromDecision(decision, input.scopeId));
+    }
+    // 2) Frontiera delle stanze (RoomRecord): indice vivo del castello.
+    for (const r of safe(() => RoomMemory.open(input.sessionDir, input.scopeId).frontier(), [])) {
+        add(candidateFromRoom(r, input.scopeId));
+    }
+    // 3) Castelli/task del piano: i task aperti sono spesso prerequisiti.
+    for (const c of safe(() => VascendPlanStore.open(input.sessionDir, input.planScopeId ?? input.scopeId).castles(), [])) {
+        for (const cand of candidatesFromCastle(c, input.planScopeId ?? input.scopeId))
+            add(cand);
+    }
+    // 4) Vision: stella polare, sempre dependency=true.
+    for (const v of safe(() => VascendVisionStore.open(input.sessionDir, input.scopeId).all(), [])) {
+        add(candidateFromVision(v, input.scopeId));
+    }
+    // 5) Working set da sessioni recenti (cross-scope), peso ridotto: solo eventi.
+    const projectScopeLimit = input.projectScopeLimit && input.projectScopeLimit > 0 ? input.projectScopeLimit : 6;
+    const allowedScopes = !input.projectScopes && input.projectKey
+        ? new Set(listContextMemoryScopes(input.sessionDir, input.projectKey))
+        : null;
+    const projectScopes = input.projectScopes ?? listMemoryScopes(input.sessionDir, {
+        excludeScope: input.scopeId,
+        // Il filtro per progetto va applicato prima del cap: scope recenti di altri
+        // repo non devono espellere una sessione valida ma meno recente.
+        limit: allowedScopes ? 10_000 : projectScopeLimit,
+    }).filter((scope) => !allowedScopes || allowedScopes.has(scope)).slice(0, projectScopeLimit);
+    for (const scope of projectScopes) {
+        for (const e of safe(() => MemoryStore.open(input.sessionDir, scope).all(), []).slice(input.projectScopes ? 0 : -12)) {
+            add(qualifyCrossScope(candidateFromEvent(e, { scopeId: scope }), scope));
+        }
+        for (const decision of safe(() => DecisionStore.open(input.sessionDir, scope).all(), []).slice(input.projectScopes ? 0 : -6)) {
+            add(qualifyCrossScope(candidateFromDecision(decision, scope), scope));
+        }
+        if (input.projectScopes) {
+            for (const room of safe(() => RoomMemory.open(input.sessionDir, scope).frontier(), [])) {
+                add(qualifyCrossScope(candidateFromRoom(room, scope), scope));
+            }
+            if (scope !== input.planScopeId)
+                for (const castle of safe(() => VascendPlanStore.open(input.sessionDir, scope).castles(), [])) {
+                    for (const candidate of candidatesFromCastle(castle, scope))
+                        add(qualifyCrossScope(candidate, scope));
+                }
+            for (const vision of safe(() => VascendVisionStore.open(input.sessionDir, scope).all(), [])) {
+                add(qualifyCrossScope(candidateFromVision(vision, scope), scope));
+            }
+        }
+    }
+    return capCandidates([...out.values()], limit);
+}
+// --- conversioni per vista --------------------------------------------------
+export function candidateFromRoom(r, scopeId) {
+    // Le stanze di livello alto (castello/regno) sono indici: dependency utile.
+    return normalizeCandidate({
+        id: r.room,
+        kind: "room",
+        domain: "rooms",
+        subject: r.title,
+        summary: r.title,
+        body: r.body,
+        terms: r.terms,
+        createdAt: r.createdAt,
+        trust: r.level > 0 ? "high" : "medium",
+        dependency: r.level > 0,
+        scopeId,
+    });
+}
+export function candidatesFromCastle(castle, scopeId) {
+    return castle.tasks.map((t) => normalizeCandidate({
+        id: `${castle.slug}/${t.id}`,
+        kind: "task",
+        domain: "plan",
+        subject: `${castle.title} :: ${t.title}`,
+        summary: `[${t.status}] ${t.title}`,
+        body: [t.title, ...(t.evidence ?? [])].join(" | "),
+        terms: tokensOf(`${castle.title} ${t.title} ${t.status} ${(t.evidence ?? []).join(" ")}`),
+        trust: "high",
+        // I task non completati sono prerequisiti per capire lo stato corrente.
+        dependency: t.status !== "completed",
+        // I task completati hanno freshness piena ma sono "fatti": status active.
+        scopeId,
+    }));
+}
+export function candidateFromVision(v, scopeId) {
+    const features = Array.isArray(v.features) ? v.features.map((f) => featureLabel(f)).filter(Boolean) : [];
+    return normalizeCandidate({
+        id: `vision/${v.taskId}`,
+        kind: "note",
+        domain: "vision",
+        subject: `vision: ${v.goal ?? ""}`.trim(),
+        summary: v.goal ?? "",
+        body: [v.goal ?? "", ...features].filter(Boolean).join(" | "),
+        terms: tokensOf(`${v.goal ?? ""} ${features.join(" ")}`),
+        trust: "high",
+        dependency: true,
+        scopeId,
+    });
+}
+export function candidateFromDecision(event, scopeId) {
+    return normalizeCandidate({
+        id: event.id,
+        kind: "decision",
+        domain: "decisions",
+        subject: event.subject || event.decision,
+        summary: event.summary || event.decision,
+        body: [event.decision, event.reason, event.context].filter(Boolean).join(" | "),
+        terms: tokensOf(`${event.decision} ${event.reason} ${event.context} ${event.task ?? ""}`),
+        links: event.task ? [event.task] : [],
+        createdAt: event.createdAt,
+        trust: event.source === "user" ? "high" : "medium",
+        dependency: true,
+        scopeId,
+    });
+}
+// --- helper -----------------------------------------------------------------
+function featureLabel(f) {
+    if (typeof f === "string")
+        return f;
+    if (f && typeof f === "object") {
+        const o = f;
+        return typeof o["title"] === "string" ? o["title"] : typeof o["text"] === "string" ? o["text"] : "";
+    }
+    return "";
+}
+function tokensOf(s) {
+    return (s.toLowerCase().match(/[a-z0-9_./-]{2,}/g) ?? []).slice(0, 12);
+}
+// Gli id MemoryStore sono locali allo scope (ogni sessione parte da E1).
+// Manteniamo invariati gli id dello scope corrente per retrocompatibilita', ma
+// qualifichiamo quelli del working set esterno per evitare collisioni E1/E1.
+function qualifyCrossScope(candidate, scopeId) {
+    const prefix = `${scopeId}::`;
+    return {
+        ...candidate,
+        // `::` distingue il namespace di sessione dal `/` semantico dei task
+        // castello (master/T01). Usare `/` qui rendeva ogni E<n> dello stesso
+        // scope un falso vicino di grafo tramite sameCastle().
+        id: `${prefix}${candidate.id}`,
+        supersededBy: candidate.supersededBy ? `${prefix}${candidate.supersededBy}` : null,
+        links: candidate.links.map((target) => target.startsWith(prefix) ? target : `${prefix}${target}`),
+    };
+}
+// Se il pool supera il cap, le dipendenze attive e i nodi raggiungibili tramite
+// link strutturati devono arrivare al retriever anche quando sono vecchi. Il cap
+// resta rigido: la priorita' sostituisce candidati recenti, non aggiunge slot.
+// A parita' vale la recenza precedente e l'output conserva l'ordine originario.
+function capCandidates(candidates, limit) {
+    if (candidates.length <= limit)
+        return candidates;
+    const activeById = new Set(candidates
+        .filter((candidate) => candidate.status === "active" && !candidate.supersededBy)
+        .map((candidate) => candidate.id));
+    const linked = new Set();
+    for (const candidate of candidates) {
+        if (!activeById.has(candidate.id))
+            continue;
+        for (const target of candidate.links) {
+            if (!activeById.has(target))
+                continue;
+            linked.add(candidate.id);
+            linked.add(target);
+        }
+    }
+    const ranked = candidates
+        .map((candidate, index) => ({
+        candidate,
+        index,
+        priority: activeById.has(candidate.id)
+            ? candidate.dependency ? 2 : linked.has(candidate.id) ? 1 : 0
+            : 0,
+    }))
+        .sort((a, b) => b.priority - a.priority ||
+        b.candidate.createdAt - a.candidate.createdAt ||
+        a.index - b.index)
+        .slice(0, limit);
+    const keep = new Set(ranked.map(({ candidate }) => candidate.id));
+    return candidates.filter((candidate) => keep.has(candidate.id));
+}
+function safe(fn, fallback) {
+    try {
+        return fn();
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/vascend/code-events.d.ts

@@ -0,0 +1,24 @@
+import { type CodeEvent, type CodeEventType } from "./code-graph-types.js";
+import { type MemoryEventInput } from "./memory-store.js";
+export interface CodeEventSink {
+    emit(event: CodeEvent): void;
+}
+export declare function codeEventToMemoryInput(event: CodeEvent): MemoryEventInput;
+export declare class InMemoryCodeEventSink implements CodeEventSink {
+    private readonly events;
+    emit(event: CodeEvent): void;
+    all(): readonly CodeEvent[];
+    ofType(type: CodeEventType): readonly CodeEvent[];
+}
+export declare class MemoryStoreCodeEventSink implements CodeEventSink {
+    private readonly sessionDir;
+    private readonly storeId;
+    private constructor();
+    static open(sessionDir: string, storeId: string): MemoryStoreCodeEventSink;
+    emit(event: CodeEvent): void;
+}
+export declare class FanoutCodeEventSink implements CodeEventSink {
+    private readonly sinks;
+    constructor(sinks: readonly CodeEventSink[]);
+    emit(event: CodeEvent): void;
+}

package/dist/vascend/code-events.js

@@ -0,0 +1,304 @@
+// Sink degli EVENTI CODE GRAPH (metodo Danilov, Memory OS).
+//
+// CodeGraphMemory non sa COME rendere durevoli/visibili i suoi eventi: delega a
+// un CodeEventSink iniettabile. Tre implementazioni:
+//   - InMemoryCodeEventSink: tiene gli eventi in RAM (test, uso programmatico)
+//   - MemoryStoreCodeEventSink: indicizza ogni evento nel MemoryStore append-only
+//     (dominio "code"), cosi' diventano ContextCandidate per il Context Window
+//     Compiler (via candidateFromEvent / candidate-collector).
+//   - FanoutCodeEventSink: inoltra a piu' sink.
+//
+// I sink NON devono mai lanciare: un fallimento d'indicizzazione non deve
+// rompere l'indicizzazione del codice (best effort). Zero dipendenze a runtime.
+import { codeActionLabel, } from "./code-graph-types.js";
+import { MemoryStore, } from "./memory-store.js";
+// --- helper di formattazione ------------------------------------------------
+function escapeValue(value) {
+    return value.replace(/\s+/g, " ").trim().replace(/"/g, "'");
+}
+// Tokenizza valori in termini d'indice: token interi + sotto-parole separate da
+// -._/# cosi' un simbolo "parseSource" o un path "src/vascend/foo.ts" e'
+// richiamabile per ogni sua parola.
+function terms(...values) {
+    const out = new Set();
+    const add = (raw) => {
+        const t = raw.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "");
+        if (t.length >= 2)
+            out.add(t);
+    };
+    for (const v of values) {
+        if (!v)
+            continue;
+        for (const whole of v.toLowerCase().match(/[a-z0-9_./#-]{2,}/g) ?? []) {
+            add(whole);
+            for (const part of whole.split(/[-._/#]+/))
+                add(part);
+        }
+    }
+    return [...out].filter((t) => t.length >= 2);
+}
+// Termini riconoscibili per il Dev Context Layout (convenzione concordata coi
+// vassalli): dominio "code"/"graph" + parole chiave test/error per i fallimenti.
+function layoutTerms(type) {
+    const base = ["code", "graph"];
+    if (type === "code.test.failed")
+        return [...base, "test", "fail", "error"];
+    if (type === "code.test.passed")
+        return [...base, "test", "passed"];
+    if (type === "code.api.changed" || type === "code.contract.changed")
+        return [...base, "api", "contract"];
+    return base;
+}
+// Soggetto sintetico dell'evento (per subject/summary).
+function subjectOf(event) {
+    if (event.symbol)
+        return event.symbol.id;
+    if (event.testFile)
+        return event.testFile;
+    if (event.import)
+        return `${event.file} -> ${event.import.module}`;
+    return event.file;
+}
+function summaryOf(event) {
+    const action = codeActionLabel(event.type);
+    switch (event.type) {
+        case "code.symbol.changed":
+            return `${event.change ?? "modified"} ${event.symbol?.kind ?? "symbol"} ${event.symbol?.name ?? ""}`.trim();
+        case "code.contract.changed":
+            return `contratto ${event.symbol?.name ?? ""}: ${event.symbol?.signature ?? ""}`.trim();
+        case "code.api.changed": {
+            const add = event.apiAdded?.length ? `+${event.apiAdded.join(",")}` : "";
+            const rem = event.apiRemoved?.length ? `-${event.apiRemoved.join(",")}` : "";
+            return `api ${event.file}: ${[add, rem].filter(Boolean).join(" ")}`.trim();
+        }
+        case "code.import.added":
+            return `import ${event.import?.module ?? ""} in ${event.file}`;
+        case "code.test.failed":
+            return `test fallito ${event.testFile ?? event.file}: ${event.message ?? ""}`.trim();
+        case "code.test.passed":
+            return `test passato ${event.testFile ?? event.file}`;
+        case "code.file.touched":
+            return `${action} ${event.file}`;
+    }
+}
+// Costruisce l'input MemoryEvent (blocco Danilov) per un evento code.
+export function codeEventToMemoryInput(event) {
+    const action = codeActionLabel(event.type);
+    const subject = subjectOf(event);
+    const summary = summaryOf(event);
+    const indexTerms = [
+        ...terms(event.file, event.symbol?.name, event.symbol?.kind),
+        ...terms(event.import?.module, event.testFile, event.area),
+        ...terms(event.apiAdded?.join(" "), event.apiRemoved?.join(" ")),
+        ...terms(event.type.replace("code.", "")),
+        ...layoutTerms(event.type),
+        action,
+    ];
+    const uniqTerms = [...new Set(indexTerms)].filter(Boolean).slice(0, 28);
+    const def = [
+        `@evento[${event.type}]: file=${event.file}, action=${action}, at=${event.at}`,
+    ];
+    if (event.symbol) {
+        def.push(`@simbolo[${event.symbol.id}]: kind=${event.symbol.kind}, exported=${event.symbol.exported}, line=${event.symbol.line}`);
+        if (event.symbol.signature)
+            def.push(`@firma[${event.symbol.name}]: "${escapeValue(event.symbol.signature)}"`);
+    }
+    if (event.change)
+        def.push(`@cambiamento[${event.file}]: ${event.change}`);
+    if (event.previousSignature)
+        def.push(`@firma_precedente: "${escapeValue(event.previousSignature)}"`);
+    if (event.import) {
+        def.push(`@import[${event.file}]: module=${event.import.module}, external=${event.import.external}, names=[${event.import.names.join(",")}]`);
+    }
+    if (event.apiAdded?.length)
+        def.push(`@api_aggiunta: [${event.apiAdded.join(",")}]`);
+    if (event.apiRemoved?.length)
+        def.push(`@api_rimossa: [${event.apiRemoved.join(",")}]`);
+    if (event.testFile)
+        def.push(`@test[${event.testFile}]: covers=[${(event.covers ?? []).join(",")}]`);
+    if (event.message)
+        def.push(`@messaggio: "${escapeValue(event.message).slice(0, 600)}"`);
+    if (event.area)
+        def.push(`@area[${event.area}]: feature_area`);
+    if (event.note)
+        def.push(`@nota: "${escapeValue(event.note).slice(0, 400)}"`);
+    const links = [];
+    if (event.import && !event.import.external) {
+        links.push({ rel: "imports", target: event.import.module, domain: "code" });
+    }
+    if (event.symbol) {
+        links.push({ rel: "defines", target: event.symbol.id, domain: "code" });
+    }
+    for (const c of event.covers ?? []) {
+        links.push({ rel: "covers", target: c, domain: "code" });
+    }
+    const rel = `@R: ${event.file} -> ${event.type} -> ${subject}  [ ${action} ]`;
+    const body = `INDICE
+${uniqTerms.map((t, i) => `${i + 1} = ${t}`).join("\n")}
+
+DEFINIZIONI
+${def.join("\n")}
+
+RELAZIONI
+${rel}
+
+OUTPUT: ${summary}; richiamabile via recall.`;
+    // I test falliti e i contratti cambiati sono prerequisiti caldi: confidence
+    // alta cosi' lo scorer del Context Window Compiler li privilegia.
+    const confidence = event.type === "code.test.failed" || event.type === "code.contract.changed" || event.type === "code.api.changed"
+        ? "high"
+        : "medium";
+    return {
+        type: event.type,
+        domain: "code",
+        subject: escapeValue(subject).slice(0, 160),
+        summary: escapeValue(summary).slice(0, 200),
+        body,
+        terms: uniqTerms,
+        links,
+        payload: {
+            confidence,
+            area: event.area ?? "",
+            change: event.change ?? "",
+            file: event.file,
+            ...(event.symbol ? { symbol: event.symbol.id, signature: event.symbol.signature } : {}),
+            ...(event.import ? { import: event.import.module } : {}),
+            ...(event.testFile ? { testFile: event.testFile } : {}),
+        },
+        createdAt: event.at,
+    };
+}
+// --- implementazioni --------------------------------------------------------
+// Sink in-memory: tiene gli eventi e li espone (test/uso programmatico).
+export class InMemoryCodeEventSink {
+    events = [];
+    emit(event) {
+        this.events.push(event);
+    }
+    all() {
+        return this.events;
+    }
+    ofType(type) {
+        return this.events.filter((e) => e.type === type);
+    }
+}
+// Sink su MemoryStore: indicizza ogni evento code nel log append-only (dominio
+// "code"). Best effort: non lancia mai. Apre lo store a ogni emit per restare
+// coerente col modello degli altri sink (asset) senza tenere stato.
+export class MemoryStoreCodeEventSink {
+    sessionDir;
+    storeId;
+    constructor(sessionDir, storeId) {
+        this.sessionDir = sessionDir;
+        this.storeId = storeId;
+    }
+    static open(sessionDir, storeId) {
+        return new MemoryStoreCodeEventSink(sessionDir, storeId);
+    }
+    emit(event) {
+        try {
+            const store = MemoryStore.open(this.sessionDir, this.storeId);
+            const input = codeEventToMemoryInput(event);
+            // Gli archi semantici originali (file/simbolo/path) sono utili come
+            // provenance, ma il retriever opera su id di ContextCandidate. Collega
+            // quindi anche gli eventi gia' persistiti che rappresentano lo stesso
+            // file/simbolo o una dipendenza import/coverage. Il cap evita hub enormi.
+            const eventLinks = relatedEventLinks(event, store.query({ domain: "code" }));
+            store.append({ ...input, links: dedupeLinks([...(input.links ?? []), ...eventLinks]) });
+        }
+        catch {
+            // best effort: l'indicizzazione non deve rompere l'analisi del codice.
+        }
+    }
+}
+function relatedEventLinks(event, previous) {
+    const related = [];
+    const wantedCovers = new Set((event.covers ?? []).map(normalizePath));
+    const importedStem = event.import && !event.import.external
+        ? importStem(event.file, event.import.module)
+        : "";
+    for (const candidate of previous) {
+        const file = payloadString(candidate, "file");
+        const symbol = payloadString(candidate, "symbol");
+        let rel = null;
+        let score = 0;
+        if (event.symbol?.id && symbol === event.symbol.id) {
+            rel = "same-symbol";
+            score = 4;
+        }
+        else if (file && wantedCovers.has(normalizePath(file))) {
+            rel = "covers";
+            score = 3;
+        }
+        else if (file && importedStem && fileStem(file) === importedStem) {
+            rel = "imports";
+            score = 3;
+        }
+        else if (file && normalizePath(file) === normalizePath(event.file)) {
+            rel = "same-file";
+            score = 2;
+        }
+        if (rel)
+            related.push({ event: candidate, rel, score });
+    }
+    return related
+        .sort((a, b) => b.score - a.score ||
+        b.event.createdAt - a.event.createdAt ||
+        b.event.id.localeCompare(a.event.id))
+        .slice(0, 8)
+        .map((item) => ({ rel: item.rel, target: item.event.id, domain: "code" }));
+}
+function dedupeLinks(links) {
+    const seen = new Set();
+    const out = [];
+    for (const link of links) {
+        const key = `${link.rel}\u0000${link.target}\u0000${link.domain ?? ""}`;
+        if (!link.target || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(link);
+    }
+    return out;
+}
+function payloadString(event, key) {
+    const value = event.payload[key];
+    return typeof value === "string" ? value : "";
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function fileStem(value) {
+    return normalizePath(value)
+        .replace(/\/[Ii][Nn][Dd][Ee][Xx]\.[cm]?[jt]sx?$/, "")
+        .replace(/\.[cm]?[jt]sx?$/i, "");
+}
+function importStem(fromFile, module) {
+    const base = normalizePath(fromFile).split("/").slice(0, -1);
+    for (const segment of normalizePath(module).split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..")
+            base.pop();
+        else
+            base.push(segment);
+    }
+    return fileStem(base.join("/"));
+}
+// Sink che inoltra a piu' sink (es. in-memory + MemoryStore). Inghiotte errori
+// dei singoli sink per non interrompere gli altri.
+export class FanoutCodeEventSink {
+    sinks;
+    constructor(sinks) {
+        this.sinks = sinks;
+    }
+    emit(event) {
+        for (const sink of this.sinks) {
+            try {
+                sink.emit(event);
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+}