@vascend/talos 0.1.0

package/dist/core/licenza.js

@@ -0,0 +1,125 @@
+// Prova di diritto offline (lato client) - porting TS di
+// vascend-terminal/src/main/licenza.js, per il cancello d'accesso di Talos.
+//
+// Il backend rilascia una prova firmata Ed25519 (vascend-agent-backend
+// app/licenza.py, GET /licenza/offline). Qui la si verifica SENZA rete, con la
+// sola chiave PUBBLICA compilata nell'app: si puo' controllare, non si puo'
+// fabbricare. E' la risposta alla domanda giusta: "e se uno si crea una
+// sessione fittizia e stacca la rete?" — senza la firma del server la prova
+// non vale, e senza rete non se ne ottiene una vera.
+//
+// La chiave pubblica sta nel codice e non si scarica: una chiave presa dalla
+// rete la puo' sostituire chi controlla la rete, ed e' esattamente l'attacco
+// da cui questa firma difende (un finto server che risponde "licenza valida").
+//
+// Cosa NON pretende di fare: chi possiede la macchina puo' modificare il
+// binario e togliere il controllo. Nessuna verifica locale lo impedisce.
+// Quello che si ottiene e' che per lavorare offline serva una prova VERA, e
+// che staccare il wifi o spostare l'orologio non siano modi per ottenerla.
+import { createPublicKey, verify as cryptoVerify } from "node:crypto";
+// La chiave PUBBLICA di Vascend, compilata nell'applicazione (identica a
+// quella di Horizon). La privata corrispondente vive solo sul server che firma.
+export const CHIAVE_PUBBLICA = [
+    "-----BEGIN PUBLIC KEY-----",
+    "MCowBQYDK2VwAyEAX/YALFQWCp0+SwqTnJ211FgRUTkOPW7R5b+pg8KCqFk=",
+    "-----END PUBLIC KEY-----",
+].join("\n");
+// Emittente atteso: deve combaciare con `jwt_issuer` del backend.
+export const EMITTENTE = "vascend";
+// Scopo dichiarato dalla prova. Un token senza questo campo non e' una
+// licenza: e' un token d'accesso, e accettarlo qui vorrebbe dire trattare la
+// sessione come un diritto perpetuo.
+export const SCOPO = "offline-entitlement";
+function base64urlToBuffer(part) {
+    const s = String(part || "").replace(/-/g, "+").replace(/_/g, "/");
+    return Buffer.from(s + "=".repeat((4 - (s.length % 4)) % 4), "base64");
+}
+// La firma EdDSA di un JWT copre esattamente "header.payload" in ASCII.
+function verificaFirma(intestazione, corpo, firma, chiavePubblicaPem) {
+    try {
+        const chiave = createPublicKey(chiavePubblicaPem);
+        if (chiave.asymmetricKeyType !== "ed25519")
+            return false;
+        return cryptoVerify(null, // Ed25519: nessun digest separato
+        Buffer.from(`${intestazione}.${corpo}`, "ascii"), chiave, base64urlToBuffer(firma));
+    }
+    catch {
+        return false;
+    }
+}
+// Verifica completa della prova. PURA: orario e chiave si iniettano, cosi' i
+// test viaggiano nel tempo senza toccare l'orologio della macchina. Non lancia
+// mai: un errore degrada in "niente licenza", non in una schermata rotta.
+export function verificaProva(token, chiavePubblicaPem = CHIAVE_PUBBLICA, opts = {}) {
+    const emittente = opts.emittente ?? EMITTENTE;
+    const adesso = Number.isFinite(opts.adesso) ? opts.adesso : Math.floor(Date.now() / 1000);
+    const pezzi = String(token || "").split(".");
+    if (pezzi.length !== 3)
+        return { ok: false, motivo: "formato" };
+    const [intestazione, corpo, firma] = pezzi;
+    let testa;
+    let claims;
+    try {
+        testa = JSON.parse(base64urlToBuffer(intestazione).toString("utf8"));
+        claims = JSON.parse(base64urlToBuffer(corpo).toString("utf8"));
+    }
+    catch {
+        return { ok: false, motivo: "illeggibile" };
+    }
+    // L'algoritmo si controlla PRIMA della firma: accettare quello dichiarato
+    // dal token e' la vulnerabilita' classica dei JWT (alg=none, o il passaggio
+    // a un algoritmo simmetrico usando la nostra pubblica come segreto).
+    if (!testa || testa["alg"] !== "EdDSA")
+        return { ok: false, motivo: "algoritmo" };
+    if (!verificaFirma(intestazione, corpo, firma, chiavePubblicaPem)) {
+        return { ok: false, motivo: "firma" };
+    }
+    // Solo DOPO la firma i claims valgono qualcosa: prima sono testo di chiunque.
+    if (!claims || claims.purpose !== SCOPO)
+        return { ok: false, motivo: "scopo" };
+    if (claims.iss !== emittente)
+        return { ok: false, motivo: "emittente" };
+    if (!Number.isFinite(claims.exp) || claims.exp <= adesso)
+        return { ok: false, motivo: "scaduta" };
+    if (Number.isFinite(claims.nbf) && claims.nbf > adesso + 60)
+        return { ok: false, motivo: "futura" };
+    return { ok: true, claims };
+}
+// --- ancoraggio dell'orologio ----------------------------------------------
+//
+// Senza rete l'unico riferimento temporale e' l'orologio di sistema, che
+// l'utente controlla: riportarlo indietro allungherebbe la finestra offline
+// all'infinito. Si conserva quindi il momento piu' avanti mai visto, e se
+// l'orologio torna prima di quello la prova non vale.
+//
+// La tolleranza esiste perche' gli orologi si correggono davvero (NTP, fuso,
+// batteria): qualche minuto all'indietro e' vita normale, un salto di giorni no.
+export const TOLLERANZA_INDIETRO_S = 15 * 60;
+export function orologioAttendibile(adesso, massimoVisto, tolleranza = TOLLERANZA_INDIETRO_S) {
+    if (!Number.isFinite(massimoVisto) || massimoVisto <= 0)
+        return true; // prima volta
+    if (!Number.isFinite(adesso))
+        return false;
+    return adesso >= massimoVisto - tolleranza;
+}
+export function nuovoMassimo(adesso, massimoVisto) {
+    const a = Number.isFinite(adesso) ? adesso : 0;
+    const m = Number.isFinite(massimoVisto) ? massimoVisto : 0;
+    return Math.max(a, m);
+}
+// Decisione completa: la prova vale QUI e ORA? Mette insieme firma, scadenza e
+// orologio, e ritorna anche il nuovo massimo da conservare.
+export function valuta(p) {
+    const ora = Number.isFinite(p.adesso) ? p.adesso : Math.floor(Date.now() / 1000);
+    const visto = Number.isFinite(p.massimoVisto) ? p.massimoVisto : 0;
+    if (!orologioAttendibile(ora, visto)) {
+        return { ok: false, motivo: "orologio", massimoVisto: nuovoMassimo(ora, visto) };
+    }
+    const esito = verificaProva(p.token, p.chiavePubblicaPem ?? CHIAVE_PUBBLICA, {
+        adesso: ora,
+        ...(p.emittente ? { emittente: p.emittente } : {}),
+    });
+    if (!esito.ok)
+        return { ok: false, motivo: esito.motivo, massimoVisto: nuovoMassimo(ora, visto) };
+    return { ok: true, claims: esito.claims, massimoVisto: nuovoMassimo(ora, visto) };
+}

