@vascend/talos 0.1.0

package/dist/vascend/memory-store.js

@@ -0,0 +1,273 @@
+import { appendFileSync, closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { withLockSync } from "./file-lock.js";
+export function listMemoryScopes(sessionDir, opts = {}) {
+    if (!existsSync(sessionDir))
+        return [];
+    const suffixes = [".memory.events.jsonl", ".rooms.jsonl", ".decisions.jsonl", ".castle.json", ".vision.json"];
+    const scopes = new Map();
+    let files = [];
+    try {
+        files = readdirSync(sessionDir);
+    }
+    catch {
+        return [];
+    }
+    for (const file of files) {
+        const suffix = suffixes.find((s) => file.endsWith(s));
+        if (!suffix)
+            continue;
+        const scopeId = file.slice(0, -suffix.length);
+        if (!scopeId || scopeId === opts.excludeScope)
+            continue;
+        let mtime = 0;
+        try {
+            mtime = statSync(join(sessionDir, file)).mtimeMs;
+        }
+        catch {
+            // best effort
+        }
+        scopes.set(scopeId, Math.max(scopes.get(scopeId) ?? 0, mtime));
+    }
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : 12;
+    return [...scopes.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .slice(0, limit)
+        .map(([scopeId]) => scopeId);
+}
+export class MemoryStore {
+    file;
+    events = [];
+    ids = new Set();
+    maxNumericId = 0;
+    loadedBytes = 0;
+    partialLine = "";
+    docTokens = [];
+    globalDf = new Map();
+    constructor(file) {
+        this.file = file;
+    }
+    static open(sessionDir, scopeId) {
+        const store = new MemoryStore(join(sessionDir, `${scopeId}.memory.events.jsonl`));
+        store.reloadFromDisk();
+        return store;
+    }
+    count() {
+        return this.events.length;
+    }
+    all() {
+        return this.events;
+    }
+    append(input) {
+        // L'istanza puo' essere stale: in Kingdoms Mode piu' processi aprono lo
+        // stesso store e scrivono in parallelo. Il lock copre l'intera transazione
+        // reload -> assegna id -> append, cosi' due writer non possono scegliere lo
+        // stesso E<n> ne' interlacciare le righe JSONL.
+        return withLockSync(this.file, () => {
+            this.reloadTailFromDisk();
+            const id = input.id ?? this.nextId();
+            if (this.ids.has(id.toUpperCase())) {
+                throw new Error(`memory-store: id duplicato ${id}`);
+            }
+            const event = normalizeEvent({
+                ...input,
+                id,
+                createdAt: input.createdAt ?? Date.now(),
+            });
+            const line = JSON.stringify(event) + "\n";
+            appendFileSync(this.file, line, "utf8");
+            this.loadedBytes += Buffer.byteLength(line, "utf8");
+            this.addEvent(event);
+            return event;
+        });
+    }
+    query(q = {}) {
+        const out = this.events.filter((e) => {
+            if (q.domain && e.domain !== q.domain)
+                return false;
+            if (q.type && e.type !== q.type)
+                return false;
+            if (q.subject && e.subject.toLowerCase() !== q.subject.toLowerCase())
+                return false;
+            return true;
+        });
+        return typeof q.limit === "number" && q.limit > 0 ? out.slice(0, q.limit) : out;
+    }
+    byIds(ids) {
+        const want = new Set(ids.map((id) => id.toUpperCase()));
+        return this.events.filter((e) => want.has(e.id.toUpperCase()));
+    }
+    search(query, opts = {}) {
+        const limit = opts.limit && opts.limit > 0 ? opts.limit : 5;
+        const pool = this.query({ domain: opts.domain, type: opts.type });
+        const qTokens = unique(tokenize(query));
+        if (!qTokens.length) {
+            return pool.slice(-limit).reverse().map((event) => ({ event, score: 0 }));
+        }
+        const n = pool.length || 1;
+        const unfiltered = !opts.domain && !opts.type && pool.length === this.events.length;
+        const df = unfiltered ? this.globalDf : new Map();
+        const docTokens = unfiltered ? this.docTokens : pool.map((e) => {
+            const toks = tokensForEvent(e);
+            for (const t of new Set(toks))
+                df.set(t, (df.get(t) ?? 0) + 1);
+            return toks;
+        });
+        const hits = pool.map((event, i) => {
+            const toks = docTokens[i] ?? [];
+            const tf = new Map();
+            for (const t of toks)
+                tf.set(t, (tf.get(t) ?? 0) + 1);
+            let score = 0;
+            for (const q of qTokens) {
+                const f = tf.get(q) ?? 0;
+                if (!f)
+                    continue;
+                score += (f / (f + 1.2)) * Math.log(1 + n / (df.get(q) ?? 1));
+            }
+            return { event, score };
+        });
+        return hits.filter((h) => h.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+    nextId() {
+        return `E${this.maxNumericId + 1}`;
+    }
+    // Ricarica la vista autoritativa. Chiamata sia all'apertura sia, sotto lock,
+    // prima di ogni append per includere le righe scritte dagli altri processi.
+    reloadFromDisk() {
+        this.resetIndexes();
+        if (!existsSync(this.file)) {
+            return;
+        }
+        const raw = readFileSync(this.file, "utf8");
+        const lines = raw.split("\n");
+        this.partialLine = raw.endsWith("\n") ? "" : (lines.pop() ?? "");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                this.addEvent(normalizeEvent(JSON.parse(line)));
+            }
+            catch {
+                // riga corrotta: ignorata, il log resta recuperabile.
+            }
+        }
+        this.loadedBytes = Buffer.byteLength(raw, "utf8");
+    }
+    // Sotto lock legge soltanto i byte aggiunti da writer concorrenti. Il costo
+    // di append passa da O(N) per evento a O(delta), mantenendo ID univoci.
+    reloadTailFromDisk() {
+        if (!existsSync(this.file)) {
+            if (this.loadedBytes || this.events.length)
+                this.resetIndexes();
+            return;
+        }
+        const size = statSync(this.file).size;
+        if (size < this.loadedBytes) {
+            this.reloadFromDisk();
+            return;
+        }
+        if (size === this.loadedBytes)
+            return;
+        const length = size - this.loadedBytes;
+        const buffer = Buffer.allocUnsafe(length);
+        const fd = openSync(this.file, "r");
+        let read = 0;
+        try {
+            while (read < length) {
+                const n = readSync(fd, buffer, read, length - read, this.loadedBytes + read);
+                if (n <= 0)
+                    break;
+                read += n;
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        this.loadedBytes += read;
+        const combined = this.partialLine + buffer.subarray(0, read).toString("utf8");
+        const lines = combined.split("\n");
+        this.partialLine = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = normalizeEvent(JSON.parse(line));
+                if (!this.ids.has(event.id.toUpperCase()))
+                    this.addEvent(event);
+            }
+            catch {
+                // Una riga corrotta non impedisce di acquisire quelle successive.
+            }
+        }
+    }
+    resetIndexes() {
+        this.events = [];
+        this.ids.clear();
+        this.maxNumericId = 0;
+        this.loadedBytes = 0;
+        this.partialLine = "";
+        this.docTokens = [];
+        this.globalDf.clear();
+    }
+    addEvent(event) {
+        const key = event.id.toUpperCase();
+        if (this.ids.has(key))
+            return;
+        this.ids.add(key);
+        const numeric = /^E(\d+)$/i.exec(event.id)?.[1];
+        if (numeric)
+            this.maxNumericId = Math.max(this.maxNumericId, Number(numeric));
+        const tokens = tokensForEvent(event);
+        this.events.push(event);
+        this.docTokens.push(tokens);
+        for (const token of new Set(tokens))
+            this.globalDf.set(token, (this.globalDf.get(token) ?? 0) + 1);
+    }
+}
+function tokensForEvent(event) {
+    return tokenize(`${event.terms.join(" ")} ${event.subject} ${event.summary} ${event.body}`);
+}
+function normalizeEvent(raw) {
+    return {
+        id: stringValue(raw.id, "E?"),
+        type: stringValue(raw.type, "memory.unknown"),
+        domain: stringValue(raw.domain, "system"),
+        subject: stringValue(raw.subject, ""),
+        summary: stringValue(raw.summary, ""),
+        body: stringValue(raw.body, ""),
+        terms: Array.isArray(raw.terms) ? cleanTerms(raw.terms.map(String)) : [],
+        links: Array.isArray(raw.links) ? raw.links.map(normalizeLink).filter((l) => l.target) : [],
+        payload: isRecord(raw.payload) ? raw.payload : {},
+        createdAt: typeof raw.createdAt === "number" ? raw.createdAt : 0,
+    };
+}
+function normalizeLink(raw) {
+    const r = isRecord(raw) ? raw : {};
+    const domain = stringValue(r["domain"], "");
+    return {
+        rel: stringValue(r["rel"], "related"),
+        target: stringValue(r["target"], ""),
+        ...(domain ? { domain } : {}),
+    };
+}
+function stringValue(value, fallback) {
+    return typeof value === "string" ? value : value == null ? fallback : String(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tokenize(s) {
+    return (s.toLowerCase().match(/[a-z0-9_./-]{2,}/g) ?? []).filter((t) => !STOP.has(t));
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function cleanTerms(values) {
+    return unique(values.map((t) => t.trim().toLowerCase()).filter((t) => t.length >= 2 && !STOP.has(t)));
+}
+const STOP = new Set([
+    "the", "and", "for", "this", "that", "with", "from", "into", "you", "are",
+    "il", "lo", "la", "le", "gli", "un", "uno", "una", "di", "da", "in", "su",
+    "al", "alla", "del", "della", "dei", "degli", "delle", "che", "con", "per",
+]);

package/dist/vascend/objective-revision.d.ts

@@ -0,0 +1,69 @@
+import type { Harness } from "../core/bootstrap.js";
+export interface CouncilVerdictLike {
+    readonly complete?: boolean;
+    readonly score?: number;
+    readonly unmetRequirements?: readonly string[];
+    readonly concerns?: readonly string[];
+    readonly summary?: string;
+}
+export interface RequirementCriterionLike {
+    readonly id?: string;
+    readonly text: string;
+}
+export interface RequirementItemLike {
+    readonly id?: string;
+    readonly text: string;
+    readonly priority?: "must" | "should" | "could" | string;
+    readonly criteria?: readonly RequirementCriterionLike[];
+}
+export interface RequirementChecklistLike {
+    readonly goal?: string;
+    readonly requirements?: readonly RequirementItemLike[];
+}
+export interface ResidualSubgoal {
+    readonly text: string;
+    readonly requirementId?: string;
+    readonly priority: "must" | "should" | "could";
+}
+export interface ObjectiveDecision {
+    readonly complete: boolean;
+    readonly reopen: boolean;
+    readonly residuals: readonly ResidualSubgoal[];
+    readonly reason: string;
+    readonly uncertain?: boolean;
+}
+export declare function objectiveRevisionEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function objectiveRevisionRounds(env: NodeJS.ProcessEnv): number;
+export declare function objectiveRevisionThreshold(env: NodeJS.ProcessEnv): number;
+export declare function residualsFromRequirements(unmet: readonly string[], checklist?: RequirementChecklistLike): ResidualSubgoal[];
+export declare function decideObjective(opts: {
+    readonly verdict?: CouncilVerdictLike;
+    readonly checklist?: RequirementChecklistLike;
+    readonly threshold?: number;
+}): ObjectiveDecision;
+interface RealCouncilVerdict {
+    readonly completion?: number;
+    readonly approved?: boolean;
+    readonly gaps?: readonly string[];
+    readonly dissent?: readonly string[];
+    readonly summary?: string;
+}
+export declare function fromCouncilVerdict(v: RealCouncilVerdict | CouncilVerdictLike): CouncilVerdictLike;
+export declare function decideFromCouncil(opts: {
+    readonly verdict: RealCouncilVerdict | CouncilVerdictLike;
+    readonly checklist?: RequirementChecklistLike;
+    readonly threshold?: number;
+}): ObjectiveDecision;
+export declare function buildReopenSteer(goal: string, decision: ObjectiveDecision): string;
+export declare function objectiveDecisionSummary(d: ObjectiveDecision): string;
+export declare function judgeObjectiveRevision(opts: {
+    readonly harness: Harness;
+    readonly goal: string;
+    readonly verdict?: CouncilVerdictLike | RealCouncilVerdict;
+    readonly checklist?: RequirementChecklistLike;
+    readonly evidence?: string;
+    readonly threshold?: number;
+    readonly signal: AbortSignal;
+}): Promise<ObjectiveDecision>;
+export declare function parseDecision(text: string, fallbackReason?: string): ObjectiveDecision;
+export {};

package/dist/vascend/objective-revision.js

@@ -0,0 +1,319 @@
+// ---------------------------------------------------------------------------
+// Flag d'ambiente (parita' con completeness.ts).
+// ---------------------------------------------------------------------------
+export function objectiveRevisionEnabled(env) {
+    const v = (env["TALOS_OBJECTIVE_REVISION"] ?? "").trim().toLowerCase();
+    return !(v === "0" || v === "off" || v === "false" || v === "no");
+}
+// Quante riaperture al massimo (anti-loop): dopo N giri ci si ferma comunque.
+export function objectiveRevisionRounds(env) {
+    const n = Number(env["TALOS_OBJECTIVE_REVISION_ROUNDS"]);
+    return Number.isInteger(n) && n >= 0 ? n : 2;
+}
+// Se il concilio porta uno score, soglia minima per considerare "completo"
+// anche quando complete non e' esplicitamente true. Default 0.8 (su scala 0..1).
+export function objectiveRevisionThreshold(env) {
+    const n = Number(env["TALOS_OBJECTIVE_REVISION_THRESHOLD"]);
+    return Number.isFinite(n) && n > 0 && n <= 1 ? n : 0.8;
+}
+// ---------------------------------------------------------------------------
+// Normalizzazioni difensive.
+// ---------------------------------------------------------------------------
+function normPriority(p) {
+    const v = (p ?? "").trim().toLowerCase();
+    if (v === "must" || v === "should" || v === "could")
+        return v;
+    return "must"; // in dubbio trattalo come essenziale
+}
+// Score normalizzato su 0..1: accetta sia 0..1 sia 0..100.
+function normScore(score) {
+    if (typeof score !== "number" || !Number.isFinite(score))
+        return undefined;
+    if (score < 0)
+        return 0;
+    if (score <= 1)
+        return score;
+    if (score <= 100)
+        return score / 100;
+    return 1;
+}
+function dedupe(items) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of items) {
+        const s = raw.replace(/\s+/g, " ").trim();
+        if (!s)
+            continue;
+        const key = s.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(s);
+    }
+    return out;
+}
+// Indicizza la checklist per id e per testo, cosi' un requisito "unmet" indicato
+// dal concilio (per id o per testo) ritrova priorita' e descrizione completa.
+function indexRequirements(checklist) {
+    const map = new Map();
+    for (const r of checklist?.requirements ?? []) {
+        if (r.id)
+            map.set(r.id.trim().toLowerCase(), r);
+        if (r.text)
+            map.set(r.text.replace(/\s+/g, " ").trim().toLowerCase(), r);
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Generazione dei sotto-obiettivi residui dai requisiti non soddisfatti.
+// ---------------------------------------------------------------------------
+// Dato l'elenco "unmet" dal concilio (id o testo) e la checklist dei requisiti,
+// costruisce i sotto-obiettivi residui, recuperando priorita' e criteri quando
+// il requisito e' noto. Se un "unmet" non matcha nessun requisito noto, lo usa
+// come testo grezzo (priorita' must, prudente).
+export function residualsFromRequirements(unmet, checklist) {
+    const index = indexRequirements(checklist);
+    const out = [];
+    const seen = new Set();
+    for (const raw of dedupe(unmet)) {
+        const key = raw.toLowerCase();
+        const req = index.get(key);
+        const text = req?.text ?? raw;
+        const dedupeKey = (req?.id ?? text).toLowerCase();
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        const criteria = (req?.criteria ?? []).map((c) => c.text).filter(Boolean);
+        const detail = criteria.length ? `${text} (criteri: ${criteria.join("; ")})` : text;
+        out.push({
+            text: detail,
+            ...(req?.id ? { requirementId: req.id } : {}),
+            priority: normPriority(req?.priority),
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Decisione deterministica.
+// ---------------------------------------------------------------------------
+// Combina il verdetto del concilio con i requisiti per decidere se chiudere o
+// riaprire. Regole (fail-safe ma NON fail-open cieco):
+//  1. residui = unmet del concilio mappati sui requisiti.
+//  2. se ci sono residui MUST -> riapri (a prescindere dal flag complete).
+//  3. se complete=true e nessun residuo must -> chiudi.
+//  4. se score sopra soglia e nessun residuo must -> chiudi.
+//  5. altrimenti, se restano residui (should/could) -> riapri con quelli.
+//  6. nessun segnale negativo -> chiudi (completo).
+export function decideObjective(opts) {
+    const { verdict, checklist } = opts;
+    const threshold = opts.threshold ?? 0.8;
+    const unmet = verdict?.unmetRequirements ?? [];
+    const residuals = residualsFromRequirements(unmet, checklist);
+    const mustResiduals = residuals.filter((r) => r.priority === "must");
+    const score = normScore(verdict?.score);
+    const explicitComplete = verdict?.complete === true;
+    // (2) Requisiti essenziali non soddisfatti: riapri sempre.
+    if (mustResiduals.length) {
+        return {
+            complete: false,
+            reopen: true,
+            residuals,
+            reason: `concilio: ${mustResiduals.length} requisito/i essenziale/i non soddisfatto/i`,
+        };
+    }
+    // (3) Concilio dichiara completo e nessun must residuo.
+    if (explicitComplete) {
+        return { complete: true, reopen: false, residuals: [], reason: "concilio: task completo" };
+    }
+    // (4) Score sopra soglia e nessun must residuo.
+    if (score !== undefined && score >= threshold) {
+        return {
+            complete: true,
+            reopen: false,
+            residuals: [],
+            reason: `concilio: score ${(score * 100).toFixed(0)}% >= soglia ${(threshold * 100).toFixed(0)}%`,
+        };
+    }
+    // (5) Restano residui non essenziali: riapri con quelli.
+    if (residuals.length) {
+        return {
+            complete: false,
+            reopen: true,
+            residuals,
+            reason: `concilio: ${residuals.length} requisito/i residuo/i da soddisfare`,
+        };
+    }
+    // (6) Assenza di segnali non e' una prova di completamento.
+    const reason = verdict?.concerns?.length
+        ? "concilio: rilievi presenti ma nessun verdetto verificabile"
+        : "concilio: completamento non verificato";
+    return { complete: false, reopen: false, residuals: [], reason, uncertain: true };
+}
+export function fromCouncilVerdict(v) {
+    const real = v;
+    // Se gia' nella forma generica (ha unmetRequirements o complete), passala.
+    const hasGeneric = real.unmetRequirements !== undefined || real.complete !== undefined;
+    if (hasGeneric && real.gaps === undefined && real.approved === undefined) {
+        return real;
+    }
+    const gaps = Array.isArray(real.gaps) ? real.gaps.map(String) : [];
+    const dissent = Array.isArray(real.dissent) ? real.dissent.map(String) : [];
+    return {
+        ...(typeof real.approved === "boolean" ? { complete: real.approved } : {}),
+        ...(typeof real.completion === "number" ? { score: real.completion } : {}),
+        unmetRequirements: dedupe([...gaps, ...dissent]),
+        ...(dissent.length ? { concerns: dissent } : {}),
+        ...(real.summary ? { summary: real.summary } : {}),
+    };
+}
+// Comodita': decide direttamente dal verdetto reale del concilio.
+export function decideFromCouncil(opts) {
+    return decideObjective({
+        verdict: fromCouncilVerdict(opts.verdict),
+        checklist: opts.checklist,
+        threshold: opts.threshold,
+    });
+}
+// ---------------------------------------------------------------------------
+// Steer in notazione Danilov: RIAPRE il goal coi sotto-obiettivi residui.
+// Parita' con buildCompletenessSteer/buildValidationSteer.
+// ---------------------------------------------------------------------------
+export function buildReopenSteer(goal, decision) {
+    const g = goal.replace(/"/g, "'").slice(0, 200);
+    const residui = decision.residuals
+        .map((r, i) => `(${i + 1}) [${r.priority}] ${r.text}${r.requirementId ? ` <${r.requirementId}>` : ""}`)
+        .join(" ; ");
+    return `[VASCEND_REVISIONE_OBIETTIVO]
+INDICE
+1 = goal
+2 = verdetto
+3 = residuo
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${g}"
+@verdetto[concilio]: ${decision.reason.replace(/"/g, "'")}
+@residuo[sotto_obiettivi]: ${residui || "nessuno"}
+@azione[riapri]: il task NON e' completo; svolgi i sotto-obiettivi residui, NON ti fermi al verdetto precedente
+
+RELAZIONI
+@R1: @verdetto[concilio] -> @residuo[sotto_obiettivi]  [ i requisiti non soddisfatti diventano sotto-obiettivi ]
+@R2: @residuo[sotto_obiettivi] -> @azione[riapri]  [ pianifica e completa i residui ]
+@R3: @azione[riapri] -> @goal[reale]  [ finche' i requisiti essenziali non sono soddisfatti ]
+
+OUTPUT: riapri l'obiettivo: crea/aggiorna attivita per i sotto-obiettivi residui (priorita' must prima), realizzali col lavoro reale e illuminali con vascend_mark. Concludi solo quando i residui essenziali sono soddisfatti.`;
+}
+// Sintesi compatta della decisione (per log/TUI), in una riga.
+export function objectiveDecisionSummary(d) {
+    if (d.complete)
+        return `obiettivo completo (${d.reason})`;
+    if (d.uncertain)
+        return `obiettivo non verificato (${d.reason})`;
+    const must = d.residuals.filter((r) => r.priority === "must").length;
+    return `riapri: ${d.residuals.length} residuo/i (${must} must) · ${d.reason}`;
+}
+// ---------------------------------------------------------------------------
+// Passaggio LLM OPZIONALE: quando il concilio non porta unmet espliciti ma non
+// dichiara nemmeno il completamento (zona grigia), un revisore raffina i
+// sotto-obiettivi residui leggendo goal + verdetto + requisiti. Gemello a valle
+// di judgeCompleteness. In dubbio conserva uno stato unknown, non chiude.
+// ---------------------------------------------------------------------------
+const REVISER_SYSTEM = `# Revisore dell'obiettivo
+INDICE
+1 = goal
+2 = verdetto
+3 = residuo
+
+DEFINIZIONI
+@goal[reale]: l'obiettivo VERO dell'utente
+@verdetto[concilio]: giudizio del concilio (completamento, lacune, dissensi)
+@residuo[regola]: elenca SOLO sotto-obiettivi ESSENZIALI ancora aperti; niente perfezionismo
+@bilancia[chiudi]: se il goal e' soddisfatto nella sostanza, complete=true e residuals=[]
+
+RELAZIONI
+@R1: @verdetto[concilio] -> @residuo[regola]  [ trasforma le lacune in sotto-obiettivi ]
+@R2: @residuo[regola] -> @goal[reale]  [ solo cio' che serve a soddisfare il goal ]
+
+OUTPUT: SOLO JSON {"complete": bool, "residuals": [{"text": str, "priority": "must|should|could"}]}. Niente prosa, niente markdown.`;
+export async function judgeObjectiveRevision(opts) {
+    const { harness, goal, checklist, evidence, signal } = opts;
+    const verdict = opts.verdict ? fromCouncilVerdict(opts.verdict) : undefined;
+    // 1) Prima la decisione DETERMINISTICA dal verdetto + requisiti.
+    const det = decideObjective({ verdict, checklist, threshold: opts.threshold });
+    // Se il deterministico ha gia' deciso di riaprire (residui dai requisiti) o di
+    // chiudere con segnale esplicito, fidati: niente chiamata LLM superflua.
+    if (det.reopen)
+        return det;
+    const explicit = verdict?.complete === true || (normScore(verdict?.score) ?? 0) >= (opts.threshold ?? 0.8);
+    if (explicit)
+        return det;
+    // 2) Zona grigia: nessun unmet esplicito ma nemmeno completamento certo.
+    //    Chiedi al modello di raffinare i residui. Fail-open: errore => chiudi.
+    const resolved = harness.providers.resolve(harness.config.model);
+    if (!resolved)
+        return det;
+    const reqBlock = (checklist?.requirements ?? [])
+        .map((r) => `- [${normPriority(r.priority)}] ${r.text}`)
+        .join("\n");
+    const user = `GOAL dell'utente:\n${goal}\n\n` +
+        (verdict?.summary ? `VERDETTO concilio:\n${verdict.summary}\n\n` : "") +
+        (verdict?.concerns?.length ? `RILIEVI:\n${verdict.concerns.join("\n")}\n\n` : "") +
+        (reqBlock ? `REQUISITI:\n${reqBlock}\n\n` : "") +
+        (evidence ? `LAVORO SVOLTO:\n${evidence.slice(0, 3000)}\n\n` : "") +
+        `Restano sotto-obiettivi ESSENZIALI da svolgere per soddisfare il goal? ` +
+        `Rispondi SOLO JSON {"complete": bool, "residuals": [{"text","priority"}]}.`;
+    try {
+        const res = await resolved.provider.complete({
+            system: REVISER_SYSTEM,
+            messages: [{ role: "user", content: [{ type: "text", text: user }] }],
+            tools: [],
+            model: resolved.modelId,
+            maxTokens: harness.config.maxTokens,
+            signal,
+            sessionId: `objrev-${harness.session.id}`,
+        });
+        return parseDecision(res.text, det.reason);
+    }
+    catch {
+        return det; // fail-open: in dubbio non bloccare
+    }
+}
+// Parser difensivo del JSON del revisore.
+export function parseDecision(text, fallbackReason = "") {
+    const m = /\{[\s\S]*\}/.exec(text);
+    if (!m)
+        return unknownObjective(fallbackReason || "risposta del revisore non strutturata");
+    try {
+        const raw = JSON.parse(m[0]);
+        const list = Array.isArray(raw.residuals) ? raw.residuals : [];
+        const residuals = list
+            .map((r) => {
+            const o = (r ?? {});
+            const t = String(o.text ?? "").replace(/\s+/g, " ").trim();
+            if (!t)
+                return null;
+            return {
+                text: t,
+                priority: normPriority(typeof o.priority === "string" ? o.priority : undefined),
+                ...(o.requirementId ? { requirementId: String(o.requirementId) } : {}),
+            };
+        })
+            .filter((x) => x !== null)
+            .slice(0, 12);
+        if (raw.complete !== true && raw.complete !== false)
+            return unknownObjective(fallbackReason || "verdetto booleano assente");
+        const complete = raw.complete === true && residuals.length === 0;
+        return {
+            complete,
+            reopen: !complete,
+            residuals: complete ? [] : residuals,
+            reason: complete ? (fallbackReason || "revisore: obiettivo completo") : `revisore: ${residuals.length} residuo/i`,
+        };
+    }
+    catch {
+        return unknownObjective(fallbackReason || "JSON del revisore non valido");
+    }
+}
+function unknownObjective(reason) {
+    return { complete: false, reopen: false, residuals: [], reason, uncertain: true };
+}