@vascend/talos 0.1.0

package/dist/core/user-inbox.js

@@ -0,0 +1,56 @@
+// Casella dei messaggi che l'utente scrive MENTRE l'agente sta lavorando.
+//
+// Il turno dell'agente non e' istantaneo: legge file, lancia comandi, itera. Se
+// l'utente ha una correzione da dare ("no, l'altro file", "fermati sul test")
+// farla aspettare la fine della risposta significa lasciar proseguire il lavoro
+// sbagliato. Qui i messaggi si accumulano e il loop li preleva al primo confine
+// sicuro -- subito dopo gli esiti dei tool, prima di interrogare di nuovo il
+// modello -- cosi' entrano nel contesto senza spezzare l'accoppiamento fra
+// tool_use e tool_result, che l'API impone.
+//
+// La casella non decide nulla: e' un punto di rendez-vous fra chi scrive
+// (host: chat, TUI, RPC) e chi consuma (il loop dell'agente). Ogni messaggio
+// porta un id, cosi' l'host puo' dire all'utente quando e' stato davvero letto.
+export function createUserInbox(now = Date.now) {
+    let queue = [];
+    let sequence = 0;
+    return {
+        push(input, id) {
+            const parts = typeof input === "string"
+                ? [{ type: "text", text: input }]
+                : input;
+            const messageId = id ?? `inbox-${now().toString(36)}-${(++sequence).toString(36)}`;
+            queue = [...queue, { id: messageId, parts, queuedAt: now() }];
+            return messageId;
+        },
+        promote(id) {
+            const target = String(id || "");
+            const index = queue.findIndex((message) => message.id === target);
+            if (index < 0)
+                return false;
+            if (index === 0)
+                return true;
+            const selected = queue[index];
+            queue = [selected, ...queue.slice(0, index), ...queue.slice(index + 1)];
+            return true;
+        },
+        get pending() {
+            return queue.length;
+        },
+        drain() {
+            if (!queue.length)
+                return [];
+            const out = queue;
+            queue = [];
+            return out;
+        },
+    };
+}
+// Testo leggibile di un messaggio in coda: serve agli host per l'eco in UI e
+// agli hook che ricevono l'input.
+export function pendingText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+}

package/dist/core/user-input.d.ts

@@ -0,0 +1,10 @@
+import type { ToolContext } from "./types.js";
+type Ask = NonNullable<ToolContext["ask"]>;
+export type UserAnswer = {
+    readonly status: "answered";
+    readonly answer: string;
+} | {
+    readonly status: "unavailable" | "unanswered" | "cancelled" | "failed";
+};
+export declare function requestAnswer(ask: Ask, question: string, options: readonly string[] | undefined, signal: AbortSignal): Promise<UserAnswer>;
+export {};

package/dist/core/user-input.js

@@ -0,0 +1,35 @@
+// One host callback owns one question surface, shared by the main agent and team.
+// Keep an active prompt in the queue even if its caller aborts: the host must
+// close that prompt before another collaborator can open one on the same UI.
+const questionQueues = new WeakMap();
+export async function requestAnswer(ask, question, options, signal) {
+    if (signal.aborted)
+        return { status: "cancelled" };
+    const previous = questionQueues.get(ask) ?? Promise.resolve();
+    const pending = previous.then(async () => {
+        if (signal.aborted)
+            return { status: "cancelled" };
+        try {
+            const answer = await ask(question, options);
+            if (signal.aborted)
+                return { status: "cancelled" };
+            return typeof answer === "string" && answer.trim()
+                ? { status: "answered", answer }
+                : { status: "unanswered" };
+        }
+        catch {
+            return { status: "failed" };
+        }
+    });
+    const settled = pending.then(() => { });
+    questionQueues.set(ask, settled);
+    void settled.then(() => { if (questionQueues.get(ask) === settled)
+        questionQueues.delete(ask); });
+    return new Promise((resolve) => {
+        const abort = () => { signal.removeEventListener("abort", abort); resolve({ status: "cancelled" }); };
+        signal.addEventListener("abort", abort, { once: true });
+        void pending.then((answer) => { signal.removeEventListener("abort", abort); resolve(answer); });
+        if (signal.aborted)
+            abort();
+    });
+}

