@vascend/talos 0.1.0

package/dist/vascend/council.js

@@ -0,0 +1,337 @@
+// ---------------------------------------------------------------------------
+// Valutatori (read-only) — uno per asse, prompt in notazione Danilov
+// ---------------------------------------------------------------------------
+// Coda comune dei prompt: ogni valutatore risponde SOLO JSON con lo stesso schema.
+const VERDICT_SCHEMA = `OUTPUT: SOLO JSON {"score": 0-100, "approve": bool, "rationale": "1-2 frasi", "gaps": [stringhe brevi]}. ` +
+    `Niente prosa fuori dal JSON, niente markdown.`;
+const EVAL_COMPLETENESS = {
+    id: "completeness",
+    axis: "completeness",
+    title: "Valutatore completezza",
+    weight: 1,
+    system: `# Valutatore del concilio — asse COMPLETEZZA
+INDICE
+1 = goal
+2 = consegna
+3 = lacuna
+
+DEFINIZIONI
+@goal[reale]: l'obiettivo VERO dell'utente, non il piano svolto
+@consegna[criterio]: completa = tutti i pezzi essenziali presenti e funzionanti (dati, flussi, UI, integrazioni richieste)
+@lacuna[regola]: elenca SOLO pezzi ESSENZIALI assenti; niente nice-to-have
+@score[scala]: 100=tutto consegnato, 0=nulla di sostanziale; misura la copertura del goal
+
+RELAZIONI
+@R1: @goal[reale] -> @consegna[criterio]  [ misura la consegna sul goal vero ]
+@R2: @consegna[criterio] -> @lacuna[regola]  [ approve=false se manca l'essenziale ]
+
+${VERDICT_SCHEMA}`,
+};
+const EVAL_CORRECTNESS = {
+    id: "correctness",
+    axis: "correctness",
+    title: "Valutatore correttezza",
+    weight: 1,
+    system: `# Valutatore del concilio — asse CORRETTEZZA
+INDICE
+1 = comportamento
+2 = errori
+3 = rischio
+
+DEFINIZIONI
+@comportamento[atteso]: l'operato fa cio' che il goal richiede senza rotture evidenti
+@errori[segnali]: bug logici, regressioni, casi limite ignorati, contratti violati
+@rischio[regola]: approve=false se ci sono difetti che rompono il flusso principale
+@score[scala]: 100=corretto e robusto, 0=non funziona; penalizza i bug sul percorso critico
+
+RELAZIONI
+@R1: @comportamento[atteso] -> @errori[segnali]  [ cerca difetti sul percorso critico ]
+@R2: @errori[segnali] -> @rischio[regola]  [ i difetti gravi abbassano score e approve ]
+
+${VERDICT_SCHEMA}`,
+};
+const EVAL_QUALITY = {
+    id: "quality",
+    axis: "quality",
+    title: "Valutatore qualita' e test",
+    weight: 1,
+    system: `# Valutatore del concilio — asse QUALITA'/TEST
+INDICE
+1 = qualita
+2 = test
+3 = manutenibilita
+
+DEFINIZIONI
+@qualita[criterio]: codice coeso, convenzioni del progetto rispettate, niente duplicazione inutile
+@test[criterio]: i percorsi importanti hanno verifica (test o prova esplicita); assente = lacuna
+@manutenibilita[regola]: approve=false solo se la qualita' compromette l'uso o la tenuta del lavoro
+@score[scala]: 100=pulito e verificato, 0=fragile e non testato; non essere perfezionista
+
+RELAZIONI
+@R1: @qualita[criterio] -> @test[criterio]  [ qualita' include la verifica ]
+@R2: @test[criterio] -> @manutenibilita[regola]  [ pesa l'impatto reale, non l'estetica ]
+
+${VERDICT_SCHEMA}`,
+};
+const EVAL_REQUIREMENTS = {
+    id: "requirements",
+    axis: "requirements",
+    title: "Valutatore allineamento requisiti",
+    weight: 1,
+    system: `# Valutatore del concilio — asse REQUISITI
+INDICE
+1 = requisiti
+2 = copertura
+3 = deriva
+
+DEFINIZIONI
+@requisiti[fonte]: i requisiti espliciti/impliciti del goal (e quelli estratti, se forniti)
+@copertura[criterio]: ogni requisito ha una risposta nell'operato; mappa requisito->evidenza
+@deriva[regola]: approve=false se requisiti chiave restano scoperti o l'operato devia dal richiesto
+@score[scala]: 100=tutti i requisiti coperti, 0=fuori tema; misura l'aderenza al richiesto
+
+RELAZIONI
+@R1: @requisiti[fonte] -> @copertura[criterio]  [ confronta operato e requisiti ]
+@R2: @copertura[criterio] -> @deriva[regola]  [ requisiti chiave scoperti = no approve ]
+
+${VERDICT_SCHEMA}`,
+};
+// Registro dei valutatori disponibili, per asse.
+const ALL_EVALUATORS = {
+    completeness: EVAL_COMPLETENESS,
+    correctness: EVAL_CORRECTNESS,
+    quality: EVAL_QUALITY,
+    requirements: EVAL_REQUIREMENTS,
+};
+// Ordine di default del concilio (tutti gli assi).
+const DEFAULT_AXES = ["completeness", "correctness", "quality", "requirements"];
+function isAxis(value) {
+    return value === "completeness" || value === "correctness" || value === "quality" || value === "requirements";
+}
+// Seleziona i valutatori in base agli assi richiesti (deduplicati, ordine stabile).
+// Assi sconosciuti vengono ignorati; lista vuota -> tutti gli assi di default.
+export function selectEvaluators(axes) {
+    const wanted = (axes && axes.length ? axes : DEFAULT_AXES)
+        .map((a) => a.trim().toLowerCase())
+        .filter(isAxis);
+    const seen = new Set();
+    const out = [];
+    for (const axis of wanted.length ? wanted : DEFAULT_AXES) {
+        if (seen.has(axis))
+            continue;
+        seen.add(axis);
+        out.push(ALL_EVALUATORS[axis]);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Aggregazione: verdetti dei valutatori -> verdetto del concilio
+// ---------------------------------------------------------------------------
+function clampScore(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(100, Math.round(n)));
+}
+// Aggrega i verdetti in un CouncilVerdict motivato. La soglia (0-100) determina
+// l'approvazione: la consegna e' approvata se il grado di completamento pesato
+// raggiunge la soglia E nessun valutatore segnala un blocco (approve=false).
+export function aggregateVerdicts(verdicts, threshold) {
+    if (!verdicts.length) {
+        return {
+            completion: 0,
+            approved: false,
+            consensus: { approve: 0, total: 0 },
+            verdicts: [],
+            dissent: [],
+            gaps: [],
+            summary: "concilio vuoto: nessun valutatore",
+        };
+    }
+    // Grado di completamento = media PESATA dei punteggi.
+    const totalWeight = verdicts.reduce((s, v) => s + (v.weight > 0 ? v.weight : 1), 0);
+    const weighted = verdicts.reduce((s, v) => s + clampScore(v.score) * (v.weight > 0 ? v.weight : 1), 0);
+    const completion = clampScore(totalWeight > 0 ? weighted / totalWeight : 0);
+    const approveCount = verdicts.filter((v) => v.approve).length;
+    const dissent = verdicts.filter((v) => !v.approve).map((v) => v.title);
+    // Carenze deduplicate da tutti gli assi.
+    const gapSet = new Set();
+    for (const v of verdicts)
+        for (const g of v.gaps) {
+            const t = g.trim();
+            if (t)
+                gapSet.add(t);
+        }
+    const gaps = [...gapSet].slice(0, 16);
+    // Approvazione: soglia raggiunta E nessun dissenso (nessun blocco su un asse).
+    const approved = completion >= threshold && dissent.length === 0;
+    const summary = approved
+        ? `concilio: APPROVATO (${completion}/100, ${approveCount}/${verdicts.length} a favore)`
+        : `concilio: NON approvato (${completion}/100, soglia ${threshold}; dissenso: ${dissent.join(", ") || "nessuno"})`;
+    return {
+        completion,
+        approved,
+        consensus: { approve: approveCount, total: verdicts.length },
+        verdicts,
+        dissent,
+        gaps,
+        summary,
+    };
+}
+// Steer in notazione Danilov: se il concilio NON approva, fa continuare l'agente
+// sui pezzi mancanti, riportando il grado di completamento e i dissensi per asse.
+export function buildCouncilSteer(goal, verdict) {
+    const dissentRows = verdict.verdicts
+        .filter((v) => !v.approve)
+        .map((v) => `@asse[${v.axis}]: score=${v.score}/100, motivo="${v.rationale.replace(/"/g, "'").slice(0, 160)}"`)
+        .join("\n");
+    const gapRows = verdict.gaps.map((g, i) => `(${i + 1}) ${g}`).join(" ; ");
+    return `[VASCEND_CONCILIO]
+INDICE
+1 = goal
+2 = verdetto
+3 = dissenso
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
+@verdetto[grado]: completamento=${verdict.completion}/100, consenso=${verdict.consensus.approve}/${verdict.consensus.total}
+${dissentRows || "@dissenso[nessuno]: tutti gli assi approvano tranne la soglia"}
+@mancante[pezzi]: ${gapRows || "nessuna lacuna esplicita: alza il grado sugli assi in dissenso"}
+@azione[continua]: chiudi i dissensi degli assi e copri le lacune, poi il concilio rivota
+
+RELAZIONI
+@R1: @dissenso[assi] -> @azione[continua]  [ risolvi prima gli assi che non approvano ]
+@R2: @mancante[pezzi] -> @goal[reale]  [ copri le lacune finche' il concilio approva ]
+
+OUTPUT: lavora sui pezzi mancanti e sui dissensi elencati, poi completa le attivita. Il concilio rivaluta: punta ad approvazione (grado alto e zero dissensi).`;
+}
+// ---------------------------------------------------------------------------
+// Esecuzione: interroga il provider per ogni valutatore, in parallelo
+// ---------------------------------------------------------------------------
+// Parsing robusto del verdetto di un valutatore: estrae il primo blocco JSON e
+// normalizza i campi. In caso di parsing fallito ritorna null (il chiamante usa
+// un fallback prudente che NON blocca).
+export function parseEvaluatorVerdict(text, ev) {
+    const m = /\{[\s\S]*\}/.exec(text);
+    if (!m)
+        return null;
+    try {
+        const raw = JSON.parse(m[0]);
+        const score = clampScore(Number(raw.score));
+        const gaps = Array.isArray(raw.gaps)
+            ? raw.gaps.map(String).map((s) => s.trim()).filter(Boolean).slice(0, 12)
+            : [];
+        // approve: se esplicito usa quello; altrimenti deduci (score alto e niente lacune).
+        const approve = typeof raw.approve === "boolean" ? raw.approve : score >= 70 && gaps.length === 0;
+        const rationale = typeof raw.rationale === "string" ? raw.rationale.trim().slice(0, 400) : "";
+        return {
+            id: ev.id,
+            axis: ev.axis,
+            title: ev.title,
+            weight: ev.weight,
+            score,
+            approve,
+            rationale: rationale || (approve ? "approva" : "non approva"),
+            gaps,
+            fallback: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// Verdetto di fallback prudente: NON blocca (approve=true, score neutro) cosi'
+// un valutatore in errore non ferma da solo la consegna; e' marcato fallback.
+function fallbackVerdict(ev) {
+    return {
+        id: ev.id,
+        axis: ev.axis,
+        title: ev.title,
+        weight: ev.weight,
+        score: 100,
+        approve: true,
+        rationale: "valutatore non disponibile: verdetto neutro (non blocca)",
+        gaps: [],
+        fallback: true,
+    };
+}
+// Convoca il concilio: interroga il provider per OGNI valutatore IN PARALLELO,
+// poi aggrega. Read-only e privo di tool. Robusto: ogni valutatore ha il suo
+// fallback, e un errore globale non lancia (ritorna un verdetto neutro).
+export async function runCouncil(input) {
+    const { harness, goal, evidence, signal } = input;
+    const threshold = clampThreshold(input.threshold ?? 75);
+    const evaluators = selectEvaluators(input.axes);
+    const resolved = harness.providers.resolve(harness.config.model);
+    if (!resolved) {
+        // Senza provider: concilio neutro che non blocca.
+        return aggregateVerdicts(evaluators.map(fallbackVerdict), threshold);
+    }
+    const reqBlock = input.requirements && input.requirements.length
+        ? `\n\nREQUISITI ESTRATTI (riferimento per l'asse requisiti):\n${input.requirements.map((r, i) => `(${i + 1}) ${r}`).join("\n")}`
+        : "";
+    const ask = async (ev) => {
+        const user = `GOAL dell'utente:\n${goal}\n\n` +
+            `OPERATO DELL'AGENTE (sintesi + attivita + output):\n${evidence}${reqBlock}\n\n` +
+            `Valuta SOLO il tuo asse (${ev.axis}). Rispondi SOLO JSON con score, approve, rationale, gaps.`;
+        try {
+            const res = await resolved.provider.complete({
+                system: ev.system,
+                messages: [{ role: "user", content: [{ type: "text", text: user }] }],
+                tools: [],
+                model: resolved.modelId,
+                maxTokens: harness.config.maxTokens,
+                signal,
+                sessionId: `council-${ev.id}-${harness.session.id}`,
+            });
+            return parseEvaluatorVerdict(res.text, ev) ?? fallbackVerdict(ev);
+        }
+        catch {
+            return fallbackVerdict(ev);
+        }
+    };
+    // Interrogazione PARALLELA: ogni valutatore e' indipendente.
+    const verdicts = await Promise.all(evaluators.map(ask));
+    return aggregateVerdicts(verdicts, threshold);
+}
+function clampThreshold(n) {
+    if (!Number.isFinite(n))
+        return 75;
+    return Math.max(0, Math.min(100, Math.round(n)));
+}
+// Il concilio e' OPT-IN (default OFF): e' un layer di valutazione piu' pesante
+// del singolo critico. Si attiva con TALOS_COUNCIL=1/on/true/yes.
+export function councilEnabled(env) {
+    const v = (env["TALOS_COUNCIL"] ?? "").trim().toLowerCase();
+    return v === "1" || v === "on" || v === "true" || v === "yes";
+}
+// Soglia di approvazione 0-100 (default 75).
+export function councilThreshold(env) {
+    const n = Number(env["TALOS_COUNCIL_THRESHOLD"]);
+    return Number.isFinite(n) && n >= 0 && n <= 100 ? Math.round(n) : 75;
+}
+// Quante volte al massimo rivotare/svegliare l'agente (anti-loop, default 1).
+export function councilRounds(env) {
+    const n = Number(env["TALOS_COUNCIL_ROUNDS"]);
+    return Number.isInteger(n) && n >= 0 ? n : 1;
+}
+// Assi da convocare, da CSV (es. "completeness,requirements"); default tutti.
+export function councilAxes(env) {
+    const csv = (env["TALOS_COUNCIL_AXES"] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    return selectEvaluators(csv).map((e) => e.axis);
+}
+export function councilOptions(env) {
+    return {
+        enabled: councilEnabled(env),
+        threshold: councilThreshold(env),
+        rounds: councilRounds(env),
+        axes: councilAxes(env),
+    };
+}
+// Riga di sintesi human-readable del verdetto del concilio (per la TUI).
+export function formatCouncilVerdict(verdict) {
+    const rows = verdict.verdicts
+        .map((v) => `  ${v.approve ? "✓" : "✗"} ${v.title}: ${v.score}/100${v.fallback ? " (neutro)" : ""}${v.rationale ? ` — ${v.rationale}` : ""}`)
+        .join("\n");
+    return `${verdict.summary}\n${rows}`;
+}

package/dist/vascend/decision-promotion.d.ts

@@ -0,0 +1,48 @@
+import type { Message } from "../core/types.js";
+import type { RoomRecord } from "./room-memory.js";
+export interface DecisionEvent {
+    readonly type: "decision.made";
+    readonly domain: "decisions";
+    readonly id: string;
+    readonly decision: string;
+    readonly reason: string;
+    readonly context: string;
+    readonly task: string | null;
+    readonly subject: string;
+    readonly summary: string;
+    readonly source: "user" | "assistant";
+    readonly createdAt: number;
+}
+export interface DecisionMatch {
+    readonly decision: string;
+    readonly reason: string;
+    readonly context: string;
+    readonly source: "user" | "assistant";
+}
+export declare function detectDecisions(text: string, source: "user" | "assistant"): readonly DecisionMatch[];
+export declare function promoteDecisions(messages: readonly Message[], opts: {
+    task?: string | null;
+    ns?: string;
+    now: number;
+    startNum?: number;
+}): readonly DecisionEvent[];
+export declare function decisionToRoomRecord(ev: DecisionEvent): RoomRecord;
+export interface DecisionSearchHit {
+    readonly event: DecisionEvent;
+    readonly score: number;
+}
+export declare class DecisionStore {
+    private readonly file;
+    private events;
+    private constructor();
+    static open(sessionDir: string, storeId: string): DecisionStore;
+    count(): number;
+    all(): readonly DecisionEvent[];
+    nextNum(ns?: string): number;
+    append(event: DecisionEvent): boolean;
+    appendAll(events: readonly DecisionEvent[]): readonly DecisionEvent[];
+    private reloadFromDisk;
+    byTask(task: string): readonly DecisionEvent[];
+    search(query: string, limit?: number): readonly DecisionSearchHit[];
+    indexBlock(): string;
+}