@vascend/talos 0.1.0

package/dist/tools/pagination.js

@@ -0,0 +1,93 @@
+import { randomUUID } from "node:crypto";
+import { ToolOutputStore } from "../core/tool-result-store.js";
+// Paginazione degli output lunghi: invece di TRONCARE ("...[troncato]"), si
+// mostra la prima pagina e si conserva il resto, recuperabile dal modello con il
+// tool output_page quando lo ritiene utile. Niente perdita di informazione.
+// Store di processo (in-memory), con eviction per non accumulare.
+const PAGE_CHARS = 30_000; // dimensione di una pagina
+const MAX_STORED = 5_000_000; // tetto per entry (5MB): oltre, si tronca a monte
+const MAX_ENTRIES = 24; // quante uscite lunghe tenere
+class PageStore {
+    map = new Map();
+    order = [];
+    seq = 0;
+    store(text, label) {
+        const id = `pg${(this.seq += 1)}`;
+        const capped = text.length > MAX_STORED ? text.slice(0, MAX_STORED)
+            + "\n[archivio temporaneo parziale: limite 5 milioni di caratteri; abilita una sessione persistente per il testo integrale]" : text;
+        this.map.set(id, { text: capped, label });
+        this.order.push(id);
+        while (this.order.length > MAX_ENTRIES) {
+            const old = this.order.shift();
+            if (old)
+                this.map.delete(old);
+        }
+        return id;
+    }
+    totalPages(id) {
+        const e = this.map.get(id);
+        return e ? Math.max(1, Math.ceil(e.text.length / PAGE_CHARS)) : 0;
+    }
+    page(id, page) {
+        const e = this.map.get(id);
+        if (!e)
+            return null;
+        return pageOf(e.text, e.label, page, id);
+    }
+}
+// Una pagina di un testo qualsiasi, con la stessa impaginazione dello store.
+// Estratta perche' `output_page` serve anche gli output ARCHIVIATI su disco
+// (tool-result-store): l'impaginazione deve essere identica, altrimenti gli id
+// `tr*` si comporterebbero diversamente dai `pg*`.
+// Marker di coda gia' presenti nel testo ("[... · pagina 1/1]"). Un recupero
+// non deve accodarne un altro sopra: nella sessione che ha rivelato il ciclo lo
+// stesso testo portava in fondo sette marker in fila, e ognuno sembrava al
+// modello una cosa ancora da recuperare. Ripulisce anche gli archivi gia'
+// scritti su disco prima di questa correzione.
+const TRAILING_MARKERS = /(?:\n\[[^\]\n]*·\s*pagina\s+\d+\/\d+[^\]\n]*\])+\s*$/;
+export function stripPageMarkers(text) {
+    let out = String(text ?? "");
+    for (let i = 0; i < 8; i += 1) {
+        const next = out.replace(TRAILING_MARKERS, "");
+        if (next === out)
+            break;
+        out = next;
+    }
+    return out;
+}
+export function pageOf(text, label, page, id) {
+    const clean = stripPageMarkers(text);
+    const total = Math.max(1, Math.ceil(clean.length / PAGE_CHARS));
+    const p = Math.min(Math.max(1, Math.floor(page)), total);
+    const slice = clean.slice((p - 1) * PAGE_CHARS, p * PAGE_CHARS);
+    // Con una sola pagina non c'e' nulla da inseguire: dirlo esplicitamente
+    // evita che il marker stesso venga letto come un invito a un altro recupero.
+    const more = p < total
+        ? ` · prossima: output_page id="${id}" page=${p + 1}`
+        : " · completo, niente altro da recuperare";
+    return `${slice}\n[${label} · pagina ${p}/${total}${more}]`;
+}
+export const pageStore = new PageStore();
+// Ritorna `text` se sta in una pagina; altrimenti la prima pagina + indicazione
+// per recuperare il resto con output_page. `label` descrive la fonte.
+export function paginate(text, label = "output", ctx) {
+    if (text.length <= PAGE_CHARS)
+        return text;
+    if (ctx?.sessionDir && ctx.sessionId) {
+        const store = ToolOutputStore.open(ctx.sessionDir, ctx.roomStoreId ?? ctx.sessionId);
+        const entry = store.put("page-" + randomUUID(), label, text);
+        if (entry)
+            return pageOf(text, label, 1, entry.id);
+        // Without a durable reference preserve the original rather than lose data.
+        return text;
+    }
+    const id = pageStore.store(text, label);
+    const total = pageStore.totalPages(id);
+    const head = text.slice(0, PAGE_CHARS);
+    const partial = text.length > MAX_STORED ? "\n[archivio temporaneo parziale: il testo oltre 5 milioni di caratteri non e' conservato]" : "";
+    return partial + `${head}\n[${label} lungo: ${text.length} char, pagina 1/${total} · altro con output_page id="${id}" page=2]`;
+}
+// True se un output e' gia' paginato (per non ricomprimerlo/ritroncarlo).
+export function isPaginated(output) {
+    return /output_page id="(?:pg|tr)\d+"/.test(output);
+}