package/dist/core/model-limits.d.ts

@@ -0,0 +1,2 @@
+export declare function maxOutputFor(model: string): number;
+export declare function resolveMaxTokens(requested: number, model: string): number;

package/dist/core/model-limits.js

@@ -0,0 +1,36 @@
+// Tetto di token di OUTPUT per modello. L'API Anthropic/OpenAI richiede comunque
+// un max_tokens: "togliere il limite" significa usare il massimo che il modello
+// accetta, non un numero arbitrario basso che troncherebbe i file lunghi.
+// maxTokens=0 nel config = AUTO (questo massimo).
+import { modelCapabilities } from "../providers/models-dev.js";
+export function maxOutputFor(model) {
+    const catalogLimit = modelCapabilities(model)?.outputLimit;
+    if (catalogLimit && catalogLimit > 0)
+        return catalogLimit;
+    const m = model.toLowerCase();
+    // Claude 5 e GPT-5.6 espongono 128k token di output. Manteniamo le regole
+    // legacy piu' conservative per gli id precedenti.
+    if (/claude-(?:fable|opus|sonnet)-5(?:\b|[-.])/.test(m))
+        return 128000;
+    if (m.includes("gpt-5.6"))
+        return 128000;
+    if (m.includes("gpt-6-astra"))
+        return 128000;
+    if (m.includes("claude-haiku-4-5"))
+        return 64000;
+    if (m.includes("haiku"))
+        return 8192;
+    if (m.includes("opus"))
+        return 32000;
+    if (m.includes("sonnet"))
+        return 64000;
+    // Famiglie OpenAI/altri ragionatori: tetto generoso ma accettato.
+    if (m.includes("gpt-5") || /\bo[134]\b/.test(m) || m.includes("codex"))
+        return 32000;
+    return 16384;
+}
+// Risolve il max_tokens effettivo: se l'utente ne ha fissato uno (>0) lo
+// rispetta, altrimenti usa il massimo del modello.
+export function resolveMaxTokens(requested, model) {
+    return requested && requested > 0 ? requested : maxOutputFor(model);
+}

