@vascend/talos 0.1.0 → 0.1.1

package/dist/vascend/completeness.js

@@ -7,22 +7,22 @@ export function completenessRounds(env) {
     const n = Number(env["TALOS_COMPLETENESS_ROUNDS"]);
     return Number.isInteger(n) && n >= 0 ? n : 2;
 }
-const CRITIC_SYSTEM = `# Critico di completezza
-INDICE
-1 = goal
-2 = consegna
-3 = mancante
-
-DEFINIZIONI
-@goal[reale]: l'obiettivo VERO dell'utente, non il piano svolto
-@consegna[criterio]: completa = funzionante e utilizzabile come chiesto (es. una SaaS: dati, auth, CRUD, UI, flussi base)
-@mancante[regola]: elenca SOLO pezzi ESSENZIALI assenti; niente perfezionismo, niente nice-to-have
-@rigore[bilancia]: se la consegna soddisfa il goal nella sostanza, complete=true
-
-RELAZIONI
-@R1: @goal[reale] -> @consegna[criterio]  [ misura la consegna sul goal vero ]
-@R2: @consegna[criterio] -> @mancante[regola]  [ elenca solo l'essenziale assente ]
-
+const CRITIC_SYSTEM = `# Critico di completezza
+INDICE
+1 = goal
+2 = consegna
+3 = mancante
+
+DEFINIZIONI
+@goal[reale]: l'obiettivo VERO dell'utente, non il piano svolto
+@consegna[criterio]: completa = funzionante e utilizzabile come chiesto (es. una SaaS: dati, auth, CRUD, UI, flussi base)
+@mancante[regola]: elenca SOLO pezzi ESSENZIALI assenti; niente perfezionismo, niente nice-to-have
+@rigore[bilancia]: se la consegna soddisfa il goal nella sostanza, complete=true
+
+RELAZIONI
+@R1: @goal[reale] -> @consegna[criterio]  [ misura la consegna sul goal vero ]
+@R2: @consegna[criterio] -> @mancante[regola]  [ elenca solo l'essenziale assente ]
+
 OUTPUT: SOLO JSON {"complete": bool, "missing": [stringhe brevi]}. Niente prosa, niente markdown.`;
 export async function judgeCompleteness(opts) {
     const { harness, goal, evidence, signal } = opts;
@@ -71,20 +71,20 @@ function unknownVerdict(reason) {
 }
 // Steer in notazione Danilov per far continuare l'agente sui pezzi mancanti.
 export function buildCompletenessSteer(goal, missing) {
-    return `[VASCEND_COMPLETEZZA]
-INDICE
-1 = goal
-2 = mancante
-3 = azione
-
-DEFINIZIONI
-@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
-@mancante[pezzi]: ${missing.map((m, i) => `(${i + 1}) ${m}`).join(" ; ")}
-@azione[continua]: NON ti fermi al piano gia' fatto; il goal non e' "ho creato i gruppi" ma "ho consegnato la cosa completa"
-
-RELAZIONI
-@R1: @mancante[pezzi] -> @azione[continua]  [ pianifica e COSTRUISCI i pezzi mancanti ]
-@R2: @azione[continua] -> @goal[reale]  [ finche' la consegna soddisfa il goal vero ]
-
+    return `[VASCEND_COMPLETEZZA]
+INDICE
+1 = goal
+2 = mancante
+3 = azione
+
+DEFINIZIONI
+@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
+@mancante[pezzi]: ${missing.map((m, i) => `(${i + 1}) ${m}`).join(" ; ")}
+@azione[continua]: NON ti fermi al piano gia' fatto; il goal non e' "ho creato i gruppi" ma "ho consegnato la cosa completa"
+
+RELAZIONI
+@R1: @mancante[pezzi] -> @azione[continua]  [ pianifica e COSTRUISCI i pezzi mancanti ]
+@R2: @azione[continua] -> @goal[reale]  [ finche' la consegna soddisfa il goal vero ]
+
 OUTPUT: crea altri gruppi/attivita e realizza i pezzi mancanti elencati, poi illuminali. Vai fino a una consegna completa e funzionante, non fermarti al primo piano.`;
 }

package/dist/vascend/context-fabric.js

@@ -365,22 +365,22 @@ function buildRetrievalQuery(userText, mission, focusTerms) {
 function renderFabricBlock(frame, inherited) {
     const pins = frame.leases.filter((lease) => lease.source === "pinned").map((lease) => lease.term);
     const working = frame.leases.filter((lease) => lease.source !== "pinned").slice(0, 20).map((lease) => lease.term);
-    return `[CONTEXT_FABRIC]
-INDICE
-1 = epoch
-2 = control_lane
-3 = working_lane
-4 = evidence_lane
-5 = quarantine_lane
-
-DEFINIZIONI
-@epoch[${frame.epoch}]: missione="${escapeValue(frame.mission)}", owner=${safeName(frame.owner)}, inherited=${inherited}
-@lane[control]: mode=${frame.activeMode}, pin="${escapeValue(pins.join(", ") || "nessuno")}" 
-@lane[working]: focus="${escapeValue(working.join(", ") || "nessuno")}" 
-@lane[evidence]: accetta fatti passati solo se presenti negli evidence slot o recuperati con recall
-@lane[quarantine]: epoch precedenti e lease scadute restano fuori dal prompt vivo; sono solo handle richiamabili
-@lease[regola]: turn=scade, mission=dura_per_epoch, pinned=non_scade
-
+    return `[CONTEXT_FABRIC]
+INDICE
+1 = epoch
+2 = control_lane
+3 = working_lane
+4 = evidence_lane
+5 = quarantine_lane
+
+DEFINIZIONI
+@epoch[${frame.epoch}]: missione="${escapeValue(frame.mission)}", owner=${safeName(frame.owner)}, inherited=${inherited}
+@lane[control]: mode=${frame.activeMode}, pin="${escapeValue(pins.join(", ") || "nessuno")}" 
+@lane[working]: focus="${escapeValue(working.join(", ") || "nessuno")}" 
+@lane[evidence]: accetta fatti passati solo se presenti negli evidence slot o recuperati con recall
+@lane[quarantine]: epoch precedenti e lease scadute restano fuori dal prompt vivo; sono solo handle richiamabili
+@lease[regola]: turn=scade, mission=dura_per_epoch, pinned=non_scade
+
 OUTPUT: continua la missione dell'epoch; non sostituirla con un follow-up deittico come 'continua'.`;
 }
 function extractRawUserText(value) {

package/dist/vascend/contract-memory.js

@@ -195,30 +195,30 @@ export function contractToRoomRecord(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 ]`}
-
+    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,
@@ -340,12 +340,12 @@ export class ContractStore {
             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}
-
+        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.`;
     }
 }

package/dist/vascend/council.js

@@ -9,22 +9,22 @@ const EVAL_COMPLETENESS = {
     axis: "completeness",
     title: "Valutatore completezza",
     weight: 1,
-    system: `# Valutatore del concilio — asse COMPLETEZZA
-INDICE
-1 = goal
-2 = consegna
-3 = lacuna
-
-DEFINIZIONI
-@goal[reale]: l'obiettivo VERO dell'utente, non il piano svolto
-@consegna[criterio]: completa = tutti i pezzi essenziali presenti e funzionanti (dati, flussi, UI, integrazioni richieste)
-@lacuna[regola]: elenca SOLO pezzi ESSENZIALI assenti; niente nice-to-have
-@score[scala]: 100=tutto consegnato, 0=nulla di sostanziale; misura la copertura del goal
-
-RELAZIONI
-@R1: @goal[reale] -> @consegna[criterio]  [ misura la consegna sul goal vero ]
-@R2: @consegna[criterio] -> @lacuna[regola]  [ approve=false se manca l'essenziale ]
-
+    system: `# Valutatore del concilio — asse COMPLETEZZA
+INDICE
+1 = goal
+2 = consegna
+3 = lacuna
+
+DEFINIZIONI
+@goal[reale]: l'obiettivo VERO dell'utente, non il piano svolto
+@consegna[criterio]: completa = tutti i pezzi essenziali presenti e funzionanti (dati, flussi, UI, integrazioni richieste)
+@lacuna[regola]: elenca SOLO pezzi ESSENZIALI assenti; niente nice-to-have
+@score[scala]: 100=tutto consegnato, 0=nulla di sostanziale; misura la copertura del goal
+
+RELAZIONI
+@R1: @goal[reale] -> @consegna[criterio]  [ misura la consegna sul goal vero ]
+@R2: @consegna[criterio] -> @lacuna[regola]  [ approve=false se manca l'essenziale ]
+
 ${VERDICT_SCHEMA}`,
 };
 const EVAL_CORRECTNESS = {
@@ -32,22 +32,22 @@ const EVAL_CORRECTNESS = {
     axis: "correctness",
     title: "Valutatore correttezza",
     weight: 1,
-    system: `# Valutatore del concilio — asse CORRETTEZZA
-INDICE
-1 = comportamento
-2 = errori
-3 = rischio
-
-DEFINIZIONI
-@comportamento[atteso]: l'operato fa cio' che il goal richiede senza rotture evidenti
-@errori[segnali]: bug logici, regressioni, casi limite ignorati, contratti violati
-@rischio[regola]: approve=false se ci sono difetti che rompono il flusso principale
-@score[scala]: 100=corretto e robusto, 0=non funziona; penalizza i bug sul percorso critico
-
-RELAZIONI
-@R1: @comportamento[atteso] -> @errori[segnali]  [ cerca difetti sul percorso critico ]
-@R2: @errori[segnali] -> @rischio[regola]  [ i difetti gravi abbassano score e approve ]
-
+    system: `# Valutatore del concilio — asse CORRETTEZZA
+INDICE
+1 = comportamento
+2 = errori
+3 = rischio
+
+DEFINIZIONI
+@comportamento[atteso]: l'operato fa cio' che il goal richiede senza rotture evidenti
+@errori[segnali]: bug logici, regressioni, casi limite ignorati, contratti violati
+@rischio[regola]: approve=false se ci sono difetti che rompono il flusso principale
+@score[scala]: 100=corretto e robusto, 0=non funziona; penalizza i bug sul percorso critico
+
+RELAZIONI
+@R1: @comportamento[atteso] -> @errori[segnali]  [ cerca difetti sul percorso critico ]
+@R2: @errori[segnali] -> @rischio[regola]  [ i difetti gravi abbassano score e approve ]
+
 ${VERDICT_SCHEMA}`,
 };
 const EVAL_QUALITY = {
@@ -55,22 +55,22 @@ const EVAL_QUALITY = {
     axis: "quality",
     title: "Valutatore qualita' e test",
     weight: 1,
-    system: `# Valutatore del concilio — asse QUALITA'/TEST
-INDICE
-1 = qualita
-2 = test
-3 = manutenibilita
-
-DEFINIZIONI
-@qualita[criterio]: codice coeso, convenzioni del progetto rispettate, niente duplicazione inutile
-@test[criterio]: i percorsi importanti hanno verifica (test o prova esplicita); assente = lacuna
-@manutenibilita[regola]: approve=false solo se la qualita' compromette l'uso o la tenuta del lavoro
-@score[scala]: 100=pulito e verificato, 0=fragile e non testato; non essere perfezionista
-
-RELAZIONI
-@R1: @qualita[criterio] -> @test[criterio]  [ qualita' include la verifica ]
-@R2: @test[criterio] -> @manutenibilita[regola]  [ pesa l'impatto reale, non l'estetica ]
-
+    system: `# Valutatore del concilio — asse QUALITA'/TEST
+INDICE
+1 = qualita
+2 = test
+3 = manutenibilita
+
+DEFINIZIONI
+@qualita[criterio]: codice coeso, convenzioni del progetto rispettate, niente duplicazione inutile
+@test[criterio]: i percorsi importanti hanno verifica (test o prova esplicita); assente = lacuna
+@manutenibilita[regola]: approve=false solo se la qualita' compromette l'uso o la tenuta del lavoro
+@score[scala]: 100=pulito e verificato, 0=fragile e non testato; non essere perfezionista
+
+RELAZIONI
+@R1: @qualita[criterio] -> @test[criterio]  [ qualita' include la verifica ]
+@R2: @test[criterio] -> @manutenibilita[regola]  [ pesa l'impatto reale, non l'estetica ]
+
 ${VERDICT_SCHEMA}`,
 };
 const EVAL_REQUIREMENTS = {
@@ -78,22 +78,22 @@ const EVAL_REQUIREMENTS = {
     axis: "requirements",
     title: "Valutatore allineamento requisiti",
     weight: 1,
-    system: `# Valutatore del concilio — asse REQUISITI
-INDICE
-1 = requisiti
-2 = copertura
-3 = deriva
-
-DEFINIZIONI
-@requisiti[fonte]: i requisiti espliciti/impliciti del goal (e quelli estratti, se forniti)
-@copertura[criterio]: ogni requisito ha una risposta nell'operato; mappa requisito->evidenza
-@deriva[regola]: approve=false se requisiti chiave restano scoperti o l'operato devia dal richiesto
-@score[scala]: 100=tutti i requisiti coperti, 0=fuori tema; misura l'aderenza al richiesto
-
-RELAZIONI
-@R1: @requisiti[fonte] -> @copertura[criterio]  [ confronta operato e requisiti ]
-@R2: @copertura[criterio] -> @deriva[regola]  [ requisiti chiave scoperti = no approve ]
-
+    system: `# Valutatore del concilio — asse REQUISITI
+INDICE
+1 = requisiti
+2 = copertura
+3 = deriva
+
+DEFINIZIONI
+@requisiti[fonte]: i requisiti espliciti/impliciti del goal (e quelli estratti, se forniti)
+@copertura[criterio]: ogni requisito ha una risposta nell'operato; mappa requisito->evidenza
+@deriva[regola]: approve=false se requisiti chiave restano scoperti o l'operato devia dal richiesto
+@score[scala]: 100=tutti i requisiti coperti, 0=fuori tema; misura l'aderenza al richiesto
+
+RELAZIONI
+@R1: @requisiti[fonte] -> @copertura[criterio]  [ confronta operato e requisiti ]
+@R2: @copertura[criterio] -> @deriva[regola]  [ requisiti chiave scoperti = no approve ]
+
 ${VERDICT_SCHEMA}`,
 };
 // Registro dei valutatori disponibili, per asse.
@@ -185,24 +185,24 @@ export function buildCouncilSteer(goal, verdict) {
         .map((v) => `@asse[${v.axis}]: score=${v.score}/100, motivo="${v.rationale.replace(/"/g, "'").slice(0, 160)}"`)
         .join("\n");
     const gapRows = verdict.gaps.map((g, i) => `(${i + 1}) ${g}`).join(" ; ");
-    return `[VASCEND_CONCILIO]
-INDICE
-1 = goal
-2 = verdetto
-3 = dissenso
-4 = azione
-
-DEFINIZIONI
-@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
-@verdetto[grado]: completamento=${verdict.completion}/100, consenso=${verdict.consensus.approve}/${verdict.consensus.total}
-${dissentRows || "@dissenso[nessuno]: tutti gli assi approvano tranne la soglia"}
-@mancante[pezzi]: ${gapRows || "nessuna lacuna esplicita: alza il grado sugli assi in dissenso"}
-@azione[continua]: chiudi i dissensi degli assi e copri le lacune, poi il concilio rivota
-
-RELAZIONI
-@R1: @dissenso[assi] -> @azione[continua]  [ risolvi prima gli assi che non approvano ]
-@R2: @mancante[pezzi] -> @goal[reale]  [ copri le lacune finche' il concilio approva ]
-
+    return `[VASCEND_CONCILIO]
+INDICE
+1 = goal
+2 = verdetto
+3 = dissenso
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
+@verdetto[grado]: completamento=${verdict.completion}/100, consenso=${verdict.consensus.approve}/${verdict.consensus.total}
+${dissentRows || "@dissenso[nessuno]: tutti gli assi approvano tranne la soglia"}
+@mancante[pezzi]: ${gapRows || "nessuna lacuna esplicita: alza il grado sugli assi in dissenso"}
+@azione[continua]: chiudi i dissensi degli assi e copri le lacune, poi il concilio rivota
+
+RELAZIONI
+@R1: @dissenso[assi] -> @azione[continua]  [ risolvi prima gli assi che non approvano ]
+@R2: @mancante[pezzi] -> @goal[reale]  [ copri le lacune finche' il concilio approva ]
+
 OUTPUT: lavora sui pezzi mancanti e sui dissensi elencati, poi completa le attivita. Il concilio rivaluta: punta ad approvazione (grado alto e zero dissensi).`;
 }
 // ---------------------------------------------------------------------------

package/dist/vascend/decision-promotion.js

@@ -145,23 +145,23 @@ function toEvent(match, id, task, now) {
 // 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)}` : ""} ]
-
+    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,
@@ -321,12 +321,12 @@ export class DecisionStore {
         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}
-
+        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.`;
     }
 }

package/dist/vascend/granular-kingdom.js

@@ -87,23 +87,23 @@ function markRule(unit, castle) {
 // del castello: una sola unita', niente sotto-scomposizione, resta nel confine.
 function unitSteer(unit, peers, castle) {
     const others = peers.filter((p) => p !== unit.id);
-    return `[UNITA' ${unit.id}]
-INDICE
-1 = ruolo
-2 = dipendenze
-3 = confine
-
-DEFINIZIONI
-@ruolo[unita]: id=${unit.id}, granularita=fine, peer=[${others.join(", ") || "nessuno"}]
-@dipendenze[done]: ${(unit.deps ?? []).join(", ") || "nessuna (gia' soddisfatte: parti subito)"}
-@confine[regola]: esegui SOLO questa unita', NON scomporla ulteriormente, NON toccare il lavoro delle altre unita'${markRule(unit, castle)}
-
-RELAZIONI
-@R1: @ruolo[unita] -> @confine[regola]  [ una sola unita', niente sovrapposizioni ]
-
-OUTPUT: esegui l'unita' e basta; le dipendenze sono gia' completate.
-
-OBIETTIVO_UNITA'
+    return `[UNITA' ${unit.id}]
+INDICE
+1 = ruolo
+2 = dipendenze
+3 = confine
+
+DEFINIZIONI
+@ruolo[unita]: id=${unit.id}, granularita=fine, peer=[${others.join(", ") || "nessuno"}]
+@dipendenze[done]: ${(unit.deps ?? []).join(", ") || "nessuna (gia' soddisfatte: parti subito)"}
+@confine[regola]: esegui SOLO questa unita', NON scomporla ulteriormente, NON toccare il lavoro delle altre unita'${markRule(unit, castle)}
+
+RELAZIONI
+@R1: @ruolo[unita] -> @confine[regola]  [ una sola unita', niente sovrapposizioni ]
+
+OUTPUT: esegui l'unita' e basta; le dipendenze sono gia' completate.
+
+OBIETTIVO_UNITA'
 `;
 }
 // Costruisce il TaskRunner che esegue una unita' come sessione di agente.

package/dist/vascend/granular-launcher.js

@@ -196,7 +196,7 @@ export function formatGranularReport(report) {
     const rows = report.results
         .map((r) => `@unit[${r.id}]: ${mark[r.status]} ${r.status}${r.error ? ` · errore: ${r.error}` : ""}${r.blockedBy?.length ? ` · bloccata da ${r.blockedBy.join(", ")}` : ""}`)
         .join("\n");
-    return `[GRANULAR_LAUNCH]
-@esito[totale]: ${report.done} done · ${report.failed} failed · ${report.skipped} skipped${report.ok ? " · OK" : ""}
+    return `[GRANULAR_LAUNCH]
+@esito[totale]: ${report.done} done · ${report.failed} failed · ${report.skipped} skipped${report.ok ? " · OK" : ""}
 ${rows}`;
 }

package/dist/vascend/kingdom-kpi.js

@@ -135,25 +135,25 @@ export function buildKingdomImproveSteer(goal, verdict) {
     const execGap = kpi.failed > 0 || kpi.mergeConflicts > 0 || kpi.emptyVassals > 0
         ? `collaboratori falliti=${kpi.failed}, conflitti merge=${kpi.mergeConflicts}, collaboratori vuoti=${kpi.emptyVassals}`
         : "esecuzione completa";
-    return `[VASCEND_ATTIVITA_MIGLIORA]
-INDICE
-1 = goal
-2 = kpi
-3 = vision
-4 = azione
-
-DEFINIZIONI
-@goal[reale]: "${g}"
-@kpi[esecuzione]: ${kpi.executionScore}/100 (soglia ${verdict.executionThreshold}) · ${execGap}
-@vision[allineamento]: ${alignment.alignment}/100 verso l'obiettivo finale (must residui=${must.length})
-@proposta[gap]: ${rows || "nessuna proposta esplicita: rifinisci verso l'obiettivo finale"}
-@azione[colma]: NON consegni un piano parziale; PRIMA risolvi i gap di esecuzione (rilavora i gruppi falliti, integra i conflitti), POI realizza le proposte must verso la Vision
-
-RELAZIONI
-@R1: @kpi[esecuzione] -> @azione[colma]  [ i fallimenti di esecuzione vanno chiusi per primi ]
-@R2: @vision[allineamento] -> @proposta[gap]  [ il gap verso l'obiettivo diventa proposte ]
-@R3: @proposta[gap] -> @azione[colma]  [ realizza i must, poi rivaluta ]
-
+    return `[VASCEND_ATTIVITA_MIGLIORA]
+INDICE
+1 = goal
+2 = kpi
+3 = vision
+4 = azione
+
+DEFINIZIONI
+@goal[reale]: "${g}"
+@kpi[esecuzione]: ${kpi.executionScore}/100 (soglia ${verdict.executionThreshold}) · ${execGap}
+@vision[allineamento]: ${alignment.alignment}/100 verso l'obiettivo finale (must residui=${must.length})
+@proposta[gap]: ${rows || "nessuna proposta esplicita: rifinisci verso l'obiettivo finale"}
+@azione[colma]: NON consegni un piano parziale; PRIMA risolvi i gap di esecuzione (rilavora i gruppi falliti, integra i conflitti), POI realizza le proposte must verso la Vision
+
+RELAZIONI
+@R1: @kpi[esecuzione] -> @azione[colma]  [ i fallimenti di esecuzione vanno chiusi per primi ]
+@R2: @vision[allineamento] -> @proposta[gap]  [ il gap verso l'obiettivo diventa proposte ]
+@R3: @proposta[gap] -> @azione[colma]  [ realizza i must, poi rivaluta ]
+
 OUTPUT: colma i gap del piano col lavoro reale (esecuzione prima, poi proposte must verso la Vision) e completa le attivita con vascend_mark. Il gate KPI rivaluta.`;
 }
 // ---------------------------------------------------------------------------

package/dist/vascend/kingdom-run.js

@@ -351,7 +351,7 @@ export async function runKingdomForHost(input) {
             at: Date.now(),
         });
         const elenco = castles.map((c) => `${c.slug}${c.role ? ` (${c.role})` : ""}`).join(", ");
-        return `Squadra al lavoro: ${elenco}.
+        return `Squadra al lavoro: ${elenco}.
 `
             + `Gli incarichi pronti partono entro il limite di concorrenza; gli altri attendono dipendenze o aree libere. Parlagli con team_say, leggi cosa rispondono con `
             + `team_inbox, e quando serve raccogli i risultati con team_report. Non aspettarli fermo: `
@@ -459,12 +459,12 @@ export function formatKingdomOutcome(reports, sessionDir, kingdomId) {
     const isolated = reports.some((r) => r.branch);
     const conflicts = collectConflicts(reports);
     const gitNote = isolated
-        ? `\n\n[NOTA_GIT]
-@stato[rami]: ogni collaboratore in worktree isolato; rami merge-ati nel ramo base
-@conflitti[merge]: ${conflicts.length ? `${conflicts.map((r) => r.slug).join(", ")} NON merge-ati (rami conservati, risoluzione manuale)` : "nessuno"}
+        ? `\n\n[NOTA_GIT]
+@stato[rami]: ogni collaboratore in worktree isolato; rami merge-ati nel ramo base
+@conflitti[merge]: ${conflicts.length ? `${conflicts.map((r) => r.slug).join(", ")} NON merge-ati (rami conservati, risoluzione manuale)` : "nessuno"}
 @azione[consegna]: verifica diff e controlli nel ramo base; push solo se richiesto dall'utente`
-        : `\n\n[NOTA_GIT]
-@stato[modifiche]: nel working tree, NON committate (i collaboratori non fanno git: working dir condivisa)
+        : `\n\n[NOTA_GIT]
+@stato[modifiche]: nel working tree, NON committate (i collaboratori non fanno git: working dir condivisa)
 @azione[consegna]: verifica diff e controlli; commit e push solo se richiesti dall'utente`;
     const stash = formatConflictList(conflicts);
     return `ESECUZIONE ATTIVITA CONCLUSA · ${reports.length} gruppi\n${lines}${index}${gitNote}${stash ? `\n\n${stash}` : ""}`;