@vascend/talos 0.1.0

package/dist/core/compaction.js

@@ -0,0 +1,270 @@
+import { modelCapabilities } from "../providers/models-dev.js";
+export const DEFAULT_COMPACTION = {
+    enabled: true,
+    reserveTokens: 16_384,
+    keepRecentTokens: 20_000,
+    perRoom: true,
+    roomFanout: 8,
+};
+// Stima grezza dei token: ~4 caratteri per token (euristica comune).
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// Costo in token di UN'IMMAGINE nel contesto. Un'immagine non e' la sua
+// didascalia: uno screenshot 1280x800 vale ~1400 token per i modelli Anthropic
+// (larghezza*altezza/750, con tetto a 1600). Contarla come "[immagine png]" —
+// cinque token — faceva sballare la stima proprio nelle sessioni Computer Use,
+// dove sei screenshot pesano piu' di tutta la conversazione.
+export const IMAGE_TOKEN_ESTIMATE = 1_400;
+function messageText(message) {
+    return message.content
+        .map((part) => {
+        if (part.type === "text")
+            return part.text;
+        if (part.type === "tool_call")
+            return part.name + JSON.stringify(part.input);
+        if (part.type === "image")
+            return `[immagine ${part.mime}]`;
+        return part.output;
+    })
+        .join("\n");
+}
+// Quante immagini viaggiano in un messaggio, comprese quelle allegate a un tool
+// result (screenshot di Computer Use): il provider le manda al modello come
+// input visivo, quindi occupano la finestra come tutto il resto.
+function messageImages(message) {
+    return message.content.reduce((count, part) => {
+        if (part.type === "image")
+            return count + 1;
+        if (part.type === "tool_result")
+            return count + (part.media?.length ?? 0);
+        return count;
+    }, 0);
+}
+export function estimateMessagesTokens(messages) {
+    return messages.reduce((acc, m) => acc + estimateTokens(messageText(m)) + messageImages(m) * IMAGE_TOKEN_ESTIMATE + 4, 0);
+}
+// Gli schemi dei tool sono parte del prompt inviato a ogni chiamata. La stima
+// del contesto li deve includere, pur restando distinta dall'usage reale che
+// arriva dal provider con il suo tokenizer.
+export function estimateToolDefinitionTokens(tools) {
+    // Providers send one input schema. `schema` is an SDK compatibility alias;
+    // serializing the registry itself counted it twice and compacted too early.
+    // Use the OpenAI function envelope as a common estimate, not provider usage.
+    return tools.length ? estimateTokens(JSON.stringify(tools.map((tool) => ({
+        type: "function",
+        function: { name: tool.name, description: tool.description, parameters: tool.inputSchema ?? tool.schema ?? {} },
+    })))) : 0;
+}
+// Finestra di contesto per modello (token). `override` (>0) ha la precedenza:
+// serve a forzare il valore reale quando non e' deducibile dall'id (es. la
+// variante 1M di Opus/Sonnet, abilitata via beta header, ha lo stesso id del
+// modello da 200k). L'id che contiene "1m" viene comunque riconosciuto.
+export function contextWindowFor(model, override = 0) {
+    if (override > 0)
+        return override;
+    const catalogLimit = modelCapabilities(model)?.context;
+    if (catalogLimit && catalogLimit > 0)
+        return catalogLimit;
+    const m = model.toLowerCase();
+    if (m.includes("1m"))
+        return 1_000_000;
+    if (m.includes("gpt-5.6") || m.includes("gpt-6-astra"))
+        return 1_050_000;
+    if (/claude-(?:fable|opus|sonnet)-5(?:\b|[-.])/.test(m))
+        return 1_000_000;
+    if (m.includes("gpt-5") || m.includes("codex"))
+        return 272_000;
+    // Opus 4.x / Sonnet 4.x: finestra 1M (beta) disponibile su abbonamento.
+    if (/opus-4|sonnet-4/.test(m))
+        return 1_000_000;
+    if (m.includes("claude"))
+        return 200_000;
+    if (m.includes("gemini"))
+        return 1_000_000;
+    if (m.includes("llama") || m.includes("mistral") || m.includes("deepseek"))
+        return 128_000;
+    return 128_000;
+}
+export function shouldCompact(contextTokens, contextWindow, reserveTokens) {
+    return contextTokens > contextWindow - reserveTokens;
+}
+// Frazione della soglia dura oltre la quale conviene gia' cominciare.
+export const SPECULATIVE_FRACTION = 0.8;
+export function planCompactionMove(input) {
+    if (!input.enabled)
+        return "none";
+    if (shouldCompact(input.tokens, input.contextWindow, input.reserveTokens)) {
+        return input.inFlight ? "await" : "now";
+    }
+    if (input.inFlight)
+        return "none";
+    const fraction = input.speculativeFraction ?? SPECULATIVE_FRACTION;
+    const threshold = Math.max(0, input.contextWindow - input.reserveTokens);
+    return input.tokens > threshold * fraction ? "speculative" : "none";
+}
+// Cammina all'indietro accumulando token fino a keepRecentTokens, poi allinea
+// il taglio a un confine di turno (messaggio utente). Ritorna null se non c'e'
+// abbastanza da riassumere.
+export function planCompaction(messages, keepRecentTokens) {
+    if (messages.length < 2)
+        return null;
+    let acc = 0;
+    let cut = messages.length;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        acc += estimateMessagesTokens([msg]);
+        cut = i;
+        if (acc >= keepRecentTokens)
+            break;
+    }
+    // Allinea a un confine di turno: arretra fino a un messaggio utente.
+    let boundary = cut;
+    while (boundary > 0) {
+        const message = messages[boundary];
+        if (message?.role === "user" && !message.content.some((part) => part.type === "tool_result"))
+            break;
+        boundary -= 1;
+    }
+    if (boundary <= 0 || estimateMessagesTokens(messages.slice(boundary)) > Math.max(keepRecentTokens * 2, keepRecentTokens + 4_000)) {
+        // Un singolo turno lungo puo' attraversare molti waypoint. Non conservare
+        // l'intero turno soltanto per raggiungere il suo messaggio utente.
+        if (cut <= 0)
+            return null;
+        boundary = cut;
+    }
+    // In un singolo turno lungo il cut grezzo puo' cadere tra una chiamata e
+    // il risultato. Risali alle chiamate dei risultati conservati, includendo
+    // l'intero batch anche quando i risultati occupano messaggi separati.
+    const resultPositions = new Map();
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        for (const part of messages[i].content) {
+            if (part.type === "tool_result" && !resultPositions.has(part.callId))
+                resultPositions.set(part.callId, i);
+            if (part.type === "tool_call" && i < boundary && (resultPositions.get(part.id) ?? -1) >= boundary) {
+                boundary = i;
+            }
+        }
+    }
+    if (boundary <= 0 || boundary >= messages.length)
+        return null;
+    return {
+        cutIndex: boundary,
+        toSummarize: messages.slice(0, boundary),
+        toKeep: messages.slice(boundary),
+    };
+}
+// --- cio' che una compattazione non ha il diritto di perdere -----------------
+//
+// Il taglio e' posizionale: guarda l'eta' dei messaggi, non il loro legame col
+// lavoro in corso. Cosi' una decisione ancora viva puo' finire dissolta in
+// prosa mentre 20k token di output stantio sopravvivono solo perche' recenti.
+// Le funzioni qui sotto danno al compattatore un secondo criterio: un elenco
+// di ANCORE (task attivo, termini pinnati, simboli dei contratti aperti) che
+// devono restare leggibili dopo la compattazione.
+//
+// Sono pure: la politica su cosa sia un'ancora sta nel chiamante.
+// Righe verbatim al massimo estratte per ancora, e loro lunghezza.
+const EXCERPT_MAX_CHARS = 1_400;
+const EXCERPT_LINE_MAX = 220;
+// Ancore assenti dal riassunto (confronto case-insensitive).
+export function verifySummary(summary, anchors, preservedMessages = []) {
+    const hay = [summary, ...preservedMessages.map(messageText)].join("\n").toLowerCase();
+    return anchors
+        .map((a) => a.trim())
+        .filter((a) => a.length > 1 && !hay.includes(a.toLowerCase()));
+}
+// Per ogni ancora, l'ULTIMA riga dei messaggi che la nomina: e' quella che
+// racconta lo stato piu' aggiornato di quel riferimento.
+export function protectedExcerpts(messages, anchors, maxChars = EXCERPT_MAX_CHARS) {
+    if (!anchors.length)
+        return [];
+    const lines = messages.flatMap((m) => messageText(m).split("\n")).map((l) => l.trim()).filter(Boolean);
+    const out = [];
+    let used = 0;
+    for (const anchor of anchors) {
+        const needle = anchor.trim().toLowerCase();
+        if (needle.length <= 1)
+            continue;
+        let found = "";
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            const line = lines[i];
+            if (line.toLowerCase().includes(needle)) {
+                found = line.length > EXCERPT_LINE_MAX ? `${line.slice(0, EXCERPT_LINE_MAX)}…` : line;
+                break;
+            }
+        }
+        const entry = `@ancora[${anchor}]: ${found || "(nessun dettaglio nei messaggi compattati)"}`;
+        if (used + entry.length > maxChars)
+            break;
+        out.push(entry);
+        used += entry.length;
+    }
+    return out;
+}
+// Innesta gli stralci in coda al riassunto. Verbatim e separati, cosi' non
+// possono essere parafrasati via da una rigenerazione.
+export function withProtectedExcerpts(summary, excerpts) {
+    if (!excerpts.length)
+        return summary;
+    return `${summary}\n\nANCORE PRESERVATE (verbatim, non riassunte)\n${excerpts.join("\n")}`;
+}
+// Istruzioni di RIPARAZIONE per il secondo tentativo: dice al compressore cosa
+// ha perso, senza rifare tutto da capo.
+export function repairInstructions(missing, base) {
+    const list = missing.join(", ");
+    const head = `Il riassunto precedente ha PERSO questi riferimenti, che sono ancora attivi e vanno mantenuti espliciti: ${list}.`;
+    return base ? `${base}\n${head}` : head;
+}
+const SUMMARY_SYSTEM = `Sei un compressore di contesto Danilov. Comprimi la conversazione in NOTAZIONE
+Danilov, mai in prosa. Preserva lo stato operativo necessario a riprendere il
+lavoro senza reinterpretarlo. Tre piani separati e chiusura OUTPUT:
+
+INDICE
+<concetti chiave, una parola per voce, numerati da 1>
+
+DEFINIZIONI
+@goal[current]: obiettivo corrente e sue revisioni esplicite; marca come superate le versioni precedenti
+@stato[done]: lavoro completato, solo con evidenze concrete (file, tool, test o risultato osservato)
+@stato[pending]: lavoro richiesto ma non ancora completato
+@blocker[..]: impedimento o errore ancora aperto e relativo effetto
+@vincolo[user]: preferenze, divieti e criteri imposti dall'utente
+@scelta[..]: decisione=motivo
+@file[..]: path, stato
+@next[action]: prossima azione esatta, eseguibile e fondata nella conversazione
+
+RELAZIONI
+@R: <dipendenze e legami tra le voci>
+
+OUTPUT: stato compatto per continuare il lavoro. Completo ma asciutto. Se una
+categoria non e' presente, omettila. Non inventare fatti, evidenze, vincoli,
+blocker o azioni; non trasformare intenzioni o tentativi in lavoro completato.
+Ai waypoint conserva obiettivo, vincoli, attivita aperte, file in lavorazione,
+decisioni, verifiche e prossimo passo. Riassumi il lavoro concluso senza
+duplicarne i log. Conserva gli identificativi degli output archiviati e i
+riferimenti utili a recuperarli con output_page o recall.`;
+// Genera il riassunto strutturato dei messaggi da compattare, dato l'eventuale
+// riassunto precedente e istruzioni opzionali dell'utente.
+export async function summarizeMessages(provider, toSummarize, opts) {
+    const transcript = toSummarize
+        .map((m) => `[${m.role}] ${messageText(m)}`)
+        .join("\n\n");
+    const prev = opts.previousSummary ? `Riassunto precedente:\n${opts.previousSummary}\n\n` : "";
+    const extra = opts.instructions ? `Istruzioni aggiuntive: ${opts.instructions}\n\n` : "";
+    const userText = `${prev}${extra}Conversazione da riassumere:\n\n${transcript}`;
+    const result = await provider.complete({
+        system: SUMMARY_SYSTEM,
+        messages: [{ role: "user", content: [{ type: "text", text: userText }] }],
+        tools: [],
+        model: opts.model,
+        maxTokens: opts.maxTokens,
+        signal: opts.signal,
+    });
+    // Un riassunto e' utilizzabile soltanto dopo una chiusura semantica completa.
+    // Testo parziale accompagnato da max_tokens/error/tool_use non deve mai
+    // sostituire il prefisso della sessione: compactNow interpreta la stringa
+    // vuota come compattazione fallita e lascia intatta la cronologia corrente.
+    return result.stopReason === "end" ? result.text.trim() : "";
+}