package/dist/core/output-lifecycle.d.ts

@@ -0,0 +1,44 @@
+export interface OutputRegion {
+    readonly id: string;
+    readonly command: string;
+    readonly start: number;
+    readonly length: number;
+    readonly open: boolean;
+}
+export interface OutputSnapshot {
+    readonly regions: readonly OutputRegion[];
+}
+export interface OutputHost {
+    length(): number;
+    removeLines(start: number, count: number): void;
+    onShift?(from: number, count: number): void;
+}
+export declare class OutputLifecycle {
+    private readonly host;
+    private readonly stateFile?;
+    private readonly regions;
+    private readonly listeners;
+    constructor(host: OutputHost, stateFile?: string | undefined);
+    register(opts: {
+        command: string;
+        start: number;
+        length: number;
+        summary?: string;
+        id?: string;
+    }): string;
+    grow(id: string, length: number, summary?: string): void;
+    close(id: string): boolean;
+    closeAll(): number;
+    openIds(): readonly string[];
+    snapshot(): OutputSnapshot;
+    onChange(fn: (snap: OutputSnapshot) => void): () => void;
+    private emit;
+    private persist;
+    clearPersisted(): void;
+    loadPersistedOpen(): ReadonlyArray<{
+        id: string;
+        command: string;
+        summary: string;
+    }>;
+}
+export declare function outputStatePath(talosDir: string): string;

package/dist/core/output-lifecycle.js

