@vascend/talos 0.1.0 → 0.1.1

package/dist/vascend/kingdom.js

@@ -79,11 +79,11 @@ export function formatConflictList(conflicts, base) {
         .map((c) => `${c.worktree ? `  git worktree remove ${quoteCommandArg(c.worktree)}\n` : ""}  git branch -d ${c.branch}`)
         .join("\n");
     const actions = [inspect, commits, merges, cleanup].filter(Boolean).join("\n");
-    return `[STASH_DA_RISOLVERE]
-@stato[sospeso]: ${conflicts.length} ramo/i di collaboratore da recuperare${into} (nessun lavoro e' stato eliminato)
-${rows}
-@azione[risoluzione]: ispeziona, committa se indicato, poi integra SOLO dal ramo base:
-${actions}
+    return `[STASH_DA_RISOLVERE]
+@stato[sospeso]: ${conflicts.length} ramo/i di collaboratore da recuperare${into} (nessun lavoro e' stato eliminato)
+${rows}
+@azione[risoluzione]: ispeziona, committa se indicato, poi integra SOLO dal ramo base:
+${actions}
 @azione[pulizia]: solo dopo aver verificato il merge: git worktree remove <path> ; git branch -d <ramo>`;
 }
 function quoteCommandArg(value) {
@@ -117,30 +117,30 @@ export function looksBigGoal(text) {
     const signals = (t.match(/\b(e poi|inoltre|vari|varie|multipl|in parallelo|workstream|diverse|diversi|piu'|più|oltre a)\b/gi) ?? []).length;
     return signals >= 2;
 }
-const DECOMPOSE_SYSTEM = `# Coordinatore del team
-
-INDICE
-1 = coordinatore
-2 = obiettivo
-3 = incarico
-4 = indipendenza
-5 = confine
-
-DEFINIZIONI
-@coordinatore[ruolo]: scompone un obiettivo grande in incarichi
-@obiettivo[input]: macro-goal da spezzare
-@incarico[unita]: sotto-obiettivo autonomo, che un collaboratore puo' portare a termine da solo
-@indipendenza[regola]: gli incarichi non dipendono dall'output l'uno dell'altro nello stesso giro
-@confine[criterio]: taglia per area/modulo/file, NON per fase sequenziale
-
-RELAZIONI
-@R1: @obiettivo[input] -> @incarico[unita]  [ scomponi in parti ]
-@R2: @incarico[unita] -> @indipendenza[regola]  [ partono tutti insieme ]
-@R3: @incarico[unita] -> @confine[criterio]  [ confini netti ]
-
-OUTPUT: SOLO un array JSON di {slug, goal, after}; slug kebab-case breve; goal autonomo e completo;
-"after" = array degli slug degli incarichi PREREQUISITO (dipendenze forti: cio' che deve esistere prima),
-[] se indipendente — e indipendente e' quasi sempre la risposta giusta: un "after" di troppo mette in
+const DECOMPOSE_SYSTEM = `# Coordinatore del team
+
+INDICE
+1 = coordinatore
+2 = obiettivo
+3 = incarico
+4 = indipendenza
+5 = confine
+
+DEFINIZIONI
+@coordinatore[ruolo]: scompone un obiettivo grande in incarichi
+@obiettivo[input]: macro-goal da spezzare
+@incarico[unita]: sotto-obiettivo autonomo, che un collaboratore puo' portare a termine da solo
+@indipendenza[regola]: gli incarichi non dipendono dall'output l'uno dell'altro nello stesso giro
+@confine[criterio]: taglia per area/modulo/file, NON per fase sequenziale
+
+RELAZIONI
+@R1: @obiettivo[input] -> @incarico[unita]  [ scomponi in parti ]
+@R2: @incarico[unita] -> @indipendenza[regola]  [ partono tutti insieme ]
+@R3: @incarico[unita] -> @confine[criterio]  [ confini netti ]
+
+OUTPUT: SOLO un array JSON di {slug, goal, after}; slug kebab-case breve; goal autonomo e completo;
+"after" = array degli slug degli incarichi PREREQUISITO (dipendenze forti: cio' che deve esistere prima),
+[] se indipendente — e indipendente e' quasi sempre la risposta giusta: un "after" di troppo mette in
 fila lavoro che poteva andare in parallelo. Niente prosa, niente markdown.`;
 // L'Imperatore scompone un obiettivo in castelli (slug + goal) con UNA chiamata
 // al modello. Ritorna [] se non risolvibile; fallback a un solo castello se il
@@ -551,33 +551,33 @@ function vassalSteer(self, peers, after, identity, git, mandateBlock) {
     const gitOut = git.isolated
         ? `committa il tuo lavoro sul TUO ramo (il merge lo fa chi ti ha ingaggiato).`
         : `NIENTE git che modifica.`;
-    return `[COLLABORATORE ${self}]
-INDICE
-1 = ruolo
-2 = dipendenze
-3 = cooperazione
-4 = confine
-
-DEFINIZIONI
-@ruolo[collaboratore]: id=${self}, ruolo=${identity.role}, parent=${identity.parent}, peer=[${others.join(", ") || "nessuno"}]
-@dipendenze[after]: ${after.length ? after.join(", ") : "nessuna (parti subito)"}
-@cooperazione[annuncio]: all'avvio usa team_say(to="${identity.parent}") per confermare task e piano breve; durante il lavoro annuncia milestone; alla fine invia esito e file toccati
-@cooperazione[ascolto]: team_inbox REGOLARMENTE — dopo ogni passaggio, non solo se dipendi da qualcuno: chi ti scrive puo' averti risparmiato un lavoro sbagliato, o aspettare una tua risposta
-@cooperazione[attesa]: team_wait(from/contains) solo se non hai altro di utile da fare; se puoi andare avanti su un altro pezzo, vai avanti
-@cooperazione[info]: tieni informato chi dipende da te, e rispondi a chi ti chiede qualcosa: un messaggio senza risposta blocca chi l'ha mandato
-@cooperazione[scoperte]: se scopri qualcosa che cambia il lavoro di un altro (un file che non e' dove sembrava, un'assunzione che non regge) diglielo SUBITO con team_say, prima che ci sbatta anche lui
-@confine[regola]: resta nel tuo incarico, non duplicare il lavoro altrui
-${gitDef}
-
-RELAZIONI
-@R1: @cooperazione[ascolto] -> @cooperazione[scoperte]  [ si lavora insieme, non in parallelo silenzioso ]
-@R2: @ruolo[collaboratore] -> @cooperazione[annuncio]  [ sblocca gli altri annunciando ]
-@R3: @ruolo[collaboratore] -> @confine[regola]  [ niente sovrapposizioni ]
-${gitRel}
-
-OUTPUT: esegui il tuo incarico cooperando con gli altri (annuncia/ascolta/aspetta), resta nel confine, ${gitOut}
-
-${mandateBlock ? `${mandateBlock}\n\n` : ""}OBIETTIVO_ATTIVITA
+    return `[COLLABORATORE ${self}]
+INDICE
+1 = ruolo
+2 = dipendenze
+3 = cooperazione
+4 = confine
+
+DEFINIZIONI
+@ruolo[collaboratore]: id=${self}, ruolo=${identity.role}, parent=${identity.parent}, peer=[${others.join(", ") || "nessuno"}]
+@dipendenze[after]: ${after.length ? after.join(", ") : "nessuna (parti subito)"}
+@cooperazione[annuncio]: all'avvio usa team_say(to="${identity.parent}") per confermare task e piano breve; durante il lavoro annuncia milestone; alla fine invia esito e file toccati
+@cooperazione[ascolto]: team_inbox REGOLARMENTE — dopo ogni passaggio, non solo se dipendi da qualcuno: chi ti scrive puo' averti risparmiato un lavoro sbagliato, o aspettare una tua risposta
+@cooperazione[attesa]: team_wait(from/contains) solo se non hai altro di utile da fare; se puoi andare avanti su un altro pezzo, vai avanti
+@cooperazione[info]: tieni informato chi dipende da te, e rispondi a chi ti chiede qualcosa: un messaggio senza risposta blocca chi l'ha mandato
+@cooperazione[scoperte]: se scopri qualcosa che cambia il lavoro di un altro (un file che non e' dove sembrava, un'assunzione che non regge) diglielo SUBITO con team_say, prima che ci sbatta anche lui
+@confine[regola]: resta nel tuo incarico, non duplicare il lavoro altrui
+${gitDef}
+
+RELAZIONI
+@R1: @cooperazione[ascolto] -> @cooperazione[scoperte]  [ si lavora insieme, non in parallelo silenzioso ]
+@R2: @ruolo[collaboratore] -> @cooperazione[annuncio]  [ sblocca gli altri annunciando ]
+@R3: @ruolo[collaboratore] -> @confine[regola]  [ niente sovrapposizioni ]
+${gitRel}
+
+OUTPUT: esegui il tuo incarico cooperando con gli altri (annuncia/ascolta/aspetta), resta nel confine, ${gitOut}
+
+${mandateBlock ? `${mandateBlock}\n\n` : ""}OBIETTIVO_ATTIVITA
 `;
 }
 const MAX_UNITS = 16;

package/dist/vascend/mandate.js

@@ -82,26 +82,26 @@ export function formatMandate(mandate, canDelegate) {
     const growthRel = canDelegate
         ? `@R3: @attivita[mie] -> @crescita[scomposizione]  [ scomponi o delega, non sforare ]`
         : `@R3: @attivita[mie] -> @crescita[scomposizione]  [ niente delega: riporta il limite ]`;
-    return `MANDATO
-INDICE
-1 = gruppo
-2 = attivita
-3 = avanzamento
-4 = crescita
-
-DEFINIZIONI
-@gruppo[assegnato]: ${mandate.castle} "${mandate.title}"${mandate.after ? ` · dopo ${mandate.after}` : ""}
-@attivita[mie]: ${total} da chiudere
-${mandate.rooms.map(roomLine).join("\n")}
-${closed}
-${scope}
-@avanzamento[marcatura]: appena APRI una attivita vascend_mark(group="${mandate.castle}", task="<ref>", status="running"), appena la CHIUDI status="completed" con evidence concreta (file + test/comando + risultato), oppure "failed" col motivo in vascend_note. E' l'unico modo in cui l'utente ti vede avanzare
-${growth}${mandate.skills?.length ? `\n@skill[gruppo]: ${mandate.skills.join(", ")} (richiamale quando servono, non tutte subito)` : ""}
-
-RELAZIONI
-@R1: @gruppo[assegnato] -> @attivita[mie]  [ il piano e' il mandato: non re-inventarlo ]
-@R2: @attivita[mie] -> @avanzamento[marcatura]  [ una marcatura per attivita, in tempo reale ]
-${growthRel}
-
+    return `MANDATO
+INDICE
+1 = gruppo
+2 = attivita
+3 = avanzamento
+4 = crescita
+
+DEFINIZIONI
+@gruppo[assegnato]: ${mandate.castle} "${mandate.title}"${mandate.after ? ` · dopo ${mandate.after}` : ""}
+@attivita[mie]: ${total} da chiudere
+${mandate.rooms.map(roomLine).join("\n")}
+${closed}
+${scope}
+@avanzamento[marcatura]: appena APRI una attivita vascend_mark(group="${mandate.castle}", task="<ref>", status="running"), appena la CHIUDI status="completed" con evidence concreta (file + test/comando + risultato), oppure "failed" col motivo in vascend_note. E' l'unico modo in cui l'utente ti vede avanzare
+${growth}${mandate.skills?.length ? `\n@skill[gruppo]: ${mandate.skills.join(", ")} (richiamale quando servono, non tutte subito)` : ""}
+
+RELAZIONI
+@R1: @gruppo[assegnato] -> @attivita[mie]  [ il piano e' il mandato: non re-inventarlo ]
+@R2: @attivita[mie] -> @avanzamento[marcatura]  [ una marcatura per attivita, in tempo reale ]
+${growthRel}
+
 OUTPUT: chiudi le tue attivita una per una marcandole; nel report finale elenca i ref chiusi, quelli falliti e i file toccati.`;
 }

package/dist/vascend/objective-revision.js

@@ -183,24 +183,24 @@ export function buildReopenSteer(goal, decision) {
     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 ]
-
+    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.
@@ -218,22 +218,22 @@ export function objectiveDecisionSummary(d) {
 // 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 ]
-
+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;

package/dist/vascend/patch-plan.js

@@ -319,27 +319,27 @@ export function buildPatchPlanBlock(p) {
     const riskDefs = p.risks.map((r) => `@${r.id}[${SEVERITY_TAG[r.severity]}]: ${q(r.text, 160)}${r.mitigation ? ` (mitiga: ${q(r.mitigation, 120)})` : ""}`);
     const testDefs = p.tests.map((t) => `@${t.id}[${t.status}]: ${q(t.text, 160)}`);
     const ver = patchPlanVerification(p);
-    return `[VASCEND_PATCH_PLAN ${p.id}]
-INDICE
-1 = goal
-2 = file
-3 = contratti
-4 = rischi
-5 = test
-
-DEFINIZIONI
-@goal[patch]: "${q(p.goal)}"
-@stato[ciclo]: ${p.status}${p.taskRef ? ` (attivita ${p.taskRef})` : ""}
-${fileDefs.length ? fileDefs.join("\n") : "@file[nessuno]: -"}
-${contractDefs.length ? contractDefs.join("\n") : "@contratti[nessuno]: -"}
-${riskDefs.length ? riskDefs.join("\n") : "@rischi[nessuno]: -"}
-${testDefs.length ? testDefs.join("\n") : "@test[nessuno]: -"}
-
-RELAZIONI
-@R-edit: @goal[patch] -> @file  [ la modifica tocca questi file per l'obiettivo ]
-@R-contract: @file -> @contratti  [ i file alterano/usano queste superfici ]
-@R-risk: @contratti -> @rischi  [ i cambi di contratto generano regressioni potenziali ]
-@R-verify: @rischi -> @test  [ i test coprono i rischi prima del verify ]
-
+    return `[VASCEND_PATCH_PLAN ${p.id}]
+INDICE
+1 = goal
+2 = file
+3 = contratti
+4 = rischi
+5 = test
+
+DEFINIZIONI
+@goal[patch]: "${q(p.goal)}"
+@stato[ciclo]: ${p.status}${p.taskRef ? ` (attivita ${p.taskRef})` : ""}
+${fileDefs.length ? fileDefs.join("\n") : "@file[nessuno]: -"}
+${contractDefs.length ? contractDefs.join("\n") : "@contratti[nessuno]: -"}
+${riskDefs.length ? riskDefs.join("\n") : "@rischi[nessuno]: -"}
+${testDefs.length ? testDefs.join("\n") : "@test[nessuno]: -"}
+
+RELAZIONI
+@R-edit: @goal[patch] -> @file  [ la modifica tocca questi file per l'obiettivo ]
+@R-contract: @file -> @contratti  [ i file alterano/usano queste superfici ]
+@R-risk: @contratti -> @rischi  [ i cambi di contratto generano regressioni potenziali ]
+@R-verify: @rischi -> @test  [ i test coprono i rischi prima del verify ]
+
 OUTPUT: piano di patch ${p.id}; verificato=${ver.verified} (test ${ver.testsPassed}/${ver.testsTotal}, falliti ${ver.testsFailed}). Edita solo i file elencati, poi esegui i test.`;
 }

package/dist/vascend/requirements.js

@@ -8,22 +8,22 @@ export function requirementsMax(env) {
     const n = Number(env["TALOS_REQUIREMENTS_MAX"]);
     return Number.isInteger(n) && n >= 1 ? n : 12;
 }
-const EXTRACTOR_SYSTEM = `# Estrattore di requisiti
-INDICE
-1 = obiettivo
-2 = requisito
-3 = criterio
-
-DEFINIZIONI
-@obiettivo[fonte]: la richiesta dell'utente, da scomporre senza inventare
-@requisito[misurabile]: cosa va consegnato, in forma OSSERVABILE e verificabile; priorita' must/should/could
-@criterio[accettazione]: condizione BINARIA (vera/falsa) che prova il requisito soddisfatto; concreta, non vaga
-@rigore[essenziale]: SOLO requisiti realmente impliciti/espliciti nel goal; niente nice-to-have, niente perfezionismo
-
-RELAZIONI
-@R1: @obiettivo[fonte] -> @requisito[misurabile]  [ scomponi il goal in requisiti misurabili ]
-@R2: @requisito[misurabile] -> @criterio[accettazione]  [ ogni requisito ha 1+ criteri verificabili ]
-
+const EXTRACTOR_SYSTEM = `# Estrattore di requisiti
+INDICE
+1 = obiettivo
+2 = requisito
+3 = criterio
+
+DEFINIZIONI
+@obiettivo[fonte]: la richiesta dell'utente, da scomporre senza inventare
+@requisito[misurabile]: cosa va consegnato, in forma OSSERVABILE e verificabile; priorita' must/should/could
+@criterio[accettazione]: condizione BINARIA (vera/falsa) che prova il requisito soddisfatto; concreta, non vaga
+@rigore[essenziale]: SOLO requisiti realmente impliciti/espliciti nel goal; niente nice-to-have, niente perfezionismo
+
+RELAZIONI
+@R1: @obiettivo[fonte] -> @requisito[misurabile]  [ scomponi il goal in requisiti misurabili ]
+@R2: @requisito[misurabile] -> @criterio[accettazione]  [ ogni requisito ha 1+ criteri verificabili ]
+
 OUTPUT: SOLO JSON {"requirements": [{"id": "R1", "text": "...", "priority": "must|should|could", "criteria": [{"id": "R1.1", "text": "..."}]}]}. Niente prosa, niente markdown.`;
 // Estrae la checklist dall'obiettivo via LLM. Se non c'e' provider o l'estrazione
 // fallisce, ritorna una checklist vuota (non bloccante).
@@ -123,19 +123,19 @@ export function buildRequirementsBlock(checklist) {
         defs.push(`@${r.id}[${PRIORITY_TAG[r.priority]}]: ${r.text}${crit ? ` -> [ ${crit} ]` : ""}`);
         rels.push(`@R-${r.id}: @${r.id} -> consegna  [ soddisfatto sse tutti i criteri ${r.id}.* sono veri ]`);
     }
-    return `[VASCEND_REQUISITI]
-INDICE
-1 = goal
-2 = requisiti
-3 = criteri
-
-DEFINIZIONI
-@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
-${defs.join("\n")}
-
-RELAZIONI
-${rels.join("\n")}
-
+    return `[VASCEND_REQUISITI]
+INDICE
+1 = goal
+2 = requisiti
+3 = criteri
+
+DEFINIZIONI
+@goal[reale]: "${goal.replace(/"/g, "'").slice(0, 200)}"
+${defs.join("\n")}
+
+RELAZIONI
+${rels.join("\n")}
+
 OUTPUT: usa questa checklist come riferimento OGGETTIVO; il goal e' completo sse ogni requisito MUST ha tutti i criteri di accettazione verificati.`;
 }
 // Conteggi sintetici, comodi per status/log.

package/dist/vascend/reviewer.js

@@ -63,31 +63,31 @@ export function buildRoomMetricsDigest(state) {
 }
 // Prompt del revisore: analizza le metriche e migliora SOLO le stanze rimaste.
 export function buildReviewerPrompt(digest) {
-    return `[VASCEND_REVISIONE]
-Sei il REVISORE del team (piano di lavoro). NON rifai il lavoro gia' fatto: analizzi
-le attivita completate (token e durata) e le note, e migliori SOLO le attivita rimaste.
-
-INDICE
-1 = metriche
-2 = analisi
-3 = azione
-
-DEFINIZIONI
-@metriche[piano]: digest sotto (attivita fatte con token/durata + attivita da fare)
-@analisi[obiettivo]: trova attivita costose/lente, lavoro ridondante, passi mancanti
-@azione[consentite]: vascend_addtasks (aggiungi attivita rimaste), vascend_note (annota analisi/ordine consigliato sulle attivita o sul gruppo), vascend_skill (abbina skill utili in anticipo). Per il dettaglio di una attivita fatta usa recall.
-
-RELAZIONI
-@R1: @metriche[piano] -> @analisi[obiettivo]  [ leggi prima di agire ]
-@R2: @analisi[obiettivo] -> @azione[consentite]  [ agisci solo sulle attivita da fare ]
-
-REGOLE
-- NON marcare attivita (niente vascend_mark) e NON eseguire il lavoro: solo revisione e riorganizzazione.
-- Sii conciso: poche azioni mirate. Se il piano e' gia' ottimale, dillo in una riga e fermati.
-- Usa le note per indicare l'ORDINE ottimale delle attivita rimaste (non puoi riordinare i bit).
-
-METRICHE
-${digest}
-
+    return `[VASCEND_REVISIONE]
+Sei il REVISORE del team (piano di lavoro). NON rifai il lavoro gia' fatto: analizzi
+le attivita completate (token e durata) e le note, e migliori SOLO le attivita rimaste.
+
+INDICE
+1 = metriche
+2 = analisi
+3 = azione
+
+DEFINIZIONI
+@metriche[piano]: digest sotto (attivita fatte con token/durata + attivita da fare)
+@analisi[obiettivo]: trova attivita costose/lente, lavoro ridondante, passi mancanti
+@azione[consentite]: vascend_addtasks (aggiungi attivita rimaste), vascend_note (annota analisi/ordine consigliato sulle attivita o sul gruppo), vascend_skill (abbina skill utili in anticipo). Per il dettaglio di una attivita fatta usa recall.
+
+RELAZIONI
+@R1: @metriche[piano] -> @analisi[obiettivo]  [ leggi prima di agire ]
+@R2: @analisi[obiettivo] -> @azione[consentite]  [ agisci solo sulle attivita da fare ]
+
+REGOLE
+- NON marcare attivita (niente vascend_mark) e NON eseguire il lavoro: solo revisione e riorganizzazione.
+- Sii conciso: poche azioni mirate. Se il piano e' gia' ottimale, dillo in una riga e fermati.
+- Usa le note per indicare l'ORDINE ottimale delle attivita rimaste (non puoi riordinare i bit).
+
+METRICHE
+${digest}
+
 OUTPUT: una breve sintesi in notazione + le azioni (addrooms/note/skill) applicate alle sole attivita rimaste.`;
 }

package/dist/vascend/room-memory.js

@@ -331,15 +331,15 @@ export class RoomMemory {
         })
             .join("\n");
         return `ATTIVITA_ARCHIVIATE (ordine cronologico: prima le piu' vecchie, ultima la piu' recente)
-Il lavoro precedente e' ARCHIVIATO fuori dal contesto vivo, in attivita raccolte
+Il lavoro precedente e' ARCHIVIATO fuori dal contesto vivo, in attivita raccolte
 in gruppi e liste. Per recuperarne il dettaglio usa il tool "recall" (per query
-o per id, anche scendendo da un gruppo alle sue attivita) invece di chiedere di
-ripetere: il contesto resta compatto.
-Per RIPRENDERE il lavoro appena svolto parti dalla voce piu' in basso (il turno
-piu' recente, marcato), NON da quelle sopra: quelle sono turni gia' conclusi.
-
-${rows}
-
+o per id, anche scendendo da un gruppo alle sue attivita) invece di chiedere di
+ripetere: il contesto resta compatto.
+Per RIPRENDERE il lavoro appena svolto parti dalla voce piu' in basso (il turno
+piu' recente, marcato), NON da quelle sopra: quelle sono turni gia' conclusi.
+
+${rows}
+
 OUTPUT: contesto compatto; dettaglio recuperabile a ogni livello via recall.`;
     }
     setParent(childId, parentId) {
@@ -389,15 +389,15 @@ export function formatRoomRecord(room, messages, createdAt) {
     // Archi tipizzati: i file e i tool del turno sono gia' estratti qui sopra,
     // quindi il grafo costa zero a scrittura.
     const edges = roomEdges(files, tools.map((t) => t.name));
-    const body = clampBody(`INDICE
-${numberedIndex(terms)}
-
-DEFINIZIONI
-${def}
-
-RELAZIONI
-${rel}
-
+    const body = clampBody(`INDICE
+${numberedIndex(terms)}
+
+DEFINIZIONI
+${def}
+
+RELAZIONI
+${rel}
+
 OUTPUT: ${escapeValue(output) || "(nessun output testuale)"}`);
     return { room, level: 0, title, terms, body, children: [], parent: null, createdAt, edges };
 }
@@ -421,14 +421,14 @@ export function formatRollupRecord(id, level, children, createdAt) {
         .join("\n");
     const body = clampBody(`RIEPILOGO_${label.toUpperCase()} ${id}
 Elementi archiviati: ${children.length}. Per il dettaglio
-di un figlio usa recall(rooms:["${children[0]?.room ?? ""}", ...]) o una query.
-
-INDICE
-${numberedIndex(terms)}
-
-${cap(childLabel)}
-${rows}
-
+di un figlio usa recall(rooms:["${children[0]?.room ?? ""}", ...]) o una query.
+
+INDICE
+${numberedIndex(terms)}
+
+${cap(childLabel)}
+${rows}
+
 OUTPUT: riepilogo delle attivita; apri i dettagli col tool recall.`);
     return {
         room: id,

package/dist/vascend/runtime.js

@@ -8,11 +8,11 @@ Comunica in italiano naturale, con spiegazioni chiare e Markdown leggibile.
 Descrivi il lavoro con una to-do list: attivita, gruppi, dipendenze e stati
 da fare, in corso, completata o fallita. I riepiloghi della memoria sono solo
 contesto interno: all'utente mostra le attivita e i risultati pertinenti.
-Per lavori con piu passi usa vascend_plan: un piano contiene gruppi di attivita,
-ogni gruppo contiene attivita con stato, dipendenze e prove di verifica.
-Aggiorna gli stati con vascend_mark; completa solo dopo le verifiche.
-Usa vascend_note per decisioni e blocchi e recall per recuperare il passato.
-Per lavori indipendenti valuta collaboratori tramite gli strumenti del team.
+Per lavori con piu passi usa vascend_plan: un piano contiene gruppi di attivita,
+ogni gruppo contiene attivita con stato, dipendenze e prove di verifica.
+Aggiorna gli stati con vascend_mark; completa solo dopo le verifiche.
+Usa vascend_note per decisioni e blocchi e recall per recuperare il passato.
+Per lavori indipendenti valuta collaboratori tramite gli strumenti del team.
 Per domande o richieste semplici non creare un piano inutile.`;
 export function validateKingdom(state) {
     const castles = state.kingdom.castles;
@@ -37,18 +37,18 @@ export function validateKingdom(state) {
 }
 // Messaggio di steering per svegliare l'agente sulle stanze da completare.
 export function buildValidationSteer(v) {
-    return `[VASCEND_VALIDAZIONE]
-INDICE
-1 = piano
-2 = aperto
-
-DEFINIZIONI
-@stato[piano]: completate=${v.done}/${v.total}
-@aperto[attivita]: ${v.pending.join(", ")} NON completate
-
-RELAZIONI
-@R: @aperto[attivita] -> @stato[piano]  [ il piano NON valida finché restano attivita da completare ]
-
+    return `[VASCEND_VALIDAZIONE]
+INDICE
+1 = piano
+2 = aperto
+
+DEFINIZIONI
+@stato[piano]: completate=${v.done}/${v.total}
+@aperto[attivita]: ${v.pending.join(", ")} NON completate
+
+RELAZIONI
+@R: @aperto[attivita] -> @stato[piano]  [ il piano NON valida finché restano attivita da completare ]
+
 OUTPUT: completa le attivita non completate facendo il lavoro reale e segnandole con vascend_mark (status completed). Se una e' davvero impossibile, marcala failed indicando il motivo. Non concludere finché non sono tutte risolte.`;
 }
 export function createVascendState() {
@@ -75,18 +75,18 @@ export function wrapVascendPrompt(state, userText, mode, checkpoint) {
     const checkpointBlock = checkpoint
         ? `\nCHECKPOINT_PRECEDENTE\n${checkpoint.trim()}\n`
         : "";
-    const immediatePrompt = `[VASCEND_GOAL]
-GOAL: ${state.goal}
-MODE: ${mode}
-${checkpointBlock}
-Piano di lavoro:
-- Comunica in modo naturale e leggibile, senza imporre notazioni speciali.
-- Per lavori con piu passi crea o riprendi il piano con vascend_plan e vascend_status.
-- Organizza il piano in gruppi e attivita; aggiorna gli stati con vascend_mark.
-- Completa le attivita solo dopo verifiche concrete; registra decisioni e blocchi.
-- Per lavori indipendenti valuta collaboratori; per domande semplici non serve un piano.
-
-INPUT_UTENTE
+    const immediatePrompt = `[VASCEND_GOAL]
+GOAL: ${state.goal}
+MODE: ${mode}
+${checkpointBlock}
+Piano di lavoro:
+- Comunica in modo naturale e leggibile, senza imporre notazioni speciali.
+- Per lavori con piu passi crea o riprendi il piano con vascend_plan e vascend_status.
+- Organizza il piano in gruppi e attivita; aggiorna gli stati con vascend_mark.
+- Completa le attivita solo dopo verifiche concrete; registra decisioni e blocchi.
+- Per lavori indipendenti valuta collaboratori; per domande semplici non serve un piano.
+
+INPUT_UTENTE
 ${userText}`;
     // Antepone il CONTESTO A LUNGO TERMINE (Vision finale) come piano SEPARATO
     // dal goal immediato. Il goal corrente viene passato come "immediato" cosi'
@@ -124,24 +124,24 @@ export function formatVascendCompact(state, messages = []) {
     const summary = messages.flatMap(message => message.content
         .filter(part => part.type === "text" && part.text.startsWith("[Riepilogo del contesto precedente]"))
         .map(part => part.type === "text" ? part.text : "")).at(-1);
-    return `INDICE
-1 = goal
-2 = gruppo
-3 = task
-4 = file
-5 = contesto
-
-DEFINIZIONI
-@stato[goal]: valore="${escapeValue(state.goal ?? "nessun_goal")}", mode=${state.mode}
+    return `INDICE
+1 = goal
+2 = gruppo
+3 = task
+4 = file
+5 = contesto
+
+DEFINIZIONI
+@stato[goal]: valore="${escapeValue(state.goal ?? "nessun_goal")}", mode=${state.mode}
 @stato[gruppo]: slug=${castle?.slug ?? "none"}, mask=${castle?.maskTarget ?? "0x0000"}
 ${groups}
 ${taskRows}
-@file[checkpoint]: path=.vascend-compact.md, ruolo=checkpoint, stato=aggiornato${recent ? `\n${recent}` : ""}
-
-RELAZIONI
-${relations}
-@R99: @file[checkpoint] -> @stato[goal], ripresa
-
+@file[checkpoint]: path=.vascend-compact.md, ruolo=checkpoint, stato=aggiornato${recent ? `\n${recent}` : ""}
+
+RELAZIONI
+${relations}
+@R99: @file[checkpoint] -> @stato[goal], ripresa
+
 OUTPUT: stato compatto della sessione, pronto a riprendere a freddo.${summary ? `\n\nCONTESTO DI RIPRESA\n${summary}` : ""}`;
 }
 export class VascendRuntime {