@vascend/talos 0.1.5 → 0.1.6

package/dist/vascend/memory-packet.js

@@ -1,17 +1,18 @@
 import { sanitizeText } from "../core/text-sanitize.js";
-import { listMemoryScopes, MemoryStore } from "./memory-store.js";
-import { VascendPlanStore } from "./plan-store.js";
-import { RoomMemory } from "./room-memory.js";
-import { VascendVisionStore, visionCompleteness } from "./vision.js";
+import { listMemoryScopes } from "./memory-store.js";
+import { ContextStoreReader } from "./context-store-reader.js";
+import { packetEventsWithoutMirrors } from "./context-packet-mirrors.js";
+import { visionCompleteness } from "./vision.js";
 import { listContextMemoryScopes } from "./context-fabric.js";
-export function buildMemoryPacket(input) {
+export function buildMemoryPacket(input, reader = new ContextStoreReader(input.sessionDir)) {
     const maxChars = input.maxChars && input.maxChars > 0 ? input.maxChars : 12_000;
     const recentLimit = input.recentLimit && input.recentLimit > 0 ? input.recentLimit : 10;
     const projectScopeLimit = input.projectScopeLimit && input.projectScopeLimit > 0 ? input.projectScopeLimit : 6;
-    const rooms = safe(() => RoomMemory.open(input.sessionDir, input.scopeId).frontier(), []);
-    const castles = safe(() => VascendPlanStore.open(input.sessionDir, input.planScopeId ?? input.scopeId).castles(), []);
-    const visions = safe(() => VascendVisionStore.open(input.sessionDir, input.scopeId).all(), []);
-    const events = safe(() => recentEvents(MemoryStore.open(input.sessionDir, input.scopeId).all(), recentLimit).map((event) => ({ scopeId: input.scopeId, value: event })), []);
+    const rooms = selectFrontierRooms(reader.rooms(input.scopeId));
+    const localPlan = reader.plan(input.scopeId);
+    const castles = (!input.planScopeId || input.planScopeId === input.scopeId
+        ? localPlan : reader.plan(input.planScopeId)) ?? [];
+    const visions = reader.visions(input.scopeId);
     const allowedScopes = !input.projectScopes && input.projectKey
         ? new Set(listContextMemoryScopes(input.sessionDir, input.projectKey))
         : null;
@@ -19,10 +20,18 @@ export function buildMemoryPacket(input) {
         excludeScope: input.scopeId,
         limit: allowedScopes ? 10_000 : projectScopeLimit,
     }).filter((scope) => !allowedScopes || allowedScopes.has(scope)).slice(0, projectScopeLimit);
-    const projectRooms = loadProjectFrontiers(input.sessionDir, projectScopes, 8);
-    const projectCastles = loadProjectCastles(input.sessionDir, projectScopes, 8);
-    const projectVisions = loadProjectVisions(input.sessionDir, projectScopes, 5);
-    const projectEvents = loadProjectEvents(input.sessionDir, projectScopes, recentLimit);
+    const projectRooms = projectScopes.flatMap(scopeId => reader.rooms(scopeId).slice(-2).map(value => ({ scopeId, value }))).slice(0, 8);
+    const projectCastles = projectScopes.flatMap(scopeId => (reader.plan(scopeId) ?? []).slice(0, 2).map(value => ({ scopeId, value }))).slice(0, 8);
+    const projectVisions = projectScopes.flatMap(scopeId => reader.visions(scopeId).slice(0, 2).map(value => ({ scopeId, value }))).slice(0, 5);
+    const localEvents = reader.events(input.scopeId);
+    const scopedEvents = projectScopes.flatMap(scopeId => reader.events(scopeId).map(value => ({ scopeId, value })));
+    const allEvents = [...localEvents.map(value => ({ scopeId: input.scopeId, value })), ...scopedEvents];
+    const displayedRooms = [...rooms.map(value => ({ scopeId: input.scopeId, value })), ...projectRooms];
+    const filtered = packetEventsWithoutMirrors(allEvents, displayedRooms);
+    const events = recentEvents(filtered.filter(e => e.scopeId === input.scopeId).map(e => e.value), recentLimit)
+        .map(value => ({ scopeId: input.scopeId, value }));
+    const projectEvents = filtered.filter(e => e.scopeId !== input.scopeId && !isSuperseded(e.value))
+        .sort((a, b) => b.value.createdAt - a.value.createdAt || b.value.id.localeCompare(a.value.id)).slice(0, recentLimit);
     const hasProject = Boolean(projectRooms.length || projectCastles.length || projectVisions.length || projectEvents.length);
     if (!rooms.length && !castles.length && !visions.length && !events.length && !hasProject)
         return "";
@@ -52,9 +61,7 @@ export function buildMemoryPacket(input) {
     ];
     return clampMemoryPacket(lines.filter(Boolean).join("\n"), maxChars);
 }