package/dist/tools/plan-status.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "../core/types.js";
+export declare const vascendStatusTool: Tool;

package/dist/tools/plan-status.js

@@ -0,0 +1,109 @@
+import { hasTaskEvidence, nextPlanTask, planBlockers } from "../vascend/plan-progress.js";
+import { VascendPlanStore } from "../vascend/plan-store.js";
+export const vascendStatusTool = {
+    name: "vascend_status",
+    description: "Legge il piano persistito: task aperti, dipendenze, prossimi passi, note e prove. "
+        + "Usalo per riprendere il lavoro dopo resume/compattazione e prima della consegna. "
+        + "Non modifica il piano e non certifica la correttezza delle prove. Per dettagli usa group e task.",
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    schema: {
+        type: "object",
+        properties: {
+            group: { type: "string", description: "Filtra un gruppo; default: intero piano della sessione" },
+            task: { type: "string", description: "Id attivita (T01); richiede group, include anche le completate" },
+            include_completed: { type: "boolean", description: "Mostra anche le attivita completate (default false)" },
+            offset: { type: "integer", minimum: 0, description: "Offset delle attivita, default 0" },
+            limit: { type: "integer", minimum: 1, maximum: 50, description: "Attivita per pagina, default 12, max 50" },
+        },
+    },
+    handler: async (input, ctx) => {
+        const scope = ctx.planStoreId ?? ctx.roomStoreId ?? ctx.sessionId;
+        if (!ctx.sessionDir || !scope)
+            return { output: "piano non disponibile in questo contesto", isError: true };
+        try {
+            const slug = String(input["group"] ?? input["castle"] ?? ctx.planCastle ?? "").trim();
+            const taskId = String(input["task"] ?? "").trim().toUpperCase();
+            if (taskId && !slug)
+                throw new Error("task richiede group");
+            const castles = VascendPlanStore.open(ctx.sessionDir, scope, { strict: true }).castles();
+            const selected = slug ? castles.filter((castle) => castle.slug === slug) : castles;
+            if (slug && !selected.length)
+                throw new Error(`gruppo non trovato: ${slug}`);
+            const rows = selected.flatMap((castle) => castle.tasks.filter((task) => !ctx.planTasks?.length
+                || castle.slug !== ctx.planCastle || ctx.planTasks.includes(task.id)).map((task) => ({ castle, task })));
+            if (taskId && !rows.some(({ task }) => task.id === taskId))
+                throw new Error(`attivita non trovata: ${slug}/${taskId}`);
+            const counts = { pending: 0, running: 0, completed: 0, failed: 0 };
+            for (const { task } of rows)
+                counts[task.status] += 1;
+            const withoutEvidence = rows.filter(({ task }) => task.status === "completed" && !hasTaskEvidence(task));
+            const dependencies = new Map(selected.map((castle) => [castle.slug, planBlockers(castles, castle.slug)]));
+            const next = selected.flatMap((castle) => {
+                const task = nextPlanTask({ ...castle, tasks: rows.filter((row) => row.castle.slug === castle.slug).map((row) => row.task) });
+                if (!task || dependencies.get(castle.slug).length)
+                    return [];
+                return [{ ref: `${castle.slug}/${task.id}`, action: task.status === "running" ? "continue" : task.status === "failed" ? "retry" : "start" }];
+            }).sort((a, b) => Number(b.action === "continue") - Number(a.action === "continue"));
+            const matching = rows.filter(({ task }) => taskId ? task.id === taskId : input["include_completed"] === true || task.status !== "completed");
+            const offset = integer(input["offset"], 0, 0, Number.MAX_SAFE_INTEGER);
+            const limit = integer(input["limit"], 12, 1, 50);
+            const candidates = matching.slice(offset, offset + limit).map(({ castle, task }) => ({
+                ref: `${castle.slug}/${task.id}`, title: clip(task.title), status: task.status,
+                after: castle.after ?? null, blocked_by: dependencies.get(castle.slug).slice(0, 8),
+                evidence: (task.evidence ?? []).slice(-3).map(clip),
+                notes: (task.notes ?? []).slice(-3).map(clip),
+                group_notes: (castle.notes ?? []).slice(-2).map(clip),
+                files: (task.files ?? []).slice(0, 6).map(clip),
+                skills: [...new Set([...(castle.skills ?? []), ...(task.skills ?? [])])].slice(0, 6).map(clip),
+                detail_truncated: (task.evidence?.length ?? 0) > 3 || (task.notes?.length ?? 0) > 3
+                    || (castle.notes?.length ?? 0) > 2 || (task.files?.length ?? 0) > 6
+                    || (castle.skills?.length ?? 0) + (task.skills?.length ?? 0) > 6 || dependencies.get(castle.slug).length > 8
+                    || [task.title, ...(task.evidence ?? []), ...(task.notes ?? []), ...(castle.notes ?? []),
+                        ...(task.files ?? []), ...(task.skills ?? []), ...(castle.skills ?? [])].some((text) => text.length > 320),
+            }));
+            const page = [];
+            let pageChars = 0;
+            for (const row of candidates) {
+                const chars = JSON.stringify(row).length;
+                if (page.length && pageChars + chars > 12_000)
+                    break;
+                page.push(row);
+                pageChars += chars;
+            }
+            const data = {
+                scope,
+                summary: {
+                    groups: selected.length, total: rows.length, ...counts,
+                    completed_without_evidence: withoutEvidence.length,
+                    all_tasks_completed: rows.length > 0 && counts.completed === rows.length,
+                    ready_for_review: rows.length > 0 && counts.completed === rows.length && !withoutEvidence.length
+                        && [...dependencies.values()].every((blockers) => blockers.length === 0),
+                },
+                next_actions: next.slice(0, 5),
+                more_next_actions: next.length > 5,
+                tasks: page,
+                matching_tasks: matching.length,
+                next_offset: offset + page.length < matching.length ? offset + page.length : null,
+                guidance: !rows.length ? "Nessun piano. Per lavori con piu' passi usa vascend_plan; per richieste semplici procedi direttamente."
+                    : "Conserva il piano: vascend_addtasks aggiunge passi, vascend_note salva decisioni. "
+                        + "Avvia/riprendi con vascend_mark status=running, chiudi con completed e prove concrete. "
+                        + "Le prove sono registrazioni da verificare, non una certificazione. Per dettagli omessi usa recall.",
+            };
+            return { output: JSON.stringify(data), structuredContent: data };
+        }
+        catch (error) {
+            return { output: `errore: ${error.message}`, isError: true };
+        }
+    },
+};
+function integer(value, fallback, min, max) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+        throw new Error(`paginazione non valida: richiesto un intero tra ${min} e ${max}`);
+    }
+    return value;
+}
+function clip(value) {
+    return value.length > 320 ? value.slice(0, 317) + "..." : value;
+}

