@vascend/talos 0.1.0

package/dist/core/prompt-attachment.js

@@ -0,0 +1,123 @@
+// Logica di invio del prompt con allegati immagine.
+//
+// L'utente compone un messaggio con dei placeholder testuali "img #N" (li
+// inserisce la UI di terminale). Quando il prompt parte,
+// questi placeholder vanno risolti nei path reali dei file immagine catturati,
+// i bytes vanno riletti dal disco e inclusi nel payload inviato al modello come
+// parti immagine (ImagePart, base64 + mime).
+//
+// Questo modulo NON conosce SessionRefManager direttamente: si appoggia a una
+// piccola interfaccia RefResolver (resolvePath/expand) che combacia con l'API
+// pubblica annunciata da session-ref-manager. Cosi' resta disaccoppiato e
+// testabile, e a merge avvenuto il vero SessionRefManager lo soddisfa.
+//
+// Zero dipendenze a runtime: lettura file via fs nativo, base64 via Buffer.
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+const defaultReader = async (path) => readFile(path);
+// Pattern di un placeholder "img #N": "img" + spazi opzionali + "#" + spazi
+// opzionali + numero. Case-insensitive, globale.
+const REF_RE = /img\s*#\s*\d+/gi;
+// Normalizza un'occorrenza grezza ("IMG  #  3") nell'etichetta canonica usata
+// dal resolver ("img #3").
+export function normalizeRef(raw) {
+    const n = raw.replace(/[^\d]/g, "");
+    return `img #${n}`;
+}
+// Estrae, in ordine di apparizione e SENZA duplicati, le etichette canoniche
+// "img #N" presenti nel testo.
+export function extractRefs(text) {
+    const out = [];
+    const seen = new Set();
+    for (const m of text.matchAll(REF_RE)) {
+        const label = normalizeRef(m[0]);
+        if (!seen.has(label)) {
+            seen.add(label);
+            out.push(label);
+        }
+    }
+    return out;
+}
+// MIME del media dedotto dall'estensione del file. Copre i formati immagine
+// supportati dai provider (Anthropic: png/jpeg/webp/gif). Default png.
+const MIME_BY_EXT = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+export function mimeFromPath(path) {
+    return MIME_BY_EXT[extname(path).toLowerCase()] ?? "image/png";
+}
+const DEFAULT_MAX_TOTAL = 16 * 1024 * 1024; // 16 MB
+// Costruisce le parti del prompt a partire dal testo utente: risolve i
+// placeholder "img #N" nei path via il resolver, rilegge i bytes di ciascun
+// file e produce un TextPart (testo originale invariato) + un ImagePart per
+// ogni immagine risolta e leggibile.
+//
+// Il testo NON viene mutato: i placeholder restano leggibili nel testo (sono
+// gia' un riferimento umano), mentre i bytes viaggiano come parti separate. Il
+// modello vede sia il testo con "img #N" sia le immagini corrispondenti.
+export async function buildPrompt(text, refs, opts = {}) {
+    const reader = opts.reader ?? defaultReader;
+    const maxTotal = opts.maxTotalBytes ?? DEFAULT_MAX_TOTAL;
+    const labels = extractRefs(text);
+    const attached = [];
+    const missing = [];
+    const unreadable = [];
+    const images = [];
+    let used = 0;
+    for (const label of labels) {
+        const path = refs.resolvePath(label);
+        if (!path) {
+            missing.push(label);
+            continue;
+        }
+        let bytes;
+        try {
+            bytes = await reader(path);
+        }
+        catch {
+            unreadable.push(label);
+            continue;
+        }
+        if (!bytes.length || used + bytes.length > maxTotal) {
+            unreadable.push(label);
+            continue;
+        }
+        used += bytes.length;
+        images.push({
+            type: "image",
+            data: Buffer.from(bytes).toString("base64"),
+            mime: mimeFromPath(path),
+            source: path,
+        });
+        attached.push(label);
+    }
+    const parts = [];
+    // Il testo resta sempre presente (anche vuoto se l'utente ha mandato solo
+    // immagini: in tal caso lo omettiamo per non inviare un blocco testo vuoto).
+    const trimmed = text.trim();
+    if (trimmed.length) {
+        const textPart = { type: "text", text };
+        parts.push(textPart);
+    }
+    for (const img of images)
+        parts.push(img);
+    // Se non c'e' ne' testo ne' immagini, garantisci almeno un blocco testo
+    // (vuoto) per non produrre un messaggio senza contenuto.
+    if (!parts.length)
+        parts.push({ type: "text", text });
+    return { parts, attached, missing, unreadable };
+}
+// Comodo per chi vuole solo il path espanso nel testo (diagnostica/log): usa
+// expand() del resolver se disponibile, altrimenti sostituisce via resolvePath.
+export function expandRefsInText(text, refs) {
+    if (refs.expand)
+        return refs.expand(text);
+    return text.replace(REF_RE, (raw) => {
+        const label = normalizeRef(raw);
+        return refs.resolvePath(label) ?? raw;
+    });
+}

