@vascend/talos 0.1.0

package/dist/core/tool-result-index.js

@@ -0,0 +1,327 @@
+// Retrocessione dei tool result vecchi a RIFERIMENTO richiamabile.
+//
+// I risultati degli strumenti sono la voce che cresce in modo monotono nella
+// finestra: ogni lettura aggiunge token che nessun meccanismo toglie piu'. La
+// compattazione interviene solo al limite della finestra e riassume TUTTO
+// (perdendo il testo esatto); la compressione content-aware non tocca i tool di
+// contenuto, giustamente. Nel mezzo non c'era niente.
+//
+// Qui il mezzo: quando la massa verbatim dei risultati supera una soglia, i piu'
+// VECCHI vengono sostituiti — solo nella proiezione inviata al modello, non nella
+// sessione su disco — da una riga che dice cosa erano, quanto pesavano, come si
+// recuperano e con le prime righe come promemoria.
+//
+// Due vincoli non negoziabili, entrambi imposti qui:
+//  1. si retrocede SOLO cio' che e' stato archiviato: senza id recuperabile
+//     sarebbe perdita di informazione, non gestione del contesto;
+//  2. si interviene A SCATTI con isteresi, non a ogni turno: riscrivere un
+//     messaggio vecchio invalida la cache del prefisso da quel punto in avanti,
+//     quindi la retrocessione deve essere un evento raro che libera molto (la
+//     stessa economia della compattazione).
+//
+// Modulo PURO: nessun IO. L'archivio arriva come funzione `archivedId`.
+import { estimateTokens } from "./compaction.js";
+export const DEFAULT_TOOL_INDEX = {
+    enabled: true,
+    triggerTokens: 24_000,
+    keepTokens: 8_000,
+    keepRecent: 4,
+    minTokens: 150,
+};
+// Quote della finestra di contesto destinate ai risultati verbatim. Le soglie
+// fisse (24k/8k) erano tarate su finestre da 128-200k: su un modello da 1M
+// significavano tenere verbatim lo 0,8% del disponibile, cioe' meno del working
+// set di un compito normale. Misurato in sessione: 80 tool call, 48 read_file su
+// tre file e ZERO edit — il modello non "esplorava troppo", ricostruiva a ogni
+// turno un contesto che gli veniva tolto sotto i piedi, e non arrivava mai
+// all'azione. Le quote valgono come PAVIMENTO sui default storici: nessun
+// modello piccolo peggiora.
+const TRIGGER_SHARE = 0.12;
+const KEEP_SHARE = 0.06;
+export function toolIndexPolicy(env, contextWindow = 0) {
+    const flag = (env["TALOS_TOOL_INDEX"] ?? "").trim().toLowerCase();
+    const enabled = !(flag === "0" || flag === "off" || flag === "false" || flag === "no");
+    const positive = (raw, fallback) => {
+        const n = Number(raw);
+        return Number.isFinite(n) && n > 0 ? Math.trunc(n) : fallback;
+    };
+    const window = Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : 0;
+    const scaledTrigger = window ? Math.max(DEFAULT_TOOL_INDEX.triggerTokens, Math.round(window * TRIGGER_SHARE)) : DEFAULT_TOOL_INDEX.triggerTokens;
+    const scaledKeep = window ? Math.max(DEFAULT_TOOL_INDEX.keepTokens, Math.round(window * KEEP_SHARE)) : DEFAULT_TOOL_INDEX.keepTokens;
+    const trigger = positive(env["TALOS_TOOL_INDEX_TRIGGER"], scaledTrigger);
+    const keep = positive(env["TALOS_TOOL_INDEX_KEEP"], scaledKeep);
+    return {
+        enabled,
+        triggerTokens: trigger,
+        // Un tetto piu' alto della soglia renderebbe l'intervento un no-op.
+        keepTokens: Math.min(keep, Math.max(1, trigger - 1)),
+        keepRecent: positive(env["TALOS_TOOL_INDEX_KEEP_RECENT"], DEFAULT_TOOL_INDEX.keepRecent),
+        minTokens: positive(env["TALOS_TOOL_INDEX_MIN"], DEFAULT_TOOL_INDEX.minTokens),
+    };
+}
+export const EMPTY_PLAN = { refs: [], freedTokens: 0, verbatimTokens: 0 };
+// Decide COSA retrocedere. Deterministico: a parita' di cronologia e archivio,
+// stesso piano.
+export function planToolResultDemotion(input) {
+    const { policy } = input;
+    if (!policy.enabled)
+        return EMPTY_PLAN;
+    const names = toolNames(input.messages);
+    // In ordine di apparizione: i primi sono i piu' vecchi.
+    const candidates = [];
+    let verbatimTokens = 0;
+    let seen = 0;
+    const results = [];
+    for (const message of input.messages) {
+        for (const part of message.content) {
+            if (part.type !== "tool_result")
+                continue;
+            if (isDemoted(part.output))
+                continue;
+            results.push({ part, tokens: estimateTokens(part.output) });
+        }
+    }
+    const lastKept = Math.max(0, results.length - Math.max(0, policy.keepRecent));
+    for (const { part, tokens } of results) {
+        verbatimTokens += tokens;
+        seen += 1;
+        if (seen > lastKept)
+            continue;
+        if (part.isError)
+            continue; // un errore e' corto e serve al recupero
+        if (tokens < policy.minTokens)
+            continue;
+        const storedId = input.archivedId(part.callId);
+        if (!storedId)
+            continue;
+        candidates.push({
+            callId: part.callId,
+            storedId,
+            name: names.get(part.callId) ?? "strumento",
+            tokens,
+            images: part.media?.length ?? 0,
+        });
+    }
+    const demotable = candidates.reduce((sum, ref) => sum + ref.tokens, 0);
+    if (demotable < policy.triggerTokens)
+        return { refs: [], freedTokens: 0, verbatimTokens };
+    // Si retrocede dal piu' vecchio, fermandosi appena la massa verbatim rientra
+    // sotto il tetto: cosi' il lavoro recente resta intatto.
+    const refs = [];
+    let remaining = verbatimTokens;
+    for (const ref of candidates) {
+        if (remaining <= policy.keepTokens)
+            break;
+        refs.push(ref);
+        remaining -= ref.tokens;
+    }
+    return {
+        refs,
+        freedTokens: refs.reduce((sum, ref) => sum + ref.tokens, 0),
+        verbatimTokens,
+    };
+}
+// Applica il piano: nuova lista di messaggi con i risultati retrocessi. La
+// sessione su disco NON viene toccata — la cronologia resta integrale, questa e'
+// solo la proiezione inviata al modello.
+export function applyToolResultDemotion(messages, plan) {
+    if (!plan.refs.length)
+        return messages;
+    const byCallId = new Map(plan.refs.map((ref) => [ref.callId, ref]));
+    return messages.map((message) => {
+        if (!message.content.some((part) => part.type === "tool_result" && byCallId.has(part.callId))) {
+            return message;
+        }
+        return {
+            ...message,
+            content: message.content.map((part) => {
+                if (part.type !== "tool_result")
+                    return part;
+                const ref = byCallId.get(part.callId);
+                if (!ref)
+                    return part;
+                // Le immagini allegate a un risultato vecchio se ne vanno con esso: uno
+                // screenshot di sei azioni fa costa 1400 token a ogni turno e lo stato
+                // che mostrava non esiste piu'. Il riferimento lo dichiara.
+                const { media: _media, ...rest } = part;
+                return { ...rest, output: demotedText(ref, part.output) };
+            }),
+        };
+    });
+}
+const MARKER = "[risultato archiviato";
+export function isDemoted(output) {
+    return output.startsWith(MARKER);
+}
+// La riga che sostituisce il corpo. Deve bastare a decidere SE recuperare:
+// quale strumento, quanto pesava, le prime righe, e la sintassi esatta del
+// recupero (senza di essa il modello inventa la chiamata).
+export function demotedText(ref, output) {
+    const head = firstLines(output, 2, 200);
+    const parts = [
+        `${MARKER} · ${ref.name} · ${output.length} caratteri (~${ref.tokens} token)`,
+        ...(head ? [`inizio: ${head}`] : []),
+        ...(ref.images ? [`${ref.images === 1 ? "1 immagine" : `${ref.images} immagini`} non piu' allegate: riacquisisci se servono`] : []),
+        `integrale: output_page id="${ref.storedId}" page=1`,
+    ];
+    return `${parts.join("\n")}]`;
+}
+function firstLines(text, lines, max) {
+    const head = String(text || "")
+        .split(/\r?\n/)
+        .filter((line) => line.trim())
+        .slice(0, lines)
+        .join(" / ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!head)
+        return "";
+    return head.length > max ? `${head.slice(0, max - 1)}…` : head;
+}
+// --- una sola copia dei byte nella sessione ----------------------------------
+//
+// Misurato su una sessione Computer Use reale: la STESSA immagine PNG compariva
+// TRE volte in ogni tool result — `media` (quella che va al modello), il blocco
+// MCP `content[image]` e `_meta` dell'host (quella della card in chat). 680 KB
+// diventavano 2 MB per schermata: 12,3 MB di sessione invece di 4, tutti
+// residenti nella memoria del processo che serve anche l'interfaccia e scritti
+// con un `appendFileSync` da 2 MB per riga.
+//
+// UI e client MCP hanno gia' ricevuto la loro copia nell'evento `tool_result`:
+// nella cronologia persistita non serve. Qui si tiene solo `media`.
+// Oltre questa lunghezza una stringa dentro `_meta` non e' un metadato: e' un
+// blob. La regola e' volutamente generica, cosi' vale per qualunque host.
+const META_BLOB_CHARS = 4_096;
+export function slimToolResultForSession(part) {
+    const content = part.content?.filter((block) => block.type !== "image");
+    const meta = part._meta ? stripBlobs(part._meta) : undefined;
+    const droppedContent = (part.content?.length ?? 0) !== (content?.length ?? 0);
+    if (!droppedContent && meta === part._meta)
+        return part;
+    const next = { ...part };
+    if (content && content.length)
+        next["content"] = content;
+    else
+        delete next["content"];
+    if (meta && Object.keys(meta).length)
+        next["_meta"] = meta;
+    else
+        delete next["_meta"];
+    return next;
+}
+export function slimMessageForSession(message) {
+    if (!message.content.some((part) => part.type === "tool_result"))
+        return message;
+    const content = message.content.map((part) => (part.type === "tool_result" ? slimToolResultForSession(part) : part));
+    // Niente da togliere, niente da copiare: la stessa istanza. Questa funzione
+    // gira su OGNI messaggio di tool, quindi il caso normale deve costare zero.
+    return content.every((part, index) => part === message.content[index]) ? message : { ...message, content };
+}
+// Rimuove ricorsivamente le stringhe-blob, lasciando una traccia leggibile.
+// Ritorna l'oggetto ORIGINALE quando non c'e' niente da togliere, cosi' il
+// chiamante puo' riconoscere il no-op per identita'.
+function stripBlobs(value) {
+    let changed = false;
+    const walk = (input) => {
+        if (typeof input === "string") {
+            if (input.length <= META_BLOB_CHARS)
+                return input;
+            changed = true;
+            return `[blob rimosso dalla cronologia: ${input.length} caratteri]`;
+        }
+        if (Array.isArray(input))
+            return input.map(walk);
+        if (input && typeof input === "object") {
+            const out = {};
+            for (const [key, item] of Object.entries(input))
+                out[key] = walk(item);
+            return out;
+        }
+        return input;
+    };
+    const result = walk(value);
+    return changed ? result : value;
+}
+export const DEFAULT_MEDIA_BUDGET = { enabled: true, keepImages: 2 };
+export function mediaBudgetPolicy(env) {
+    const flag = (env["TALOS_MEDIA_BUDGET"] ?? "").trim().toLowerCase();
+    const raw = Number(env["TALOS_MEDIA_KEEP"]);
+    return {
+        enabled: !(flag === "0" || flag === "off" || flag === "false" || flag === "no"),
+        keepImages: Number.isFinite(raw) && raw >= 0 ? Math.trunc(raw) : DEFAULT_MEDIA_BUDGET.keepImages,
+    };
+}
+export const EMPTY_MEDIA_PLAN = { callIds: [], images: 0, bytes: 0, totalImages: 0 };
+// Decide quali risultati perdono le immagini. Le immagini allegate DALL'UTENTE
+// non si toccano: le ha messe lui, e sono poche.
+export function planMediaEviction(input) {
+    if (!input.policy.enabled)
+        return EMPTY_MEDIA_PLAN;
+    const carriers = [];
+    for (const message of input.messages) {
+        for (const part of message.content) {
+            if (part.type !== "tool_result" || !part.media?.length)
+                continue;
+            carriers.push({
+                callId: part.callId,
+                images: part.media.length,
+                bytes: part.media.reduce((sum, image) => sum + image.data.length, 0),
+            });
+        }
+    }
+    const totalImages = carriers.reduce((sum, item) => sum + item.images, 0);
+    if (totalImages <= input.policy.keepImages)
+        return { ...EMPTY_MEDIA_PLAN, totalImages };
+    // Si tengono le PIU' RECENTI: sono lo stato su cui il modello sta decidendo.
+    const keep = new Set();
+    let kept = 0;
+    for (let index = carriers.length - 1; index >= 0 && kept < input.policy.keepImages; index -= 1) {
+        const carrier = carriers[index];
+        if (!carrier)
+            continue;
+        keep.add(carrier.callId);
+        kept += carrier.images;
+    }
+    const dropped = carriers.filter((carrier) => !keep.has(carrier.callId));
+    return {
+        callIds: dropped.map((carrier) => carrier.callId),
+        images: dropped.reduce((sum, carrier) => sum + carrier.images, 0),
+        bytes: dropped.reduce((sum, carrier) => sum + carrier.bytes, 0),
+        totalImages,
+    };
+}
+const MEDIA_NOTE = "[schermata non piu' allegata";
+export function applyMediaEviction(messages, plan) {
+    if (!plan.callIds.length)
+        return messages;
+    const drop = new Set(plan.callIds);
+    return messages.map((message) => {
+        if (!message.content.some((part) => part.type === "tool_result" && drop.has(part.callId) && part.media?.length)) {
+            return message;
+        }
+        return {
+            ...message,
+            content: message.content.map((part) => {
+                if (part.type !== "tool_result" || !drop.has(part.callId) || !part.media?.length)
+                    return part;
+                const kb = Math.round(part.media.reduce((sum, image) => sum + image.data.length, 0) / 1024);
+                const count = part.media.length;
+                const { media: _media, ...rest } = part;
+                const note = `${MEDIA_NOTE}: ${count === 1 ? "1 immagine" : `${count} immagini`}, ${kb} KB `
+                    + "rimossi dalla finestra perche' mostravano uno stato superato. Riacquisisci se serve rivedere.]";
+                return { ...rest, output: `${part.output}\n${note}` };
+            }),
+        };
+    });
+}
+// Mappa callId -> nome dello strumento che ha prodotto il risultato.
+function toolNames(messages) {
+    const names = new Map();
+    for (const message of messages) {
+        for (const part of message.content) {
+            if (part.type === "tool_call")
+                names.set(part.id, part.name);
+        }
+    }
+    return names;
+}

package/dist/core/tool-result-store.d.ts

@@ -0,0 +1,38 @@
+import type { ToolResultPart } from "./types.js";
+export interface StoredToolOutput {
+    readonly id: string;
+    readonly callId: string;
+    readonly name: string;
+    readonly chars: number;
+    readonly at: number;
+    readonly sha256?: string;
+}
+export declare class ToolOutputStore {
+    private readonly dir;
+    readonly scope: string;
+    private index;
+    private signature;
+    private constructor();
+    static open(sessionDir: string, sessionId: string): ToolOutputStore;
+    put(callId: string, name: string, output: string, result?: ToolResultPart): StoredToolOutput | null;
+    /**
+     * Lega un nuovo callId a un archivio GIA' esistente, senza creare un id ne'
+     * un file nuovi.
+     *
+     * Serve al recupero (`output_page` su un id `tr*`): il suo risultato e' una
+     * COPIA di qualcosa che l'archivio contiene gia'. Archiviandolo come nuovo si
+     * otteneva un `tr` nuovo a ogni recupero, che alla retrocessione successiva
+     * diventava un marker nuovo, che invitava un altro recupero: in una sessione
+     * reale sono state 52 chiamate output_page su 80, con i marker accodati in
+     * catena dentro lo stesso testo. Alias = il recupero e' idempotente e non
+     * genera mai una nuova esca.
+     */
+    alias(callId: string, id: string): StoredToolOutput | null;
+    byCallId(callId: string): StoredToolOutput | null;
+    entry(id: string): StoredToolOutput | null;
+    text(id: string): string | null;
+    result(id: string): ToolResultPart | null;
+    private refresh;
+    private writeIndex;
+    private read;
+}

package/dist/core/tool-result-store.js

@@ -0,0 +1,190 @@
+import { createHash } from "node:crypto";
+import { withLockSync } from "../vascend/file-lock.js";
+// Archivio su disco degli output degli strumenti.
+//
+// Un tool result entra nel contesto una volta e poi ci resta per sempre: la
+// cronologia e' append-only, quindi tre `read_file` da 5k token diventano 15k
+// token pagati a OGNI chiamata successiva, per il resto della conversazione.
+// Comprimere non basta (i tool di CONTENUTO sono giustamente esenti: il modello
+// ne vuole il testo verbatim) e troncare perde informazione.
+//
+// La via d'uscita e' l'indirizzabilita': l'output completo si archivia qui, con
+// un id corto e stabile, e nella finestra resta un riferimento richiamabile.
+// Niente e' perduto — `output_page` risolve l'id e restituisce il testo — quindi
+// la retrocessione e' reversibile su richiesta del modello.
+//
+// Store per SESSIONE, su disco: sopravvive al riavvio del processo host, che e'
+// il requisito che lo store di pagine in memoria non soddisfa.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+const EMPTY = { version: 1, nextSeq: 1, entries: {} };
+export class ToolOutputStore {
+    dir;
+    scope;
+    index = EMPTY;
+    signature = "";
+    constructor(dir, scope) {
+        this.dir = dir;
+        this.scope = scope;
+        this.index = this.read();
+    }
+    static open(sessionDir, sessionId) {
+        return new ToolOutputStore(join(sessionDir, "tool-outputs", sanitize(sessionId)), sessionId);
+    }
+    // Archivia un output. Idempotente per callId: un turno ripetuto (retry del
+    // provider, riparazione) non moltiplica i file ne' gli id.
+    put(callId, name, output, result) {
+        const key = sanitize(callId);
+        if (!key || !output)
+            return null;
+        try {
+            return withLockSync(join(this.dir, "index.json"), () => {
+                this.index = this.read(true);
+                const existing = this.index.entries[key];
+                if (existing)
+                    return existing;
+                const id = `tr${this.index.nextSeq}`;
+                writeFileSync(join(this.dir, `${id}.txt`), output, "utf8");
+                const entry = {
+                    id,
+                    callId: key,
+                    name: String(name || "strumento"),
+                    chars: output.length,
+                    at: Date.now(),
+                    sha256: createHash("sha256").update(output).digest("hex"),
+                };
+                this.index = {
+                    version: 1,
+                    nextSeq: this.index.nextSeq + 1,
+                    entries: { ...this.index.entries, [key]: entry },
+                };
+                if (result)
+                    writeFileSync(join(this.dir, id + ".json"), JSON.stringify(result), "utf8");
+                this.writeIndex();
+                return entry;
+            });
+        }
+        catch {
+            // L'archivio e' un acceleratore: se il disco non collabora, l'output resta
+            // verbatim nel contesto. Mai perdere contenuto per salvare token.
+            return null;
+        }
+    }
+    /**
+     * Lega un nuovo callId a un archivio GIA' esistente, senza creare un id ne'
+     * un file nuovi.
+     *
+     * Serve al recupero (`output_page` su un id `tr*`): il suo risultato e' una
+     * COPIA di qualcosa che l'archivio contiene gia'. Archiviandolo come nuovo si
+     * otteneva un `tr` nuovo a ogni recupero, che alla retrocessione successiva
+     * diventava un marker nuovo, che invitava un altro recupero: in una sessione
+     * reale sono state 52 chiamate output_page su 80, con i marker accodati in
+     * catena dentro lo stesso testo. Alias = il recupero e' idempotente e non
+     * genera mai una nuova esca.
+     */
+    alias(callId, id) {
+        const key = sanitize(callId);
+        if (!key)
+            return null;
+        try {
+            return withLockSync(join(this.dir, "index.json"), () => {
+                this.index = this.read(true);
+                const existing = this.index.entries[key];
+                if (existing)
+                    return existing;
+                const target = Object.values(this.index.entries).find((entry) => entry.id === id);
+                if (!target)
+                    return null;
+                const entry = { ...target, callId: key };
+                this.index = {
+                    ...this.index,
+                    entries: { ...this.index.entries, [key]: entry },
+                };
+                mkdirSync(this.dir, { recursive: true });
+                this.writeIndex();
+                return entry;
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    byCallId(callId) {
+        this.refresh();
+        return this.index.entries[sanitize(callId)] ?? null;
+    }
+    entry(id) {
+        this.refresh();
+        for (const value of Object.values(this.index.entries)) {
+            if (value.id === id)
+                return value;
+        }
+        return null;
+    }
+    text(id) {
+        if (!/^tr\d+$/.test(id))
+            return null;
+        try {
+            const path = join(this.dir, `${id}.txt`);
+            return existsSync(path) ? readFileSync(path, "utf8") : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    result(id) {
+        if (!/^tr\d+$/.test(id))
+            return null;
+        try {
+            return JSON.parse(readFileSync(join(this.dir, id + ".json"), "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    refresh() {
+        try {
+            const stat = statSync(join(this.dir, "index.json"));
+            const signature = stat.size + ":" + stat.mtimeMs + ":" + stat.ctimeMs;
+            if (signature !== this.signature) {
+                this.index = this.read();
+                this.signature = signature;
+            }
+        }
+        catch { /* keep the last readable index */ }
+    }
+    writeIndex() {
+        const path = join(this.dir, "index.json");
+        const temp = path + "." + process.pid + ".tmp";
+        writeFileSync(temp, JSON.stringify(this.index), "utf8");
+        renameSync(temp, path);
+        this.signature = "";
+    }
+    read(strict = false) {
+        try {
+            const path = join(this.dir, "index.json");
+            if (!existsSync(path))
+                return EMPTY;
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            if (!parsed || typeof parsed !== "object" || !parsed.entries || Array.isArray(parsed.entries))
+                throw new Error("indice output non valido");
+            const seq = Number(parsed.nextSeq);
+            const ids = Object.values(parsed.entries).map((entry) => /^tr(\d+)$/.exec(entry?.id ?? "")?.[1]).map(Number);
+            if (!Number.isInteger(seq) || seq <= 0 || ids.some((id) => !Number.isFinite(id) || id >= seq))
+                throw new Error("sequenza output non valida");
+            return {
+                version: 1,
+                nextSeq: Number.isFinite(seq) && seq > 0 ? Math.trunc(seq) : 1,
+                entries: parsed.entries,
+            };
+        }
+        catch (error) {
+            if (strict)
+                throw error;
+            return EMPTY;
+        }
+    }
+}
+function sanitize(value) {
+    return String(value || "").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120);
+}

package/dist/core/tool-scheduler.d.ts

@@ -0,0 +1,16 @@
+import type { ToolCallPart } from "./types.js";
+export declare function toolConcurrency(env: NodeJS.ProcessEnv): number;
+/**
+ * Finestre limitate di chiamate contigue e indipendenti. Ogni altra chiamata
+ * e' una barriera: parte solo dopo il completamento e il consumo degli esiti
+ * precedenti. Il consumer applica hook, archiviazione ed eventi in ordine.
+ * `run` deve restituire un esito anche per errori e chiamate annullate.
+ */
+export declare function scheduleToolCalls<T>(calls: readonly ToolCallPart[], options: {
+    readonly concurrency: number;
+    readonly parallel: (call: ToolCallPart) => boolean;
+    readonly run: (call: ToolCallPart) => Promise<T>;
+}): AsyncGenerator<{
+    readonly call: ToolCallPart;
+    readonly result: T;
+}>;

package/dist/core/tool-scheduler.js

@@ -0,0 +1,35 @@
+export function toolConcurrency(env) {
+    const raw = env["TALOS_TOOL_CONCURRENCY"];
+    if (!raw?.trim())
+        return 4;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 1 ? Math.min(16, Math.floor(value)) : 4;
+}
+/**
+ * Finestre limitate di chiamate contigue e indipendenti. Ogni altra chiamata
+ * e' una barriera: parte solo dopo il completamento e il consumo degli esiti
+ * precedenti. Il consumer applica hook, archiviazione ed eventi in ordine.
+ * `run` deve restituire un esito anche per errori e chiamate annullate.
+ */
+export async function* scheduleToolCalls(calls, options) {
+    const limit = Number.isFinite(options.concurrency)
+        ? Math.max(1, Math.min(16, Math.floor(options.concurrency))) : 1;
+    let cursor = 0;
+    while (cursor < calls.length) {
+        const start = cursor++;
+        if (limit > 1 && options.parallel(calls[start])) {
+            while (cursor < calls.length && cursor - start < limit && options.parallel(calls[cursor]))
+                cursor++;
+        }
+        // Anche un errore inatteso deve drenare il batch prima di propagarsi:
+        // nessun handler rimane abbandonato in background dal generatore.
+        const window = calls.slice(start, cursor);
+        const outcomes = await Promise.allSettled(window.map((call) => Promise.resolve().then(() => options.run(call))));
+        for (let index = 0; index < window.length; index++) {
+            const outcome = outcomes[index];
+            if (outcome.status === "rejected")
+                throw outcome.reason;
+            yield { call: window[index], result: outcome.value };
+        }
+    }
+}

package/dist/core/trust.d.ts

@@ -0,0 +1,21 @@
+export type TrustDecision = "trust" | "deny";
+export type DefaultProjectTrust = "ask" | "trust" | "deny";
+export declare function resourcesRequiringTrust(cwd: string): readonly string[];
+type TrustStore = Record<string, TrustDecision>;
+export declare function readTrustStore(env: NodeJS.ProcessEnv): TrustStore;
+export declare function writeTrustDecision(env: NodeJS.ProcessEnv, cwd: string, decision: TrustDecision): void;
+export declare function savedDecision(store: TrustStore, cwd: string): TrustDecision | undefined;
+export declare function parseDefaultTrust(value: string | undefined): DefaultProjectTrust;
+export interface TrustResolution {
+    readonly trusted: boolean;
+    readonly resources: readonly string[];
+    readonly persist: boolean;
+    readonly source: "default" | "stored" | "prompt";
+}
+export declare function resolveProjectTrust(opts: {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly defaultTrust: DefaultProjectTrust;
+    readonly prompt?: (resources: readonly string[]) => Promise<boolean>;
+}): Promise<TrustResolution>;
+export {};