package/dist/tools/program-input.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandlerOutput } from "../core/types.js";
+/** Compile the same async body as the child; never run it or touch kernel state. */
+export declare function programSyntaxError(code: string): ToolHandlerOutput | undefined;

package/dist/tools/program-input.js

@@ -0,0 +1,19 @@
+const AsyncFunction = (async () => { }).constructor;
+/** Compile the same async body as the child; never run it or touch kernel state. */
+export function programSyntaxError(code) {
+    try {
+        new AsyncFunction("tools", "state", "console", "require", "process", code);
+        return undefined;
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        const detail = "JavaScript non valido: " + error.message;
+        const recovery = "Nessuna operazione avviata; stato del kernel conservato. "
+            + "Per un solo comando usa execute mode=call, tool=bash, args.command. "
+            + "Nei programmi passa script e testi nel parametro JSON data e leggili con tools.$data: "
+            + "non inserire ritorni a capo letterali o virgolette non protette in stringhe JavaScript.";
+        return { output: `${detail}\n${recovery}`, isError: true,
+            structuredContent: { status: "syntax_error", stage: "parse", operationsStarted: false, detail, recovery } };
+    }
+}

package/dist/tools/program.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from "../core/types.js";
+export declare function disposeProgramKernels(): void;
+export declare const runProgramTool: Tool;