package/dist/core/request-plan.d.ts

@@ -0,0 +1,16 @@
+import { type ContextLedger, type ContextLedgerInput } from "./context-ledger.js";
+import type { CompletionRequest, Usage } from "./types.js";
+export interface RequestPlan {
+    readonly request: CompletionRequest;
+    readonly ledger: ContextLedger;
+    readonly fits: boolean;
+    readonly estimatedInputTokens: number;
+    readonly calibration: number;
+}
+/** One request object feeds both the provider and its context accounting. */
+export declare class RequestBudget {
+    private factor;
+    plan(request: CompletionRequest, metadata: ContextLedgerInput): RequestPlan;
+    /** Providers normalize inputTokens as uncached input; cached input is separate. */
+    observe(usage: Usage | undefined, estimate: number): void;
+}

package/dist/core/request-plan.js

@@ -0,0 +1,36 @@
+import { buildContextLedger } from "./context-ledger.js";
+import { resolveMaxTokens } from "./model-limits.js";
+/** One request object feeds both the provider and its context accounting. */
+export class RequestBudget {
+    factor = 1;
+    plan(request, metadata) {
+        const requestedOutput = resolveMaxTokens(request.maxTokens, request.model);
+        const declared = metadata.turnBlocks ?? [];
+        const turnBlocks = declared.map((block) => block.text ?? "").join("\n\n") === (request.turnContext ?? "")
+            ? declared : request.turnContext ? [{ key: "turn", label: "Contesto operativo", text: request.turnContext, cacheable: false }] : [];
+        const ledger = buildContextLedger({
+            ...metadata, model: request.model, system: request.system,
+            tools: request.tools, messages: request.messages, turnBlocks,
+            reserveTokens: Math.max(metadata.reserveTokens ?? 0, requestedOutput),
+        });
+        const estimatedInputTokens = Math.ceil(ledger.tokens * this.factor);
+        const available = Math.max(0, ledger.window - estimatedInputTokens);
+        const maxTokens = Math.min(requestedOutput, available);
+        const fits = maxTokens >= Math.min(requestedOutput, 1024);
+        return {
+            request: { ...request, maxTokens }, ledger: { ...ledger,
+                admission: { estimatedInputTokens, calibration: this.factor, outputTokens: maxTokens, fits } }, fits,
+            estimatedInputTokens, calibration: this.factor,
+        };
+    }
+    /** Providers normalize inputTokens as uncached input; cached input is separate. */
+    observe(usage, estimate) {
+        if (!usage || estimate <= 0)
+            return;
+        const actual = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+        if (!Number.isFinite(actual) || actual <= 0)
+            return;
+        // Underestimates matter for admission; a cheap turn must not erase the margin.
+        this.factor = Math.max(this.factor, Math.min(3, actual / estimate));
+    }
+}

package/dist/core/run-timing.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent, Provider } from "./types.js";
+export declare class RunTiming {
+    private fd?;
+    private readonly runId;
+    private readonly started;
+    private boundary;
+    private requests;
+    private completed;
+    private readonly active;
+    constructor(sessionDir: string, sessionId: string, env: NodeJS.ProcessEnv);
+    private record;
+    private close;
+    provider(provider: Provider): Provider;
+    wait<T>(kind: "permission" | "question", action: () => Promise<T>): Promise<T>;
+    event(event: AgentEvent): void;
+    finish(aborted: boolean, failed: boolean): void;
+}

