@vascend/talos 0.1.0

package/dist/vascend/contract-memory.js

@@ -0,0 +1,435 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { sanitizeText } from "../core/text-sanitize.js";
+const CONTRACT_PATTERNS = [
+    // RENAME — IT: "rinominato X in Y", "rinomino X in Y"
+    { re: /\brinomin(?:at[oi]|o|iamo|are)\s+(?:la\s+|il\s+|lo\s+)?(?:funzione\s+|metodo\s+|tipo\s+|api\s+)?([A-Za-z_$][\w.$]*)\s+(?:in|->|=>|a)\s+([A-Za-z_$][\w.$]*)/i, kind: "rename", symbolGroup: 1, afterGroup: 2 },
+    // RENAME — EN: "renamed X to Y", "rename X to Y"
+    { re: /\brenam(?:ed|e|ing)\s+([A-Za-z_$][\w.$]*)\s+(?:to|into|->|=>)\s+([A-Za-z_$][\w.$]*)/i, kind: "rename", symbolGroup: 1, afterGroup: 2 },
+    // REMOVE param — IT: "rimosso il parametro foo da bar"
+    { re: /\brimoss[oi]\s+(?:il\s+|lo\s+)?(?:parametro|argomento|campo)\s+([A-Za-z_$][\w.$]*)\s+(?:da|di|dalla?)\s+([A-Za-z_$][\w.$]*)/i, kind: "remove", symbolGroup: 2, beforeGroup: 1 },
+    // REMOVE param — EN: "removed the param foo from bar"
+    { re: /\bremoved\s+(?:the\s+)?(?:param(?:eter)?|arg(?:ument)?|field)\s+([A-Za-z_$][\w.$]*)\s+from\s+([A-Za-z_$][\w.$]*)/i, kind: "remove", symbolGroup: 2, beforeGroup: 1 },
+    // REMOVE symbol — IT/EN: "rimosso X" / "removed X" (funzione/metodo/api)
+    { re: /\b(?:rimoss[oi]|removed|delet(?:ed|e))\s+(?:la\s+|il\s+|lo\s+|the\s+)?(?:funzione|metodo|tipo|api|function|method|type)\s+([A-Za-z_$][\w.$]*)/i, kind: "remove", symbolGroup: 1 },
+    // ADD param — IT: "aggiunto il parametro foo a bar"
+    { re: /\baggiunt[oi]\s+(?:il\s+|lo\s+)?(?:parametro|argomento|campo)\s+([A-Za-z_$][\w.$]*)\s+(?:a|alla?|in)\s+([A-Za-z_$][\w.$]*)/i, kind: "add", symbolGroup: 2, afterGroup: 1 },
+    // ADD param — EN: "added param foo to bar"
+    { re: /\badded\s+(?:the\s+)?(?:param(?:eter)?|arg(?:ument)?|field)\s+([A-Za-z_$][\w.$]*)\s+to\s+([A-Za-z_$][\w.$]*)/i, kind: "add", symbolGroup: 2, afterGroup: 1 },
+    // SIGNATURE — IT: "cambiato la firma di X da A a B"
+    { re: /\b(?:cambiat[oi]|modificat[oi])\s+(?:la\s+)?(?:firma|signature|interfaccia|api)\s+(?:di|del|della)\s+([A-Za-z_$][\w.$]*)(?:\s+da\s+(.+?)\s+a\s+(.+))?/i, kind: "signature", symbolGroup: 1, beforeGroup: 2, afterGroup: 3 },
+    // SIGNATURE — EN: "changed the signature of X from A to B"
+    { re: /\b(?:changed|modified|updated)\s+(?:the\s+)?(?:signature|interface|api)\s+of\s+([A-Za-z_$][\w.$]*)(?:\s+from\s+(.+?)\s+to\s+(.+))?/i, kind: "signature", symbolGroup: 1, beforeGroup: 2, afterGroup: 3 },
+    // SIGNATURE — IT: "X ora accetta/restituisce ..." (cambio firma implicito)
+    { re: /\b([A-Za-z_$][\w.$]*)\s+(?:ora|adesso)\s+(?:accetta|prende|restituisce|ritorna|richiede)\s+(.+)/i, kind: "signature", symbolGroup: 1, afterGroup: 2 },
+    // BEHAVIOR — IT/EN: "cambiato il comportamento di X" / "X now behaves"
+    { re: /\b(?:cambiat[oi]|modificat[oi])\s+(?:il\s+)?comportamento\s+(?:di|del|della)\s+([A-Za-z_$][\w.$]*)/i, kind: "behavior", symbolGroup: 1 },
+    { re: /\b([A-Za-z_$][\w.$]*)\s+now\s+(?:returns|takes|accepts|expects|behaves)\s+(.+)/i, kind: "behavior", symbolGroup: 1, afterGroup: 2 },
+];
+// Estrazione di liste correlate dalla frase/contesto.
+//   callsite: "callsite: a, b", "chiamato da X", "callers: ..."
+//   test: "test: a, b", "rieseguire i test X", "tests: ..."
+//   docs: "docs: ...", "aggiornare la doc X", "documentazione: ..."
+// NB: le forme con verbo/locuzione lunga (che catturano la lista SENZA
+// separatore) vanno PRIMA; la keyword "nuda" richiede invece ":"/"=" cosi' non
+// inghiotte parole di servizio come "da aggiornare:".
+// Forma keyword + eventuali parole di servizio (es. "da aggiornare") + ":"/"="
+// + lista. Il [^:=\n]* assorbe "da aggiornare" SENZA finire nella lista, che
+// parte solo dopo il separatore. La forma con verbo iniziale ("chiamato da X")
+// non richiede separatore.
+const CALLSITE_PATTERNS = [
+    /\b(?:chiamat[oi]\s+(?:da|in)|usat[oi]\s+(?:da|in)|impatta(?:no|ti)?)\s+(.+)/i,
+    /\b(?:callsite[s]?|call\s*site[s]?|caller[s]?)[^:=\n]*[:=]\s*(.+)/i,
+];
+const TESTS_PATTERNS = [
+    /\b(?:rieseguire\s+(?:i\s+)?test)\s+(.+)/i,
+    /\b(?:test[s]?|tests?\s+required)[^:=\n]*[:=]\s*(.+)/i,
+];
+const DOCS_PATTERNS = [
+    /\b(?:doc[s]?|documentazione|docs?\s+to\s+update)[^:=\n]*[:=]\s*(.+)/i,
+];
+// --- detection (puro) ------------------------------------------------------
+// Riconosce le frasi di cambio contratto in un testo (di un singolo messaggio)
+// e ne estrae symbol/before/after/kind/context. Niente side-effect. Ritorna 0+
+// match in ordine di apparizione, deduplicati per simbolo.
+export function detectContractChanges(text, source) {
+    const out = [];
+    const seen = new Set();
+    for (const sentence of splitSentences(text)) {
+        const match = matchSentence(sentence, source);
+        if (!match)
+            continue;
+        const key = normalizeKey(`${match.symbol} ${match.kind}`);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(match);
+    }
+    return out;
+}
+// Prova i pattern su UNA frase. Ritorna il primo che combacia.
+function matchSentence(sentence, source) {
+    const s = sentence.trim();
+    if (!s || s.length < 6)
+        return null;
+    for (const p of CONTRACT_PATTERNS) {
+        const m = p.re.exec(s);
+        if (!m)
+            continue;
+        const symbol = cleanSymbol(m[p.symbolGroup] ?? "");
+        if (!symbol)
+            continue;
+        const before = p.beforeGroup ? cleanClause(m[p.beforeGroup] ?? "") : "";
+        const after = p.afterGroup ? cleanClause(m[p.afterGroup] ?? "") : "";
+        return {
+            symbol,
+            before,
+            after,
+            kind: p.kind,
+            context: oneLine(s).slice(0, 280),
+            source,
+        };
+    }
+    return null;
+}
+// Estrae callsite/test/docs da un testo (cerca su TUTTE le frasi). Le voci sono
+// separate da virgola/"e"/"and"; ogni voce e' ripulita e deduplicata.
+export function extractImpacts(text) {
+    return {
+        callsites: extractList(text, CALLSITE_PATTERNS),
+        testsRequired: extractList(text, TESTS_PATTERNS),
+        docsToUpdate: extractList(text, DOCS_PATTERNS),
+    };
+}
+function extractList(text, patterns) {
+    const out = [];
+    for (const sentence of splitSentences(text)) {
+        for (const re of patterns) {
+            const m = re.exec(sentence.trim());
+            if (m && m[1]) {
+                for (const item of splitItems(m[1])) {
+                    const v = cleanClause(item);
+                    if (v && v.length >= 2 && !out.includes(v))
+                        out.push(v);
+                }
+                break; // un solo pattern per frase
+            }
+        }
+    }
+    return out;
+}
+// --- promozione: match -> evento ------------------------------------------
+// Trasforma i match rilevati nei messaggi di un turno in eventi
+// contract.changed, assegnando id progressivi, callsite/test/docs estratti dal
+// testo del medesimo messaggio, link al task e timestamp. `startNum` da' il
+// primo numero libero (es. dal ContractStore). Funzione pura.
+export function promoteContractChanges(messages, opts) {
+    const events = [];
+    let num = opts.startNum ?? 1;
+    const ns = opts.ns ? `${opts.ns}-` : "";
+    const seen = new Set();
+    for (const m of messages) {
+        if (m.role !== "user" && m.role !== "assistant")
+            continue;
+        const source = m.role === "user" ? "user" : "assistant";
+        const text = plainText(m);
+        if (!text.trim())
+            continue;
+        const impacts = extractImpacts(text);
+        for (const match of detectContractChanges(text, source)) {
+            const key = normalizeKey(`${match.symbol} ${match.kind}`);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            events.push(toEvent(match, impacts, `${ns}CT${num}`, opts.task ?? null, opts.now));
+            num += 1;
+        }
+    }
+    return events;
+}
+function toEvent(match, impacts, id, task, now) {
+    const symbol = oneLine(match.symbol).slice(0, 120);
+    const before = oneLine(match.before).slice(0, 200);
+    const after = oneLine(match.after).slice(0, 200);
+    const summary = buildSummary(symbol, match.kind, before, after, impacts.callsites.length);
+    return {
+        type: "contract.changed",
+        domain: "contracts",
+        id,
+        symbol,
+        before,
+        after,
+        kind: match.kind,
+        callsites: impacts.callsites.slice(0, 24),
+        testsRequired: impacts.testsRequired.slice(0, 24),
+        docsToUpdate: impacts.docsToUpdate.slice(0, 24),
+        context: oneLine(match.context).slice(0, 280),
+        task,
+        subject: symbol,
+        summary,
+        source: match.source,
+        createdAt: now,
+    };
+}
+function buildSummary(symbol, kind, before, after, nCallsites) {
+    const label = {
+        signature: "firma",
+        rename: "rinomina",
+        remove: "rimozione",
+        add: "aggiunta",
+        behavior: "comportamento",
+    };
+    const change = before && after ? `${before} -> ${after}` : after || before;
+    const head = `${symbol} [${label[kind]}]${change ? `: ${change}` : ""}`;
+    const tail = nCallsites ? ` · ${nCallsites} callsite da rivedere` : "";
+    return oneLine(`${head}${tail}`).slice(0, 280);
+}
+// --- formato RoomRecord (richiamabile via recall) --------------------------
+// Rende un ContractEvent come RoomRecord Danilov, cosi' che il tool recall lo
+// trovi insieme alle stanze. level=0 (foglia), parent=null (resta in frontiera
+// finche' non viene compattato). I termini includono "contract", "callsite",
+// "firma" e il simbolo per renderlo facile da cercare e prevenire i callsite
+// dimenticati.
+export function contractToRoomRecord(ev) {
+    const terms = contractTerms(ev);
+    const callsites = ev.callsites.length ? ev.callsites.map((c) => esc(c)).join(", ") : "(nessuno indicato)";
+    const tests = ev.testsRequired.length ? ev.testsRequired.map((t) => esc(t)).join(", ") : "(nessuno indicato)";
+    const docs = ev.docsToUpdate.length ? ev.docsToUpdate.map((d) => esc(d)).join(", ") : "(nessuna indicata)";
+    const body = `INDICE
+1 = symbol
+2 = before
+3 = after
+4 = callsite_impattati
+5 = test_richiesti
+6 = docs_da_aggiornare
+
+DEFINIZIONI
+@contract.changed[${ev.id}]: domain=contracts, kind=${ev.kind}
+@symbol[${ev.id}]: "${esc(ev.symbol)}"
+@before[${ev.id}]: "${esc(ev.before) || "(non espresso)"}"
+@after[${ev.id}]: "${esc(ev.after) || "(non espresso)"}"
+@callsites[${ev.id}]: ${callsites}
+@testsRequired[${ev.id}]: ${tests}
+@docsToUpdate[${ev.id}]: ${docs}
+@context[${ev.id}]: "${esc(ev.context)}"
+@task[${ev.id}]: ${ev.task ? esc(ev.task) : "(nessuno)"}
+@source[${ev.id}]: ${ev.source}
+
+RELAZIONI
+@R1: ${ev.id} -> contract.changed [ dominio contracts, ${ev.kind}${ev.task ? `, task ${esc(ev.task)}` : ""} ]
+${ev.callsites.map((c, i) => `@R2.${i + 1}: ${ev.id} -> ${esc(c)} [ callsite da rivedere ]`).join("\n") || `@R2: ${ev.id} -> nessun_callsite [ verificare manualmente i chiamanti ]`}
+
+OUTPUT: ${esc(ev.summary)}`;
+    return {
+        room: ev.id,
+        level: 0,
+        title: ev.summary,
+        terms,
+        body,
+        children: [],
+        parent: null,
+        createdAt: ev.createdAt,
+    };
+}
+function contractTerms(ev) {
+    const base = ["contract", "contracts", "contract.changed", "callsite", "firma", "signature", ev.kind];
+    const fromText = tokenize(`${ev.symbol} ${ev.before} ${ev.after} ${ev.callsites.join(" ")}`).slice(0, 12);
+    return [...new Set([...base, ...fromText])].slice(0, 18);
+}
+// Store append-only degli eventi contract.changed su file jsonl dedicato
+// (`<store>.contracts.jsonl`), separato dalle stanze ma nella stessa
+// sessionDir. Espone count/all/nextNum + query/search per il dominio contracts.
+export class ContractStore {
+    file;
+    events = [];
+    constructor(file) {
+        this.file = file;
+    }
+    static open(sessionDir, storeId) {
+        const file = join(sessionDir, `${storeId}.contracts.jsonl`);
+        const store = new ContractStore(file);
+        if (existsSync(file)) {
+            const raw = readFileSync(file, "utf8");
+            for (const line of raw.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    store.events.push(normalizeEvent(JSON.parse(line)));
+                }
+                catch {
+                    // riga corrotta: ignorata
+                }
+            }
+        }
+        return store;
+    }
+    count() {
+        return this.events.length;
+    }
+    all() {
+        return this.events;
+    }
+    // Primo numero libero per gli id CT<n> di un namespace (vassallo/castello).
+    nextNum(ns) {
+        const prefix = `${ns ? `${ns}-` : ""}CT`;
+        return this.events.filter((e) => e.id.startsWith(prefix)).length + 1;
+    }
+    // Aggiunge un evento (fast path append). Idempotente sull'id: salta i duplicati.
+    append(event) {
+        if (this.events.some((e) => e.id === event.id))
+            return false;
+        this.events.push(event);
+        mkdirSync(dirname(this.file), { recursive: true });
+        appendFileSync(this.file, JSON.stringify(event) + "\n", "utf8");
+        return true;
+    }
+    // Aggiunge piu' eventi, ritorna quelli effettivamente scritti.
+    appendAll(events) {
+        const written = [];
+        for (const e of events)
+            if (this.append(e))
+                written.push(e);
+        return written;
+    }
+    byTask(task) {
+        return this.events.filter((e) => e.task === task);
+    }
+    bySymbol(symbol) {
+        const want = symbol.toLowerCase();
+        return this.events.filter((e) => e.symbol.toLowerCase() === want);
+    }
+    // Ricerca BM25-lite (offline) sugli eventi di contratto.
+    search(query, limit = 5) {
+        const qTokens = unique(tokenize(query));
+        if (!qTokens.length) {
+            return this.events.slice(-limit).reverse().map((event) => ({ event, score: 0 }));
+        }
+        const n = this.events.length || 1;
+        const df = new Map();
+        const docTokens = this.events.map((e) => {
+            const toks = tokenize(`${e.symbol} ${e.before} ${e.after} ${e.callsites.join(" ")} ${e.testsRequired.join(" ")} ${e.docsToUpdate.join(" ")} ${e.context} ${e.kind}`);
+            for (const t of new Set(toks))
+                df.set(t, (df.get(t) ?? 0) + 1);
+            return toks;
+        });
+        const hits = this.events.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);
+    }
+    // INDICE compatto dei contratti (per /regno o iniezione contestuale). Mette
+    // in evidenza i callsite ancora da rivedere: e' la rete di sicurezza contro i
+    // callsite dimenticati.
+    indexBlock() {
+        if (!this.events.length)
+            return "";
+        const rows = this.events
+            .map((e) => {
+            const cs = e.callsites.length ? ` · callsite=${e.callsites.length}` : "";
+            return `@contract[${e.id}]: "${esc(e.summary)}"${e.task ? ` · task=${esc(e.task)}` : ""}${cs}`;
+        })
+            .join("\n");
+        return `INDICE_CONTRATTI (dominio contracts, piano di lavoro)
+Cambi di API/firma promossi automaticamente. Richiamabili col tool "recall"
+(per query o per id CT<n>) per non dimenticare callsite, test e docs.
+
+${rows}
+
+OUTPUT: indice contratti; dettaglio (callsite/test/docs) via recall.`;
+    }
+}
+function normalizeEvent(raw) {
+    const kind = isKind(raw.kind) ? raw.kind : "signature";
+    return {
+        type: "contract.changed",
+        domain: "contracts",
+        id: raw.id ?? "CT?",
+        symbol: raw.symbol ?? "",
+        before: raw.before ?? "",
+        after: raw.after ?? "",
+        kind,
+        callsites: Array.isArray(raw.callsites) ? raw.callsites.map(String) : [],
+        testsRequired: Array.isArray(raw.testsRequired) ? raw.testsRequired.map(String) : [],
+        docsToUpdate: Array.isArray(raw.docsToUpdate) ? raw.docsToUpdate.map(String) : [],
+        context: raw.context ?? "",
+        task: raw.task ?? null,
+        subject: raw.subject ?? raw.symbol ?? "",
+        summary: raw.summary ?? raw.symbol ?? "",
+        source: raw.source === "assistant" ? "assistant" : "user",
+        createdAt: typeof raw.createdAt === "number" ? raw.createdAt : 0,
+    };
+}
+function isKind(v) {
+    return v === "signature" || v === "rename" || v === "remove" || v === "add" || v === "behavior";
+}
+// --- util ------------------------------------------------------------------
+function plainText(message) {
+    return message.content
+        .filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("\n");
+}
+// Divide il testo in frasi su terminatori e a-capo, mantenendo clausole utili.
+function splitSentences(text) {
+    return text
+        .split(/(?<=[.!?\n])\s+|\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+// Spezza una lista testuale in voci: separatori virgola/punto e virgola/"e"/"and".
+function splitItems(s) {
+    return oneLine(s)
+        .replace(/[.;]+$/, "")
+        .split(/\s*,\s*|\s+e\s+|\s+and\s+|\s*;\s*/i)
+        .map((x) => x.trim())
+        .filter(Boolean);
+}
+// Pulisce un nome di simbolo: toglie punteggiatura di bordo e backtick.
+function cleanSymbol(s) {
+    return oneLine(s)
+        .replace(/[`'"()]/g, "")
+        .replace(/^[^A-Za-z_$]+/, "") // togli rumore iniziale (deve partire da id-char)
+        .replace(/[^A-Za-z0-9_$]+$/, "") // togli punteggiatura di bordo, anche "." e ","
+        .trim();
+}
+// Pulisce una clausola: toglie punteggiatura di bordo, articoli iniziali residui
+// e spazi multipli. Conserva il contenuto sostanziale.
+function cleanClause(s) {
+    return oneLine(s)
+        .replace(/^[\s,;:]+/, "")
+        .replace(/[\s.,;:]+$/, "")
+        .replace(/[`]/g, "")
+        .trim();
+}
+function normalizeKey(s) {
+    return oneLine(s).toLowerCase().replace(/[^a-z0-9 ]/g, "").trim();
+}
+function tokenize(s) {
+    return (s.toLowerCase().match(/[a-z0-9_./-]{2,}/g) ?? []).filter((t) => !STOP.has(t));
+}
+const STOP = new Set([
+    "the", "and", "for", "this", "that", "with", "from", "into", "you", "are", "use", "now", "to",
+    "il", "lo", "la", "le", "gli", "un", "uno", "una", "di", "da", "in", "su",
+    "che", "con", "per", "non", "ed", "tra", "fra", "come", "piu", "ora", "adesso",
+    "cambiato", "modificato", "rinominato", "rimosso", "aggiunto",
+]);
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function oneLine(value) {
+    return sanitizeText(value).replace(/\s+/g, " ").trim();
+}
+function esc(value) {
+    return oneLine(value).replace(/"/g, "'");
+}

package/dist/vascend/council.d.ts

@@ -0,0 +1,58 @@
+import type { Harness } from "../core/bootstrap.js";
+export type CouncilAxis = "completeness" | "correctness" | "quality" | "requirements";
+export interface CouncilEvaluator {
+    readonly id: string;
+    readonly axis: CouncilAxis;
+    readonly title: string;
+    readonly weight: number;
+    readonly system: string;
+}
+export interface EvaluatorVerdict {
+    readonly id: string;
+    readonly axis: CouncilAxis;
+    readonly title: string;
+    readonly weight: number;
+    readonly score: number;
+    readonly approve: boolean;
+    readonly rationale: string;
+    readonly gaps: readonly string[];
+    readonly fallback: boolean;
+}
+export interface CouncilVerdict {
+    readonly completion: number;
+    readonly approved: boolean;
+    readonly consensus: {
+        readonly approve: number;
+        readonly total: number;
+    };
+    readonly verdicts: readonly EvaluatorVerdict[];
+    readonly dissent: readonly string[];
+    readonly gaps: readonly string[];
+    readonly summary: string;
+}
+export declare function selectEvaluators(axes?: readonly string[]): readonly CouncilEvaluator[];
+export declare function aggregateVerdicts(verdicts: readonly EvaluatorVerdict[], threshold: number): CouncilVerdict;
+export declare function buildCouncilSteer(goal: string, verdict: CouncilVerdict): string;
+export declare function parseEvaluatorVerdict(text: string, ev: CouncilEvaluator): EvaluatorVerdict | null;
+export interface CouncilInput {
+    readonly harness: Harness;
+    readonly goal: string;
+    readonly evidence: string;
+    readonly signal: AbortSignal;
+    readonly axes?: readonly string[];
+    readonly threshold?: number;
+    readonly requirements?: readonly string[];
+}
+export declare function runCouncil(input: CouncilInput): Promise<CouncilVerdict>;
+export interface CouncilOptions {
+    readonly enabled: boolean;
+    readonly threshold: number;
+    readonly rounds: number;
+    readonly axes: readonly CouncilAxis[];
+}
+export declare function councilEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function councilThreshold(env: NodeJS.ProcessEnv): number;
+export declare function councilRounds(env: NodeJS.ProcessEnv): number;
+export declare function councilAxes(env: NodeJS.ProcessEnv): readonly CouncilAxis[];
+export declare function councilOptions(env: NodeJS.ProcessEnv): CouncilOptions;
+export declare function formatCouncilVerdict(verdict: CouncilVerdict): string;