package/dist/core/version.d.ts

@@ -0,0 +1 @@
+export declare const TALOS_VERSION: string;

package/dist/core/version.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+export const TALOS_VERSION = (() => {
+    try {
+        const value = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+        return typeof value === "string" ? value : "dev";
+    }
+    catch {
+        return "dev";
+    }
+})();

package/dist/core/vibe-modes.d.ts

@@ -0,0 +1,38 @@
+import type { BudgetPolicy } from "../vascend/budget-allocator.js";
+import type { ScoreWeights, TierThresholds } from "../vascend/context-scorer.js";
+export declare const VIBE_MODE_IDS: readonly ["classic", "flow", "architect", "debug", "refactor", "test", "review", "ui", "ship", "migrate", "incident", "research", "security", "performance", "swarm", "ultracheck"];
+export type VibeModeId = (typeof VIBE_MODE_IDS)[number];
+export type VibeModeSelection = VibeModeId | "auto";
+export interface VibeModeContextRecipe {
+    readonly totalTokens: number;
+    readonly policy: BudgetPolicy;
+    readonly weights: ScoreWeights;
+    readonly thresholds: TierThresholds;
+    readonly focusTerms: readonly string[];
+    readonly proofChains: boolean;
+}
+export interface VibeModeSpec {
+    readonly id: VibeModeId;
+    readonly label: string;
+    readonly summary: string;
+    readonly firstMove: string;
+    readonly operatingRules: readonly string[];
+    readonly completionGates: readonly string[];
+    readonly signals: ReadonlyArray<{
+        readonly phrase: string;
+        readonly weight: number;
+    }>;
+    readonly context: VibeModeContextRecipe;
+}
+export interface VibeModeRoute {
+    readonly requested: VibeModeSelection;
+    readonly resolved: VibeModeId;
+    readonly confidence: number;
+    readonly reasons: readonly string[];
+}
+export declare function parseVibeMode(value: unknown): VibeModeSelection | undefined;
+export declare function vibeModeSpec(id: VibeModeId): VibeModeSpec;
+export declare function listVibeModes(): readonly VibeModeSpec[];
+export declare function isContinuationText(value: string): boolean;
+export declare function routeVibeMode(requested: VibeModeSelection, _userText: string, _previous?: VibeModeId): VibeModeRoute;
+export declare function renderVibeModeBlock(route: VibeModeRoute): string;

package/dist/core/vibe-modes.js