package/dist/core/run-timing.js

@@ -0,0 +1,123 @@
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { validateSessionId } from "./session.js";
+// Local metadata only: no prompts, commands, answers, reasoning or tool output.
+// Spans overlap (nested tools and permissions); durations must not be summed.
+export class RunTiming {
+    fd;
+    runId = randomUUID();
+    started = performance.now();
+    boundary = this.started;
+    requests = 0;
+    completed = false;
+    active = new Map();
+    constructor(sessionDir, sessionId, env) {
+        if (/^(0|off|false)$/i.test(env["TALOS_TIMING"] ?? ""))
+            return;
+        try {
+            const directory = join(sessionDir, "timing");
+            mkdirSync(directory, { recursive: true });
+            if (lstatSync(directory).isSymbolicLink())
+                return;
+            const path = join(directory, `${validateSessionId(sessionId)}.jsonl`);
+            if (existsSync(path) && lstatSync(path).isSymbolicLink())
+                return;
+            this.fd = openSync(path, "a", 0o600);
+            this.record("run_start", {});
+        }
+        catch { /* diagnostics must never prevent work */ }
+    }
+    record(event, fields) {
+        if (this.fd === undefined)
+            return;
+        try {
+            writeSync(this.fd, JSON.stringify({ version: 1, runId: this.runId, at: Date.now(), event, ...fields }) + "\n");
+        }
+        catch {
+            this.close();
+        }
+    }
+    close() {
+        if (this.fd === undefined)
+            return;
+        try {
+            closeSync(this.fd);
+        }
+        catch { /* already unavailable */ }
+        this.fd = undefined;
+    }
+    provider(provider) {
+        return { ...provider, id: provider.id, models: provider.models, supportsFastMode: provider.supportsFastMode, complete: async (request) => {
+                const started = performance.now();
+                const index = ++this.requests;
+                this.record("prepare_end", { request: index, durationMs: started - this.boundary });
+                this.record("provider_start", { request: index, provider: provider.id, model: request.model, effort: request.effort ?? "" });
+                let first = false;
+                const firstOutput = (kind, nonempty) => {
+                    if (first || !nonempty)
+                        return;
+                    first = true;
+                    this.record("provider_first_output", { request: index, kind, durationMs: performance.now() - started });
+                };
+                try {
+                    const result = await provider.complete({ ...request,
+                        onDelta: delta => { firstOutput("text", Boolean(delta)); request.onDelta?.(delta); },
+                        onReasoning: delta => { firstOutput("reasoning", Boolean(delta)); request.onReasoning?.(delta); },
+                        onToolDelta: event => { firstOutput("tool", Boolean(event.delta)); request.onToolDelta?.(event); },
+                    });
+                    this.record("provider_end", { request: index, durationMs: performance.now() - started,
+                        stopReason: result.stopReason, calls: result.toolCalls.length, usage: result.usage });
+                    return result;
+                }
+                catch (error) {
+                    this.record("provider_end", { request: index, durationMs: performance.now() - started,
+                        stopReason: request.signal.aborted ? "aborted" : "exception" });
+                    throw error;
+                }
+                finally {
+                    this.boundary = performance.now();
+                }
+            } };
+    }
+    async wait(kind, action) {
+        const started = performance.now();
+        const id = randomUUID();
+        this.record("wait_start", { kind, id });
+        try {
+            const result = await action();
+            this.record("wait_end", { kind, id, durationMs: performance.now() - started,
+                outcome: result === false || result === null ? "declined_or_unanswered" : "returned" });
+            return result;
+        }
+        catch (error) {
+            this.record("wait_end", { kind, id, durationMs: performance.now() - started, outcome: "exception" });
+            throw error;
+        }
+    }
+    event(event) {
+        if (event.type === "done")
+            this.completed = true;
+        if (event.type === "tool_call") {
+            const key = `${event.parentId ?? ""}:${event.call.id}`;
+            this.active.set(key, performance.now());
+            this.record("tool_start", { request: this.requests, id: event.call.id, parentId: event.parentId, tool: event.call.name });
+        }
+        else if (event.type === "tool_result") {
+            const key = `${event.parentId ?? ""}:${event.result.callId}`;
+            const started = this.active.get(key);
+            this.active.delete(key);
+            this.record("tool_end", { request: this.requests, id: event.result.callId, parentId: event.parentId,
+                ...(started !== undefined ? { durationMs: performance.now() - started } : {}), isError: event.result.isError === true });
+            if (!event.parentId)
+                this.boundary = performance.now();
+        }
+    }
+    finish(aborted, failed) {
+        this.record("run_end", { durationMs: performance.now() - this.started, requests: this.requests,
+            outcome: aborted ? "aborted" : failed ? "exception" : this.completed ? "completed" : "incomplete",
+            unfinishedTools: this.active.size });
+        this.active.clear();
+        this.close();
+    }
+}

