@vascend/talos 0.1.0

package/dist/vascend/decision-promotion.js

@@ -0,0 +1,410 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { sanitizeText } from "../core/text-sanitize.js";
+import { withLockSync } from "./file-lock.js";
+const DECISION_PATTERNS = [
+    // IT: "abbiamo deciso di ...", "ho deciso di ...", "si e' deciso di ..."
+    { re: /\b(?:abbiamo|ho|si\s*(?:e'|è)|si\s+e)\s+decis[oi]\s+(?:di\s+|che\s+)?(.+)/i, kind: "decided" },
+    // IT: "decidiamo di ...", "decido di ..."
+    { re: /\bdecid(?:iamo|o|e)\s+(?:di\s+|che\s+)?(.+)/i, kind: "decided" },
+    // IT: "da ora (in poi) usiamo ...", "d'ora in poi ...", "d'ora in avanti ..."
+    { re: /\b(?:da\s+ora(?:\s+in\s+poi)?|d['’]?\s*ora\s+in\s+(?:poi|avanti))[,:]?\s+(.+)/i, kind: "fromNow" },
+    // IT: "useremo ...", "adotteremo ...", "passiamo a ..."
+    { re: /\b(?:useremo|adotteremo|adottiamo|passiamo\s+a|optiamo\s+per)\s+(.+)/i, kind: "willUse" },
+    // IT: "la scelta e' ...", "scegliamo ...", "abbiamo scelto ..."
+    { re: /\b(?:scegliamo|abbiamo\s+scelto|la\s+scelta\s+(?:e'|è)|opt(?:iamo|o))\s+(?:di\s+|per\s+)?(.+)/i, kind: "chosen" },
+    // EN: "we decided to ...", "i decided to ...", "it was decided to ..."
+    { re: /\b(?:we|i|it\s+was)\s+decided\s+(?:to\s+|that\s+)?(.+)/i, kind: "decided" },
+    // EN: "from now on (we use) ...", "going forward ..."
+    { re: /\b(?:from\s+now\s+on|going\s+forward|henceforth)[,:]?\s+(.+)/i, kind: "fromNow" },
+    // EN: "we'll use ...", "we will use ...", "we are going to use ..."
+    { re: /\b(?:we['’]?ll|we\s+will|we['’]?re\s+going\s+to|let['’]?s)\s+(?:use|adopt|go\s+with)\s+(.+)/i, kind: "willUse" },
+    // EN: "we chose ...", "the choice is ...", "we'll go with ..."
+    { re: /\b(?:we\s+chose|the\s+choice\s+is|we['’]?ll\s+go\s+with|we\s+go\s+with)\s+(.+)/i, kind: "chosen" },
+];
+// Pattern CAUSALE: "la causa era X quindi/percio' Y" -> decisione=Y, reason=X.
+// Catturiamo causa (g1) ed effetto/azione (g2).
+const CAUSAL_PATTERNS = [
+    /\b(?:la\s+causa\s+(?:era|e'|è)|il\s+problema\s+(?:era|e'|è)|il\s+motivo\s+(?:era|e'|è))\s+(.+?)\s+(?:quindi|perci(?:o'|ò)|dunque|allora|cos(?:i'|ì))\s+(.+)/i,
+    /\b(?:the\s+(?:cause|issue|problem|reason)\s+was)\s+(.+?)\s+(?:so|therefore|thus|hence)\s+(.+)/i,
+];
+// Estrae la MOTIVAZIONE da una frase decisionale: clausola dopo
+// "perche'/poiche'/dato che/since/because", oppure "cosi'/per/to ...".
+const REASON_PATTERNS = [
+    /\b(?:perch(?:e'|é)|poich(?:e'|é)|dato\s+che|visto\s+che|siccome|in\s+quanto)\s+(.+)/i,
+    /\b(?:because|since|as|given\s+that)\s+(.+)/i,
+];
+// --- detection (puro) ------------------------------------------------------
+// Riconosce le frasi decisionali in un testo (di un singolo messaggio) e ne
+// estrae decision/reason/context. Niente side-effect. Ritorna 0+ match in
+// ordine di apparizione, deduplicati per decisione.
+export function detectDecisions(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.decision);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(match);
+    }
+    return out;
+}
+// Prova i pattern su UNA frase. Prima il causale (cattura anche la reason),
+// poi i pattern decisionali generici.
+function matchSentence(sentence, source) {
+    const s = sentence.trim();
+    if (!s || s.length < 6)
+        return null;
+    for (const re of CAUSAL_PATTERNS) {
+        const m = re.exec(s);
+        if (m && m[2]) {
+            return {
+                decision: cleanClause(m[2]),
+                reason: cleanClause(m[1] ?? ""),
+                context: oneLine(s).slice(0, 280),
+                source,
+            };
+        }
+    }
+    for (const { re } of DECISION_PATTERNS) {
+        const m = re.exec(s);
+        if (m && m[1]) {
+            const rest = m[1];
+            const { decision, reason } = splitReason(rest);
+            const d = cleanClause(decision);
+            if (!d || d.length < 2)
+                continue;
+            return { decision: d, reason: cleanClause(reason), context: oneLine(s).slice(0, 280), source };
+        }
+    }
+    return null;
+}
+// Separa la decisione dalla motivazione quando la frase contiene "perche'/...".
+function splitReason(clause) {
+    for (const re of REASON_PATTERNS) {
+        const m = re.exec(clause);
+        if (m && m.index >= 0 && m[1]) {
+            return { decision: clause.slice(0, m.index), reason: m[1] };
+        }
+    }
+    return { decision: clause, reason: "" };
+}
+// --- promozione: match -> evento ------------------------------------------
+// Trasforma i match rilevati nei messaggi di un turno in eventi decision.made,
+// assegnando id progressivi, link al task e timestamp. `nextNum` da' il primo
+// numero libero (es. dal DecisionStore). Funzione pura.
+export function promoteDecisions(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;
+        for (const match of detectDecisions(text, source)) {
+            const key = normalizeKey(match.decision);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            events.push(toEvent(match, `${ns}D${num}`, opts.task ?? null, opts.now));
+            num += 1;
+        }
+    }
+    return events;
+}
+function toEvent(match, id, task, now) {
+    const decision = oneLine(match.decision).slice(0, 240);
+    const reason = oneLine(match.reason).slice(0, 240);
+    const summary = reason ? `${decision} (perche': ${reason})` : decision;
+    return {
+        type: "decision.made",
+        domain: "decisions",
+        id,
+        decision,
+        reason,
+        context: oneLine(match.context).slice(0, 280),
+        task,
+        subject: decision,
+        summary: oneLine(summary).slice(0, 280),
+        source: match.source,
+        createdAt: now,
+    };
+}
+// --- formato RoomRecord (richiamabile via recall) --------------------------
+// Rende un DecisionEvent 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 come le stanze). I termini includono "decision"
+// e "decisione" per renderlo facile da cercare.
+export function decisionToRoomRecord(ev) {
+    const terms = decisionTerms(ev);
+    const body = `INDICE
+1 = decisione
+2 = motivazione
+3 = contesto
+4 = task
+
+DEFINIZIONI
+@decision.made[${ev.id}]: domain=decisions
+@decision[${ev.id}]: "${esc(ev.decision)}"
+@reason[${ev.id}]: "${esc(ev.reason) || "(non espressa)"}"
+@context[${ev.id}]: "${esc(ev.context)}"
+@task[${ev.id}]: ${ev.task ? esc(ev.task) : "(nessuno)"}
+@source[${ev.id}]: ${ev.source}
+
+RELAZIONI
+@R: ${ev.id} -> decision.made [ dominio decisions${ev.task ? `, task ${esc(ev.task)}` : ""} ]
+
+OUTPUT: ${esc(ev.summary)}`;
+    return {
+        room: ev.id,
+        level: 0,
+        title: ev.summary,
+        terms,
+        body,
+        children: [],
+        parent: null,
+        createdAt: ev.createdAt,
+    };
+}
+function decisionTerms(ev) {
+    const base = ["decision", "decisione", "decision.made", "decisions"];
+    const fromText = tokenize(`${ev.decision} ${ev.reason}`).slice(0, 10);
+    return [...new Set([...base, ...fromText])].slice(0, 16);
+}
+// Store append-only degli eventi decision.made su file jsonl dedicato
+// (`<store>.decisions.jsonl`), separato dalle stanze ma nella stessa
+// sessionDir. Espone count/all/nextNum + query/search per il dominio decisions.
+export class DecisionStore {
+    file;
+    events = [];
+    constructor(file) {
+        this.file = file;
+    }
+    static open(sessionDir, storeId) {
+        const file = join(sessionDir, `${storeId}.decisions.jsonl`);
+        const store = new DecisionStore(file);
+        store.reloadFromDisk();
+        return store;
+    }
+    count() {
+        return this.events.length;
+    }
+    all() {
+        return this.events;
+    }
+    // Primo numero libero per gli id D<n> di un namespace (vassallo/castello).
+    nextNum(ns) {
+        return withLockSync(this.file, () => {
+            this.reloadFromDisk();
+            const prefix = `${ns ? `${ns}-` : ""}D`;
+            let max = 0;
+            for (const event of this.events) {
+                if (!event.id.startsWith(prefix))
+                    continue;
+                const suffix = event.id.slice(prefix.length);
+                if (!/^\d+$/.test(suffix))
+                    continue;
+                const value = Number(suffix);
+                if (Number.isSafeInteger(value) && value > max)
+                    max = value;
+            }
+            return max + 1;
+        });
+    }
+    // Aggiunge un evento. Il reload sotto lock rende l'idempotenza valida anche
+    // quando questa istanza e' stata aperta prima di un writer concorrente.
+    append(event) {
+        return this.appendAll([event]).length === 1;
+    }
+    // Aggiunge piu' eventi in una singola transazione append-only e ritorna
+    // quelli effettivamente scritti. Duplicati gia' su disco o nello stesso
+    // batch vengono ignorati in modo idempotente. Se due writer hanno allocato
+    // lo stesso D<n> prima dell'append, il secondo evento (se diverso) viene
+    // rinumerato sotto lo stesso lock: nextNum()+append non perde decisioni.
+    appendAll(events) {
+        if (!events.length)
+            return [];
+        return withLockSync(this.file, () => {
+            this.reloadFromDisk();
+            const byId = new Map(this.events.map((event) => [event.id, event]));
+            const maxByPrefix = new Map();
+            for (const event of this.events)
+                updateDecisionMax(maxByPrefix, event.id);
+            const written = [];
+            for (const incoming of events) {
+                // Replay esatto: puo' avere gia' ricevuto un id rinumerato da un altro
+                // writer. Il payload (timestamp incluso) ne conserva l'idempotenza.
+                if ([...byId.values()].some((event) => sameDecisionPayload(event, incoming)))
+                    continue;
+                let event = incoming;
+                if (byId.has(event.id)) {
+                    const parts = decisionIdParts(event.id);
+                    const prefix = parts?.prefix ?? "";
+                    let next = (maxByPrefix.get(prefix) ?? 0) + 1;
+                    while (byId.has(`${prefix}D${next}`))
+                        next += 1;
+                    event = { ...event, id: `${prefix}D${next}` };
+                }
+                byId.set(event.id, event);
+                updateDecisionMax(maxByPrefix, event.id);
+                written.push(event);
+            }
+            if (!written.length)
+                return written;
+            mkdirSync(dirname(this.file), { recursive: true });
+            appendFileSync(this.file, written.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8");
+            this.events.push(...written);
+            return written;
+        });
+    }
+    reloadFromDisk() {
+        this.events = [];
+        if (!existsSync(this.file))
+            return;
+        const raw = readFileSync(this.file, "utf8");
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                this.events.push(normalizeEvent(JSON.parse(line)));
+            }
+            catch {
+                // riga corrotta: ignorata
+            }
+        }
+    }
+    byTask(task) {
+        return this.events.filter((e) => e.task === task);
+    }
+    // Ricerca BM25-lite (offline) sugli eventi decisionali.
+    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.decision} ${e.reason} ${e.context}`);
+            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 delle decisioni (per /regno o iniezione contestuale).
+    indexBlock() {
+        if (!this.events.length)
+            return "";
+        const rows = this.events
+            .map((e) => `@decision[${e.id}]: "${esc(e.summary)}"${e.task ? ` · task=${esc(e.task)}` : ""}`)
+            .join("\n");
+        return `INDICE_DECISIONI (dominio decisions, piano di lavoro)
+Decisioni promosse automaticamente dalle conversazioni. Richiamabili col tool
+"recall" (per query o per id D<n>).
+
+${rows}
+
+OUTPUT: indice decisioni; dettaglio via recall.`;
+    }
+}
+function decisionIdParts(id) {
+    const match = /^(.*?)(?:D)(\d+)$/.exec(id);
+    if (!match)
+        return null;
+    const value = Number(match[2]);
+    return Number.isSafeInteger(value) ? { prefix: match[1] ?? "", value } : null;
+}
+function updateDecisionMax(maxByPrefix, id) {
+    const parts = decisionIdParts(id);
+    if (!parts)
+        return;
+    maxByPrefix.set(parts.prefix, Math.max(maxByPrefix.get(parts.prefix) ?? 0, parts.value));
+}
+function sameDecisionPayload(a, b) {
+    return a.type === b.type && a.domain === b.domain && a.decision === b.decision &&
+        a.reason === b.reason && a.context === b.context && a.task === b.task &&
+        a.subject === b.subject && a.summary === b.summary && a.source === b.source &&
+        a.createdAt === b.createdAt;
+}
+function normalizeEvent(raw) {
+    return {
+        type: "decision.made",
+        domain: "decisions",
+        id: raw.id ?? "D?",
+        decision: raw.decision ?? "",
+        reason: raw.reason ?? "",
+        context: raw.context ?? "",
+        task: raw.task ?? null,
+        subject: raw.subject ?? raw.decision ?? "",
+        summary: raw.summary ?? raw.decision ?? "",
+        source: raw.source === "assistant" ? "assistant" : "user",
+        createdAt: typeof raw.createdAt === "number" ? raw.createdAt : 0,
+    };
+}
+// --- 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);
+}
+// Pulisce una clausola: toglie punteggiatura di bordo, "che/di" iniziali residui
+// e spazi multipli. Conserva il contenuto sostanziale.
+function cleanClause(s) {
+    return oneLine(s)
+        .replace(/^[\s,;:]+/, "")
+        .replace(/[\s.,;:]+$/, "")
+        .replace(/^(?:di|che|to|that)\s+/i, "")
+        .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",
+    "il", "lo", "la", "le", "gli", "un", "uno", "una", "di", "da", "in", "su",
+    "che", "con", "per", "non", "ed", "tra", "fra", "come", "piu", "quindi",
+    "abbiamo", "deciso", "decidiamo", "ora", "poi", "usiamo", "useremo",
+]);
+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/delta-context.d.ts

@@ -0,0 +1,12 @@
+export interface DeltaInput {
+    readonly stable: string;
+    readonly previousStableHash?: string | null;
+    readonly delta: string;
+}
+export interface DeltaResult {
+    readonly stableHash: string;
+    readonly stableChanged: boolean;
+    readonly emit: string;
+}
+export declare function hashText(text: string): string;
+export declare function computeDelta(input: DeltaInput): DeltaResult;

package/dist/vascend/delta-context.js

@@ -0,0 +1,36 @@
+// Delta Context (metodo Danilov, Memory OS).
+//
+// Non reinviare tutto a ogni turno. Si separa il CONTESTO STABILE (system,
+// Vision, policy, piano attivo) dal DELTA del turno (nuovi eventi/evidenze).
+// Tramite un hash del blocco stabile si capisce se e' cambiato: se no, il pack
+// puo' riferirlo come gia' noto invece di ripeterlo per intero.
+//
+//   Cosa e' stabile? Cosa e' cambiato? Cosa serve ora? Cosa lascio come handle?
+//
+// Modulo PURO e deterministico: hash FNV-1a (no crypto, no deps), nessun I/O.
+// FNV-1a 32-bit in hex: hash deterministico e veloce, senza dipendenze.
+export function hashText(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    // >>> 0 per interpretarlo come unsigned.
+    return (h >>> 0).toString(16).padStart(8, "0");
+}
+// Calcola il delta: se lo stabile e' invariato, non lo reinvia per intero ma lo
+// referenzia per hash. Deterministico.
+export function computeDelta(input) {
+    const stableHash = hashText(input.stable);
+    const stableChanged = !input.previousStableHash || input.previousStableHash !== stableHash;
+    const delta = input.delta.trim();
+    if (stableChanged) {
+        // Stabile cambiato (o primo turno): emetti tutto.
+        const emit = [input.stable.trim(), delta].filter(Boolean).join("\n\n");
+        return { stableHash, stableChanged: true, emit };
+    }
+    // Stabile invariato: riferiscilo per hash, emetti solo il delta.
+    const ref = `[CTX:STABLE_REF]\n@stabile[invariato]: hash=${stableHash}  [ contesto stabile gia' noto dal turno precedente ]`;
+    const emit = [ref, delta].filter(Boolean).join("\n\n");
+    return { stableHash, stableChanged: false, emit };
+}

package/dist/vascend/dev-context-compiler.d.ts

@@ -0,0 +1,27 @@
+import { type ScoreWeights, type TierThresholds } from "./context-scorer.js";
+import { type ContextScore } from "./context-candidate.js";
+export interface DevCompileInput {
+    readonly sessionDir: string;
+    readonly scopeId: string;
+    readonly userText: string;
+    readonly totalTokens?: number;
+    readonly now?: number;
+    readonly goal?: string;
+    readonly stack?: readonly string[];
+    readonly scope?: readonly string[];
+    readonly done?: string;
+    readonly constraints?: readonly string[];
+    readonly nextAction?: string;
+    readonly requiredTests?: readonly string[];
+    readonly recallBlock?: string;
+    readonly toolBlock?: string;
+    readonly systemBlock?: string;
+    readonly weights?: ScoreWeights;
+    readonly thresholds?: TierThresholds;
+}
+export interface DevCompiledContext {
+    readonly pack: string;
+    readonly selected: readonly ContextScore[];
+    readonly tokensUsed: number;
+}
+export declare function compileDevContext(input: DevCompileInput): DevCompiledContext;

package/dist/vascend/dev-context-compiler.js

@@ -0,0 +1,133 @@
+// Dev Context Compiler (metodo Danilov, Memory OS).
+//
+// Variante del Context Window Compiler orientata allo SVILUPPO: usa il Dev
+// Context Layout (dev-context-layout) invece del layout generico. Stessa
+// pipeline deterministica del compiler canonico:
+//
+//   collect  -> candidati dagli store (candidate-collector)
+//   retrieve -> ranking ibrido, drop superseded (context-retriever)
+//   score    -> scoring multi-fattore + tier (context-scorer)
+//   categorize -> smista i candidati nelle zone dev (decisioni, code graph,
+//                 errori/test, patch plan, evidence)
+//   budget   -> alloca token per zona dev, packing greedy (budget-allocator)
+//   layout   -> assembla il Dev Prompt Pack con anchor tecnici
+//
+// Modulo di SOLA LETTURA verso gli store (via collector). Nessuna scrittura.
+import { collectCandidates } from "./candidate-collector.js";
+import { retrieve } from "./context-retriever.js";
+import { scoreCandidate, } from "./context-scorer.js";
+import { estimateCandidateTokens, } from "./context-candidate.js";
+import { estimateTokens, packToBudget } from "./budget-allocator.js";
+import { assembleDevLayout, buildDevMissionAnchor, buildDevTailAnchor, categorizeCandidates, renderCodeGraph, renderDecisions, renderEvidence, renderFailures, renderHandles, renderPatchPlan, } from "./dev-context-layout.js";
+const DEV_DEFAULT_TOTAL = 3_000;
+// Quote di budget per zona dev (sommano a ~1, escluso user). Le zone dev
+// danno piu' peso a code graph, errori/test e patch plan rispetto al layout
+// generico: e' la roba che serve a chi tocca codice.
+const DEV_SHARES = {
+    mission: 0.06,
+    constraints: 0.06,
+    decisions: 0.1,
+    codegraph: 0.22,
+    failures: 0.18,
+    evidence: 0.16,
+    patchplan: 0.1,
+    recall: 0.06,
+    tail: 0.06,
+};
+// Compila la dev context window del turno. Deterministico a parita' di store+now.
+export function compileDevContext(input) {
+    const now = input.now ?? Date.now();
+    const total = input.totalTokens && input.totalTokens > 0 ? input.totalTokens : DEV_DEFAULT_TOTAL;
+    const userTokens = estimateTokens(input.userText);
+    const budget = Math.max(0, total - userTokens);
+    const share = (pct) => Math.floor(budget * pct);
+    // 1) collect + 2) retrieve.
+    const pool = collectCandidates({ sessionDir: input.sessionDir, scopeId: input.scopeId });
+    const retrieved = retrieve(pool, { query: input.userText, limit: 40 }).map((r) => r.candidate);
+    // 3) score (novelty incrementale).
+    const ctx = {
+        query: input.userText,
+        now,
+        tokenBudget: budget,
+        ...(input.weights ? { weights: input.weights } : {}),
+        ...(input.thresholds ? { thresholds: input.thresholds } : {}),
+    };
+    const scored = scoreWithNovelty(retrieved, ctx);
+    // Solo i candidati che meritano spazio (tier high/mid). I "low" restano fuori.
+    const kept = scored.filter((s) => s.tier !== "low");
+    const cands = kept.map((s) => s.candidate);
+    const scoreOf = new Map(kept.map((s) => [s.candidate.id, s.score]));
+    // 4) categorize: smista i candidati nelle zone dev.
+    const buckets = categorizeCandidates(cands);
+    // 5) budget per zona: packing greedy per categoria.
+    const pack = (list, maxTokens, form) => packToBudget(list.map((c) => ({ ref: c, tokens: estimateCandidateTokens(c, form), priority: scoreOf.get(c.id) ?? 0 })), maxTokens).included;
+    const decisionsSel = pack(buckets.decisions, share(DEV_SHARES.decisions), "handle");
+    const codegraphSel = pack(buckets.codegraph, share(DEV_SHARES.codegraph), "handle");
+    const failuresSel = pack(buckets.failures, share(DEV_SHARES.failures), "body");
+    const evidenceSel = pack(buckets.evidence, share(DEV_SHARES.evidence), "body");
+    const patchplanSel = pack(buckets.patchplan, share(DEV_SHARES.patchplan), "handle");
+    // Gli scartati dalle zone "body" scendono a recall handles (richiamabili).
+    const usedIds = new Set([...decisionsSel, ...codegraphSel, ...failuresSel, ...evidenceSel, ...patchplanSel].map((c) => c.id));
+    const leftovers = cands.filter((c) => !usedIds.has(c.id));
+    const recallSel = pack(leftovers, share(DEV_SHARES.recall), "handle");
+    // Decisioni attive (per il tail anchor).
+    const activeDecisions = decisionsSel.map((c) => c.summary || c.subject).slice(0, 4);
+    const goal = input.goal ?? input.userText;
+    // 6) layout: assembla le zone dev.
+    const content = {
+        ...(input.systemBlock ? { system: input.systemBlock } : {}),
+        mission: buildDevMissionAnchor({
+            goal,
+            ...(input.stack ? { stack: input.stack } : {}),
+            ...(input.scope ? { scope: input.scope } : {}),
+            ...(input.done ? { done: input.done } : {}),
+        }),
+        ...(input.constraints?.length
+            ? { constraints: renderConstraints(input.constraints) }
+            : {}),
+        decisions: renderDecisions(decisionsSel),
+        codegraph: renderCodeGraph(codegraphSel),
+        failures: renderFailures(failuresSel),
+        evidence: renderEvidence(evidenceSel),
+        patchplan: renderPatchPlan(patchplanSel),
+        recall: input.recallBlock ?? renderHandles(recallSel),
+        ...(input.toolBlock ? { tool: input.toolBlock } : {}),
+        tail: buildDevTailAnchor({
+            goal,
+            ...(input.constraints ? { constraints: input.constraints } : {}),
+            ...(activeDecisions.length ? { activeDecisions } : {}),
+            ...(input.nextAction ? { nextAction: input.nextAction } : {}),
+            ...(input.requiredTests ? { requiredTests: input.requiredTests } : {}),
+            recallPolicy: true,
+        }),
+    };
+    const out = assembleDevLayout(content);
+    return { pack: out, selected: scored, tokensUsed: estimateTokens(out) };
+}
+// --- helper -----------------------------------------------------------------
+// Vincoli non negoziabili: blocco in testa che il modello non deve violare.
+function renderConstraints(constraints) {
+    const lines = ["INDICE", "1 = vincoli_duri", "", "DEFINIZIONI"];
+    let i = 1;
+    for (const c of constraints) {
+        lines.push(`@vincolo[${i}]: "${c.replace(/\s+/g, " ").trim().replace(/"/g, "'")}"`);
+        i += 1;
+    }
+    lines.push("", "OUTPUT: questi vincoli sono NON negoziabili; una violazione invalida il lavoro.");
+    return lines.join("\n");
+}
+// Scoring con novelty incrementale (penalizza i simili ai gia' accettati).
+function scoreWithNovelty(candidates, ctx) {
+    const base = candidates
+        .map((c) => scoreCandidate(c, ctx))
+        .sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+    const seen = [];
+    const out = [];
+    for (const s of base) {
+        const rescored = scoreCandidate(s.candidate, ctx, { seenTermSets: seen });
+        out.push(rescored);
+        if (rescored.tier !== "low")
+            seen.push(new Set(s.candidate.terms));
+    }
+    return out.sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+}

package/dist/vascend/dev-context-layout.d.ts

@@ -0,0 +1,30 @@
+import type { ContextCandidate } from "./context-candidate.js";
+export type DevZone = "system" | "mission" | "constraints" | "decisions" | "codegraph" | "failures" | "evidence" | "patchplan" | "recall" | "tool" | "user" | "tail";
+export declare const DEV_ZONE_ORDER: readonly DevZone[];
+export type DevZoneContent = Partial<Record<DevZone, string>>;
+export interface DevMissionAnchorInput {
+    readonly goal: string;
+    readonly stack?: readonly string[];
+    readonly done?: string;
+    readonly scope?: readonly string[];
+}
+export declare function buildDevMissionAnchor(input: DevMissionAnchorInput): string;
+export interface DevTailAnchorInput {
+    readonly goal: string;
+    readonly constraints?: readonly string[];
+    readonly activeDecisions?: readonly string[];
+    readonly nextAction?: string;
+    readonly requiredTests?: readonly string[];
+    readonly recallPolicy?: boolean;
+}
+export declare function buildDevTailAnchor(input: DevTailAnchorInput): string;
+export type DevCategory = "decisions" | "codegraph" | "failures" | "patchplan" | "evidence";
+export declare function categorizeCandidate(c: ContextCandidate): DevCategory;
+export declare function categorizeCandidates(cands: readonly ContextCandidate[]): Readonly<Record<DevCategory, readonly ContextCandidate[]>>;
+export declare function renderDecisions(cands: readonly ContextCandidate[]): string;
+export declare function renderCodeGraph(cands: readonly ContextCandidate[]): string;
+export declare function renderFailures(cands: readonly ContextCandidate[]): string;
+export declare function renderPatchPlan(cands: readonly ContextCandidate[]): string;
+export declare function renderEvidence(cands: readonly ContextCandidate[]): string;
+export declare function renderHandles(cands: readonly ContextCandidate[]): string;
+export declare function assembleDevLayout(content: DevZoneContent): string;