package/dist/core/config.d.ts

@@ -0,0 +1,49 @@
+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.";
+export type TalosBanner = "vascend-terminal" | "minimal" | "custom" | "none";
+export type TalosEffort = "" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type TalosPermMode = "normal" | "acceptEdits" | "auto";
+export type TalosColor = "blue" | "cyan" | "dim" | "gray" | "green" | "magenta" | "red" | "white" | "yellow";
+export interface TalosUiConfig {
+    readonly banner: TalosBanner;
+    readonly logoLines: readonly string[];
+    readonly title: string;
+    readonly subtitle: string;
+    readonly prompt: string;
+    readonly accentColor: TalosColor;
+    readonly mutedColor: TalosColor;
+    readonly showMeta: boolean;
+    readonly theme: string;
+}
+export interface PiConfig {
+    readonly cwd: string;
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly system: string;
+    readonly autoDelegatePlans: boolean;
+    readonly workerModelPool?: readonly string[];
+    readonly sessionDir: string;
+    readonly contextFiles: readonly string[];
+    readonly loadedConfigFiles: readonly string[];
+    readonly ui: TalosUiConfig;
+    readonly compaction: CompactionConfig;
+    readonly contextWindow: number;
+    readonly roomStoreId?: string;
+    readonly roomNamespace?: string;
+    readonly planStoreId?: string;
+    /** Assigned portion of the shared plan, independent of the worker's slug. */
+    readonly planCastle?: string;
+    readonly planTasks?: readonly string[];
+    readonly effort: TalosEffort;
+    readonly fast?: boolean;
+    readonly permMode: TalosPermMode;
+    readonly statusLine?: readonly string[];
+    readonly vibeMode: VibeModeSelection;
+}
+export declare function buildConfig(opts: {
+    cwd?: string;
+    model?: string;
+    env: NodeJS.ProcessEnv;
+}): PiConfig;