package/dist/core/self-update.d.ts

@@ -0,0 +1,17 @@
+import { type TalosUpdate } from "./update-check.js";
+import { type UpdateRunner } from "./update-process.js";
+export declare const TALOS_INSTALL_ROOT: string;
+export type UpdateFailure = "unsupported" | "modified" | "diverged" | "version" | "download" | "build" | "install";
+export type UpdateResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: UpdateFailure;
+    readonly changed: boolean;
+};
+export declare function installTalosUpdate(update: TalosUpdate, options: {
+    readonly env: NodeJS.ProcessEnv;
+    readonly root?: string;
+    readonly run?: UpdateRunner;
+    readonly bun?: string;
+}): Promise<UpdateResult>;

package/dist/core/self-update.js

@@ -0,0 +1,54 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseUpdateVersion, TALOS_REPOSITORY } from "./update-check.js";
+import { runUpdateCommand } from "./update-process.js";
+import { installPackageUpdate } from "./package-update.js";
+export const TALOS_INSTALL_ROOT = fileURLToPath(new URL("../../", import.meta.url));
+export async function installTalosUpdate(update, options) {
+    const root = options.root ?? TALOS_INSTALL_ROOT;
+    const run = options.run ?? runUpdateCommand;
+    const env = { ...options.env, GIT_TERMINAL_PROMPT: "0" };
+    const git = (...args) => run({ command: "git", args, cwd: root, env, timeoutMs: 30_000 });
+    const target = parseUpdateVersion(update.tag);
+    if (!target || target.prerelease || target.version !== update.version) {
+        return { ok: false, reason: "version", changed: false };
+    }
+    if (!existsSync(join(root, ".git")))
+        return installPackageUpdate(update, { root, env: options.env, run });
+    let changed = false;
+    try {
+        const origin = await git("remote", "get-url", "origin");
+        const official = new RegExp(`^(?:https://github\\.com/|git@github\\.com:|ssh://git@github\\.com/)${TALOS_REPOSITORY}(?:\\.git)?/?$`, "i");
+        if (!official.test(origin))
+            return { ok: false, reason: "unsupported", changed: false };
+        if (await git("status", "--porcelain", "--untracked-files=normal")) {
+            return { ok: false, reason: "modified", changed: false };
+        }
+        await git("fetch", "--no-tags", "origin", `refs/tags/${update.tag}`);
+        const commit = await git("rev-parse", "--verify", "FETCH_HEAD^{commit}");
+        if (!/^[a-f0-9]{40,64}$/.test(commit))
+            return { ok: false, reason: "version", changed: false };
+        const pkg = JSON.parse(await git("show", `${commit}:package.json`));
+        if (pkg.name !== "@vascend/talos" || pkg.version !== update.version) {
+            return { ok: false, reason: "version", changed: false };
+        }
+        try {
+            await git("merge-base", "--is-ancestor", "HEAD", commit);
+        }
+        catch {
+            return { ok: false, reason: "diverged", changed: false };
+        }
+        // Refuse dirty/diverged checkouts; never reset, stash or discard local work.
+        await git("merge", "--ff-only", commit);
+        changed = true;
+        const bun = options.bun ?? (process.versions.bun ? process.execPath : process.platform === "win32" ? "bun.exe" : "bun");
+        for (const args of [["install", "--frozen-lockfile"], ["run", "install:cli"]]) {
+            await run({ command: bun, args, cwd: root, env, inherit: true, timeoutMs: 300_000 });
+        }
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, reason: changed ? "build" : "download", changed };
+    }
+}

