@vascend/talos 0.1.0

package/dist/vascend/room-memory.d.ts

@@ -0,0 +1,57 @@
+import type { Message } from "../core/types.js";
+import { RoomGraph, type RoomEdge, type RoomNeighbor } from "./room-graph.js";
+export interface RoomRecord {
+    readonly room: string;
+    readonly level: number;
+    readonly title: string;
+    readonly terms: readonly string[];
+    readonly body: string;
+    readonly children: readonly string[];
+    readonly parent: string | null;
+    readonly createdAt: number;
+    readonly edges?: readonly RoomEdge[];
+}
+export interface RoomSearchHit {
+    readonly record: RoomRecord;
+    readonly score: number;
+    readonly viaGraph?: boolean;
+    readonly via?: readonly string[];
+}
+export declare const DEFAULT_FANOUT = 8;
+export declare const DEFAULT_RECENT_KEEP = 2;
+export declare class RoomMemory {
+    private readonly file;
+    private readonly fanout;
+    private readonly memory;
+    private records;
+    private synonyms;
+    private tokenCache;
+    private graphCache;
+    private readonly recentKeep;
+    private constructor();
+    withSynonyms(groups: readonly (readonly string[])[]): this;
+    private tokensFor;
+    private indexedDocs;
+    static open(sessionDir: string, sessionId: string, fanout?: number): RoomMemory;
+    count(): number;
+    all(): readonly RoomRecord[];
+    frontier(): readonly RoomRecord[];
+    nextId(level: number, ns?: string): string;
+    nextRoomId(ns?: string): string;
+    append(record: RoomRecord): void;
+    filePath(): string;
+    reloadFromDisk(): void;
+    appendRoomNamespaced(build: (id: string) => RoomRecord, ns: string | undefined): RoomRecord;
+    rollup(now: number): boolean;
+    byRooms(ids: readonly string[]): readonly RoomRecord[];
+    expandRooms(ids: readonly string[]): readonly RoomRecord[];
+    search(query: string, limit?: number): readonly RoomSearchHit[];
+    graph(): RoomGraph;
+    neighbors(room: string, limit?: number): readonly RoomNeighbor[];
+    searchGraph(query: string, limit?: number): readonly RoomSearchHit[];
+    indexBlock(): string;
+    private setParent;
+    private persistAll;
+}
+export declare function formatRoomRecord(room: string, messages: readonly Message[], createdAt: number): RoomRecord;
+export declare function formatRollupRecord(id: string, level: number, children: readonly RoomRecord[], createdAt: number): RoomRecord;

package/dist/vascend/room-memory.js

