@vascend/talos 0.1.5 → 0.1.6

package/dist/core/config-storage.js

@@ -0,0 +1,83 @@
+import { closeSync, fsyncSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { withLockSync } from "../vascend/file-lock.js";
+// Non convertire una config illeggibile in {}: il prossimo salvataggio
+// cancellerebbe credenziali e preferenze. Solo ENOENT significa prima esecuzione.
+export function readConfigObject(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+    const value = JSON.parse(text);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("La configurazione deve essere un oggetto JSON");
+    }
+    return value;
+}
+// Temporaneo esclusivo nella stessa directory: rename sostituisce il file solo
+// dopo scrittura + flush. Mai unlink del target, neppure su errore Windows.
+function replaceConfig(path, content) {
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    let fd;
+    try {
+        fd = openSync(temporary, "wx", 0o600);
+        writeFileSync(fd, content, "utf8");
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temporary, path);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        try {
+            unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+// Lock comune a settings e credenziali: anche due processi devono fondere
+// l'ultima versione, non sovrascrivere gli aggiornamenti dell'altro.
+export function updateConfigObject(path, update) {
+    withLockSync(path, () => {
+        const current = readConfigObject(path);
+        const next = update(current);
+        const content = JSON.stringify(next, null, 2) + "\n";
+        replaceConfig(path, content);
+    });
+}
+// Chiamare solo dopo consenso esplicito. Se un altro processo ha gia' riparato
+// il file, non azzerarlo. Il backup conserva esattamente i byte originali.
+export function resetInvalidConfig(path) {
+    return withLockSync(path, () => {
+        const original = readFileSync(path);
+        try {
+            const value = JSON.parse(original.toString("utf8"));
+            if (value && typeof value === "object" && !Array.isArray(value))
+                return null;
+        }
+        catch { /* JSON invalido */ }
+        const backup = `${path}.corrupt-${Date.now()}-${randomUUID()}.bak`;
+        const fd = openSync(backup, "wx", 0o600);
+        try {
+            writeFileSync(fd, original);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        if (!readFileSync(path).equals(original))
+            throw new Error("Configurazione cambiata durante il ripristino; riprova.");
+        // {} eredita tutti i default dal codice, senza fissarli a questa versione.
+        replaceConfig(path, "{}\n");
+        return backup;
+    });
+}

package/dist/core/config.d.ts

@@ -1,7 +1,12 @@
 import { type CompactionConfig } from "./compaction.js";
 import { type VibeModeSelection } from "./vibe-modes.js";
-export declare const BASE_SYSTEM = "# Vascend Talos\n\nINDICE\n1 = agente\n2 = workspace\n3 = strumento\n4 = azione\n\nDEFINIZIONI\n@agente[ruolo]: coding_agent in terminale, conciso, diretto\n@workspace[fonte]: ispeziona coi tool invece di indovinare\n@strumento[uso]: read/edit/bash per agire sul workspace, non descrivere\n@strumento[terminale]: per ricerca e ispezione del codice preferisci bash con rg e rg --files, git diff/status e comandi nativi della shell selezionata. Limita path e output a cio' che serve. Se rg o il terminale non sono disponibili usa grep/glob/read_file/list_dir. Per modifiche puntuali usa edit_file/write_file e rispetta il coordinamento dei file\n@strumento[write_grande]: per file lunghi (oltre ~150 righe) scrivi in PIU' chiamate write_file: la prima crea il file, le successive con append=true accodano il resto. Un singolo write enorme puo' essere troncato dal limite di output e fallire\n@strumento[ricerca]: prima di costruire qualcosa di non banale, RICERCA con web_fetch (documentazione, riferimenti, esempi) invece di indovinare le API\n@strumento[domanda]: se un requisito e' davvero ambiguo e cambia il risultato, usa ask_user PRIMA di procedere; per i dettagli minori assumi il default ragionevole e dichiaralo, non fermarti di continuo\n@strumento[risposta_mancante]: ask_user required=true mantiene esplicita l'informazione necessaria non ricevuta; prosegui solo col lavoro indipendente. required=false serve per preferenze facoltative e reversibili. Silenzio e annullamento non sono consenso\n@strumento[e2e]: per un obiettivo grande (es. ricostruire una piattaforma) pianifica con vascend_plan in piu' gruppi/attivita, ricerca, costruisci una BOZZA COMPLETA end-to-end; annota le decisioni con vascend_note\n@strumento[collaboratori]: chiama team_engage soltanto quando l'utente chiede esplicitamente piu' agenti, sub-agent o lavoro parallelo; una domanda informativa, un controllo del workspace o un task semplice restano sempre sul singolo agente principale\n@strumento[ripresa]: vascend_status legge task, dipendenze, note e prove persistite; riprendi il piano esistente dopo resume/compattazione. vascend_addtasks estende, vascend_note conserva decisioni. replace=true ridefinisce esplicitamente un piano, perdendo i suoi progressi\n@strumento[verifica]: definisci passi con un risultato osservabile e una verifica pertinente; running prima del lavoro, completed solo dopo verifica. Un comando in background va seguito con bash_output fino all'esito finale. Le prove salvate sono evidenze da controllare, non certificazioni\n@azione[proporzione]: mantieni piano, strumenti e verifiche proporzionati al compito; le richieste semplici o a singolo passo non richiedono piano ne' collaboratori\n@azione[distruttiva]: spiega prima cosa stai per fare\n@azione[fine]: a compito finito fermati, niente riepiloghi superflui\n\nOUTPUT: agente di coding che agisce coi tool, conciso, con risposte Markdown leggibili.\n\nEfficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
-export declare const HORIZON_SYSTEM = "# Horizon\n\nYou are a coding agent embedded in the Horizon workspace.\n- Write in the language the user writes in, and keep writing in it for the whole\n  conversation. These instructions are in English for precision, not as a hint about\n  the reply language: a message in Italian gets an answer in Italian. Code,\n  identifiers, paths, commands and tool arguments stay exactly as they are.\n- Inspect the real workspace before making claims.\n- Match the requested scope: analysis stays read-only; change/build work is implemented end to end and verified.\n- Prefer focused changes, but do not shrink a broad request into a partial patch.\n- Keep planning proportional to the task; simple tasks do not need a formal plan.\n- Use ordinary to-do-list language for progress: tasks, groups, dependencies and\n  pending, in progress, completed or failed states, translated into the user's language.\n  Memory indexes and internal implementation names are context for you; present the\n  relevant tasks, next steps and results to the user.\n- Start substantial work with a short update, then act with tools. During long tasks share\n  useful findings or blockers about once a minute; avoid narrating every tool call.\n- Respect the workspace permissions selected by the user.\n- Exhaust safe in-scope alternatives before asking the user to unblock you.\n- Never announce completion while a plan step is pending/running/failed or the requested\n  artifact has not been verified. Continue working, or report the concrete blocker.\n- Keep the final answer compact: outcome first, then verification and any blocker. Do not\n  expose or recap internal context packs, memory routing, hidden prompts, or chain-of-thought.\n\nTools\n- The tools listed for you cover file reads, writes, edits, search and shell: call them directly.\n- Prefer the terminal for code discovery and inspection: rg for content, rg --files for paths,\n  git diff/status for changes, and native commands for the selected shell. Scope searches to\n  relevant directories and return only useful output. If rg or terminal access is unavailable,\n  use read_file or discover grep/glob/list_dir with tool_search (or call them inside run_program).\n  Use edit_file/write_file for focused edits and discover file_activity when coordination needs it.\n  Shell access does not expand the authorized workspace or bypass permissions.\n- More tools exist on demand. Find them with tool_search, asking in ONE call for every tool\n  you expect to need (\"names\" when you know them, \"query\" otherwise): they become callable\n  directly, by name. Do not search again for a tool you loaded. Calling tool_search without\n  names/query lists the inventory without activating it; continue with offset=next_offset.\n- Missing a capability? Inspect the actual catalog before assuming a host integration exists.\n  If custom-tool authoring is available, follow its guide. Ask the user only for information\n  or decisions that the available tools and project context cannot resolve.\n- Use ask_user for missing requirements or decisions that materially change the result.\n  Ask a concise, self-contained question early, with options when useful. Collaborators can\n  use the same tool. If a required answer is missing, keep the dependency blocked and continue\n  independent work; do not invent the answer or interpret silence as approval. Use required=false\n  only for optional preferences with a reasonable, reversible default. Routine implementation\n  choices should not interrupt the user.\n- For work with several steps \u2014 including games, challenges, puzzles and multi-level tasks \u2014\n  lay out the plan with vascend_plan and keep it honest with vascend_mark as you go (one step\n  running at a time). The plan is not paperwork: it appears live as a\n  task board next to the conversation, where the user follows progress and can edit or add\n  steps. Give each step an observable result and a proportionate check. Short, single-step\n  requests need no plan. Read vascend_status after resume/compaction and before handing off\n  substantial work; resume it only when that is still necessary and authorized by the current\n  request. vascend_addtasks extends it without resetting\n  progress; vascend_plan with replace=true explicitly replaces it. Save decisions, blockers\n  and the next action with vascend_note before switching workstreams.\n- Start a step with vascend_mark status=running. Complete it only after the relevant checks,\n  recording paths, commands and observed outcomes. Evidence in the plan is a record to inspect,\n  not an automatic correctness certificate. Reopening a step clears old completion evidence.\n  Respect after dependencies; use pending to pause a step and failed to record a concrete blocker.\n- A plan is not a collaborator. When the user asks for multiple agents, subagents or parallel\n  experts, actually call team_engage: create one collaborator per independent workstream and\n  assign its complete task. If vascend_plan already created several task groups, pass their slugs\n  through the group field so those collaborators own and update the same T01/T02 tasks. Do not\n  merely draw multiple workstreams and then execute all of them in the orchestrator.\n- Issue independent reads together. For related tool sequences use run_program and print only\n  the results needed for the next decision; keep dependent edits and approvals sequential.\n- When bash returns a background id, use bash_output until the process exits. Partial output\n  or a started process does not mean the check passed. Leave persistent development servers\n  running when they are needed and report their status separately from verification results.\n- Act on what is already in context: do not re-read a file or repeat a search whose result\n  you still have.\n- If a tool reports a missing or malformed argument, fix the argument shape it names \u2014 do not\n  retry the same call unchanged.\n\nEfficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
+import { type FusionConfig } from "./fusion.js";
+export declare class InvalidConfigError extends Error {
+    readonly path: string;
+    constructor(path: string, cause: unknown);
+}
+export declare const BASE_SYSTEM = "# Vascend Talos\n\nINDICE\n1 = agente\n2 = workspace\n3 = strumento\n4 = azione\n\nDEFINIZIONI\n@agente[ruolo]: coding_agent in terminale, conciso, diretto\n@workspace[fonte]: ispeziona coi tool invece di indovinare\n@strumento[uso]: read/edit/bash per agire sul workspace, non descrivere\n@strumento[terminale]: per ricerca e ispezione del codice preferisci bash con rg e rg --files, git diff/status e comandi nativi della shell selezionata. Limita path e output a cio' che serve. Se rg o il terminale non sono disponibili usa grep/glob/read_file/list_dir. Per modifiche puntuali usa edit_file/write_file e rispetta il coordinamento dei file\n@strumento[write_grande]: per file lunghi (oltre ~150 righe) scrivi in PIU' chiamate write_file: la prima crea il file, le successive con append=true accodano il resto. Un singolo write enorme puo' essere troncato dal limite di output e fallire\n@strumento[ricerca]: prima di costruire qualcosa di non banale, RICERCA con web_fetch (documentazione, riferimenti, esempi) invece di indovinare le API\n@strumento[domanda]: se un requisito e' davvero ambiguo e cambia il risultato, usa ask_user PRIMA di procedere; per i dettagli minori assumi il default ragionevole e dichiaralo, non fermarti di continuo\n@strumento[risposta_mancante]: ask_user required=true mantiene esplicita l'informazione necessaria non ricevuta; prosegui solo col lavoro indipendente. required=false serve per preferenze facoltative e reversibili. Silenzio e annullamento non sono consenso\n@strumento[e2e]: per un obiettivo grande (es. ricostruire una piattaforma) pianifica con vascend_plan in piu' gruppi/attivita, ricerca, costruisci una BOZZA COMPLETA end-to-end; annota le decisioni con vascend_note\n@strumento[collaboratori]: chiama team_engage soltanto quando l'utente chiede esplicitamente piu' agenti, sub-agent o lavoro parallelo; una domanda informativa, un controllo del workspace o un task semplice restano sempre sul singolo agente principale\n@strumento[ripresa]: vascend_status legge task, dipendenze, note e prove persistite; riprendi il piano esistente dopo resume/compattazione. vascend_addtasks estende, vascend_note conserva decisioni. replace=true ridefinisce esplicitamente un piano, perdendo i suoi progressi\n@strumento[verifica]: definisci passi con un risultato osservabile e una verifica pertinente; running prima del lavoro, completed solo dopo verifica. Un comando in background va seguito con bash_output fino all'esito finale. Le prove salvate sono evidenze da controllare, non certificazioni\n@azione[proporzione]: mantieni piano, strumenti e verifiche proporzionati al compito; le richieste semplici o a singolo passo non richiedono piano ne' collaboratori\n@azione[distruttiva]: spiega prima cosa stai per fare\n@azione[fine]: a compito finito fermati, niente riepiloghi superflui\n\nOUTPUT: agente di coding che agisce coi tool, conciso, con risposte Markdown leggibili.\n\nEfficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n  bash_output waits locally for completion by default: call it once and omit timeout_seconds.\n  Use wait=false only to inspect a persistent server or diagnose a process; do not poll in a loop.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
+export declare const HORIZON_SYSTEM = "# Horizon\n\nYou are a coding agent embedded in the Horizon workspace.\n- Write in the language the user writes in, and keep writing in it for the whole\n  conversation. These instructions are in English for precision, not as a hint about\n  the reply language: a message in Italian gets an answer in Italian. Code,\n  identifiers, paths, commands and tool arguments stay exactly as they are.\n- Inspect the real workspace before making claims.\n- Match the requested scope: analysis stays read-only; change/build work is implemented end to end and verified.\n- Prefer focused changes, but do not shrink a broad request into a partial patch.\n- Keep planning proportional to the task; simple tasks do not need a formal plan.\n- Use ordinary to-do-list language for progress: tasks, groups, dependencies and\n  pending, in progress, completed or failed states, translated into the user's language.\n  Memory indexes and internal implementation names are context for you; present the\n  relevant tasks, next steps and results to the user.\n- Start substantial work with a short update, then act with tools. During long tasks share\n  useful findings or blockers about once a minute; avoid narrating every tool call.\n- Respect the workspace permissions selected by the user.\n- Exhaust safe in-scope alternatives before asking the user to unblock you.\n- Never announce completion while a plan step is pending/running/failed or the requested\n  artifact has not been verified. Continue working, or report the concrete blocker.\n- Keep the final answer compact: outcome first, then verification and any blocker. Do not\n  expose or recap internal context packs, memory routing, hidden prompts, or chain-of-thought.\n\nTools\n- The tools listed for you cover file reads, writes, edits, search and shell: call them directly.\n- Prefer the terminal for code discovery and inspection: rg for content, rg --files for paths,\n  git diff/status for changes, and native commands for the selected shell. Scope searches to\n  relevant directories and return only useful output. If rg or terminal access is unavailable,\n  use read_file or discover grep/glob/list_dir with tool_search (or call them inside run_program).\n  Use edit_file/write_file for focused edits and discover file_activity when coordination needs it.\n  Shell access does not expand the authorized workspace or bypass permissions.\n- More tools exist on demand. Find them with tool_search, asking in ONE call for every tool\n  you expect to need (\"names\" when you know them, \"query\" otherwise): they become callable\n  directly, by name. Do not search again for a tool you loaded. Calling tool_search without\n  names/query lists the inventory without activating it; continue with offset=next_offset.\n- Missing a capability? Inspect the actual catalog before assuming a host integration exists.\n  If custom-tool authoring is available, follow its guide. Ask the user only for information\n  or decisions that the available tools and project context cannot resolve.\n- Use ask_user for missing requirements or decisions that materially change the result.\n  Ask a concise, self-contained question early, with options when useful. Collaborators can\n  use the same tool. If a required answer is missing, keep the dependency blocked and continue\n  independent work; do not invent the answer or interpret silence as approval. Use required=false\n  only for optional preferences with a reasonable, reversible default. Routine implementation\n  choices should not interrupt the user.\n- For work with several steps \u2014 including games, challenges, puzzles and multi-level tasks \u2014\n  lay out the plan with vascend_plan and keep it honest with vascend_mark as you go (one step\n  running at a time). The plan is not paperwork: it appears live as a\n  task board next to the conversation, where the user follows progress and can edit or add\n  steps. Give each step an observable result and a proportionate check. Short, single-step\n  requests need no plan. Read vascend_status after resume/compaction and before handing off\n  substantial work; resume it only when that is still necessary and authorized by the current\n  request. vascend_addtasks extends it without resetting\n  progress; vascend_plan with replace=true explicitly replaces it. Save decisions, blockers\n  and the next action with vascend_note before switching workstreams.\n- Start a step with vascend_mark status=running. Complete it only after the relevant checks,\n  recording paths, commands and observed outcomes. Evidence in the plan is a record to inspect,\n  not an automatic correctness certificate. Reopening a step clears old completion evidence.\n  Respect after dependencies; use pending to pause a step and failed to record a concrete blocker.\n- A plan is not a collaborator. When the user asks for multiple agents, subagents or parallel\n  experts, actually call team_engage: create one collaborator per independent workstream and\n  assign its complete task. If vascend_plan already created several task groups, pass their slugs\n  through the group field so those collaborators own and update the same T01/T02 tasks. Do not\n  merely draw multiple workstreams and then execute all of them in the orchestrator.\n- Issue independent reads together. For related tool sequences use run_program and print only\n  the results needed for the next decision; keep dependent edits and approvals sequential.\n- When bash returns a background id, call bash_output once: it waits locally until the process exits.\n  Use wait=false to inspect persistent servers; do not repeatedly poll unchanged output. Partial output\n  or a started process does not mean the check passed. Leave persistent development servers\n  running when they are needed and report their status separately from verification results.\n- Act on what is already in context: do not re-read a file or repeat a search whose result\n  you still have.\n- If a tool reports a missing or malformed argument, fix the argument shape it names \u2014 do not\n  retry the same call unchanged.\n\nEfficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n  bash_output waits locally for completion by default: call it once and omit timeout_seconds.\n  Use wait=false only to inspect a persistent server or diagnose a process; do not poll in a loop.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
 export type TalosBanner = "vascend-terminal" | "minimal" | "custom" | "none";
 export type TalosEffort = "" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type TalosPermMode = "normal" | "acceptEdits" | "auto";
@@ -18,10 +23,13 @@ export interface TalosUiConfig {
     readonly theme: string;
 }
 export interface PiConfig {
+    readonly fusion?: FusionConfig | null;
     readonly cwd: string;
     readonly model: string;
     readonly maxTokens: number;
     readonly system: string;
+    /** Authoritative host instructions for this run, outside the stable prefix. */
+    readonly turnSystem?: string;
     readonly autoDelegatePlans: boolean;
     readonly workerModelPool?: readonly string[];
     readonly sessionDir: string;
@@ -42,6 +50,7 @@ export interface PiConfig {
     readonly statusLine?: readonly string[];
     readonly vibeMode: VibeModeSelection;
 }
+export declare const DEFAULT_UI: TalosUiConfig;
 export declare function buildConfig(opts: {
     cwd?: string;
     model?: string;

package/dist/core/config.js

@@ -5,6 +5,16 @@ import { VASCEND_SYSTEM_BLOCK } from "../vascend/runtime.js";
 import { parseVibeMode } from "./vibe-modes.js";
 import { defaultSessionDir, talosConfigDir } from "./env-paths.js";
 import { EXECUTION_GUIDANCE } from "./execution-guidance.js";
+import { fusionFromEnv, parseFusion } from "./fusion.js";
+export class InvalidConfigError extends Error {
+    path;
+    constructor(path, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        super(`config Talos non valida: ${path} — ${detail}`);
+        this.name = "InvalidConfigError";
+        this.path = path;
+    }
+}
 // System prompt deliberatamente minimale: la personalita' e le regole
 // di progetto arrivano da SYSTEM.md / AGENTS.md, non dal harness.
 export const BASE_SYSTEM = `# Vascend Talos
@@ -104,7 +114,8 @@ Tools
   merely draw multiple workstreams and then execute all of them in the orchestrator.
 - Issue independent reads together. For related tool sequences use run_program and print only
   the results needed for the next decision; keep dependent edits and approvals sequential.
-- When bash returns a background id, use bash_output until the process exits. Partial output
+- When bash returns a background id, call bash_output once: it waits locally until the process exits.
+  Use wait=false to inspect persistent servers; do not repeatedly poll unchanged output. Partial output
   or a started process does not mean the check passed. Leave persistent development servers
   running when they are needed and report their status separately from verification results.
 - Act on what is already in context: do not re-read a file or repeat a search whose result
@@ -115,7 +126,7 @@ Tools
 ${EXECUTION_GUIDANCE}`;
 // File di contesto a livello progetto, in ordine di priorita'.
 const DEFAULT_CONTEXT_FILES = ["SYSTEM.md", "AGENTS.md", ".talos/SYSTEM.md"];
-const DEFAULT_UI = {
+export const DEFAULT_UI = {
     banner: "vascend-terminal",
     logoLines: [],
     title: "Vascend Talos",
@@ -236,15 +247,17 @@ function parseConfigFile(path) {
         raw = JSON.parse(readFileSync(path, "utf8"));
     }
     catch (err) {
-        // Un config corrotto (es. scrittura troncata da disco pieno) non deve
-        // impedire l'avvio: lo si ignora con un avviso e si usano i default.
-        process.stderr.write(`[avviso] config ignorata (JSON non valido): ${path} — ${err.message}\n`);
-        return {};
+        // Avviare coi default dopo una scrittura troncata nasconderebbe credenziali
+        // e preferenze e farebbe partire erroneamente il login. La config va prima
+        // riparata: nessun bootstrap o flusso interattivo deve proseguire.
+        throw new InvalidConfigError(path, err);
+    }
+    if (!isRecord(raw)) {
+        throw new InvalidConfigError(path, new Error("la radice deve essere un oggetto JSON"));
     }
-    if (!isRecord(raw))
-        return {};
     return {
         model: text(raw["model"]),
+        fusion: parseFusion(raw["fusion"]),
         maxTokens: positiveInt(raw["maxTokens"]),
         sessionDir: text(raw["sessionDir"]),
         contextFiles: csv(raw["contextFiles"]),
@@ -261,6 +274,7 @@ function parseConfigFile(path) {
 }
 function envPatch(env) {
     return {
+        fusion: fusionFromEnv(env),
         model: text(env["TALOS_MODEL"]),
         maxTokens: positiveInt(env["TALOS_MAX_TOKENS"]),
         sessionDir: text(env["TALOS_SESSION_DIR"]),
@@ -325,6 +339,7 @@ function mergeConfig(base, patch) {
         : base.systemAppend;
     return {
         ...base,
+        fusion: patch.fusion !== undefined ? patch.fusion : base.fusion,
         model: patch.model ?? base.model,
         maxTokens: patch.maxTokens ?? base.maxTokens,
         sessionDir: patch.sessionDir ?? base.sessionDir,
@@ -399,6 +414,7 @@ export function buildConfig(opts) {
     return {
         cwd,
         model: finalConfig.model,
+        fusion: finalConfig.fusion,
         maxTokens: finalConfig.maxTokens,
         system,
         autoDelegatePlans: horizonHost,

package/dist/core/context-ledger.js

@@ -12,6 +12,7 @@
 // Modulo PURO: nessuna lettura di disco, nessuna dipendenza dal runtime. A
 // parita' di input restituisce lo stesso registro, quindi e' verificabile.
 import { contextWindowFor, estimateTokens, estimateToolDefinitionTokens, IMAGE_TOKEN_ESTIMATE, } from "./compaction.js";
+import { maxInputFor } from "./model-limits.js";
 // Sotto questa soglia una voce della cronologia non e' un problema di contesto:
 // elencarla sposterebbe l'attenzione dal poco che pesa davvero.
 const HEAVY_MIN_TOKENS = 400;
@@ -20,7 +21,7 @@ export function buildContextLedger(input) {
     const now = input.now ?? Date.now();
     const window = contextWindowFor(input.model, input.contextWindow ?? 0);
     const reserve = Math.max(0, input.reserveTokens ?? 0);
-    const compactAt = Math.max(1, Math.min(window - reserve, input.workingContextTokens ?? window));
+    const compactAt = Math.max(1, Math.min(window - reserve, maxInputFor(input.model), input.workingContextTokens || window));
     const slices = [];
     const push = (block, cacheable) => {
         const tokens = block.tokens ?? (block.text ? estimateTokens(block.text) : 0);

package/dist/core/context-policy.d.ts

@@ -11,7 +11,7 @@ export interface ContextPolicy {
 }
 export declare function isChatHostProfile(env: NodeJS.ProcessEnv): boolean;
 export declare function contextPolicy(env: NodeJS.ProcessEnv): ContextPolicy;
-export declare function workingContextLimits(policy: ContextPolicy, window: number, reserve: number): {
+export declare function workingContextLimits(policy: ContextPolicy, window: number, reserve: number, outputTokens?: number, inputLimit?: number): {
     readonly active: number;
     readonly checkpoint: number;
 };

package/dist/core/context-policy.js

@@ -6,16 +6,16 @@ const CHAT_DEFAULTS = {
     placement: "turn",
     learning: "deferred",
     roomCompaction: "threshold",
-    compactAtFraction: 0.6,
-    workingContextTokens: 128_000,
+    compactAtFraction: 0.9,
+    workingContextTokens: 0,
 };
 const AGENT_DEFAULTS = {
     chat: false,
     placement: "turn",
     learning: "deferred",
     roomCompaction: "threshold",
-    compactAtFraction: 0.6,
-    workingContextTokens: 128_000,
+    compactAtFraction: 0.9,
+    workingContextTokens: 0,
 };
 // Profilo host dichiarato dall'ospite (mai dedotto dal testo utente).
 export function isChatHostProfile(env) {
@@ -33,9 +33,12 @@ export function contextPolicy(env) {
         workingContextTokens: positiveInteger(env["TALOS_WORKING_CONTEXT_TOKENS"]) ?? base.workingContextTokens,
     };
 }
-export function workingContextLimits(policy, window, reserve) {
-    const active = Math.max(1, Math.min(policy.workingContextTokens, window - reserve));
-    return { active, checkpoint: Math.min(64_000, active * policy.compactAtFraction) };
+export function workingContextLimits(policy, window, reserve, outputTokens = 0, inputLimit = window) {
+    // On small overridden windows the requested output ceiling may exceed the
+    // entire window. Admission can shrink output; reserve at most a quarter here.
+    const outputReserve = Math.min(outputTokens, Math.floor(window / 4));
+    const active = Math.max(1, Math.min(policy.workingContextTokens || window, inputLimit, window - Math.max(reserve, outputReserve)));
+    return { active, checkpoint: active * policy.compactAtFraction };
 }
 function positiveInteger(raw) {
     const n = Number(raw);

package/dist/core/credentials.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { updateConfigObject } from "./config-storage.js";
 import { readOpenRouterCreds } from "../providers/openrouter-auth.js";
 import { talosConfigDir } from "./env-paths.js";
 // Posizione del file globale. null se la config globale e' disattivata
@@ -90,21 +91,21 @@ export function saveCredential(env, providerId, patch) {
     if (!path || !providerId.trim())
         return false;
     try {
-        const current = readJson(path);
-        const providers = parseStore(current["providers"]);
-        const merged = mergeCredential(providers[providerId], patch);
-        const nextProviders = { ...providers };
-        if (merged)
-            nextProviders[providerId] = merged;
-        else
-            delete nextProviders[providerId];
-        const next = { ...current };
-        if (Object.keys(nextProviders).length > 0)
-            next["providers"] = nextProviders;
-        else
-            delete next["providers"];
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+        updateConfigObject(path, (current) => {
+            const providers = parseStore(current["providers"]);
+            const merged = mergeCredential(providers[providerId], patch);
+            const nextProviders = { ...providers };
+            if (merged)
+                nextProviders[providerId] = merged;
+            else
+                delete nextProviders[providerId];
+            const next = { ...current };
+            if (Object.keys(nextProviders).length > 0)
+                next["providers"] = nextProviders;
+            else
+                delete next["providers"];
+            return next;
+        });
         return true;
     }
     catch {
@@ -118,19 +119,17 @@ export function deleteCredential(env, providerId) {
     if (!path || !providerId.trim())
         return false;
     try {
-        const current = readJson(path);
-        const providers = parseStore(current["providers"]);
-        if (!(providerId in providers))
-            return true;
-        const nextProviders = { ...providers };
-        delete nextProviders[providerId];
-        const next = { ...current };
-        if (Object.keys(nextProviders).length > 0)
-            next["providers"] = nextProviders;
-        else
-            delete next["providers"];
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+        updateConfigObject(path, (current) => {
+            const providers = parseStore(current["providers"]);
+            const nextProviders = { ...providers };
+            delete nextProviders[providerId];
+            const next = { ...current };
+            if (Object.keys(nextProviders).length > 0)
+                next["providers"] = nextProviders;
+            else
+                delete next["providers"];
+            return next;
+        });
         return true;
     }
     catch {

package/dist/core/effort.d.ts

@@ -1,5 +1,5 @@
 export type Effort = "" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export declare function effectiveToolName(name: string, input?: Record<string, unknown>): string;
-export declare function effortRoutingEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function effortRoutingEnabled(env: NodeJS.ProcessEnv, providerId?: string): boolean;
 export declare function isRoutineBatch(toolNames: readonly string[], hadError: boolean): boolean;
 export declare function routeEffort(base: Effort, turn: number, routine: boolean, enabled: boolean): Effort;

package/dist/core/effort.js

@@ -22,7 +22,11 @@ export function effectiveToolName(name, input) {
     const target = input?.["name"];
     return typeof target === "string" && target.trim() ? target.trim() : name;
 }
-export function effortRoutingEnabled(env) {
+export function effortRoutingEnabled(env, providerId = "") {
+    // Top-level effort changes invalidate Claude's message cache. Keep the
+    // user's effort stable rather than trading a cheap read for a full rewrite.
+    if (providerId === "anthropic" || providerId === "claude-code")
+        return false;
     const v = (env["TALOS_EFFORT_ROUTING"] ?? "").trim().toLowerCase();
     return !(v === "0" || v === "off" || v === "false" || v === "no");
 }

package/dist/core/execution-guidance.d.ts

@@ -1,5 +1,5 @@
 import type { ToolCallPart, ToolResultPart } from "./types.js";
-export declare const EXECUTION_GUIDANCE = "Efficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
+export declare const EXECUTION_GUIDANCE = "Efficient execution\n- Determine whether the user wants advice, an explanation, instructions for manual work, or\n  actual execution. Advice and manual instructions are fulfilled by the response; do not run\n  their example scripts or perform the user's setup. A todo list does not grant authorization.\n  Before continuing after an error, check whether further agent action is needed and authorized.\n  Stop when the request is answered; wait when the next step belongs to the user or needs input.\n  Preserve incomplete tasks honestly instead of forcing completion or retrying indefinitely.\n- For a small cosmetic change (one button color, label, spacing or font), locate the affected\n  component, edit it, then verify the local result. Do not create a plan, delegate, research the\n  web, inspect the whole repository or run a global test/build cycle unless evidence requires it.\n  Escalate scope only when the actual dependency or failure demands it.\n- Decide what evidence is needed for the next decision. Issue independent reads together and\n  reuse results that are still valid. Do not spend a model round on each already-decided action.\n- Use run_program for known sequences: await dependent edits and plan transitions in order,\n  stop on errors, and return a concise summary. Complete a task only after its checks succeed.\n- Prepare related replacements in one round. Never edit the same file concurrently. Independent\n  edits on distinct files may run together in bounded groups of at most four; await every outcome\n  before inspecting the result or starting dependent work. Keep permission gates in place.\n- For short checks use foreground bash, or background with its brief initial wait. Use\n  background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.\n  Collect ready background results together; a running command is not a passed check.\n  bash_output waits locally for completion by default: call it once and omit timeout_seconds.\n  Use wait=false only to inspect a persistent server or diagnose a process; do not poll in a loop.\n- Run the relevant integrated checks after the edits. Repeat checks only after changes, failures\n  or a concrete unresolved concern; do not duplicate typecheck and build without a reason.\n- When parallel work is authorized and worthwhile, start with at most two collaborators on\n  concrete disjoint areas, agree on interfaces and acceptance checks, and declare after dependencies.\n  The coordinator reviews the combined result. Prefer one agent for small or tightly coupled work.\n- Format user-facing responses in readable Markdown: short paragraphs, **bold** key findings,\n  lists for steps, tables for comparisons, fenced code with a language, and descriptive links.\n  Keep internal planning notation out of ordinary explanations unless the user asks for it.";
 export declare class ExecutionGuidance {
     private previous;
     private readonly reminded;

package/dist/core/execution-guidance.js

@@ -20,6 +20,8 @@ export const EXECUTION_GUIDANCE = `Efficient execution
 - For short checks use foreground bash, or background with its brief initial wait. Use
   background=true with yield_time_ms=0 for persistent servers or work that must detach immediately.
   Collect ready background results together; a running command is not a passed check.
+  bash_output waits locally for completion by default: call it once and omit timeout_seconds.
+  Use wait=false only to inspect a persistent server or diagnose a process; do not poll in a loop.
 - Run the relevant integrated checks after the edits. Repeat checks only after changes, failures
   or a concrete unresolved concern; do not duplicate typecheck and build without a reason.
 - When parallel work is authorized and worthwhile, start with at most two collaborators on

package/dist/core/file-coordination.d.ts

@@ -54,7 +54,10 @@ export declare class FileCoordinationHub {
     observe(pathValue: string, actor: FileActor): readonly FilePresence[];
     acquire(pathValue: string, actor: FileActor): FileLeaseResult;
     validate(lease: FileLease): readonly FilePresence[];
+    acquireAsync(pathValue: string, actor: FileActor, signal?: AbortSignal): Promise<FileLeaseResult>;
+    releaseAsync(lease: FileLease): Promise<void>;
     release(lease: FileLease): void;
+    private forgetLease;
     clearActor(actorId: string, includeLeases?: boolean): void;
     private activeConflicts;
     private storageFailure;

package/dist/core/file-coordination.js

@@ -85,11 +85,39 @@ export class FileCoordinationHub {
             return [this.storageFailure(lease.path, error)];
         }
     }
+    async acquireAsync(pathValue, actor, signal) {
+        const path = this.path(pathValue);
+        const conflicts = this.activeConflicts(path, actor.id);
+        if (conflicts.length)
+            return { ok: false, conflicts };
+        const lease = { id: `fl-${randomUUID()}`, path, actor };
+        try {
+            const shared = await this.persistent.acquireAsync(lease, signal);
+            if (shared.length)
+                return { ok: false, conflicts: shared };
+        }
+        catch (error) {
+            return { ok: false, conflicts: [this.storageFailure(path, error)] };
+        }
+        this.leases.set(lease.id, lease);
+        this.put({ path, mode: "writing", actor, updatedAt: Date.now(), leaseId: lease.id });
+        return { ok: true, lease };
+    }
+    async releaseAsync(lease) {
+        try {
+            await this.persistent.releaseAsync(lease);
+        }
+        catch { /* fail closed: retain the persistent lease */ }
+        this.forgetLease(lease);
+    }
     release(lease) {
         try {
             this.persistent.release(lease);
         }
         catch { /* fail closed: a later writer sees the retained lease */ }
+        this.forgetLease(lease);
+    }
+    forgetLease(lease) {
         this.leases.delete(lease.id);
         const entries = this.byPath.get(lease.path);
         const current = entries?.get(lease.actor.id);

package/dist/core/file-lease-store.d.ts

@@ -7,8 +7,11 @@ export declare class FileLeaseStore {
     constructor(directory: string);
     acquire(lease: FileLease): readonly FilePresence[];
     validate(lease: FileLease): readonly FilePresence[];
+    acquireAsync(lease: FileLease, signal?: AbortSignal): Promise<readonly FilePresence[]>;
+    releaseAsync(lease: FileLease): Promise<void>;
     release(lease: FileLease): void;
     list(path?: string): readonly FilePresence[];
     private transaction;
+    private update;
     private read;
 }

package/dist/core/file-lease-store.js

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, renameSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
-import { withLockSync } from "../vascend/file-lock.js";
+import { withLock, withLockSync } from "../vascend/file-lock.js";
 import { executionTargetKey, localExecutionTarget } from "./execution-target.js";
 import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
@@ -33,6 +33,21 @@ export class FileLeaseStore {
             : current ? [presence(current)] : [{ path: lease.path, mode: "writing", updatedAt: Date.now(),
                     actor: { id: "lease-lost", label: "lease di scrittura non piu' valida", kind: "external" } }];
     }
+    async acquireAsync(lease, signal) {
+        return withLock(this.path, () => this.update(records => {
+            const current = records[lease.path];
+            if (current)
+                return [presence(current)];
+            records[lease.path] = { ...lease, pid: process.pid, at: Date.now() };
+            return [];
+        }), {}, signal);
+    }
+    async releaseAsync(lease) {
+        await withLock(this.path, () => this.update(records => {
+            if (records[lease.path]?.id === lease.id)
+                delete records[lease.path];
+        }));
+    }
     release(lease) {
         this.transaction((records) => {
             if (records[lease.path]?.id === lease.id)
@@ -43,17 +58,18 @@ export class FileLeaseStore {
         return Object.values(this.read()).filter((record) => (!path || record.path === path) && alive(record.pid)).map(presence);
     }
     transaction(fn) {
-        return withLockSync(this.path, () => {
-            const records = this.read();
-            for (const [key, record] of Object.entries(records))
-                if (!alive(record.pid))
-                    delete records[key];
-            const value = fn(records);
-            const temp = this.path + "." + randomUUID() + ".tmp";
-            writeFileSync(temp, JSON.stringify(records), "utf8");
-            renameSync(temp, this.path);
-            return value;
-        });
+        return withLockSync(this.path, () => this.update(fn));
+    }
+    update(fn) {
+        const records = this.read();
+        for (const [key, record] of Object.entries(records))
+            if (!alive(record.pid))
+                delete records[key];
+        const value = fn(records);
+        const temp = this.path + "." + randomUUID() + ".tmp";
+        writeFileSync(temp, JSON.stringify(records), "utf8");
+        renameSync(temp, this.path);
+        return value;
     }
     read() {
         try {

package/dist/core/fusion.d.ts

@@ -0,0 +1,24 @@
+export type FusionGateMode = "guard" | "auto";
+export interface FusionConfig {
+    /** Modelli qualificati fra cui Jev puo' scegliere per un compito nuovo (oltre a quello attivo). */
+    readonly routes: readonly string[];
+    /** guard: Jev puo' solo bloccare o far chiedere; auto: un allow netto salta la domanda. */
+    readonly gate: FusionGateMode;
+    /** Focus per passo con pacchetti di tool. */
+    readonly focus: boolean;
+}
+export declare const DEFAULT_FUSION: FusionConfig;
+export declare function parseFusion(value: unknown): FusionConfig | null | undefined;
+export declare function fusionFromEnv(env: NodeJS.ProcessEnv): FusionConfig | null | undefined;
+export declare function isPaidTier(tier: string | undefined): boolean;
+export type FusionAvailability = {
+    readonly ok: true;
+    readonly channel: "dev" | "client";
+} | {
+    readonly ok: false;
+    readonly channel: "dev" | "client";
+    readonly reason: "missing_openrouter" | "missing_login" | "free_plan";
+};
+/** Cosa puo' fare questa installazione. Il tier, se noto, arriva dalla sessione Vascend. */
+export declare function fusionAvailability(env: NodeJS.ProcessEnv, tier?: string, hostProxy?: boolean): FusionAvailability;
+export declare function fusionUnavailableMessage(reason: "missing_openrouter" | "missing_login" | "free_plan" | "not_entitled"): string;