package/dist/core/session-refs.d.ts

@@ -0,0 +1,27 @@
+export interface SessionRef {
+    readonly id: string;
+    readonly index: number;
+    readonly path: string;
+    readonly kind: string;
+}
+export declare function refLabel(kind: string, index: number): string;
+export declare function parseRefLabel(label: string): {
+    kind: string;
+    index: number;
+} | null;
+export declare class SessionRefManager {
+    private readonly byPath;
+    private readonly byId;
+    private readonly counters;
+    register(path: string, kind?: string): SessionRef;
+    resolve(id: string): SessionRef | undefined;
+    resolvePath(id: string): string | undefined;
+    lookup(path: string, kind?: string): SessionRef | undefined;
+    has(id: string): boolean;
+    get size(): number;
+    list(): readonly SessionRef[];
+    expand(text: string): string;
+    reset(): void;
+    toJSON(): readonly SessionRef[];
+    static fromJSON(refs: readonly SessionRef[]): SessionRefManager;
+}

package/dist/core/session-refs.js

@@ -0,0 +1,126 @@
+// Gestore di riferimenti per sessione: assegna a ogni allegato un
+// identificatore progressivo leggibile (img #1, img #2, ...) e mantiene una
+// mappa id->path valida per la sessione corrente. Serve a referenziare gli
+// allegati nel testo (es. "vedi img #2") risolvendoli poi al path reale.
+//
+// Zero dipendenze, stato incapsulato. La mappa e' append-only nell'arco di
+// una sessione: gli id non vengono mai riusati finche' non si chiama reset().
+// Prefisso di default per gli allegati immagine.
+const DEFAULT_KIND = "img";
+// Costruisce l'etichetta leggibile a partire da tipo e indice: "img #1".
+export function refLabel(kind, index) {
+    return `${kind} #${index}`;
+}
+// Estrae (kind, index) da un'etichetta "img #2", o null se non valida.
+export function parseRefLabel(label) {
+    const m = /^(\w[\w-]*)\s*#(\d+)$/.exec(label.trim());
+    if (!m)
+        return null;
+    const index = Number.parseInt(m[2], 10);
+    if (!Number.isFinite(index) || index < 1)
+        return null;
+    return { kind: m[1], index };
+}
+// Gestore della mappa id<->path per una singola sessione. Lo stato e'
+// incapsulato; i metodi mutano lo stato interno ma ritornano sempre nuovi
+// oggetti SessionRef (immutabili) verso l'esterno.
+export class SessionRefManager {
+    // path -> ref gia' registrato (dedup: lo stesso path riusa lo stesso id).
+    byPath = new Map();
+    // id leggibile (es. "img #1") -> ref.
+    byId = new Map();
+    // Contatore progressivo per tipo: garantisce numerazione indipendente per
+    // ogni kind ("img #1", "img #2", "file #1", ...).
+    counters = new Map();
+    // Registra un allegato e ritorna il suo riferimento. Se il path e' gia'
+    // noto (stesso kind), ritorna il riferimento esistente senza crearne uno
+    // nuovo (dedup), cosi' lo stesso allegato mantiene un id stabile.
+    register(path, kind = DEFAULT_KIND) {
+        const key = dedupKey(kind, path);
+        const existing = this.byPath.get(key);
+        if (existing)
+            return existing;
+        const index = (this.counters.get(kind) ?? 0) + 1;
+        this.counters.set(kind, index);
+        const ref = {
+            id: refLabel(kind, index),
+            index,
+            path,
+            kind,
+        };
+        this.byPath.set(key, ref);
+        this.byId.set(ref.id, ref);
+        return ref;
+    }
+    // Risolve un'etichetta (es. "img #2") al riferimento, o undefined se ignota.
+    resolve(id) {
+        return this.byId.get(id.trim());
+    }
+    // Risolve un'etichetta direttamente al path, o undefined.
+    resolvePath(id) {
+        return this.byId.get(id.trim())?.path;
+    }
+    // Ritorna il riferimento gia' associato a un path (stesso kind), o undefined.
+    lookup(path, kind = DEFAULT_KIND) {
+        return this.byPath.get(dedupKey(kind, path));
+    }
+    // True se l'etichetta e' un riferimento noto in questa sessione.
+    has(id) {
+        return this.byId.has(id.trim());
+    }
+    // Numero di riferimenti registrati.
+    get size() {
+        return this.byId.size;
+    }
+    // Tutti i riferimenti nell'ordine di registrazione (per kind, poi indice).
+    list() {
+        return [...this.byId.values()].sort((a, b) => {
+            if (a.kind !== b.kind)
+                return a.kind < b.kind ? -1 : 1;
+            return a.index - b.index;
+        });
+    }
+    // Sostituisce nel testo ogni etichetta nota con il path risolto. Utile per
+    // espandere "vedi img #1" nel path reale prima dell'invio al modello.
+    // Le etichette ignote restano invariate.
+    expand(text) {
+        return text.replace(/(\w[\w-]*)\s*#(\d+)/g, (whole) => {
+            const ref = this.byId.get(normalizeLabel(whole));
+            return ref ? ref.path : whole;
+        });
+    }
+    // Azzera la mappa: nuova sessione, gli id ripartono da #1.
+    reset() {
+        this.byPath.clear();
+        this.byId.clear();
+        this.counters.clear();
+    }
+    // Serializza lo stato per la persistenza (snapshot della sessione).
+    toJSON() {
+        return this.list();
+    }
+    // Ricostruisce un gestore da uno snapshot serializzato, ripristinando i
+    // contatori al massimo indice visto per ciascun kind.
+    static fromJSON(refs) {
+        const mgr = new SessionRefManager();
+        for (const ref of refs) {
+            const key = dedupKey(ref.kind, ref.path);
+            mgr.byPath.set(key, ref);
+            mgr.byId.set(ref.id, ref);
+            const cur = mgr.counters.get(ref.kind) ?? 0;
+            if (ref.index > cur)
+                mgr.counters.set(ref.kind, ref.index);
+        }
+        return mgr;
+    }
+}
+// Chiave di dedup: combina kind e path cosi' lo stesso path con kind diversi
+// resta distinto.
+function dedupKey(kind, path) {
+    return `${kind}\u0000${path}`;
+}
+// Normalizza un'etichetta grezza ("img  #2") nella forma canonica ("img #2").
+function normalizeLabel(raw) {
+    const parsed = parseRefLabel(raw);
+    return parsed ? refLabel(parsed.kind, parsed.index) : raw.trim();
+}

