@vascend/talos 0.1.0

package/dist/vascend/self-improve.js

@@ -0,0 +1,396 @@
+// ---------------------------------------------------------------------------
+// Flag d'ambiente (parita' con completeness.ts/council.ts/objective-revision.ts).
+// ---------------------------------------------------------------------------
+// L'auto-miglioramento e' OPT-IN (default OFF): e' un layer orientato alla
+// Vision di lungo periodo, non al goal immediato. Si attiva con
+// TALOS_SELF_IMPROVE=1/on/true/yes.
+export function selfImproveEnabled(env) {
+    const v = (env["TALOS_SELF_IMPROVE"] ?? "").trim().toLowerCase();
+    return v === "1" || v === "on" || v === "true" || v === "yes";
+}
+// Quante iterazioni di miglioramento al massimo (anti-loop, default 2).
+export function selfImproveRounds(env) {
+    const n = Number(env["TALOS_SELF_IMPROVE_ROUNDS"]);
+    return Number.isInteger(n) && n >= 0 ? n : 2;
+}
+// Soglia di allineamento 0..100 per considerare lo stato "alla Vision" quando
+// non ci sono proposte must (default 85: la Vision e' esigente).
+export function selfImproveThreshold(env) {
+    const n = Number(env["TALOS_SELF_IMPROVE_THRESHOLD"]);
+    return Number.isFinite(n) && n >= 0 && n <= 100 ? Math.round(n) : 85;
+}
+// Quante proposte al massimo riportare (anti-rumore, default 8).
+export function selfImproveMaxProposals(env) {
+    const n = Number(env["TALOS_SELF_IMPROVE_MAX"]);
+    return Number.isInteger(n) && n > 0 && n <= 32 ? n : 8;
+}
+export function selfImproveOptions(env) {
+    return {
+        enabled: selfImproveEnabled(env),
+        rounds: selfImproveRounds(env),
+        threshold: selfImproveThreshold(env),
+        maxProposals: selfImproveMaxProposals(env),
+    };
+}
+// ---------------------------------------------------------------------------
+// Normalizzazioni difensive (parita' con objective-revision.ts).
+// ---------------------------------------------------------------------------
+function clamp100(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(100, Math.round(n)));
+}
+function normPriority(p) {
+    const v = (p ?? "").trim().toLowerCase();
+    if (v === "must" || v === "should" || v === "could")
+        return v;
+    // Sinonimi comuni dei modelli.
+    if (v === "high" || v === "critical" || v === "p0" || v === "p1")
+        return "must";
+    if (v === "medium" || v === "p2")
+        return "should";
+    if (v === "low" || v === "minor" || v === "nice-to-have" || v === "p3")
+        return "could";
+    return "should"; // default prudente: ne' bloccante ne' trascurabile
+}
+const CATEGORIES = new Set([
+    "feature",
+    "quality",
+    "ux",
+    "robustness",
+    "performance",
+    "alignment",
+]);
+function normCategory(c) {
+    const v = (c ?? "").trim().toLowerCase();
+    if (CATEGORIES.has(v))
+        return v;
+    // Sinonimi.
+    if (v === "functionality" || v === "feat")
+        return "feature";
+    if (v === "test" || v === "tests" || v === "maintainability" || v === "refactor")
+        return "quality";
+    if (v === "ui" || v === "usability" || v === "design")
+        return "ux";
+    if (v === "error" || v === "errors" || v === "resilience" || v === "edge" || v === "security")
+        return "robustness";
+    if (v === "perf" || v === "speed" || v === "efficiency")
+        return "performance";
+    if (v === "scope" || v === "drift" || v === "vision")
+        return "alignment";
+    return "feature"; // default: il caso piu' frequente verso la Vision
+}
+function normEffort(e) {
+    const v = (e ?? "").trim().toLowerCase();
+    if (v === "small" || v === "s" || v === "low")
+        return "small";
+    if (v === "medium" || v === "m" || v === "mid")
+        return "medium";
+    if (v === "large" || v === "l" || v === "high" || v === "big")
+        return "large";
+    return undefined;
+}
+function oneLine(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+const PRIORITY_RANK = { must: 0, should: 1, could: 2 };
+// Ordina le proposte: priorita' (must>should>could) poi impatto decrescente.
+function sortProposals(list) {
+    return [...list].sort((a, b) => {
+        const pr = PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
+        if (pr !== 0)
+            return pr;
+        return b.impact - a.impact;
+    });
+}
+// Deduplica le proposte per testo normalizzato (case-insensitive), tenendo la
+// prima occorrenza (che, dopo sort, e' quella a priorita'/impatto maggiore).
+function dedupeProposals(list) {
+    const seen = new Set();
+    const out = [];
+    for (const p of list) {
+        const key = p.text.toLowerCase();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(p);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Aggregazione deterministica: dato un grezzo elenco di proposte (gia' parse) e
+// un allineamento grezzo, costruisce il SelfImproveReport finale applicando
+// normalizzazione, dedup, ordinamento, taglio a maxProposals e gating soglia.
+// PURO: nessun side-effect, nessun provider. Testabile in isolamento.
+// ---------------------------------------------------------------------------
+export function aggregateProposals(opts) {
+    const threshold = clamp100(opts.threshold ?? 85);
+    const maxProposals = opts.maxProposals && opts.maxProposals > 0 ? opts.maxProposals : 8;
+    const ordered = dedupeProposals(sortProposals(opts.proposals)).slice(0, maxProposals);
+    const mustCount = ordered.filter((p) => p.priority === "must").length;
+    // Allineamento: usa quello dichiarato dal modello se valido; altrimenti
+    // derivalo in modo prudente dall'impatto residuo delle proposte (piu' e piu'
+    // pesanti sono le proposte, piu' basso l'allineamento).
+    const alignment = typeof opts.alignment === "number" && Number.isFinite(opts.alignment)
+        ? clamp100(opts.alignment)
+        : deriveAlignment(ordered);
+    // "Alla Vision" se NON ci sono proposte essenziali (must) E l'allineamento
+    // raggiunge la soglia. Le proposte should/could non bloccano.
+    const atVision = mustCount === 0 && alignment >= threshold;
+    const summary = atVision
+        ? `auto-miglioramento: ALLINEATO alla Vision (${alignment}/100, ${ordered.length} proposte minori)`
+        : `auto-miglioramento: ${ordered.length} proposte (${mustCount} must) · allineamento ${alignment}/100, soglia ${threshold}`;
+    return {
+        alignment,
+        atVision,
+        proposals: ordered,
+        summary,
+        fallback: opts.fallback === true,
+    };
+}
+// Deriva un allineamento prudente quando il modello non lo dichiara: parte da
+// 100 e sottrae in base alla gravita' delle proposte (must pesano piu' di
+// should/could). Mai sotto 0.
+function deriveAlignment(proposals) {
+    if (!proposals.length)
+        return 100;
+    let penalty = 0;
+    for (const p of proposals) {
+        const base = p.priority === "must" ? 18 : p.priority === "should" ? 8 : 3;
+        // Scala col peso d'impatto dichiarato (impact alto = piu' lontano dalla Vision).
+        penalty += base * (0.5 + (clamp100(p.impact) / 100) * 0.5);
+    }
+    return clamp100(100 - penalty);
+}
+// ---------------------------------------------------------------------------
+// Vision -> testo: ricompone una descrizione testuale della Vision dai campi
+// duck-typed, usata come contesto per il modello. Se la Vision porta gia' un
+// summary, lo preferisce (vision-schema: visionSummary).
+// ---------------------------------------------------------------------------
+export function visionToText(vision) {
+    if (!vision)
+        return "";
+    if (typeof vision === "string")
+        return oneLine(vision);
+    if (vision.summary && vision.summary.trim())
+        return vision.summary.trim();
+    const parts = [];
+    if (vision.title)
+        parts.push(`TITOLO: ${oneLine(vision.title)}`);
+    if (vision.finalGoal)
+        parts.push(`OBIETTIVO FINALE: ${oneLine(vision.finalGoal)}`);
+    const value = vision.value;
+    if (typeof value === "string" && value.trim()) {
+        parts.push(`VALORE: ${oneLine(value)}`);
+    }
+    else if (value && typeof value === "object") {
+        const stmt = value.statement ?? value.text;
+        if (stmt)
+            parts.push(`VALORE: ${oneLine(stmt)}`);
+        if (value.metrics?.length)
+            parts.push(`METRICHE: ${value.metrics.map((m) => oneLine(m)).join("; ")}`);
+    }
+    const feats = (vision.features ?? [])
+        .map((f) => {
+        const name = f.title ?? f.name ?? "";
+        if (!name)
+            return "";
+        const pr = f.priority ? `[${normPriority(f.priority)}] ` : "";
+        const done = f.done ? " (fatto)" : "";
+        const desc = f.description ? ` — ${oneLine(f.description)}` : "";
+        return `- ${pr}${oneLine(name)}${desc}${done}`;
+    })
+        .filter(Boolean);
+    if (feats.length)
+        parts.push(`FUNZIONALITA' ATTESE:\n${feats.join("\n")}`);
+    const crits = (vision.readinessCriteria ?? [])
+        .map((c) => {
+        const text = c.text ?? c.description ?? "";
+        if (!text)
+            return "";
+        return `- ${oneLine(text)}${c.met ? " (soddisfatto)" : ""}`;
+    })
+        .filter(Boolean);
+    if (crits.length)
+        parts.push(`CRITERI DI PRONTO:\n${crits.join("\n")}`);
+    return parts.join("\n");
+}
+// ---------------------------------------------------------------------------
+// System prompt del motore (notazione Danilov): confronta STATO vs VISION e
+// produce proposte di miglioramento. SOLO JSON in output.
+// ---------------------------------------------------------------------------
+const ENGINE_SYSTEM = `# Motore di auto-miglioramento — confronto STATO vs VISION
+INDICE
+1 = vision
+2 = stato
+3 = gap
+4 = proposta
+
+DEFINIZIONI
+@vision[finale]: lo stato IDEALE desiderato dall'utente (obiettivo finale, valore, funzionalita' attese, criteri di pronto)
+@stato[corrente]: cio' che e' stato effettivamente realizzato finora (operato, attivita, output)
+@gap[misura]: distanza stato->vision; alignment 0..100 (100=vision gia' realizzata, 0=lontanissimo)
+@proposta[regola]: ogni proposta AVVICINA lo stato alla Vision; concreta, azionabile, frase imperativa breve
+@proposta[campi]: category(feature|quality|ux|robustness|performance|alignment), priority(must|should|could), impact 0..100, effort(small|medium|large), visionRef(feature/criterio di riferimento se noto), rationale
+@priorita[criterio]: must=essenziale per la Vision, should=migliora molto, could=rifinitura
+@bilancia[no_rumore]: proponi SOLO miglioramenti reali verso la Vision; niente perfezionismo, niente proposte generiche
+
+RELAZIONI
+@R1: @vision[finale] -> @gap[misura]  [ misura quanto manca alla Vision ]
+@R2: @gap[misura] -> @proposta[regola]  [ ogni gap diventa una proposta azionabile ]
+@R3: @proposta[regola] -> @priorita[criterio]  [ ordina per impatto sulla Vision ]
+
+OUTPUT: SOLO JSON {"alignment": 0-100, "proposals": [{"text","category","priority","impact","effort","visionRef","rationale"}]}. Niente prosa fuori dal JSON, niente markdown.`;
+// Normalizza un singolo oggetto grezzo in ImprovementProposal, o null se vuoto.
+export function normalizeProposal(raw) {
+    const text = oneLine(String(raw.text ?? ""));
+    if (!text)
+        return null;
+    const impactRaw = Number(raw.impact);
+    // Impatto: se assente/non valido, derivalo dalla priorita'.
+    const priority = normPriority(typeof raw.priority === "string" ? raw.priority : undefined);
+    const impact = Number.isFinite(impactRaw)
+        ? clamp100(impactRaw)
+        : priority === "must" ? 90 : priority === "should" ? 60 : 30;
+    const effort = normEffort(typeof raw.effort === "string" ? raw.effort : undefined);
+    const visionRef = raw.visionRef ? oneLine(String(raw.visionRef)) : "";
+    const rationale = raw.rationale ? oneLine(String(raw.rationale)).slice(0, 400) : "";
+    return {
+        text: text.slice(0, 300),
+        category: normCategory(typeof raw.category === "string" ? raw.category : undefined),
+        priority,
+        impact,
+        ...(effort ? { effort } : {}),
+        ...(visionRef ? { visionRef: visionRef.slice(0, 120) } : {}),
+        ...(rationale ? { rationale } : {}),
+    };
+}
+// Estrae solo l'elenco di proposte da un testo JSON (utile nei test).
+export function parseProposals(text) {
+    const m = /\{[\s\S]*\}/.exec(text);
+    if (!m)
+        return [];
+    try {
+        const raw = JSON.parse(m[0]);
+        const list = Array.isArray(raw.proposals) ? raw.proposals : [];
+        return list
+            .map((p) => normalizeProposal((p ?? {})))
+            .filter((x) => x !== null);
+    }
+    catch {
+        return [];
+    }
+}
+// Estrae alignment + proposte e aggrega nel report finale.
+export function parseReport(text, opts) {
+    const m = /\{[\s\S]*\}/.exec(text);
+    if (!m) {
+        // Parsing fallito: fallback prudente che NON blocca.
+        return aggregateProposals({ proposals: [], alignment: 100, fallback: true, ...opts });
+    }
+    try {
+        const raw = JSON.parse(m[0]);
+        const list = Array.isArray(raw.proposals) ? raw.proposals : [];
+        const proposals = list
+            .map((p) => normalizeProposal((p ?? {})))
+            .filter((x) => x !== null);
+        const alignment = Number.isFinite(Number(raw.alignment)) ? clamp100(Number(raw.alignment)) : undefined;
+        return aggregateProposals({ proposals, ...(alignment !== undefined ? { alignment } : {}), ...opts });
+    }
+    catch {
+        return aggregateProposals({ proposals: [], alignment: 100, fallback: true, ...opts });
+    }
+}
+export async function runSelfImprove(input) {
+    const { harness, evidence, signal } = input;
+    const threshold = clamp100(input.threshold ?? 85);
+    const maxProposals = input.maxProposals && input.maxProposals > 0 ? input.maxProposals : 8;
+    const opts = { threshold, maxProposals };
+    const visionText = visionToText(input.vision);
+    // Senza una Vision sostanziale non c'e' nulla con cui confrontare: allineato
+    // per definizione (il motore e' orientato alla Vision, non al goal immediato).
+    if (!visionText.trim()) {
+        return aggregateProposals({ proposals: [], alignment: 100, fallback: true, ...opts });
+    }
+    const resolved = harness.providers.resolve(harness.config.model);
+    if (!resolved) {
+        return aggregateProposals({ proposals: [], alignment: 100, fallback: true, ...opts });
+    }
+    const goalBlock = input.goal ? `GOAL IMMEDIATO DEL TASK:\n${input.goal}\n\n` : "";
+    const user = `VISION FINALE (stato ideale desiderato):\n${visionText}\n\n` +
+        goalBlock +
+        `STATO CORRENTE (operato + attivita + output realizzati finora):\n${evidence.slice(0, 8000)}\n\n` +
+        `Confronta lo STATO CORRENTE con la VISION. Stima l'allineamento (0..100) e ` +
+        `genera proposte di miglioramento CONCRETE e prioritizzate che avvicinano lo ` +
+        `stato alla Vision. Rispondi SOLO JSON {"alignment", "proposals":[...]}.`;
+    try {
+        const res = await resolved.provider.complete({
+            system: ENGINE_SYSTEM,
+            messages: [{ role: "user", content: [{ type: "text", text: user }] }],
+            tools: [],
+            model: resolved.modelId,
+            maxTokens: harness.config.maxTokens,
+            signal,
+            sessionId: `self-improve-${harness.session.id}`,
+        });
+        return parseReport(res.text, opts);
+    }
+    catch {
+        // Fail-open: in dubbio non bloccare.
+        return aggregateProposals({ proposals: [], alignment: 100, fallback: true, ...opts });
+    }
+}
+// ---------------------------------------------------------------------------
+// Steer in notazione Danilov: se lo stato NON e' ancora alla Vision, fa
+// continuare l'agente sulle proposte di miglioramento (must prima), riportando
+// l'allineamento. Parita' con buildCompletenessSteer/buildCouncilSteer/
+// buildReopenSteer.
+// ---------------------------------------------------------------------------
+export function buildSelfImproveSteer(goal, report) {
+    const g = goal.replace(/"/g, "'").slice(0, 200);
+    const rows = report.proposals
+        .map((p, i) => `(${i + 1}) [${p.priority}/${p.category}] ${p.text}${p.visionRef ? ` <${p.visionRef}>` : ""} (impatto ${p.impact})`)
+        .join(" ; ");
+    const mustCount = report.proposals.filter((p) => p.priority === "must").length;
+    return `[VASCEND_AUTO_MIGLIORAMENTO]
+INDICE
+1 = goal
+2 = vision
+3 = proposta
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${g}"
+@vision[allineamento]: stato_corrente=${report.alignment}/100 verso la Vision finale (must residui=${mustCount})
+@proposta[miglioramenti]: ${rows || "nessuna proposta esplicita: rifinisci verso la Vision"}
+@azione[migliora]: NON ti fermi allo stato attuale; avvicina il lavoro alla VISION finale realizzando le proposte (must prima)
+
+RELAZIONI
+@R1: @vision[allineamento] -> @proposta[miglioramenti]  [ il gap verso la Vision diventa proposte ]
+@R2: @proposta[miglioramenti] -> @azione[migliora]  [ realizza prima le proposte must, poi should ]
+@R3: @azione[migliora] -> @goal[reale]  [ finche' lo stato non e' allineato alla Vision ]
+
+OUTPUT: realizza le proposte di miglioramento elencate (priorita' must prima) col lavoro reale e completa le attivita con vascend_mark. Punta ad allineare lo stato alla Vision: il motore rivaluta.`;
+}
+// Sintesi compatta del report (per log/TUI), in una riga.
+export function selfImproveSummary(report) {
+    return report.summary;
+}
+// Vista human-readable del report (per la TUI): allineamento + proposte.
+export function formatSelfImproveReport(report) {
+    const head = report.atVision
+        ? `Allineato alla Vision (${report.alignment}/100)`
+        : `Allineamento ${report.alignment}/100 — ${report.proposals.length} proposte`;
+    const rows = report.proposals
+        .map((p) => `  - [${p.priority}/${p.category}] ${p.text}${p.effort ? ` (sforzo ${p.effort})` : ""}${p.rationale ? ` — ${p.rationale}` : ""}`)
+        .join("\n");
+    return rows ? `${head}\n${rows}` : head;
+}
+export function fromVision(vision, summary) {
+    // Una Vision reale e' strutturalmente compatibile con VisionLike: la passiamo
+    // cosi' com'e', aggiungendo un summary se fornito dal chiamante.
+    if (summary && summary.trim()) {
+        return { ...vision, summary: summary.trim() };
+    }
+    return vision;
+}

package/dist/vascend/session-search.d.ts

@@ -0,0 +1,52 @@
+export interface SessionIndexEntry {
+    readonly id: string;
+    readonly file: string;
+    readonly mtimeMs: number;
+    readonly size: number;
+    readonly startedAt: number;
+    readonly endedAt: number;
+    readonly turns: number;
+    readonly objective: string;
+    readonly name: string;
+    readonly terms: Readonly<Record<string, number>>;
+}
+export interface SessionIndex {
+    readonly version: number;
+    readonly entries: readonly SessionIndexEntry[];
+}
+export interface SessionHit {
+    readonly id: string;
+    readonly objective: string;
+    readonly name: string;
+    readonly endedAt: number;
+    readonly turns: number;
+    readonly score: number;
+    readonly snippets: readonly string[];
+}
+export declare function normalizeTerms(text: string): readonly string[];
+export declare function pickObjective(userTexts: readonly string[]): string;
+/**
+ * Aggiorna l'indice: rilegge soltanto le sessioni nuove o cambiate (mtime+size).
+ * `skipId` esclude la sessione corrente, che e' gia' nel contesto.
+ */
+export declare function refreshSessionIndex(sessionDir: string, opts?: {
+    readonly skipId?: string;
+}): SessionIndex;
+/**
+ * Cartelle in cui cercare. Un host puo' dare a ogni run il suo workspace
+ * effimero (Horizon: `.../run-<id>/.talos/sessions`): in quel caso la cartella
+ * corrente contiene UNA sola conversazione e cercare solo la' non troverebbe
+ * mai niente. Si includono allora le cartelle sorelle degli altri run.
+ */
+export declare function sessionDirsFor(sessionDir: string, limit?: number): readonly string[];
+/**
+ * Cerca nelle sessioni passate. Il punteggio pesa quanti termini della query
+ * compaiono e con che frequenza; a pari merito vince la sessione piu' recente.
+ */
+export declare function searchSessions(sessionDir: string, query: string, opts?: {
+    readonly limit?: number;
+    readonly skipId?: string;
+    readonly withSnippets?: boolean;
+}): readonly SessionHit[];
+export declare function describeWhen(ts: number, now?: number): string;
+export declare function formatSessionHits(hits: readonly SessionHit[], now?: number): string;