@@ -0,0 +1,383 @@
+// Le modalita' di vibecoding non sono semplici prompt cosmetici: ogni profilo
+// cambia il processo operativo, i gate di completamento e la lente con cui il
+// Context Fabric spende il budget della context window.
+export const VIBE_MODE_IDS = [
+    "classic",
+    "flow",
+    "architect",
+    "debug",
+    "refactor",
+    "test",
+    "review",
+    "ui",
+    "ship",
+    "migrate",
+    "incident",
+    "research",
+    "security",
+    "performance",
+    "swarm",
+    "ultracheck",
+];
+const BALANCED_POLICY = {
+    system: 0.06,
+    mission: 0.09,
+    vision: 0.1,
+    memory: 0.16,
+    evidence: 0.3,
+    recall: 0.12,
+    tool: 0.13,
+    tail: 0.04,
+};
+const EVIDENCE_POLICY = {
+    system: 0.05,
+    mission: 0.08,
+    vision: 0.06,
+    memory: 0.12,
+    evidence: 0.4,
+    recall: 0.15,
+    tool: 0.1,
+    tail: 0.04,
+};
+const DESIGN_POLICY = {
+    system: 0.06,
+    mission: 0.12,
+    vision: 0.16,
+    memory: 0.18,
+    evidence: 0.24,
+    recall: 0.14,
+    tool: 0.06,
+    tail: 0.04,
+};
+const EXECUTION_POLICY = {
+    system: 0.05,
+    mission: 0.08,
+    vision: 0.07,
+    memory: 0.12,
+    evidence: 0.28,
+    recall: 0.08,
+    tool: 0.28,
+    tail: 0.04,
+};
+const BASE_WEIGHTS = {
+    relevance: 1,
+    dependency: 0.8,
+    trust: 0.65,
+    freshness: 0.55,
+    novelty: 0.4,
+    conflictRisk: 1,
+    tokenCost: 0.3,
+};
+const EVIDENCE_WEIGHTS = {
+    relevance: 1.2,
+    dependency: 0.9,
+    trust: 0.95,
+    freshness: 0.75,
+    novelty: 0.35,
+    conflictRisk: 1.25,
+    tokenCost: 0.2,
+};
+const ARCHITECTURE_WEIGHTS = {
+    relevance: 1.05,
+    dependency: 1.15,
+    trust: 0.9,
+    freshness: 0.45,
+    novelty: 0.55,
+    conflictRisk: 1.15,
+    tokenCost: 0.25,
+};
+const FRESH_WEIGHTS = {
+    relevance: 1.1,
+    dependency: 0.75,
+    trust: 0.7,
+    freshness: 1.1,
+    novelty: 0.35,
+    conflictRisk: 1,
+    tokenCost: 0.22,
+};
+const DEFAULT_THRESHOLDS = { high: 1.2, mid: 0.5 };
+const STRICT_THRESHOLDS = { high: 1.35, mid: 0.65 };
+function recipe(totalTokens, policy, weights, focusTerms, proofChains = false, thresholds = DEFAULT_THRESHOLDS) {
+    return { totalTokens, policy, weights, thresholds, focusTerms, proofChains };
+}
+const MODES = {
+    classic: {
+        id: "classic",
+        label: "Classic",
+        summary: "Comportamento Talos essenziale, senza una procedura specializzata.",
+        firstMove: "Comprendi la richiesta e scegli la prossima azione minima utile.",
+        operatingRules: ["Usa le primitive del repository", "Mantieni il cambiamento proporzionato alla richiesta"],
+        completionGates: ["Risultato richiesto consegnato", "Verifica proporzionata al rischio"],
+        signals: [],
+        context: recipe(3_000, BALANCED_POLICY, BASE_WEIGHTS, []),
+    },
+    flow: {
+        id: "flow",
+        label: "Flow",
+        summary: "Vertical slice rapido con feedback frequente e poco overhead.",
+        firstMove: "Trova il percorso end-to-end piu' corto che produce valore osservabile.",
+        operatingRules: ["Costruisci una slice funzionante prima di rifinire", "Mantieni cicli edit-test brevi", "Evita astrazioni premature"],
+        completionGates: ["Percorso principale eseguibile", "Test mirati verdi", "Nessuna regressione evidente"],
+        signals: [
+            { phrase: "prototype", weight: 3 }, { phrase: "prototipo", weight: 3 },
+            { phrase: "mvp", weight: 3 }, { phrase: "scaffold", weight: 2 },
+            { phrase: "velocemente", weight: 1.5 }, { phrase: "quick", weight: 1.5 },
+        ],
+        context: recipe(2_800, EXECUTION_POLICY, FRESH_WEIGHTS, ["vertical slice", "feedback", "main path", "targeted test"]),
+    },
+    architect: {
+        id: "architect",
+        label: "Architect",
+        summary: "Contratti e confini prima del codice, con alternative e conseguenze esplicite.",
+        firstMove: "Mappa componenti, invarianti, flussi e punti di estensione prima di scegliere la forma.",
+        operatingRules: ["Rendi espliciti invarianti e trade-off", "Preferisci interfacce piccole e reversibili", "Confronta almeno due opzioni quando la scelta e' strutturale"],
+        completionGates: ["Contratti coerenti", "Rischi e migrazione considerati", "Decisione verificabile nel codice"],
+        signals: [
+            { phrase: "architettura", weight: 3 }, { phrase: "architecture", weight: 3 },
+            { phrase: "paradigma", weight: 4 }, { phrase: "design system", weight: 2 },
+            { phrase: "context management", weight: 3 }, { phrase: "gestione del context", weight: 3 },
+            { phrase: "api design", weight: 2 }, { phrase: "contratto", weight: 1.5 },
+        ],
+        context: recipe(4_200, DESIGN_POLICY, ARCHITECTURE_WEIGHTS, ["invariant", "contract", "boundary", "trade-off", "decision", "dependency"], true),
+    },
+    debug: {
+        id: "debug",
+        label: "Debug Lab",
+        summary: "Riproduzione, ipotesi falsificabili, root cause e regression test.",
+        firstMove: "Riproduci il difetto e raccogli l'evidenza che separa sintomo e causa.",
+        operatingRules: ["Non correggere prima di avere una riproduzione", "Cambia una variabile alla volta", "Preferisci la causa minima al workaround"],
+        completionGates: ["Root cause dimostrata", "Regression test rosso poi verde", "Fix minimo senza mascherare errori"],
+        signals: [
+            { phrase: "bug", weight: 3 }, { phrase: "errore", weight: 2.5 },
+            { phrase: "error", weight: 2.5 }, { phrase: "debug", weight: 4 },
+            { phrase: "root cause", weight: 4 }, { phrase: "non funziona", weight: 3 },
+            { phrase: "failing", weight: 2 }, { phrase: "stack trace", weight: 3 },
+        ],
+        context: recipe(4_000, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["failure", "reproduction", "root cause", "stacktrace", "regression", "last known good"], true),
+    },
+    refactor: {
+        id: "refactor",
+        label: "Refactor",
+        summary: "Trasformazione incrementale a comportamento invariato.",
+        firstMove: "Blocca il comportamento corrente con test di caratterizzazione e identifica il seam piu' sicuro.",
+        operatingRules: ["Separa ristrutturazione e cambio funzionale", "Procedi per passi compilabili", "Riduci accoppiamento senza ampliare lo scope"],
+        completionGates: ["Comportamento preservato", "Test caratterizzazione verdi", "Diff leggibile e reversibile"],
+        signals: [
+            { phrase: "refactor", weight: 4 }, { phrase: "ristruttur*", weight: 3 },
+            { phrase: "cleanup", weight: 2 }, { phrase: "debt", weight: 2 },
+            { phrase: "duplicazione", weight: 2 }, { phrase: "coupling", weight: 2 },
+        ],
+        context: recipe(3_500, EXECUTION_POLICY, ARCHITECTURE_WEIGHTS, ["public behavior", "characterization", "callsite", "seam", "contract", "dependency"]),
+    },
+    test: {
+        id: "test",
+        label: "Test Lock",
+        summary: "Fault model e prove deterministiche prima della dichiarazione di successo.",
+        firstMove: "Definisci il fault model e il test che fallirebbe se il requisito fosse violato.",
+        operatingRules: ["Testa comportamento, non dettagli accidentali", "Copri confini ed error path", "Elimina flakiness e dipendenze globali"],
+        completionGates: ["Test nuovo significativo", "Suite pertinente verde", "Fallimento osservabile prima del fix quando applicabile"],
+        signals: [
+            { phrase: "aggiungi test", weight: 4 }, { phrase: "test suite", weight: 3 },
+            { phrase: "coverage", weight: 3 }, { phrase: "flaky", weight: 4 },
+            { phrase: "regression test", weight: 4 }, { phrase: "property test", weight: 3 },
+        ],
+        context: recipe(3_600, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["assertion", "fixture", "edge case", "failure", "coverage", "deterministic"]),
+    },
+    review: {
+        id: "review",
+        label: "Review",
+        summary: "Revisione evidence-first orientata a difetti azionabili e rischio reale.",
+        firstMove: "Leggi il diff e ricostruisci i contratti toccati prima di formulare findings.",
+        operatingRules: ["Dai priorita' a correttezza e data loss", "Ogni finding deve avere evidenza e impatto", "Evita preferenze stilistiche non bloccanti"],
+        completionGates: ["Findings ordinati per severita'", "Linee e scenario di riproduzione", "Copertura dei percorsi critici"],
+        signals: [
+            { phrase: "review", weight: 4 }, { phrase: "code review", weight: 4 },
+            { phrase: "audit", weight: 3 }, { phrase: "trova bug", weight: 3 },
+            { phrase: "pull request", weight: 2 }, { phrase: "diff", weight: 1.5 },
+        ],
+        context: recipe(4_000, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["diff", "contract", "regression", "data loss", "security", "callsite"], true, STRICT_THRESHOLDS),
+    },
+    ui: {
+        id: "ui",
+        label: "UI Studio",
+        summary: "Interfacce complete di stati, responsive, accessibilita' e visual QA.",
+        firstMove: "Inventaria design system, layout, stati e superfici gia' esistenti prima di modificare la vista.",
+        operatingRules: ["Progetta loading, empty, error e success", "Verifica tastiera e responsive", "Riusa token e componenti esistenti"],
+        completionGates: ["Stati principali visibili", "Accessibilita' e tastiera verificate", "Visual QA alle larghezze critiche"],
+        signals: [
+            { phrase: "ui", weight: 2.5 }, { phrase: "interfaccia", weight: 3 },
+            { phrase: "frontend", weight: 2 }, { phrase: "layout", weight: 2 },
+            { phrase: "responsive", weight: 3 }, { phrase: "accessibil*", weight: 3 },
+            { phrase: "tui", weight: 3 }, { phrase: "desktop", weight: 1.5 },
+        ],
+        context: recipe(3_600, EXECUTION_POLICY, FRESH_WEIGHTS, ["design token", "component", "state", "keyboard", "responsive", "accessibility", "visual qa"]),
+    },
+    ship: {
+        id: "ship",
+        label: "Release Guard",
+        summary: "Hardening di rilascio con build, compatibilita', sicurezza e rollback.",
+        firstMove: "Definisci artefatto, ambienti, gate CI e strategia di rollback.",
+        operatingRules: ["Non confondere build riuscita con release sicura", "Controlla config e migrazioni", "Mantieni un rollback praticabile"],
+        completionGates: ["Build e suite richieste verdi", "Migrazione/rollback verificati", "Note operative aggiornate"],
+        signals: [
+            { phrase: "release", weight: 4 }, { phrase: "ship", weight: 3 },
+            { phrase: "deploy", weight: 3 }, { phrase: "production", weight: 3 },
+            { phrase: "pubblic*", weight: 2 }, { phrase: "ci/cd", weight: 3 },
+        ],
+        context: recipe(4_000, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["build", "release", "compatibility", "migration", "rollback", "security", "ci"]),
+    },
+    migrate: {
+        id: "migrate",
+        label: "Migration Wave",
+        summary: "Migrazione a ondate con compatibilita' esplicita e rollback.",
+        firstMove: "Mappa produttori, consumatori, dati e contratti prima di definire le ondate.",
+        operatingRules: ["Mantieni compatibilita' durante la transizione", "Separa schema, backfill e cutover", "Ogni onda deve essere osservabile e reversibile"],
+        completionGates: ["Callsite inventariati", "Backfill/cutover verificati", "Rollback e rimozione legacy pianificati"],
+        signals: [
+            { phrase: "migrazione", weight: 4 }, { phrase: "migration", weight: 4 },
+            { phrase: "upgrade", weight: 3 }, { phrase: "backfill", weight: 4 },
+            { phrase: "legacy", weight: 2 }, { phrase: "deprecat*", weight: 2 },
+        ],
+        context: recipe(4_300, DESIGN_POLICY, ARCHITECTURE_WEIGHTS, ["compatibility", "schema", "consumer", "producer", "backfill", "cutover", "rollback"], true),
+    },
+    incident: {
+        id: "incident",
+        label: "Incident Glassbox",
+        summary: "Contenimento e ripristino evidence-first, senza refactor opportunistici.",
+        firstMove: "Stabilisci impatto, timeline e misura di contenimento piu' reversibile.",
+        operatingRules: ["Contieni prima di ottimizzare", "Preserva evidenza e timeline", "Evita cambiamenti non necessari durante il recupero"],
+        completionGates: ["Impatto contenuto", "Servizio verificato", "Root cause e azioni preventive registrate"],
+        signals: [
+            { phrase: "incident", weight: 5 }, { phrase: "outage", weight: 5 },
+            { phrase: "down", weight: 2 }, { phrase: "produzione rotta", weight: 5 },
+            { phrase: "emergenza", weight: 4 }, { phrase: "sev1", weight: 5 },
+        ],
+        context: recipe(4_500, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["impact", "timeline", "containment", "last known good", "rollback", "root cause"], true, STRICT_THRESHOLDS),
+    },
+    research: {
+        id: "research",
+        label: "Research",
+        summary: "Ricerca verificabile con fonti primarie, esperimenti e decision matrix.",
+        firstMove: "Formula le domande decisionali e raccogli evidenza primaria per ciascuna.",
+        operatingRules: ["Distingui fatti, inferenze e ipotesi", "Preferisci fonti primarie", "Riduci l'incertezza con piccoli esperimenti"],
+        completionGates: ["Fonti/evidenze tracciabili", "Alternative confrontate", "Raccomandazione e incertezze esplicite"],
+        signals: [
+            { phrase: "ricerca", weight: 3 }, { phrase: "research", weight: 3 },
+            { phrase: "confront*", weight: 2 }, { phrase: "benchmark", weight: 2 },
+            { phrase: "documentazione", weight: 2 }, { phrase: "documentation", weight: 2 },
+            { phrase: "best practice", weight: 2 },
+        ],
+        context: recipe(4_200, DESIGN_POLICY, EVIDENCE_WEIGHTS, ["source", "evidence", "hypothesis", "experiment", "alternative", "uncertainty"], true),
+    },
+    security: {
+        id: "security",
+        label: "Security",
+        summary: "Threat model, confini di fiducia e prove negative prima del fix.",
+        firstMove: "Mappa asset, attori, trust boundary e percorso di abuso.",
+        operatingRules: ["Assumi input ostile ai confini", "Non esporre segreti nei log", "Preferisci deny-by-default e least privilege"],
+        completionGates: ["Abuse case riprodotto o escluso", "Fix sul trust boundary", "Test negativo e regressione"],
+        signals: [
+            { phrase: "security", weight: 4 }, { phrase: "sicurezza", weight: 4 },
+            { phrase: "vulnerab*", weight: 4 }, { phrase: "auth", weight: 2 },
+            { phrase: "permission", weight: 2 }, { phrase: "segreto", weight: 2 },
+            { phrase: "injection", weight: 4 },
+        ],
+        context: recipe(4_300, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["asset", "attacker", "trust boundary", "permission", "secret", "abuse case", "negative test"], true, STRICT_THRESHOLDS),
+    },
+    performance: {
+        id: "performance",
+        label: "Performance",
+        summary: "Ottimizzazione guidata da baseline, profilo e confronto ripetibile.",
+        firstMove: "Misura una baseline rappresentativa e localizza il collo di bottiglia.",
+        operatingRules: ["Non ottimizzare senza misura", "Cambia un fattore alla volta", "Controlla memoria, latenza e correttezza insieme"],
+        completionGates: ["Baseline e benchmark ripetibili", "Miglioramento misurato", "Correttezza invariata"],
+        signals: [
+            { phrase: "performance", weight: 4 }, { phrase: "prestazioni", weight: 4 },
+            { phrase: "ottimizz*", weight: 3 }, { phrase: "latency", weight: 3 },
+            { phrase: "memory leak", weight: 4 }, { phrase: "profil*", weight: 3 },
+        ],
+        context: recipe(3_800, EVIDENCE_POLICY, FRESH_WEIGHTS, ["baseline", "profile", "hot path", "latency", "allocation", "benchmark", "regression"]),
+    },
+    swarm: {
+        id: "swarm",
+        label: "Swarm",
+        summary: "Decomposizione parallela con contratti, isolamento e gate di integrazione.",
+        firstMove: "Separa workstream indipendenti e definisci contratti di integrazione prima di avviare i collaboratori.",
+        operatingRules: ["Parallelizza solo lavoro realmente indipendente", "Assegna ownership di file e contratti", "Conserva ogni ramo finche' merge e verifica non riescono"],
+        completionGates: ["Report di ogni workstream", "Merge senza perdita dati", "Verifica integrata finale"],
+        signals: [
+            { phrase: "parallel", weight: 3 }, { phrase: "parallelo", weight: 3 },
+            { phrase: "sub-agent", weight: 3 }, { phrase: "subagent", weight: 3 },
+            { phrase: "kingdom", weight: 4 }, { phrase: "swarm", weight: 4 },
+            { phrase: "vassall*", weight: 4 },
+        ],
+        context: recipe(4_500, DESIGN_POLICY, ARCHITECTURE_WEIGHTS, ["workstream", "ownership", "dependency", "contract", "branch", "merge", "integration"], true),
+    },
+    ultracheck: {
+        id: "ultracheck",
+        label: "Ultracheck",
+        summary: "Modalita' avversariale completa: requisiti, prove, parallelismo sicuro e doppio gate.",
+        firstMove: "Costruisci una mappa dei requisiti e dei rischi, poi separa audit e implementazione.",
+        operatingRules: ["Cerca controesempi prima di accettare il risultato", "Usa parallelismo solo con isolamento verificato", "Promuovi ogni conclusione importante a prova richiamabile"],
+        completionGates: ["Tutti i MUST verificati", "Test e typecheck pertinenti verdi", "Review avversariale senza finding bloccanti", "Nessun ramo o dato perso"],
+        signals: [{ phrase: "ultracheck", weight: 100 }],
+        context: recipe(5_500, EVIDENCE_POLICY, EVIDENCE_WEIGHTS, ["requirement", "counterexample", "evidence", "risk", "regression", "integration", "completion"], true, STRICT_THRESHOLDS),
+    },
+};
+export function parseVibeMode(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "auto")
+        return "auto";
+    return VIBE_MODE_IDS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+export function vibeModeSpec(id) {
+    return MODES[id];
+}
+export function listVibeModes() {
+    return VIBE_MODE_IDS.map((id) => MODES[id]);
+}
+export function isContinuationText(value) {
+    const text = value.trim().toLowerCase().replace(/[.!?]+$/g, "");
+    if (!text)
+        return false;
+    if (text.split(/\s+/).length > 12)
+        return false;
+    return /^(continua|continuate|riprendi|riprendiamo|prosegui|procedi|vai avanti|fallo|fai pure|ok|okay|si|sì|yes|go on|continue|resume|keep going|do it)(\b|$)/i.test(text);
+}
+export function routeVibeMode(requested, _userText, _previous) {
+    if (requested !== "auto") {
+        return { requested, resolved: requested, confidence: 1, reasons: [`modalita' selezionata: ${requested}`] };
+    }
+    return {
+        requested,
+        resolved: "classic",
+        confidence: 1,
+        reasons: ["modalita' auto: profilo classic deterministico"],
+    };
+}
+export function renderVibeModeBlock(route) {
+    const spec = MODES[route.resolved];
+    const rules = spec.operatingRules.map((rule, index) => `@regola[${index + 1}]: "${escapeValue(rule)}"`);
+    const gates = spec.completionGates.map((gate, index) => `@gate[${index + 1}]: "${escapeValue(gate)}"`);
+    return `[VIBE_MODE]
+INDICE
+1 = profilo
+2 = processo
+3 = gate
+
+DEFINIZIONI
+@profilo[attivo]: id=${spec.id}, nome="${escapeValue(spec.label)}", confidence=${route.confidence.toFixed(2)}
+@profilo[scopo]: "${escapeValue(spec.summary)}"
+@azione[prima]: "${escapeValue(spec.firstMove)}"
+${rules.join("\n")}
+${gates.join("\n")}
+
+OUTPUT: applica davvero processo e gate del profilo; non limitarti a citarne il nome.`;
+}
+function escapeValue(value) {
+    return value.replace(/\s+/g, " ").trim().replace(/"/g, "'");
+}

package/dist/core/workspace-roots.d.ts

@@ -0,0 +1,13 @@
+export declare class WorkspaceRootError extends Error {
+    constructor(message: string);
+}
+/**
+ * Normalizza le root aggiuntive del workspace. La root primaria resta `cwd`;
+ * il risultato contiene soltanto le directory extra, canoniche e deduplicate.
+ */
+export declare function resolveWorkspaceRoots(opts: {
+    readonly cwd: string;
+    readonly explicit?: readonly string[];
+    readonly env?: NodeJS.ProcessEnv;
+}): readonly string[];
+export declare function workspaceSystemBlock(cwd: string, roots: readonly string[]): string;

package/dist/core/workspace-roots.js

@@ -0,0 +1,91 @@
+import { realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+const MAX_WORKSPACE_ROOTS = 32;
+export class WorkspaceRootError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WorkspaceRootError";
+    }
+}
+function envRoots(raw) {
+    const value = String(raw ?? "").trim();
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+            throw new WorkspaceRootError("TALOS_WORKSPACE_ROOTS deve essere un array JSON di percorsi");
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err instanceof WorkspaceRootError)
+            throw err;
+        throw new WorkspaceRootError("TALOS_WORKSPACE_ROOTS contiene JSON non valido");
+    }
+}
+function legacyRoots(raw) {
+    return String(raw ?? "")
+        .split(/[;,]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function canonicalDirectory(raw, cwd) {
+    const target = resolve(cwd, raw);
+    try {
+        const canonical = realpathSync.native(target);
+        if (!statSync(canonical).isDirectory()) {
+            throw new WorkspaceRootError(`la root workspace non e' una cartella: ${raw}`);
+        }
+        return canonical;
+    }
+    catch (err) {
+        if (err instanceof WorkspaceRootError)
+            throw err;
+        throw new WorkspaceRootError(`root workspace non disponibile: ${raw}`);
+    }
+}
+function pathKey(value) {
+    return process.platform === "win32" ? value.toLowerCase() : value;
+}
+/**
+ * Normalizza le root aggiuntive del workspace. La root primaria resta `cwd`;
+ * il risultato contiene soltanto le directory extra, canoniche e deduplicate.
+ */
+export function resolveWorkspaceRoots(opts) {
+    const cwd = canonicalDirectory(opts.cwd, process.cwd());
+    const env = opts.env ?? process.env;
+    const candidates = [
+        ...envRoots(env["TALOS_WORKSPACE_ROOTS"]),
+        ...legacyRoots(env["TALOS_EXTRA_ROOTS"]),
+        ...(opts.explicit ?? []),
+    ];
+    if (candidates.length > MAX_WORKSPACE_ROOTS) {
+        throw new WorkspaceRootError(`troppe root workspace: massimo ${MAX_WORKSPACE_ROOTS}`);
+    }
+    const seen = new Set([pathKey(cwd)]);
+    const roots = [];
+    for (const raw of candidates) {
+        const value = String(raw ?? "").trim();
+        if (!value)
+            continue;
+        const canonical = canonicalDirectory(value, cwd);
+        const key = pathKey(canonical);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        roots.push(canonical);
+    }
+    return Object.freeze(roots);
+}
+export function workspaceSystemBlock(cwd, roots) {
+    if (!roots.length)
+        return "";
+    return [
+        "# Workspace multi-root",
+        `La cartella primaria e': ${cwd}`,
+        "Le seguenti cartelle fanno parte dello stesso progetto e sono accessibili nello stesso turno:",
+        ...roots.map((root) => `- ${root}`),
+        "Trattale come un unico workspace; non cercare copie del progetto fuori da queste root.",
+    ].join("\n");
+}