package/dist/core/session-storage.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareSessionStorage(config: {
+    readonly cwd: string;
+    readonly sessionDir: string;
+}, env: NodeJS.ProcessEnv): void;

package/dist/core/session-storage.js

@@ -0,0 +1,48 @@
+import { cpSync, existsSync, lstatSync, writeFileSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { defaultSessionDir } from "./env-paths.js";
+import { withLockSync } from "../vascend/file-lock.js";
+// Importa una sola volta lo store storico prima di resume/continue. Gli
+// originali restano disponibili anche per processi avviati con la vecchia
+// versione. Gli override espliciti continuano a usare il proprio store.
+export function prepareSessionStorage(config, env) {
+    const destination = defaultSessionDir(config.cwd, env);
+    if (resolve(config.sessionDir) !== destination)
+        return;
+    const legacy = join(config.cwd, ".talos", "sessions");
+    const marker = join(destination, ".legacy-import.json");
+    if (!existsSync(legacy) || existsSync(marker))
+        return;
+    // Non importare directory reindirizzate fuori dal progetto.
+    if (lstatSync(join(config.cwd, ".talos")).isSymbolicLink()
+        || lstatSync(legacy).isSymbolicLink() || !lstatSync(legacy).isDirectory())
+        return;
+    // Un override TALOS_CONFIG_DIR dentro lo store storico non va ricopiato
+    // ricorsivamente su se stesso.
+    const destinationRelative = relative(legacy, destination);
+    if (!destinationRelative || (destinationRelative !== ".." && !destinationRelative.startsWith(`..${sep}`) && !isAbsolute(destinationRelative))) {
+        throw new Error("TALOS_CONFIG_DIR non puo' collocare le sessioni dentro lo store storico");
+    }
+    withLockSync(marker, () => {
+        if (existsSync(marker))
+            return;
+        cpSync(legacy, destination, {
+            recursive: true,
+            force: false,
+            preserveTimestamps: true,
+            filter: (source, target) => {
+                const name = basename(source);
+                if (name.endsWith(".lock") || name.endsWith(".tmp") || name === ".legacy-import.json")
+                    return false;
+                const stat = lstatSync(source);
+                if (stat.isSymbolicLink() || (!stat.isDirectory() && !stat.isFile()))
+                    return false;
+                if (existsSync(target) && lstatSync(target).isSymbolicLink()) {
+                    throw new Error(`Importazione sessioni: destinazione simbolica non ammessa: ${target}`);
+                }
+                return true;
+            },
+        });
+        writeFileSync(marker, JSON.stringify({ version: 1, source: legacy, importedAt: Date.now() }), { mode: 0o600 });
+    }, { staleMs: 300_000, timeoutMs: 30_000 });
+}

package/dist/core/session-title.d.ts

@@ -0,0 +1 @@
+export declare function sessionTitle(source: string): string;

package/dist/core/session-title.js

@@ -0,0 +1,21 @@
+import { stripVTControlCharacters } from "node:util";
+// Display-only cleanup for old prompts wrapped in the Danilov notation.
+// Never changes the persisted messages or the context sent to the model.
+export function sessionTitle(source) {
+    const lines = stripVTControlCharacters(source).split(/\r?\n/).map(line => line.trim().replace(/^#{1,6}\s+/, ""));
+    const goal = /^(?:GOAL|OBIETTIVO(?:_ATTIVITA|_CASTELLO)?)\s*[:=]\s*(.*)$/i;
+    const clean = (line) => line.replace(/\s+(?:MODE|CHECKPOINT(?:_PRECEDENTE)?|INDICE|OUTPUT)\s*[:=].*$/i, "").replace(/\s+/g, " ").trim().slice(0, 100);
+    for (const line of lines) {
+        const match = goal.exec(line);
+        if (match?.[1]?.trim())
+            return clean(match[1]);
+    }
+    for (const line of lines) {
+        if (!line || /^[\[@<]|^```|^\d+\s*=/.test(line))
+            continue;
+        if (/^(?:INDICE(?:_MEMORIA)?|INDEX|DEFINIZIONI|DEFINITIONS|RELAZIONI|RELATIONS|OUTPUT|GOAL|OBIETTIVO|MODE|CHECKPOINT(?:_PRECEDENTE)?|ATTIVITA_ARCHIVIATE)(?:\s*[:=\d].*|\s*)$/i.test(line))
+            continue;
+        return clean(line);
+    }
+    return "";
+}

package/dist/core/session-usage.d.ts

@@ -0,0 +1,17 @@
+import type { EventSink, PlanLimits, Provider, Usage } from "./types.js";
+export interface SessionUsageRecord {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly model: string;
+    readonly providerId: string;
+    readonly at: number;
+    readonly usage?: Usage;
+    readonly limits?: PlanLimits;
+    readonly actor?: string;
+}
+export declare function saveSessionUsage(base: string, sessionId: string, record: SessionUsageRecord): boolean;
+export declare function readSessionUsage(base: string, sessionId: string): {
+    records: SessionUsageRecord[];
+    incomplete: boolean;
+};
+export declare function trackSessionUsage(provider: Provider, base: string, sessionId: string, sink: EventSink): Provider;