@@ -0,0 +1,190 @@
+// Lifecycle degli output di comando nella cronologia chat.
+//
+// Problema: i comandi con output lungo (config, sessions, tree, bg, vascend...)
+// occupano molte righe nello scrollback. Quando l'utente CHIUDE un output
+// collassato non vogliamo solo nasconderlo (come fa un fold): vogliamo
+// RIMUOVERLO FISICAMENTE dalla cronologia, liberando le righe e riallineando
+// tutto cio' che le segue. Solo gli output ANCORA APERTI vengono persistiti, in
+// modo temporaneo, cosi' che lo stato visivo (cosa e' aperto) sopravviva a un
+// ridisegno o a un riavvio leggero, mentre il contenuto chiuso sparisce.
+//
+// Modulo disaccoppiato dalla TUI: opera su un OutputHost astratto (la repl gli
+// passa il proprio log di righe; i test passano un array). Immutabilita' per i
+// dati esportati (snapshot), mutazione confinata allo store.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+let seq = 0;
+function regionId() {
+    seq += 1;
+    return `out-${Date.now().toString(36)}-${seq.toString(36)}`;
+}
+// Store del lifecycle. Tiene le regioni di output e la loro posizione nel log
+// dell'host. Alla chiusura di una regione rimuove FISICAMENTE le sue righe e
+// riallinea gli offset delle regioni successive. Persiste, su richiesta, il
+// solo stato aperto.
+export class OutputLifecycle {
+    host;
+    stateFile;
+    regions = [];
+    listeners = new Set();
+    constructor(host, 
+    // File opzionale per la persistenza temporanea del solo stato aperto.
+    stateFile) {
+        this.host = host;
+        this.stateFile = stateFile;
+    }
+    // Registra un nuovo output di comando come APERTO. `start` e' la prima riga
+    // che occupa nel log; `length` quante righe; `summary` la riga di sintesi
+    // (persistita per ricostruire lo stato aperto). Ritorna l'id stabile.
+    register(opts) {
+        const id = opts.id ?? regionId();
+        this.regions.push({
+            id,
+            command: opts.command,
+            start: opts.start,
+            length: Math.max(0, opts.length),
+            open: true,
+            summary: opts.summary ?? "",
+        });
+        this.emit();
+        this.persist();
+        return id;
+    }
+    // Aggiorna la lunghezza/sintesi di una regione aperta (output che cresce
+    // mentre il comando produce righe).
+    grow(id, length, summary) {
+        const r = this.regions.find((x) => x.id === id);
+        if (!r || !r.open)
+            return;
+        r.length = Math.max(0, length);
+        if (summary !== undefined)
+            r.summary = summary;
+        this.emit();
+        this.persist();
+    }
+    // CHIUDE una regione: ne rimuove FISICAMENTE le righe dal log e riallinea
+    // tutte le regioni che venivano dopo (i loro start scalano di -length).
+    // Ritorna true se ha rimosso qualcosa.
+    close(id) {
+        const idx = this.regions.findIndex((x) => x.id === id);
+        if (idx === -1)
+            return false;
+        const r = this.regions[idx];
+        if (!r.open)
+            return false;
+        const removed = r.length;
+        if (removed > 0) {
+            // Rimozione fisica dal log dell'host.
+            this.host.removeLines(r.start, removed);
+            this.host.onShift?.(r.start, removed);
+            // Riallinea le regioni che iniziavano dopo la fine di questa.
+            for (const other of this.regions) {
+                if (other.id === r.id)
+                    continue;
+                if (other.start >= r.start + removed)
+                    other.start -= removed;
+            }
+        }
+        // La regione chiusa non occupa piu' righe: esce dallo stato.
+        this.regions.splice(idx, 1);
+        this.emit();
+        this.persist();
+        return removed > 0;
+    }
+    // Chiude TUTTE le regioni aperte (es. all'arrivo di un nuovo prompt utente).
+    // Rimuove dal log dalla piu' in basso alla piu' in alto, cosi' gli offset
+    // delle ancora-da-rimuovere restano validi. Ritorna quante righe ha tolto.
+    closeAll() {
+        const open = [...this.regions].sort((a, b) => b.start - a.start);
+        let total = 0;
+        for (const r of open) {
+            total += r.length;
+            this.close(r.id);
+        }
+        return total;
+    }
+    // Id delle regioni attualmente aperte (in ordine di posizione nel log).
+    openIds() {
+        return this.regions
+            .filter((r) => r.open)
+            .sort((a, b) => a.start - b.start)
+            .map((r) => r.id);
+    }
+    // Snapshot immutabile dello stato corrente.
+    snapshot() {
+        return {
+            regions: this.regions
+                .slice()
+                .sort((a, b) => a.start - b.start)
+                .map((r) => ({ id: r.id, command: r.command, start: r.start, length: r.length, open: r.open })),
+        };
+    }
+    // Sottoscrizione ai cambi di stato (la TUI ridisegna).
+    onChange(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    emit() {
+        const snap = this.snapshot();
+        for (const fn of this.listeners)
+            fn(snap);
+    }
+    // Persistenza TEMPORANEA del solo stato aperto. Scrive su stateFile solo le
+    // regioni open (id, comando, sintesi). Se non ci sono regioni aperte rimuove
+    // il file: niente stato chiuso lasciato a sporcare il disco. Best-effort: un
+    // errore di IO non deve far cadere la TUI.
+    persist() {
+        if (!this.stateFile)
+            return;
+        try {
+            const open = this.regions.filter((r) => r.open);
+            if (open.length === 0) {
+                if (existsSync(this.stateFile))
+                    rmSync(this.stateFile);
+                return;
+            }
+            const data = {
+                version: 1,
+                open: open.map((r) => ({ id: r.id, command: r.command, summary: r.summary })),
+                ts: Date.now(),
+            };
+            mkdirSync(dirname(this.stateFile), { recursive: true });
+            writeFileSync(this.stateFile, JSON.stringify(data), "utf8");
+        }
+        catch {
+            // persistenza best-effort: ignora gli errori di IO
+        }
+    }
+    // Cancella esplicitamente lo stato persistito (es. a fine sessione/reset).
+    clearPersisted() {
+        if (!this.stateFile)
+            return;
+        try {
+            if (existsSync(this.stateFile))
+                rmSync(this.stateFile);
+        }
+        catch {
+            // ignora
+        }
+    }
+    // Legge lo stato aperto persistito (id/comando/sintesi delle regioni che
+    // erano aperte). NON ricolloca le righe (gli offset di log sono volatili):
+    // serve a sapere COSA era aperto, non DOVE. Ritorna [] se assente/corrotto.
+    loadPersistedOpen() {
+        if (!this.stateFile || !existsSync(this.stateFile))
+            return [];
+        try {
+            const parsed = JSON.parse(readFileSync(this.stateFile, "utf8"));
+            if (parsed.version !== 1 || !Array.isArray(parsed.open))
+                return [];
+            return parsed.open.map((o) => ({ id: o.id, command: o.command, summary: o.summary }));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// Path standard per lo stato temporaneo degli output aperti, sotto .talos.
+export function outputStatePath(talosDir) {
+    return `${talosDir}/output-state.json`;
+}

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

@@ -0,0 +1,15 @@
+import type { TalosUpdate } from "./update-check.js";
+import { type UpdateRunner } from "./update-process.js";
+import type { UpdateResult } from "./self-update.js";
+export type PackageManager = "npm" | "bun" | "pnpm" | "yarn";
+export declare function managerCommand(manager: PackageManager, env: NodeJS.ProcessEnv): {
+    command: string;
+    args: readonly string[];
+} | null;
+export declare function packageUpdateArgs(manager: PackageManager, version: string, prefix?: string): readonly string[];
+export declare function installPackageUpdate(update: TalosUpdate, options: {
+    readonly root: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly run?: UpdateRunner;
+    readonly managerCommand?: typeof managerCommand;
+}): Promise<UpdateResult>;

package/dist/core/package-update.js

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { homeDirFromEnv } from "./env-paths.js";
+import { runUpdateCommand } from "./update-process.js";
+const PACKAGE = "@vascend/talos";
+const REGISTRY = "https://registry.npmjs.org";
+export function managerCommand(manager, env) {
+    if (process.platform !== "win32")
+        return { command: manager, args: [] };
+    const path = Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+    const directories = path.split(delimiter).filter(Boolean).map(directory => directory.replace(/^"|"$/g, ""));
+    const node = process.versions.bun ? directories.map(directory => join(directory, "node.exe")).find(file => existsSync(file)) : process.execPath;
+    for (const directory of directories) {
+        const exe = join(directory, `${manager}.exe`);
+        if (existsSync(exe))
+            return { command: exe, args: [] };
+        // Execute package-manager JS directly: Windows .cmd wrappers require a shell.
+        const scripts = {
+            npm: ["npm/bin/npm-cli.js"],
+            pnpm: ["pnpm/bin/pnpm.cjs", "corepack/dist/pnpm.js"],
+            yarn: ["yarn/bin/yarn.js", "corepack/dist/yarn.js"],
+        };
+        if (manager !== "bun")
+            for (const script of scripts[manager]) {
+                const file = join(directory, "node_modules", script);
+                if (node && existsSync(file))
+                    return { command: node, args: [file] };
+            }
+    }
+    return null;
+}
+function samePath(a, b) {
+    try {
+        const normalize = (path) => process.platform === "win32" ? path.toLowerCase() : path;
+        return normalize(realpathSync(a)) === normalize(realpathSync(b));
+    }
+    catch {
+        return false;
+    }
+}
+// An explicit npm prefix (including the curl installer) may differ from npm's
+// default. Accept it only when its global CLI shim points to this installation.
+function npmPrefix(root) {
+    const modules = dirname(dirname(root));
+    if (dirname(root).split(/[\\/]/).pop() !== "@vascend" || modules.split(/[\\/]/).pop() !== "node_modules")
+        return null;
+    const prefix = process.platform === "win32" ? dirname(modules) : dirname(dirname(modules));
+    if (process.platform !== "win32") {
+        return samePath(join(prefix, "bin", "talos"), join(root, "dist", "index.js")) ? prefix : null;
+    }
+    try {
+        return /node_modules[\\/]@vascend[\\/]talos[\\/]dist[\\/]index\.js/i.test(readFileSync(join(prefix, "talos.cmd"), "utf8"))
+            ? prefix : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function packageUpdateArgs(manager, version, prefix) {
+    const target = `${PACKAGE}@${version}`;
+    if (manager === "npm")
+        return ["install", "--global", target, `--registry=${REGISTRY}`, ...(prefix ? ["--prefix", prefix] : [])];
+    if (manager === "yarn")
+        return ["global", "add", target, `--registry=${REGISTRY}`];
+    return ["add", "--global", target, `--registry=${REGISTRY}`];
+}
+export async function installPackageUpdate(update, options) {
+    const { root, env } = options;
+    const run = options.run ?? runUpdateCommand;
+    try {
+        if (JSON.parse(readFileSync(join(root, "package.json"), "utf8")).name !== PACKAGE) {
+            return { ok: false, reason: "unsupported", changed: false };
+        }
+    }
+    catch {
+        return { ok: false, reason: "unsupported", changed: false };
+    }
+    const normalized = root.replaceAll("\\", "/").toLowerCase();
+    const preferred = normalized.includes("/.pnpm/") || normalized.includes("/pnpm/") ? "pnpm"
+        : normalized.includes("/yarn/") ? "yarn" : normalized.includes("/.bun/") ? "bun" : "npm";
+    const managers = [...new Set([preferred, "npm", "bun", "pnpm", "yarn"])];
+    for (const manager of managers) {
+        const executable = (options.managerCommand ?? managerCommand)(manager, env);
+        if (!executable)
+            continue;
+        const command = (args, inherit = false) => ({
+            ...executable, args: [...executable.args, ...args], cwd: homeDirFromEnv(env), env,
+            inherit, timeoutMs: inherit ? 300_000 : 2_000,
+        });
+        let prefix;
+        let matches = false;
+        try {
+            if (manager === "bun") {
+                matches = samePath(root, join(env.BUN_INSTALL ?? join(homeDirFromEnv(env), ".bun"), "install", "global", "node_modules", PACKAGE));
+            }
+            else if (manager === "yarn") {
+                matches = samePath(root, join(await run(command(["global", "dir"])), "node_modules", PACKAGE));
+            }
+            else {
+                matches = samePath(root, join(await run(command(["root", "--global"])), PACKAGE));
+                if (!matches && manager === "npm") {
+                    prefix = npmPrefix(root) ?? undefined;
+                    matches = Boolean(prefix);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (!matches)
+            continue;
+        try {
+            await run(command(packageUpdateArgs(manager, update.version, prefix), true));
+            return { ok: true };
+        }
+        catch {
+            return { ok: false, reason: "install", changed: true };
+        }
+    }
+    return { ok: false, reason: "unsupported", changed: false };
+}

package/dist/core/permission-queue.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from "./types.js";
+export declare function queuedConfirmation(confirm: ToolContext["confirm"], action: string, detail: string, signal: AbortSignal): Promise<boolean>;

package/dist/core/permission-queue.js

@@ -0,0 +1,20 @@
+const queues = new WeakMap();
+// Concurrent file work shares one interactive permission channel. Fast
+// automatic approvals still resolve immediately, without overlapping prompts.
+export async function queuedConfirmation(confirm, action, detail, signal) {
+    const previous = queues.get(confirm) ?? Promise.resolve();
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    queues.set(confirm, current);
+    await previous;
+    try {
+        if (signal.aborted)
+            return false;
+        return await confirm(action, detail);
+    }
+    finally {
+        release();
+        if (queues.get(confirm) === current)
+            queues.delete(confirm);
+    }
+}

package/dist/core/prompt-attachment.d.ts

@@ -0,0 +1,21 @@
+import type { ContentPart } from "./types.js";
+export interface RefResolver {
+    resolvePath(id: string): string | undefined;
+    expand?(text: string): string;
+}
+export type BytesReader = (path: string) => Promise<Uint8Array>;
+export declare function normalizeRef(raw: string): string;
+export declare function extractRefs(text: string): string[];
+export declare function mimeFromPath(path: string): string;
+export interface BuiltPrompt {
+    readonly parts: readonly ContentPart[];
+    readonly attached: readonly string[];
+    readonly missing: readonly string[];
+    readonly unreadable: readonly string[];
+}
+export interface BuildOptions {
+    readonly maxTotalBytes?: number;
+    readonly reader?: BytesReader;
+}
+export declare function buildPrompt(text: string, refs: RefResolver, opts?: BuildOptions): Promise<BuiltPrompt>;
+export declare function expandRefsInText(text: string, refs: RefResolver): string;