@@ -0,0 +1,631 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { sanitizeText } from "../core/text-sanitize.js";
+import { MemoryStore } from "./memory-store.js";
+import { STOP, tokenize, buildSynonyms, expandQuery, bm25Score, } from "./lexical-search.js";
+import { withLockSync } from "./file-lock.js";
+import { RoomGraph, clusterByAffinity, clusterLabel, roomEdges, topTerms, } from "./room-graph.js";
+// Peso di un vicino a 2 hop rispetto al seme che lo ha portato. Allineato al
+// peso del link tipizzato in context-retriever.ts: stessa semantica, stesso
+// numero, cosi' recall e compilazione del contesto non si contraddicono.
+const GRAPH_HOP_WEIGHT = 0.68;
+export const DEFAULT_FANOUT = 8;
+const MAX_BODY = 4_000;
+// Quante stanze recenti restano SEMPRE individuali in frontiera (mai assorbite
+// da un rollup): sono il "dove eravamo rimasti" dell'agente. Limitata a
+// fanout-1 perche' con fanout piccoli la gerarchia non si formerebbe mai.
+export const DEFAULT_RECENT_KEEP = 2;
+export class RoomMemory {
+    file;
+    fanout;
+    memory;
+    records = [];
+    // Indice sinonimi (default; configurabile via withSynonyms) per espandere le
+    // query verso forme equivalenti IT/EN.
+    synonyms = buildSynonyms();
+    // INDICE INVERTITO: i token di ogni record, calcolati una volta sola. Senza
+    // questa cache ogni recall ritokenizzava l'intero corpus (misurato: 38 ms su
+    // 569 record, crescita lineare). Il corpo di un record non cambia mai dopo la
+    // scrittura — solo `parent` viene riassegnato dal rollup, e non entra
+    // nell'indice — quindi la chiave e' l'id della stanza.
+    tokenCache = new Map();
+    // Grafo memoizzato: la firma e' il numero di record (i record esistenti non
+    // cambiano mai corpo ne' archi dopo la scrittura).
+    graphCache = null;
+    recentKeep;
+    constructor(file, fanout, memory) {
+        this.file = file;
+        this.fanout = fanout;
+        this.memory = memory;
+        this.recentKeep = Math.max(0, Math.min(this.fanout - 1, DEFAULT_RECENT_KEEP));
+    }
+    // Sostituisce la tabella sinonimi (es. per dominio specifico). Ritorna this
+    // per concatenare dopo open(). Deterministico.
+    withSynonyms(groups) {
+        this.synonyms = buildSynonyms(groups);
+        return this;
+    }
+    // Token indicizzati di un record (memoizzati per id).
+    tokensFor(record) {
+        const hit = this.tokenCache.get(record.room);
+        if (hit)
+            return hit;
+        const tokens = tokenize(`${record.terms.join(" ")} ${record.title} ${record.body}`);
+        this.tokenCache.set(record.room, tokens);
+        return tokens;
+    }
+    // Corpus indicizzato per la ricerca lessicale.
+    indexedDocs() {
+        return this.records.map((record) => ({ ref: record, tokens: this.tokensFor(record) }));
+    }
+    static open(sessionDir, sessionId, fanout = DEFAULT_FANOUT) {
+        const file = join(sessionDir, `${sessionId}.rooms.jsonl`);
+        const mem = new RoomMemory(file, Math.max(2, fanout), MemoryStore.open(sessionDir, sessionId));
+        if (existsSync(file)) {
+            const raw = readFileSync(file, "utf8");
+            for (const line of raw.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    mem.records.push(normalize(JSON.parse(line)));
+                }
+                catch {
+                    // riga corrotta: ignorata
+                }
+            }
+        }
+        return mem;
+    }
+    count() {
+        return this.records.length;
+    }
+    all() {
+        return this.records;
+    }
+    // Frontiera: i nodi non ancora compattati in un livello superiore, in ordine.
+    frontier() {
+        return this.records.filter((r) => r.parent === null).slice().sort((a, b) => a.createdAt - b.createdAt);
+    }
+    // Prossimo id per un dato livello (R/C/K/L<n>). Con `ns` (slug castello) gli
+    // id sono namespaced (es. "auth-R1") e contati per-namespace: evita le
+    // collisioni quando piu' vassalli scrivono sullo stesso store del regno.
+    nextId(level, ns) {
+        const prefix = `${ns ? `${ns}-` : ""}${levelPrefix(level)}`;
+        const n = this.records.filter((r) => r.level === level && r.room.startsWith(prefix)).length + 1;
+        return `${prefix}${n}`;
+    }
+    nextRoomId(ns) {
+        return this.nextId(0, ns);
+    }
+    // Aggiunge una stanza (livello 0): fast path append, protetto da lock
+    // file-system cosi' due processi concorrenti non interlacciano le righe.
+    append(record) {
+        this.records.push(record);
+        mkdirSync(dirname(this.file), { recursive: true });
+        withLockSync(this.file, () => {
+            appendFileSync(this.file, JSON.stringify(record) + "\n", "utf8");
+        });
+        // Sink eventi: emette room.closed nel log append-only multi-dominio
+        // (Memory OS) per recall/packet/rollup. Non bloccante.
+        this.memory.append(roomEvent("room.closed", record));
+    }
+    // Percorso del file (per il writer unico/scribe che deve coordinare il lock).
+    filePath() {
+        return this.file;
+    }
+    // Ricarica lo stato dal disco (le righe scritte da altri writer da quando
+    // questa istanza ha aperto il file). Usato dal writer unico per assegnare id
+    // monotoni su una vista FRESCA prima di scrivere.
+    reloadFromDisk() {
+        // Vista sostituita per intero: gli indici memoizzati non sono piu'
+        // affidabili (un writer concorrente puo' aver riscritto lo store).
+        this.tokenCache.clear();
+        this.graphCache = null;
+        if (!existsSync(this.file)) {
+            this.records = [];
+            return;
+        }
+        const raw = readFileSync(this.file, "utf8");
+        const next = [];
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                next.push(normalize(JSON.parse(line)));
+            }
+            catch {
+                // riga corrotta: ignorata
+            }
+        }
+        this.records = next;
+    }
+    // WRITER UNICO sicuro: sotto lock cross-processo, ricarica la vista dal
+    // disco (ordine autoritativo), costruisce il record con un id MONOTONO
+    // calcolato sulla vista fresca (niente collisioni anche con piu' processi)
+    // e appende una sola riga atomica. Ritorna il record scritto.
+    appendRoomNamespaced(build, ns) {
+        mkdirSync(dirname(this.file), { recursive: true });
+        const record = withLockSync(this.file, () => {
+            this.reloadFromDisk();
+            const id = this.nextRoomId(ns);
+            const rec = build(id);
+            this.records.push(rec);
+            appendFileSync(this.file, JSON.stringify(rec) + "\n", "utf8");
+            return rec;
+        });
+        // Sink eventi anche per la scrittura del writer unico.
+        this.memory.append(roomEvent("room.closed", record));
+        return record;
+    }
+    // Compatta a cascata: quando un livello ha abbastanza nodi in frontiera, li
+    // chiude in nodi padre del livello superiore. Ritorna true se qualcosa e'
+    // stato compattato (e persiste l'intero store).
+    //
+    // Due proprieta' rispetto alla versione a fetta di tempo:
+    //
+    //   AFFINITA' — il gruppo non e' "le prime N in ordine di arrivo" ma il
+    //   grappolo piu' denso per termini e file condivisi. Un castello torna a
+    //   essere un'unita' di senso: misurato su 48 stanze interlacciate, la
+    //   purezza dei padri passa da 0.25 a 0.75 e il payload pertinente di un
+    //   recall dal 25% al 75%, a parita' di token.
+    //
+    //   RECENZA — le ultime `recentKeep` stanze non vengono mai assorbite:
+    //   restano in frontiera, individuali e cronologiche. Senza, dopo un rollup
+    //   il marcatore "TURNO PIU' RECENTE" finiva su un castello e "riprendi da
+    //   dove eravamo" perdeva il suo aggancio.
+    rollup(now) {
+        let changed = false;
+        let level = 0;
+        const maxLevel = () => this.records.reduce((m, r) => Math.max(m, r.level), 0);
+        while (level <= maxLevel()) {
+            for (;;) {
+                const front = this.frontier().filter((r) => r.level === level);
+                // La finestra di recenza protegge solo le stanze: ai livelli superiori
+                // il dettaglio e' gia' archiviato e l'ordine cronologico non serve a
+                // riprendere il lavoro.
+                const keep = level === 0 ? this.recentKeep : 0;
+                const eligible = keep > 0 ? front.slice(0, Math.max(0, front.length - keep)) : front;
+                if (eligible.length < this.fanout)
+                    break;
+                const groups = clusterByAffinity(eligible, this.fanout);
+                if (!groups.length)
+                    break;
+                for (const group of groups) {
+                    const parent = formatRollupRecord(this.nextId(level + 1), level + 1, group, now);
+                    this.records.push(parent);
+                    this.memory.append(roomEvent("rollup.created", parent, group));
+                    for (const child of group)
+                        this.setParent(child.room, parent.room);
+                    changed = true;
+                }
+            }
+            level += 1;
+        }
+        if (changed)
+            this.persistAll();
+        return changed;
+    }
+    byRooms(ids) {
+        const want = new Set(ids.map((id) => id.toUpperCase()));
+        return this.records.filter((r) => want.has(r.room.toUpperCase()));
+    }
+    // Espande ricorsivamente nodi gerarchici (castelli/regni/livelli) nei figli,
+    // preservando il nodo richiesto come intestazione e deduplicando i discendenti.
+    expandRooms(ids) {
+        const out = [];
+        const seen = new Set();
+        const byId = new Map(this.records.map((r) => [r.room.toUpperCase(), r]));
+        const visit = (record) => {
+            const key = record.room.toUpperCase();
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            out.push(record);
+            for (const childId of record.children) {
+                const child = byId.get(childId.toUpperCase());
+                if (child)
+                    visit(child);
+            }
+        };
+        for (const record of this.byRooms(ids))
+            visit(record);
+        return out;
+    }
+    // Ricerca LESSICALE BM25 (offline, deterministica) su TUTTI i livelli: una
+    // query puo' colpire una stanza (dettaglio) o un castello/regno (indice ->
+    // figli da cui scendere). Aumenta il richiamo su parole non perfettamente
+    // coincidenti tramite normalizzazione (fold accenti + stemming), espansione
+    // sinonimi e prefix/fuzzy match (vedi lexical-search.ts). API invariata.
+    search(query, limit = 5) {
+        const qTokens = unique(tokenize(query));
+        if (!qTokens.length) {
+            return this.frontier().slice(-limit).reverse().map((record) => ({ record, score: 0 }));
+        }
+        const docs = this.indexedDocs();
+        const weighted = expandQuery(qTokens, this.synonyms);
+        const scored = bm25Score(docs, weighted);
+        // RECENCY BIAS (freshness): a parita' o quasi-parita' di rilevanza vince la
+        // stanza piu' RECENTE. Senza, il recall pescava task vecchi gia' risolti
+        // invece del turno precedente. Rank ordinale deterministico in [0,1]
+        // (0=piu' vecchio, 1=piu' recente) applicato come moltiplicatore lieve: una
+        // forte rilevanza testuale di una stanza vecchia puo' ancora prevalere.
+        const minT = this.records.reduce((m, r) => Math.min(m, r.createdAt), Infinity);
+        const maxT = this.records.reduce((m, r) => Math.max(m, r.createdAt), -Infinity);
+        const span = maxT - minT || 1;
+        const RECENCY_WEIGHT = 0.2;
+        // Posizione di append: tie-break finale quando i timestamp coincidono
+        // (append rapidi nello stesso ms) -> l'ultimo scritto e' il piu' recente.
+        const pos = new Map(this.records.map((r, i) => [r.room, i]));
+        return scored
+            .filter((h) => h.score > 0)
+            .map((h) => {
+            const rank = (h.ref.createdAt - minT) / span; // 0..1
+            return { record: h.ref, score: h.score * (1 + RECENCY_WEIGHT * rank) };
+        })
+            .sort((a, b) => b.score - a.score ||
+            b.record.createdAt - a.record.createdAt ||
+            (pos.get(b.record.room) ?? 0) - (pos.get(a.record.room) ?? 0))
+            .slice(0, limit);
+    }
+    // Grafo degli archi tipizzati (stanza -> file -> stanza). Memoizzato: il
+    // numero di record e' la firma, e i record esistenti non cambiano corpo.
+    graph() {
+        const cached = this.graphCache;
+        if (cached && cached.size === this.records.length)
+            return cached.graph;
+        const graph = RoomGraph.build(this.records);
+        this.graphCache = { size: this.records.length, graph };
+        return graph;
+    }
+    // Stanze vicine: hanno toccato almeno un file in comune con `room`.
+    neighbors(room, limit = 8) {
+        return this.graph().neighbors(room, limit);
+    }
+    // Ricerca lessicale + TRAVERSATA a un hop. I match diretti restano i piu'
+    // forti; i vicini entrano con peso ridotto e possono spodestare solo le code
+    // lessicali deboli. Risponde a "chi altro ha messo le mani qui", che la sola
+    // BM25 non puo' vedere: due stanze possono descrivere lo stesso file con
+    // parole completamente diverse.
+    searchGraph(query, limit = 5) {
+        const direct = this.search(query, limit);
+        if (!direct.length)
+            return direct;
+        const graph = this.graph();
+        const byId = new Map(this.records.map((r) => [r.room, r]));
+        const merged = new Map(direct.map((h) => [h.record.room, h]));
+        const seeds = direct.filter((h) => h.record.level === 0).slice(0, 3);
+        for (const seed of seeds) {
+            for (const neighbor of graph.neighbors(seed.record.room, limit)) {
+                if (merged.has(neighbor.room))
+                    continue;
+                const record = byId.get(neighbor.room);
+                if (!record)
+                    continue;
+                merged.set(neighbor.room, {
+                    record,
+                    score: seed.score * GRAPH_HOP_WEIGHT,
+                    viaGraph: true,
+                    via: neighbor.via,
+                });
+            }
+        }
+        return [...merged.values()]
+            .sort((a, b) => b.score - a.score ||
+            Number(Boolean(a.viaGraph)) - Number(Boolean(b.viaGraph)) ||
+            b.record.createdAt - a.record.createdAt ||
+            a.record.room.localeCompare(b.record.room))
+            .slice(0, limit);
+    }
+    // INDICE della frontiera: il blocco compatto iniettato nel contesto (diventa
+    // il riassunto di compattazione). Elenca i nodi di frontiera (stanze sciolte
+    // + castelli/regni gia' chiusi) e istruisce l'uso di recall per scendere.
+    indexBlock() {
+        const front = this.frontier(); // ordine cronologico: vecchio -> recente
+        if (!front.length)
+            return "";
+        const last = front.length - 1;
+        const rows = front
+            .map((r, i) => {
+            const marker = i === last ? "   <- TURNO PIU' RECENTE" : "";
+            return `${i + 1}. @${levelLabel(r.level)}[${r.room}]: "${escapeValue(r.title)}" · termini=${r.terms.slice(0, 8).join(",")}${marker}`;
+        })
+            .join("\n");
+        return `ATTIVITA_ARCHIVIATE (ordine cronologico: prima le piu' vecchie, ultima la piu' recente)
+Il lavoro precedente e' ARCHIVIATO fuori dal contesto vivo, in attivita raccolte
+in gruppi e liste. Per recuperarne il dettaglio usa il tool "recall" (per query
+o per id, anche scendendo da un gruppo alle sue attivita) invece di chiedere di
+ripetere: il contesto resta compatto.
+Per RIPRENDERE il lavoro appena svolto parti dalla voce piu' in basso (il turno
+piu' recente, marcato), NON da quelle sopra: quelle sono turni gia' conclusi.
+
+${rows}
+
+OUTPUT: contesto compatto; dettaglio recuperabile a ogni livello via recall.`;
+    }
+    setParent(childId, parentId) {
+        const i = this.records.findIndex((r) => r.room === childId);
+        if (i >= 0)
+            this.records[i] = { ...this.records[i], parent: parentId };
+    }
+    persistAll() {
+        mkdirSync(dirname(this.file), { recursive: true });
+        withLockSync(this.file, () => {
+            writeFileSync(this.file, this.records.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf8");
+        });
+    }
+}
+function roomEvent(type, record, children = []) {
+    return {
+        type,
+        domain: "rooms",
+        subject: record.room,
+        summary: record.title,
+        body: record.body,
+        terms: record.terms,
+        links: children.map((child) => ({ rel: "contains", target: child.room, domain: "rooms" })),
+        payload: { room: record },
+        createdAt: record.createdAt,
+    };
+}
+// Record Danilov compatto di una STANZA (livello 0) dai messaggi del turno.
+export function formatRoomRecord(room, messages, createdAt) {
+    const title = roomTitle(messages);
+    const tools = collectToolCalls(messages);
+    const files = collectFiles(messages);
+    const output = lastAssistantText(messages);
+    const terms = cleanTerms([
+        ...tokenize(title).slice(0, 6),
+        ...tools.map((t) => t.name),
+        ...files.map((f) => baseName(f)),
+    ]).slice(0, 12);
+    const def = [
+        `@goal[${room}]: "${escapeValue(title)}"`,
+        ...tools.slice(0, 12).map((t, i) => `@tool[${room}.${i + 1}]: ${t.name}(${escapeValue(t.arg)}) -> ${escapeValue(t.result)}`),
+        ...files.slice(0, 12).map((f, i) => `@file[${room}.${i + 1}]: ${escapeValue(f)}`),
+    ].join("\n");
+    const rel = tools.length
+        ? `@R: ${room} -> ${tools.slice(0, 8).map((t) => t.name).join(" -> ")}`
+        : `@R: ${room} -> nessuno_strumento`;
+    // Archi tipizzati: i file e i tool del turno sono gia' estratti qui sopra,
+    // quindi il grafo costa zero a scrittura.
+    const edges = roomEdges(files, tools.map((t) => t.name));
+    const body = clampBody(`INDICE
+${numberedIndex(terms)}
+
+DEFINIZIONI
+${def}
+
+RELAZIONI
+${rel}
+
+OUTPUT: ${escapeValue(output) || "(nessun output testuale)"}`);
+    return { room, level: 0, title, terms, body, children: [], parent: null, createdAt, edges };
+}
+// Record di ROLLUP (castello/regno/...): indice sui figli che ha chiuso.
+export function formatRollupRecord(id, level, children, createdAt) {
+    const label = levelLabel(level);
+    const childLabel = levelLabel(level - 1);
+    const childCountLabel = level === 1 ? "attivita" : level === 2 ? "gruppi" : "liste";
+    // Termini RICORRENTI nel gruppo, non l'unione piatta: descrivono il nodo
+    // padre invece di elencare tutto quello che c'e' sotto.
+    const recurring = topTerms(children, 16);
+    const terms = cleanTerms(recurring.length ? recurring : children.flatMap((c) => c.terms)).slice(0, 16);
+    // Titolo ONESTO: l'area comune + i termini ricorrenti. Prima era il titolo
+    // del PRIMO figlio con "… +7" in coda, quindi un castello si annunciava col
+    // nome di un ottavo del suo contenuto e sviava sia l'agente sia la ricerca.
+    const title = children.length > 1
+        ? `${clusterLabel(children)} · ${children.length} ${childCountLabel}`.slice(0, 160)
+        : oneLine(children[0]?.title ?? "").slice(0, 120);
+    const rows = children
+        .map((c) => `@${childLabel}[${c.room}]: "${escapeValue(c.title)}" · termini=${c.terms.slice(0, 8).join(",")}`)
+        .join("\n");
+    const body = clampBody(`RIEPILOGO_${label.toUpperCase()} ${id}
+Elementi archiviati: ${children.length}. Per il dettaglio
+di un figlio usa recall(rooms:["${children[0]?.room ?? ""}", ...]) o una query.
+
+INDICE
+${numberedIndex(terms)}
+
+${cap(childLabel)}
+${rows}
+
+OUTPUT: riepilogo delle attivita; apri i dettagli col tool recall.`);
+    return {
+        room: id,
+        level,
+        title: title || cap(label),
+        terms,
+        body,
+        children: children.map((c) => c.room),
+        parent: null,
+        // Il padre eredita il timestamp del figlio piu' recente: con i gruppi per
+        // affinita' l'istante del rollup non direbbe nulla, mentre cosi' la
+        // frontiera resta ordinata per "quanto e' recente il lavoro che contiene".
+        createdAt: children.reduce((max, c) => Math.max(max, c.createdAt), 0) || createdAt,
+    };
+}
+// --- livelli ---------------------------------------------------------------
+function levelPrefix(level) {
+    if (level === 0)
+        return "R";
+    if (level === 1)
+        return "C";
+    if (level === 2)
+        return "K";
+    return `L${level}`;
+}
+function levelLabel(level) {
+    if (level <= 0)
+        return "attivita";
+    if (level === 1)
+        return "gruppo";
+    if (level === 2)
+        return "lista";
+    return `raccolta${level}`;
+}
+function cap(s) {
+    return s ? s[0].toUpperCase() + s.slice(1) : s;
+}
+// INDICE Danilov: vocabolario numerato (una voce per riga), come prescrive il
+// metodo, invece di una lista piatta separata da virgole.
+function numberedIndex(terms) {
+    if (!terms.length)
+        return "1 = (nessun termine)";
+    return terms.map((t, i) => `${i + 1} = ${t}`).join("\n");
+}
+function normalize(raw) {
+    const body = currentMemoryLabels(raw.body ?? "");
+    const title = raw.title ?? "";
+    return {
+        room: raw.room ?? "R?",
+        level: typeof raw.level === "number" ? raw.level : 0,
+        title: body === raw.body ? title : title.replace(/( · \d+) (stanza|castello|regno)$/, (_, count, label) => `${count} ${label === "stanza" ? "attivita" : label === "castello" ? "gruppi" : "liste"}`),
+        terms: Array.isArray(raw.terms) ? raw.terms : [],
+        body,
+        children: Array.isArray(raw.children) ? raw.children : [],
+        parent: raw.parent ?? null,
+        createdAt: typeof raw.createdAt === "number" ? raw.createdAt : 0,
+        ...(Array.isArray(raw.edges) ? { edges: raw.edges.filter(isRoomEdge) } : {}),
+    };
+}
+// Aggiorna solo le etichette generate dei vecchi riepiloghi. Gli ID,
+// le prove e il testo originale dell'utente restano quelli salvati.
+function currentMemoryLabels(body) {
+    if (!/^INDICE_(?:CASTELLO|REGNO|LIVELLO\d+) \S+\r?\n/.test(body))
+        return body;
+    const labels = { stanza: "attivita", castello: "gruppo", regno: "lista" };
+    return body
+        .replace(/^INDICE_(CASTELLO|REGNO|LIVELLO\d+)/, (_, label) => `RIEPILOGO_${(labels[label.toLowerCase()] ?? label.replace("LIVELLO", "RACCOLTA")).toUpperCase()}`)
+        .replace(/^(?:Castello|Regno|Livello\d+) chiuso: (\d+) \w+ archiviati\./m, "Elementi archiviati: $1.")
+        .replace(/^@(stanza|castello|regno)(?=\[)/gm, (_, label) => `@${labels[label]}`)
+        .replace(/^(Stanza|Castello|Regno)\r?$/gm, (_, label) => cap(labels[label.toLowerCase()]))
+        .replace(/^OUTPUT: indice del (?:castello|regno|livello\d+);.*$/m, "OUTPUT: riepilogo delle attivita; apri i dettagli col tool recall.");
+}
+function isRoomEdge(value) {
+    const edge = value;
+    return Boolean(edge && typeof edge.target === "string" && edge.target && (edge.kind === "file" || edge.kind === "tool"));
+}
+// --- estrazione deterministica dai messaggi --------------------------------
+function roomTitle(messages) {
+    const firstUser = messages.find((m) => m.role === "user");
+    const text = firstUser ? messageText(firstUser) : "";
+    // Collaboratore: il task reale e' appeso DOPO il preambolo di
+    // steering, sotto il marker OBIETTIVO_CASTELLO. Senza riconoscerlo, il titolo
+    // (e quindi i termini-indice e la ricerca) catturerebbe il boilerplate
+    // "[COLLABORATORE ...] INDICE 1 = ruolo 2 = dipendenze ..." IDENTICO per ogni
+    // stanza, rendendo indexBlock e recall inservibili: la causa per cui le
+    // stanze passate non si distinguono ne' si richiamano.
+    const objective = /OBIETTIVO_(?:ATTIVITA|CASTELLO)\s*\n([\s\S]*)$/.exec(text);
+    if (objective?.[1]?.trim())
+        return oneLine(objective[1]).slice(0, 160);
+    const input = /INPUT_UTENTE\n([\s\S]*)$/.exec(text);
+    if (input?.[1]?.trim())
+        return oneLine(input[1]).slice(0, 160);
+    const goal = /GOAL:\s*(.+)/.exec(text);
+    if (goal?.[1])
+        return oneLine(goal[1]).slice(0, 160);
+    return oneLine(text).slice(0, 160) || "attivita";
+}
+function collectToolCalls(messages) {
+    const calls = new Map();
+    const out = [];
+    for (const m of messages) {
+        for (const part of m.content) {
+            if (part.type === "tool_call") {
+                calls.set(part.id, { name: part.name, arg: firstArg(part.input) });
+            }
+            if (part.type === "tool_result") {
+                const call = calls.get(part.callId);
+                if (call)
+                    out.push({ name: call.name, arg: call.arg, result: firstLine(part.output).slice(0, 100) });
+            }
+        }
+    }
+    for (const [, c] of calls) {
+        if (!out.some((o) => o.name === c.name && o.arg === c.arg))
+            out.push({ name: c.name, arg: c.arg, result: "" });
+    }
+    return out;
+}
+function collectFiles(messages) {
+    const files = new Set();
+    for (const m of messages) {
+        for (const part of m.content) {
+            if (part.type === "tool_call") {
+                const p = part.input["path"];
+                // Scarta i path "directory corrente" (".", "./") che non sono file utili.
+                if (typeof p === "string" && p && !/^\.\/?$/.test(p.trim()))
+                    files.add(p);
+            }
+        }
+    }
+    return [...files];
+}
+function lastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (m?.role === "assistant") {
+            const text = m.content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
+            if (text.trim())
+                return oneLine(text).slice(0, 400);
+        }
+    }
+    return "";
+}
+function firstArg(input) {
+    const path = input["path"];
+    if (typeof path === "string")
+        return path;
+    const cmd = input["command"];
+    if (typeof cmd === "string")
+        return cmd.slice(0, 60);
+    const keys = Object.keys(input);
+    if (!keys.length)
+        return "";
+    const v = input[keys[0]];
+    return typeof v === "string" ? v.slice(0, 60) : JSON.stringify(v).slice(0, 60);
+}
+// --- util ------------------------------------------------------------------
+function messageText(message) {
+    return message.content
+        .map((part) => {
+        if (part.type === "text")
+            return part.text;
+        if (part.type === "tool_call")
+            return `${part.name} ${JSON.stringify(part.input)}`;
+        if (part.type === "image")
+            return `[immagine ${part.mime}]`;
+        return part.output;
+    })
+        .join("\n");
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+// Termini per l'INDICE: niente duplicati, niente STOP, niente rumore (deve
+// contenere almeno una lettera -> scarta ".", numeri puri, punteggiatura).
+function cleanTerms(values) {
+    return [...new Set(values
+            // Togli la punteggiatura ai BORDI (mantieni i punti interni: "prova.txt")
+            // cosi' "directory." -> "directory", "prosa." -> "prosa" (poi STOP filtra).
+            .map((t) => t.trim().toLowerCase().replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, ""))
+            .filter((t) => t.length >= 2 && /[a-z]/.test(t) && !STOP.has(t)))];
+}
+function baseName(p) {
+    const parts = p.split(/[\\/]/).filter(Boolean);
+    return parts[parts.length - 1] ?? p;
+}
+function firstLine(s) {
+    return (s.split("\n")[0] ?? "").trim();
+}
+function oneLine(value) {
+    // Strip ANSI/byte di controllo PRIMA di collassare gli spazi: cosi' i
+    // "caratteri strani" da output di tool non entrano in title/body/output.
+    return sanitizeText(value).replace(/\s+/g, " ").trim();
+}
+function escapeValue(value) {
+    return oneLine(value).replace(/"/g, "'");
+}
+function clampBody(s) {
+    return s.length > MAX_BODY ? s.slice(0, MAX_BODY) + "\n...[troncato]" : s;
+}