-function frontierRows(rooms) {
-    if (!rooms.length)
-        return ["@frontiera[vuota]: nessuna attivita indicizzata"];
+function selectFrontierRooms(rooms) {
     // La frontiera e' ordinata vecchio->recente. Conserva un indice per livello
     // ma dedica la maggior parte degli slot allo stato piu' recente: slice(0,10)
     // nascondeva proprio le ultime stanze nei run lunghi.
@@ -63,8 +70,12 @@ function frontierRows(rooms) {
         if (!byLevel.has(room.level))
             byLevel.set(room.level, room);
     const picked = [...byLevel.values(), ...rooms.slice(-8)];
-    const unique = [...new Map(picked.map((room) => [room.room, room])).values()].slice(-10);
-    return unique.map((r) => `@frontiera[${r.room}]: level=${r.level}, title="${q(r.title)}", termini=${r.terms.slice(0, 6).join(",")}`);
+    return [...new Map(picked.map((room) => [room.room, room])).values()].slice(-10);
+}
+function frontierRows(rooms) {
+    if (!rooms.length)
+        return ["@frontiera[vuota]: nessuna attivita indicizzata"];
+    return rooms.map((r) => `@frontiera[${r.room}]: level=${r.level}, title="${q(r.title)}", termini=${r.terms.slice(0, 6).join(",")}${r.attachments?.length ? `, allegati=${r.attachments.length}, recupero=recall rooms=["${r.room}"] attachments=true` : ''}`);
 }
 function planRows(castles) {
     if (!castles.length)
@@ -75,7 +86,7 @@ function planRows(castles) {
             .sort((a, b) => Number(a.status === "completed") - Number(b.status === "completed") || a.bit - b.bit)
             .slice(0, 8)
             .map((t) => `@task[${castle.slug}/${t.id}]: status=${t.status}, title="${q(t.title)}"`);
-        return [`@plan[${castle.slug}]: title="${q(castle.title)}", target=${castle.maskTarget}, attivita=${castle.tasks.length}`, ...tasks];
+        return [`@plan[${castle.slug}]: title="${q(castle.title)}", target=${castle.maskTarget}, attivita=${castle.tasks.length}${castle.after?.trim() ? `, after="${q(castle.after)}"` : ""}`, ...tasks];
     }).slice(0, 32);
 }
 function visionRows(visions) {
@@ -93,7 +104,7 @@ function projectRows(rooms, castles, visions) {
         "[WORKING_SET_PROGETTO]",
         ...rooms.map((r) => `@project_frontiera[${r.scopeId}/${r.value.room}]: level=${r.value.level}, title="${q(r.value.title)}"`),
         ...castles.flatMap((c) => [
-            `@project_plan[${c.scopeId}/${c.value.slug}]: title="${q(c.value.title)}", target=${c.value.maskTarget}, attivita=${c.value.tasks.length}`,
+            `@project_plan[${c.scopeId}/${c.value.slug}]: title="${q(c.value.title)}", target=${c.value.maskTarget}, attivita=${c.value.tasks.length}${c.value.after?.trim() ? `, after="${q(c.value.after)}"` : ""}`,
             ...c.value.tasks.slice(0, 4).map((t) => `@project_task[${c.scopeId}/${c.value.slug}/${t.id}]: status=${t.status}, title="${q(t.title)}"`),
         ]),
         ...visions.map((v) => `@project_vision[${v.scopeId}/${v.value.taskId}]: goal="${q(v.value.goal)}"`),
@@ -116,30 +127,6 @@ function isSuperseded(event) {
     const status = typeof event.payload?.["status"] === "string" ? event.payload["status"] : "active";
     return status === "superseded" || status === "archived" || typeof event.payload?.["supersededBy"] === "string";
 }
-function loadProjectFrontiers(sessionDir, scopes, limit) {
-    return scopes.flatMap((scopeId) => safe(() => RoomMemory.open(sessionDir, scopeId).frontier().slice(-2).map((value) => ({ scopeId, value })), [])).slice(0, limit);
-}
-function loadProjectCastles(sessionDir, scopes, limit) {
-    return scopes.flatMap((scopeId) => safe(() => VascendPlanStore.open(sessionDir, scopeId).castles().slice(0, 2).map((value) => ({ scopeId, value })), [])).slice(0, limit);
-}
-function loadProjectVisions(sessionDir, scopes, limit) {
-    return scopes.flatMap((scopeId) => safe(() => VascendVisionStore.open(sessionDir, scopeId).all().slice(0, 2).map((value) => ({ scopeId, value })), [])).slice(0, limit);
-}
-function loadProjectEvents(sessionDir, scopes, limit) {
-    const events = scopes.flatMap((scopeId) => safe(() => MemoryStore.open(sessionDir, scopeId).all().map((value) => ({ scopeId, value })), []));
-    return events
-        .filter((e) => !isSuperseded(e.value))
-        .sort((a, b) => b.value.createdAt - a.value.createdAt || b.value.id.localeCompare(a.value.id))
-        .slice(0, limit);
-}
-function safe(fn, fallback) {
-    try {
-        return fn();
-    }
-    catch {
-        return fallback;
-    }
-}
 function q(value, max = 120) {
     const oneLine = sanitizeText(value).replace(/\s+/g, " ").trim().replace(/"/g, "'");
     return oneLine.length > max ? oneLine.slice(0, max - 1).trimEnd() + "..." : oneLine;

package/dist/vascend/plan-store.d.ts

@@ -37,8 +37,10 @@ export interface KingdomPlan {
 }
 export declare class VascendPlanStore {
     private readonly file;
-    private readonly memory;
+    private readonly openMemory;
     private kingdom;
+    private memoryStore?;
+    private get memory();
     private constructor();
     static open(sessionDir: string, sessionId: string, options?: {
         strict?: boolean;

package/dist/vascend/plan-store.js

@@ -63,14 +63,16 @@ function buildCastle(slug, title, taskTitles, after) {
 }
 export class VascendPlanStore {
     file;
-    memory;
+    openMemory;
     kingdom = { castles: [] };
-    constructor(file, memory) {
+    memoryStore;
+    get memory() { return this.memoryStore ??= this.openMemory(); }
+    constructor(file, openMemory) {
         this.file = file;
-        this.memory = memory;
+        this.openMemory = openMemory;
     }
     static open(sessionDir, sessionId, options = {}) {
-        const store = new VascendPlanStore(join(sessionDir, `${sessionId}.castle.json`), MemoryStore.open(sessionDir, sessionId));
+        const store = new VascendPlanStore(join(sessionDir, `${sessionId}.castle.json`), () => MemoryStore.open(sessionDir, sessionId));
         if (existsSync(store.file)) {
             try {
                 const raw = JSON.parse(readFileSync(store.file, "utf8"));

package/dist/vascend/room-memory.d.ts

@@ -1,6 +1,13 @@
-import type { Message } from "../core/types.js";
+import type { Message, ImagePart } from "../core/types.js";
 import { RoomGraph, type RoomEdge, type RoomNeighbor } from "./room-graph.js";
+export interface RoomAttachment {
+    readonly id: string;
+    readonly mime: string;
+    readonly source?: string;
+    readonly bytes: number;
+}
 export interface RoomRecord {
+    readonly attachments?: readonly RoomAttachment[];
     readonly room: string;
     readonly level: number;
     readonly title: string;
@@ -35,6 +42,8 @@ export declare class RoomMemory {
     private tokensFor;
     private indexedDocs;
     static open(sessionDir: string, sessionId: string, fanout?: number): RoomMemory;
+    private persistMedia;
+    attachmentMedia(rooms: readonly string[]): readonly ImagePart[];
     count(): number;
     all(): readonly RoomRecord[];
     frontier(): readonly RoomRecord[];

package/dist/vascend/room-memory.js

@@ -1,10 +1,15 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
 import { sanitizeText } from "../core/text-sanitize.js";
 import { MemoryStore } from "./memory-store.js";
 import { STOP, tokenize, buildSynonyms, expandQuery, bm25Score, } from "./lexical-search.js";
 import { withLockSync } from "./file-lock.js";
 import { RoomGraph, clusterByAffinity, clusterLabel, roomEdges, topTerms, } from "./room-graph.js";
+const pendingMedia = new WeakMap();
+const validImage = (image) => /^image\/(png|jpeg|webp|gif)$/.test(image.mime)
+    && image.data.length > 0 && image.data.length <= 28_000_000 && /^[A-Za-z0-9+/=\s]+$/.test(image.data);
+const attachmentId = (image) => createHash('sha256').update(image.mime).update(image.data).digest('hex');
 // Peso di un vicino a 2 hop rispetto al seme che lo ha portato. Allineato al
 // peso del link tipizzato in context-retriever.ts: stessa semantica, stesso
 // numero, cosi' recall e compilazione del contesto non si contraddicono.
@@ -78,6 +83,31 @@ export class RoomMemory {
         }
         return mem;
     }
+    persistMedia(record) {
+        const media = pendingMedia.get(record) || [];
+        if (!media.length)
+            return;
+        const dir = this.file + '.attachments';
+        mkdirSync(dir, { recursive: true });
+        for (const image of media)
+            writeFileSync(join(dir, attachmentId(image) + '.json'), JSON.stringify(image), { encoding: 'utf8', mode: 0o600 });
+        pendingMedia.delete(record);
+    }
+    attachmentMedia(rooms) {
+        const allowed = this.expandRooms(rooms).flatMap(record => record.attachments || []);
+        const out = [];
+        for (const ref of allowed.slice(0, 8)) {
+            if (!/^[a-f0-9]{64}$/.test(ref.id))
+                continue;
+            try {
+                const image = JSON.parse(readFileSync(join(this.file + '.attachments', ref.id + '.json'), 'utf8'));
+                if (validImage(image) && attachmentId(image) === ref.id)
+                    out.push(image);
+            }
+            catch { /* Allegato assente: non inventare dati visivi. */ }
+        }
+        return out;
+    }
     count() {
         return this.records.length;
     }
@@ -102,6 +132,7 @@ export class RoomMemory {
     // Aggiunge una stanza (livello 0): fast path append, protetto da lock
     // file-system cosi' due processi concorrenti non interlacciano le righe.
     append(record) {
+        this.persistMedia(record);
         this.records.push(record);
         mkdirSync(dirname(this.file), { recursive: true });
         withLockSync(this.file, () => {
@@ -151,6 +182,7 @@ export class RoomMemory {
             this.reloadFromDisk();
             const id = this.nextRoomId(ns);
             const rec = build(id);
+            this.persistMedia(rec);
             this.records.push(rec);
             appendFileSync(this.file, JSON.stringify(rec) + "\n", "utf8");
             return rec;
@@ -329,7 +361,7 @@ export class RoomMemory {
         const rows = front
             .map((r, i) => {
             const marker = i === last ? "   <- TURNO PIU' RECENTE" : "";
-            return `${i + 1}. @${levelLabel(r.level)}[${r.room}]: "${escapeValue(r.title)}" · termini=${r.terms.slice(0, 8).join(",")}${marker}`;
+            return `${i + 1}. @${levelLabel(r.level)}[${r.room}]: "${escapeValue(r.title)}" · termini=${r.terms.slice(0, 8).join(",")}${r.attachments?.length ? ` · allegati=${r.attachments.length}; recall rooms=["${r.room}"] attachments=true` : ''}${marker}`;
         })
             .join("\n");
         return `ATTIVITA_ARCHIVIATE (ordine cronologico: prima le piu' vecchie, ultima la piu' recente)
@@ -371,6 +403,8 @@ function roomEvent(type, record, children = []) {
 }
 // Record Danilov compatto di una STANZA (livello 0) dai messaggi del turno.
 export function formatRoomRecord(room, messages, createdAt) {
+    const media = messages.filter(message => message.role === 'user').flatMap(message => message.content.filter((part) => part.type === 'image')).filter(validImage).slice(0, 8);
+    const attachments = media.map(image => ({ id: attachmentId(image), mime: image.mime, bytes: Math.floor(image.data.length * 0.75), ...(image.source ? { source: image.source } : {}) }));
     const title = roomTitle(messages);
     const tools = collectToolCalls(messages);
     const files = collectFiles(messages);
@@ -382,6 +416,7 @@ export function formatRoomRecord(room, messages, createdAt) {
     ]).slice(0, 12);
     const def = [
         `@goal[${room}]: "${escapeValue(title)}"`,
+        ...attachments.map(att => `@attachment[${att.id}]: ${att.mime}, source=${escapeValue(att.source || 'immagine')}; recall rooms=["${room}"] attachments=true`),
         ...tools.slice(0, 12).map((t, i) => `@tool[${room}.${i + 1}]: ${t.name}(${escapeValue(t.arg)}) -> ${escapeValue(t.result)}`),
         ...files.slice(0, 12).map((f, i) => `@file[${room}.${i + 1}]: ${escapeValue(f)}`),
     ].join("\n");
@@ -401,7 +436,10 @@ RELAZIONI
 ${rel}
 
 OUTPUT: ${escapeValue(output) || "(nessun output testuale)"}`);
-    return { room, level: 0, title, terms, body, children: [], parent: null, createdAt, edges };
+    const record = { room, level: 0, title, terms, body, children: [], parent: null, createdAt, edges, ...(attachments.length ? { attachments } : {}) };
+    if (media.length)
+        pendingMedia.set(record, media);
+    return record;
 }
 // Record di ROLLUP (castello/regno/...): indice sui figli che ha chiuso.
 export function formatRollupRecord(id, level, children, createdAt) {
@@ -439,6 +477,7 @@ OUTPUT: riepilogo delle attivita; apri i dettagli col tool recall.`);
         terms,
         body,
         children: children.map((c) => c.room),
+        attachments: children.flatMap(c => c.attachments || []),
         parent: null,
         // Il padre eredita il timestamp del figlio piu' recente: con i gruppi per
         // affinita' l'istante del rollup non direbbe nulla, mentre cosi' la
@@ -488,6 +527,7 @@ function normalize(raw) {
         parent: raw.parent ?? null,
         createdAt: typeof raw.createdAt === "number" ? raw.createdAt : 0,
         ...(Array.isArray(raw.edges) ? { edges: raw.edges.filter(isRoomEdge) } : {}),
+        ...(Array.isArray(raw.attachments) ? { attachments: raw.attachments.filter(att => att && /^[a-f0-9]{64}$/.test(att.id)) } : {}),
     };
 }
 // Aggiorna solo le etichette generate dei vecchi riepiloghi. Gli ID,

package/dist/vascend/runtime.d.ts

@@ -1,5 +1,4 @@
-import type { Message } from "../core/types.js";
-import { type VisionLike } from "./long-term-context.js";
+import type { VisionLike } from "./long-term-context.js";
 export type VascendMode = "off" | "sticky";
 export type VascendPromptMode = "one-shot" | "sticky";
 export type VascendTaskStatus = "pending" | "running" | "completed" | "failed";
@@ -48,10 +47,6 @@ export type VascendCommandResult = {
     readonly message: string;
     readonly input: string;
 };
-export interface VascendCheckpoint {
-    readonly path: string;
-    readonly text: string;
-}
 export declare const VASCEND_SYSTEM_BLOCK = "# Lista delle attivita\nComunica in italiano naturale, con spiegazioni chiare e Markdown leggibile.\nDescrivi il lavoro con una to-do list: attivita, gruppi, dipendenze e stati\nda fare, in corso, completata o fallita. I riepiloghi della memoria sono solo\ncontesto interno: all'utente mostra le attivita e i risultati pertinenti.\nPer lavori con piu passi usa vascend_plan: un piano contiene gruppi di attivita,\nogni gruppo contiene attivita con stato, dipendenze e prove di verifica.\nAggiorna gli stati con vascend_mark; completa solo dopo le verifiche.\nUsa vascend_note per decisioni e blocchi e recall per recuperare il passato.\nPer lavori indipendenti valuta collaboratori tramite gli strumenti del team.\nPer domande o richieste semplici non creare un piano inutile.";
 export interface VascendVerdict {
     readonly ok: boolean;
@@ -66,19 +61,16 @@ export declare function createVascendState(): VascendState;
 export declare function createVascendGoal(state: VascendState, goal: string): VascendState;
 export declare function setVascendMode(state: VascendState, mode: VascendMode): VascendState;
 export declare function setVascendVision(state: VascendState, vision: VisionLike | null): VascendState;
-export declare function wrapVascendPrompt(state: VascendState, userText: string, mode: VascendPromptMode, checkpoint?: string): string;
-export declare function formatVascendCompact(state: VascendState, messages?: readonly Message[]): string;
+export declare function wrapVascendPrompt(_state: VascendState, userText: string, _mode: VascendPromptMode): string;
 export declare class VascendRuntime {
-    private readonly cwd;
     private stateValue;
     private customPlan;
-    constructor(cwd: string, initialMode?: VascendMode);
+    constructor(_cwd: string, initialMode?: VascendMode);
     state(): VascendState;
     hasCustomPlan(): boolean;
     loadPlan(sessionDir: string, sessionId: string): boolean;
     resetPlan(sessionDir: string, sessionId: string): void;
     handleCommand(args: string): VascendCommandResult;
     prepareUserInput(userText: string): PreparedVascendInput;
-    compact(messages: readonly Message[]): VascendCheckpoint;
     private wrap;
 }

package/dist/vascend/runtime.js

@@ -1,8 +1,5 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { sanitizeText } from "../core/text-sanitize.js";
 import { VascendPlanStore } from "./plan-store.js";
-import { injectLongTermContext } from "./long-term-context.js";
 export const VASCEND_SYSTEM_BLOCK = `# Lista delle attivita
 Comunica in italiano naturale, con spiegazioni chiare e Markdown leggibile.
 Descrivi il lavoro con una to-do list: attivita, gruppi, dipendenze e stati
@@ -14,6 +11,7 @@ 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.`;
+const MAX_GOAL_CHARS = 240;
 export function validateKingdom(state) {
     const castles = state.kingdom.castles;
     const multi = castles.length > 1;
@@ -55,7 +53,9 @@ export function createVascendState() {
     return { mode: "off", goal: null, kingdom: { castles: [] } };
 }
 export function createVascendGoal(state, goal) {
-    const title = oneLine(goal) || "obiettivo";
+    // Il goal e' una chiave breve per UI, routing e memoria. Resta nello stato
+    // strutturato e non viene copiato dentro al messaggio utente.
+    const title = oneLine(goal).slice(0, MAX_GOAL_CHARS) || "obiettivo";
     // NIENTE castello automatico: il castello (con le sue stanze) si crea solo su
     // richiesta (comando /castle) o quando l'agente pianifica con vascend_plan.
     // Cosi' il riquadro non compare quando non serve (es. un saluto).
@@ -69,90 +69,19 @@ export function setVascendMode(state, mode) {
 export function setVascendVision(state, vision) {
     return { ...state, vision };
 }
-export function wrapVascendPrompt(state, userText, mode, checkpoint) {
-    if (!state.goal)
-        return userText;
-    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
-${userText}`;
-    // Antepone il CONTESTO A LUNGO TERMINE (Vision finale) come piano SEPARATO
-    // dal goal immediato. Il goal corrente viene passato come "immediato" cosi'
-    // che il blocco espliciti la distinzione momentaneo/visione. Se non c'e'
-    // Vision con contenuto, injectLongTermContext ritorna il prompt invariato.
-    const currentCastle = state.kingdom.castles[0];
-    const currentRoom = currentCastle?.tasks.find((t) => t.status === "running");
-    return injectLongTermContext(immediatePrompt, {
-        vision: state.vision ?? null,
-        immediate: {
-            ...(state.goal ? { goal: state.goal } : {}),
-            ...(currentCastle ? { castle: currentCastle.title } : {}),
-            ...(currentRoom ? { room: currentRoom.title } : {}),
-        },
-    });
-}
-export function formatVascendCompact(state, messages = []) {
-    const castle = state.kingdom.castles[0];
-    const multi = state.kingdom.castles.length > 1;
-    const tasks = state.kingdom.castles.flatMap(group => group.tasks.map(task => ({ ...task,
-        id: multi ? `${group.slug}/${task.id}` : task.id,
-    })));
-    const groups = state.kingdom.castles.map(group => `@gruppo[${group.slug}]: titolo="${escapeValue(group.title)}", dipendenza=${group.after ?? "none"}`).join("\n");
-    const taskRows = tasks.length
-        ? tasks.map((task) => compactTaskRow(task)).join("\n")
-        : "@aperto[goal]: nessun_gruppo_attivo, blocco=none";
-    const recent = messagePreviews(messages)
-        .map((text, index) => `@stato[recent_${index + 1}]: ${text}`)
-        .join("\n");
-    const relations = tasks.length
-        ? tasks.map((task, index) => `@R${index + 1}: @stato[goal] -> @${task.status === "completed" ? "fatto" : "aperto"}[${task.id}], task`).join("\n")
-        : "@R1: @stato[goal] -> @aperto[goal], crea_gruppo";
-    // The synthetic summary is usually older than the last four messages.
-    // Keep it in the cold-start checkpoint, not just 140-character previews.
-    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}
-@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
-
-OUTPUT: stato compatto della sessione, pronto a riprendere a freddo.${summary ? `\n\nCONTESTO DI RIPRESA\n${summary}` : ""}`;
+export function wrapVascendPrompt(_state, userText, _mode) {
+    // La richiesta dell'utente deve comparire una sola volta nel payload. Goal,
+    // piano, Vision e ricevute vengono gia' composti dal Context Fabric e dagli
+    // store JSON nel canale di contesto del turno.
+    return userText;
 }
 export class VascendRuntime {
-    cwd;
     stateValue;
     customPlan = false;
     // initialMode permette di rendere il metodo Vascend NATIVO (sticky) di
     // default nella TUI, senza dover digitare /vascend on. Default "off" per
     // mantenere puro il runtime fuori dalla TUI (test, print, SDK).
-    constructor(cwd, initialMode = "off") {
-        this.cwd = cwd;
+    constructor(_cwd, initialMode = "off") {
         this.stateValue = setVascendMode(createVascendState(), initialMode);
     }
     state() {
@@ -233,54 +162,13 @@ export class VascendRuntime {
         this.stateValue = createVascendGoal(this.stateValue, userText);
         return { active: true, input: this.wrap(userText, "sticky") };
     }
-    compact(messages) {
-        const text = formatVascendCompact(this.stateValue, messages);
-        const path = checkpointPath(this.cwd);
-        writeFileSync(path, text + "\n", "utf8");
-        return { path, text };
-    }
     wrap(userText, mode) {
-        return wrapVascendPrompt(this.stateValue, userText, mode, readCheckpoint(this.cwd));
+        return wrapVascendPrompt(this.stateValue, userText, mode);
     }
 }
-function compactTaskRow(task) {
-    const kind = task.status === "completed" ? "fatto" : "aperto";
-    const block = task.status === "failed" ? ", blocco=failed" : "";
-    const evidence = task.evidence?.length
-        ? `, prove="${escapeValue(task.evidence.slice(-3).join(" | "))}"`
-        : "";
-    return `@${kind}[${task.id}]: titolo="${escapeValue(task.title)}", bit=${task.bit}, mask=${task.mask}, esito=${task.status}${block}${evidence}`;
-}
-function messagePreviews(messages) {
-    return messages.slice(-4).flatMap((message) => {
-        const text = message.content
-            .map((part) => {
-            if (part.type === "text")
-                return part.text;
-            if (part.type === "tool_call")
-                return `${part.name} ${JSON.stringify(part.input)}`;
-            if (part.type === "image")
-                return `[immagine ${part.mime}]`;
-            return part.output;
-        })
-            .join(" ");
-        const compact = oneLine(text).slice(0, 140);
-        return compact ? [`role=${message.role}, text="${escapeValue(compact)}"`] : [];
-    });
-}
-function checkpointPath(cwd) {
-    return join(cwd, ".vascend-compact.md");
-}
-function readCheckpoint(cwd) {
-    const path = checkpointPath(cwd);
-    return existsSync(path) ? readFileSync(path, "utf8") : undefined;
-}
 function oneLine(value) {
     return sanitizeText(value).replace(/\s+/g, " ").trim();
 }
-function escapeValue(value) {
-    return oneLine(value).replace(/"/g, "'");
-}
 function hexMask(value) {
     return `0x${value.toString(16).padStart(4, "0")}`;
 }

package/dist/vascend/session-search.js

@@ -80,6 +80,8 @@ function lineText(line) {
 const BOILERPLATE = /^\s*(?:\[COLLABORATORE|\[VASSALLO|\[VASCEND_GOAL\]|INDICE\s+\d\s*=|<!--\s*vascend:|@regno|@stato\[)/i;
 const OBJECTIVE_MARKER = /(?:OBIETTIVO_ATTIVITA|OBIETTIVO_CASTELLO|OBIETTIVO|GOAL)\s*[:=]\s*(.{4,})/i;
 export function pickObjective(userTexts) {
+    // Compatibilita di sola lettura con sessioni storiche che contenevano il
+    // vecchio wrapper/checkpoint. Non carica file e non aggiunge dati al prompt.
     const cut = (text) => text.split(/\s(?:MODE|CHECKPOINT_PRECEDENTE|CHECKPOINT|INDICE|OUTPUT)\s*[:=]/)[0].trim().slice(0, 200);
     const plain = userTexts.find((text) => !BOILERPLATE.test(text));
     if (plain)

package/dist/vascend/team-session.js

@@ -119,8 +119,9 @@ function checkpoint(team) {
 export async function waitForTeamChange(team, signal, interrupted) {
     const signature = (current) => JSON.stringify(current.members.map((member) => [member.slug, member.status]));
     const before = signature(team);
-    const deadline = Date.now() + 30_000;
-    while (!signal.aborted && !interrupted() && Date.now() < deadline) {
+    // Poll local state only. A wall-clock deadline used to wake the provider
+    // repeatedly even when no worker or message had changed.
+    while (!signal.aborted && !interrupted()) {
         const current = teamById(team.sessionId, team.id);
         if (!current || current.done || signature(current) !== before)
             return;

package/dist/vascend/vision.d.ts

@@ -60,8 +60,10 @@ export declare function visionFromJSON(json: string, opts?: {
 }): Vision | null;
 export declare class VascendVisionStore {
     private readonly file;
-    private readonly memory;
+    private readonly openMemory;
     private visions;
+    private memoryStore?;
+    private get memory();
     private constructor();
     static open(sessionDir: string, sessionId: string): VascendVisionStore;
     has(taskId: string): boolean;

package/dist/vascend/vision.js

@@ -202,14 +202,16 @@ export function visionFromJSON(json, opts) {
 // VascendPlanStore: API immutabile verso l'esterno, persistenza su mutazione.
 export class VascendVisionStore {
     file;
-    memory;
+    openMemory;
     visions = {};
-    constructor(file, memory) {
+    memoryStore;
+    get memory() { return this.memoryStore ??= this.openMemory(); }
+    constructor(file, openMemory) {
         this.file = file;
-        this.memory = memory;
+        this.openMemory = openMemory;
     }
     static open(sessionDir, sessionId) {
-        const store = new VascendVisionStore(join(sessionDir, `${sessionId}.vision.json`), MemoryStore.open(sessionDir, sessionId));
+        const store = new VascendVisionStore(join(sessionDir, `${sessionId}.vision.json`), () => MemoryStore.open(sessionDir, sessionId));
         if (existsSync(store.file)) {
             try {
                 const raw = JSON.parse(readFileSync(store.file, "utf8"));

package/dist/vascend/worker-session.d.ts

@@ -0,0 +1,20 @@
+import { type AgentDeps } from "../core/agent.js";
+import type { AgentEvent } from "../core/types.js";
+import { createWorkerInbox } from "./kingdom-live.js";
+/** Un incarico finisce, la conversazione puo' restare disponibile per l'host. */
+export declare function createWorkerSession(opts: {
+    kingdomId: string;
+    slug: string;
+    sessionId: string;
+    goal: string;
+    parentSignal: AbortSignal;
+    controller: AbortController;
+    retain: boolean | "queued";
+    onController?: (controller: AbortController) => void;
+    binding: ReturnType<typeof createWorkerInbox>;
+    deps: AgentDeps;
+    sink: (event: AgentEvent) => void;
+}): {
+    readonly signal: AbortSignal;
+    finish: () => void;
+};