@vascend/talos 0.1.0

package/dist/sdk.js

@@ -0,0 +1,64 @@
+// Superficie pubblica per l'embedding di Vascend Talos in un'altra applicazione
+// (es. il processo main di vascend-terminal). Quattro modalita' condividono
+// lo stesso nucleo: TUI, print, RPC e questo SDK.
+export { bootstrap } from "./core/bootstrap.js";
+export { runTurn } from "./core/agent.js";
+export { FileCoordinationHub, fileActor, formatFileConflicts, withFileActor } from "./core/file-coordination.js";
+// Casella dei messaggi scritti mentre l'agente lavora: un host che usa runTurn
+// direttamente (senza HorizonEngine) la crea e la passa fra le dipendenze.
+export { createUserInbox, pendingText } from "./core/user-inbox.js";
+export { WorkspaceSession, workspaceSessionKey } from "./core/workspace-sessions.js";
+export { Session } from "./core/session.js";
+export { ToolRegistry } from "./tools/registry.js";
+export { registerComputerUse } from "./tools/computer-use.js";
+export { executionPathKey, executionTargetKey, localExecutionTarget, normalizeExecutionTarget, workspaceUri, } from "./core/execution-target.js";
+export { MCP_APP_MIME_TYPE, MCP_PROTOCOL_VERSION, MCP_UI_EXTENSION_ID, isToolVisibleToModel, mcpAppUiMeta, normalizeMcpToolResult, supportsMcpApps, textFromMcpToolResult, toolDefinitionForCapabilities, toolInputSchema, } from "./mcp/protocol.js";
+export { builtinTools } from "./tools/builtin.js";
+export { resolveTool } from "./tools/resolve.js";
+export { executeTool } from "./tools/execute.js";
+export { ProviderRegistry, defaultRegistry } from "./providers/registry.js";
+export { ModelRegistry, loadModelRegistry } from "./providers/model-registry.js";
+export { KnowledgeBase, knowledgeBase } from "./vascend/competitor-knowledge.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+// Catalogo autoritativo dei provider: lo espone il core perche' l'host (la
+// dashboard di Horizon) deve mostrare gli STESSI provider che il registry sa
+// servire. Una seconda lista scritta a mano nella UI divergerebbe al primo
+// provider aggiunto.
+export { PROVIDER_CATALOG } from "./providers/catalog.js";
+export { buildConfig, BASE_SYSTEM } from "./core/config.js";
+export { VIBE_MODE_IDS, listVibeModes, parseVibeMode, routeVibeMode, vibeModeSpec, } from "./core/vibe-modes.js";
+export { buildContextFabric, contextFramePath, contextProjectKey, loadContextFrame, renderContextFrame, resetContextFrame, updateContextPins, } from "./vascend/context-fabric.js";
+// Stato della memoria per gli host che vogliono mostrarlo (frontiera, costo
+// dell'indice vivo, densita' del grafo). Legge solo lo store delle stanze.
+export { memoryStatus } from "./vascend/memory-status.js";
+// Composizione della finestra di contesto: l'host la riceve nell'evento
+// `context_window` a ogni turno e puo' ricostruirla da se' (es. per un pannello
+// che mostra dove sono finiti i token prima di inviare).
+export { buildContextLedger } from "./core/context-ledger.js";
+// Indice dei tool result: retrocessione dei risultati vecchi a riferimento
+// richiamabile (`output_page id="tr7"`) e archivio su disco che li risolve.
+export { applyMediaEviction, applyToolResultDemotion, mediaBudgetPolicy, planMediaEviction, planToolResultDemotion, slimMessageForSession, slimToolResultForSession, toolIndexPolicy, DEFAULT_MEDIA_BUDGET, DEFAULT_TOOL_INDEX, } from "./core/tool-result-index.js";
+export { ToolOutputStore } from "./core/tool-result-store.js";
+// Lavoro autonomo di lunga durata: il ciclo vive FUORI dalla conversazione.
+// Coda durevole con lease (un crash diventa un ritardo), runner che apre un
+// agente NUOVO per ogni unita' (il costo per unita' non cresce), verifica
+// esterna come arbitro.
+export { claim, claimable, complete, counts, expire, fail, formatQueue, heartbeat, makeItem, WorkQueue, DEFAULT_LEASE_MS, DEFAULT_MAX_ATTEMPTS, } from "./vascend/work-queue.js";
+export { runWorkLoop } from "./vascend/work-runner.js";
+export { briefFor, createFreshAgentRunner, parseOutcome } from "./vascend/work-agent.js";
+// Funzionalita' di architettura: mappa moduli/dipendenze/cicli del workspace.
+// Stessa sorgente del tool `architecture_map` e del comando TUI /arch: un host
+// (es. Vascend Terminal) puo' costruirci sopra pannelli nativi.
+export { buildArchitectureMap, renderArchitectureMap, scanArchitectureMap, } from "./vascend/architecture-map.js";
+// Diagnostica ambiente (stessa del comando `talos --doctor`).
+export { doctorExitCode, renderDoctorReport, runDoctor } from "./core/doctor.js";
+// Horizon: facade headless stabile per l'embedding in Vascend Terminal.
+export { HORIZON_CAPABILITIES, HorizonContextUnavailableError, HorizonEngine, HorizonMainTeam, needsGuideArbitration, HorizonSessionNotFoundError, HorizonStateError, routeWorkerModels, } from "./horizon/index.js";
+// Modulo Cowork: workspace condivisi collaborativi su engine Talos (desktop).
+export { CoworkManager, localIdentity, CoworkStore, CoworkSyncChannel, CoworkEngine, createCoworkIpc, createCoworkClient, } from "./cowork/index.js";
+// Kingdoms Mode osservabile e INTERROGABILE dall'host: scrivere a un singolo
+// collaboratore mentre lavora, e sapere chi e' ancora vivo nel regno.
+export { kingdomLive, KingdomLive } from "./vascend/kingdom-live.js";
+export { loadModelsDev, cachedModelCatalog, modelCapabilities } from "./providers/models-dev.js";
+export { ModelCatalog, parseModelCatalog } from "./providers/model-catalog.js";
+export { modelEfforts } from "./providers/model-effort.js";

package/dist/skills/skills.d.ts

@@ -0,0 +1,17 @@
+export interface Skill {
+    readonly name: string;
+    readonly description: string;
+    readonly allowedTools: readonly string[] | null;
+    readonly disableModelInvocation: boolean;
+    readonly body: string;
+    readonly path: string;
+}
+export interface SkillDiscoveryOptions {
+    readonly extraPaths?: readonly string[];
+    readonly disabled?: boolean;
+    readonly projectTrusted?: boolean;
+}
+export declare function discoverSkills(cwd: string, opts?: SkillDiscoveryOptions): readonly Skill[];
+export declare function findSkill(skills: readonly Skill[], name: string): Skill | undefined;
+export declare function skillsSystemBlock(skills: readonly Skill[]): string;
+export declare function renderSkillInvocation(skill: Skill, args: string): string;

package/dist/skills/skills.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function unquote(s) {
+    if (s.length >= 2 && ((s[0] === '"' && s.at(-1) === '"') || (s[0] === "'" && s.at(-1) === "'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+function parseList(value) {
+    const inner = value.replace(/^\[/, "").replace(/\]$/, "");
+    return inner.split(",").map((s) => unquote(s.trim())).filter(Boolean);
+}
+function parseFrontmatter(raw) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (!m)
+        return { body: raw };
+    const head = m[1] ?? "";
+    const body = m[2] ?? "";
+    const out = {};
+    for (const line of head.split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
+        if (!kv)
+            continue;
+        const key = (kv[1] ?? "").toLowerCase();
+        const value = (kv[2] ?? "").trim();
+        if (key === "name")
+            out.name = unquote(value);
+        else if (key === "description")
+            out.description = unquote(value);
+        else if (key === "allowed-tools" || key === "allowedtools")
+            out.allowedTools = parseList(value);
+        else if (key === "disable-model-invocation" || key === "disablemodelinvocation") {
+            out.disableModelInvocation = /^(1|true|yes|on)$/i.test(value);
+        }
+    }
+    return { ...out, body };
+}
+const NAME_RE = /^[a-z0-9-]{1,64}$/;
+function skillFromFile(path, fallbackName) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const fm = parseFrontmatter(raw);
+        const name = fm.name && NAME_RE.test(fm.name) ? fm.name : fallbackName;
+        if (!fm.description)
+            return null;
+        return {
+            name,
+            description: fm.description.slice(0, 1024),
+            allowedTools: fm.allowedTools ?? null,
+            disableModelInvocation: fm.disableModelInvocation ?? false,
+            body: fm.body.replace(/^\s+/, ""),
+            path,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function globalRootDirs() {
+    return [
+        join(homedir(), ".talos", "agent", "skills"),
+        join(homedir(), ".talos", "skills"),
+    ];
+}
+function projectRootDirs(cwd) {
+    return [join(cwd, ".talos", "skills")];
+}
+// Scopre le skill in una dir radice: i .md diretti sono skill individuali; le
+// sottocartelle con SKILL.md sono skill (ricorsivamente).
+function discoverInRoot(root, into) {
+    if (!existsSync(root))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(root, entry);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isFile() && entry.toLowerCase().endsWith(".md")) {
+            const skill = skillFromFile(full, entry.replace(/\.md$/i, ""));
+            if (skill)
+                into.set(skill.name, skill);
+        }
+        else if (st.isDirectory()) {
+            const skillMd = join(full, "SKILL.md");
+            if (existsSync(skillMd)) {
+                const skill = skillFromFile(skillMd, entry);
+                if (skill)
+                    into.set(skill.name, skill);
+            }
+            else {
+                discoverInRoot(full, into); // ricorsione nelle sottocartelle
+            }
+        }
+    }
+}
+// Tutte le skill disponibili (dir radici + path extra da --skill). Con
+// `disabled` solo le skill esplicite da extraPaths vengono caricate. Le skill
+// di progetto richiedono projectTrusted.
+export function discoverSkills(cwd, opts = {}) {
+    const byName = new Map();
+    if (!opts.disabled) {
+        for (const root of globalRootDirs())
+            discoverInRoot(root, byName);
+        if (opts.projectTrusted !== false) {
+            for (const root of projectRootDirs(cwd))
+                discoverInRoot(root, byName);
+        }
+    }
+    for (const path of opts.extraPaths ?? []) {
+        const file = path.toLowerCase().endsWith(".md") ? path : join(path, "SKILL.md");
+        const skill = skillFromFile(file, path.replace(/.*[\\/]/, "").replace(/\.md$/i, ""));
+        if (skill)
+            byName.set(skill.name, skill);
+    }
+    return [...byName.values()];
+}
+export function findSkill(skills, name) {
+    return skills.find((s) => s.name === name);
+}
+// Progressive disclosure: nel system prompt entra solo nome+descrizione in XML.
+// Il corpo completo viene letto solo quando la skill e' invocata.
+export function skillsSystemBlock(skills) {
+    const invocable = skills.filter((s) => !s.disableModelInvocation);
+    if (!invocable.length)
+        return "";
+    const items = invocable
+        .map((s) => `  <skill name="${escapeXml(s.name)}">${escapeXml(s.description)}</skill>`)
+        .join("\n");
+    return [
+        "<available-skills>",
+        "Capacita' on-demand. Per usarne una, leggi il file della skill o invoca /skill:<nome>.",
+        items,
+        "</available-skills>",
+    ].join("\n");
+}
+function escapeXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+// Costruisce il messaggio utente per l'invocazione esplicita /skill:name [args].
+export function renderSkillInvocation(skill, args) {
+    const head = `# Skill: ${skill.name}\n\n${skill.body}`;
+    return args.trim() ? `${head}\n\nUser: ${args.trim()}` : head;
+}

package/dist/text-sanitize.js

@@ -0,0 +1,28 @@
+// Sanitizzazione del testo che entra in MEMORIA/CONTEXT (metodo Danilov).
+//
+// Output di tool (bash, web_fetch, ...), incolla da terminale e contenuti
+// esterni possono trascinare sequenze di escape ANSI (es. \x1b[31m), OSC
+// (hyperlink), e byte di controllo non-stampabili. Se finiscono nei title/
+// terms/body delle stanze o nei summary degli eventi, vengono iniettati TALI
+// E QUALI nel memory packet -> system prompt: sono i "caratteri strani" che
+// si leggono nel context e che lo sporcano (e gonfiano inutilmente i token).
+//
+// Questa funzione e' PURA e DETERMINISTICA: strip ANSI/OSC + caratteri di
+// controllo, preservando solo \n e \t (la collassatura degli spazi resta agli
+// helper oneLine/escapeValue gia' esistenti).
+// CSI: ESC [ ... lettera finale.  OSC: ESC ] ... (BEL | ESC \).
+// Singoli ESC + intro a 1/2 byte (es. ESC ( B, ESC =) inclusi.
+const ANSI_RE = 
+// eslint-disable-next-line no-control-regex
+/[\u001b\u009b][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PR-TZcf-ntqry=><~]|[\u001b\u009b][@-Z\\-_]/g;
+// Caratteri di controllo C0/C1 non-stampabili, ESCLUSI \t (0x09) e \n (0x0a).
+// Anche \r (0x0d) viene rimosso: lo normalizziamo via newline a monte.
+// eslint-disable-next-line no-control-regex
+const CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+// Rimuove escape ANSI/OSC e byte di controllo non-stampabili dal testo.
+// Mantiene \n e \t. Non collassa gli spazi (lo fanno oneLine/escapeValue).
+export function sanitizeText(value) {
+    if (!value)
+        return "";
+    return value.replace(ANSI_RE, "").replace(CONTROL_RE, "");
+}

package/dist/tools/ask-user.d.ts

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

package/dist/tools/ask-user.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { requestAnswer } from "../core/user-input.js";
+function questionResult(result, question, required) {
+    const labels = {
+        unavailable: "L'host non dispone di un canale per le domande.",
+        unanswered: "L'utente non ha risposto alla domanda.",
+        cancelled: "La richiesta e' stata interrotta.",
+        failed: "Il canale delle domande ha restituito un errore.",
+    };
+    const output = result.status === "answered" ? `risposta utente: ${result.answer}`
+        : `${labels[result.status]} ${required
+            ? "L'informazione necessaria resta mancante: non inventare una risposta e non eseguire il lavoro che ne dipende. Prosegui con il lavoro indipendente e segnala cosa resta da chiarire."
+            : "Per questa preferenza facoltativa puoi scegliere un valore ragionevole, reversibile e dichiarato."} L'assenza di risposta non e' un consenso.`;
+    return {
+        output,
+        structuredContent: { ...result, question, required },
+        ...(result.status !== "answered" && (required || result.status === "cancelled") ? { isError: true } : {}),
+    };
+}
+export const askUserTool = {
+    name: "ask_user",
+    description: "Chiedi all'utente un requisito mancante o una decisione che cambia il risultato. "
+        + "Attende una risposta libera o una scelta tra options. required=true (default) mantiene esplicito il blocco se manca la risposta; "
+        + "usa required=false solo per preferenze facoltative con un default reversibile. Prima controlla il contesto disponibile. "
+        + "Disponibile anche ai collaboratori; le domande dello stesso host vengono mostrate una alla volta.",
+    schema: {
+        type: "object",
+        properties: {
+            question: { type: "string", description: "domanda breve e autosufficiente, con il motivo della scelta" },
+            options: { type: "array", items: { type: "string" }, maxItems: 8, description: "scelte facoltative, distinte e comprensibili" },
+            required: { type: "boolean", default: true, description: "false solo per una preferenza facoltativa; mai per chiedere un'autorizzazione" },
+        },
+        required: ["question"],
+    },
+    handler: async (input, ctx) => {
+        const invalid = (output) => ({ isError: true, output });
+        if (typeof input["question"] !== "string" || !input["question"].trim())
+            return invalid("errore: question deve essere una domanda non vuota");
+        if (input["required"] !== undefined && typeof input["required"] !== "boolean")
+            return invalid("errore: required deve essere booleano");
+        const rawOptions = input["options"];
+        if (rawOptions !== undefined && (!Array.isArray(rawOptions) || rawOptions.length > 8
+            || rawOptions.some((option) => typeof option !== "string" || !option.trim()))) {
+            return invalid("errore: options deve contenere al massimo 8 stringhe non vuote");
+        }
+        const options = rawOptions?.map((option) => option.trim());
+        if (options && new Set(options).size !== options.length)
+            return invalid("errore: options contiene scelte duplicate");
+        const question = input["question"].trim();
+        const required = input["required"] !== false;
+        const shownQuestion = ctx.kingdom?.self ? `[${ctx.kingdom.self}] ${question}` : question;
+        const result = ctx.signal.aborted ? { status: "cancelled" }
+            : ctx.ask ? await requestAnswer(ctx.ask, shownQuestion, options?.length ? options : undefined, ctx.signal)
+                : { status: "unavailable" };
+        const response = questionResult(result, question, required);
+        return { ...response, structuredContent: { ...response.structuredContent, questionId: randomUUID(),
+                actor: ctx.kingdom?.self ?? "main", teamId: ctx.kingdom?.id ?? null,
+                taskIds: ctx.planTasks ?? [], sessionId: ctx.sessionId ?? null } };
+    },
+};

package/dist/tools/builtin.d.ts

@@ -0,0 +1,48 @@
+import type { Tool } from "../core/types.js";
+export { askUserTool } from "./ask-user.js";
+export declare const bashTool: Tool;
+export declare const bashOutputTool: Tool;
+export declare const readTool: Tool;
+export declare const writeTool: Tool;
+export interface EditMatch {
+    readonly result: string;
+    readonly via: "exact" | "eol" | "whitespace";
+}
+export declare function findEditMatch(cur: string, old: string, next: string): EditMatch | string;
+export declare const editTool: Tool;
+export declare const fileActivityTool: Tool;
+export declare const lsTool: Tool;
+export declare const recallTool: Tool;
+export declare const imageGenerateTool: Tool;
+export declare const webFetchTool: Tool;
+export declare const WIDE_SEARCH_FILES = 3000;
+/**
+ * Nota di ampiezza da appendere al risultato di una ricerca.
+ *
+ * Perche' esiste: con la conversazione puntata alla radice di un monorepo, una
+ * grep cammina su decine di migliaia di file (misurato: 28.575 file, ~25
+ * secondi, contro 137 file della sottocartella del task) e il modello non ha
+ * modo di saperlo — vede solo un risultato lento e rumoroso, e continua a
+ * cercare in largo. Qui il costo diventa esplicito insieme al rimedio: `path`.
+ */
+export declare function wideSearchNote(root: string, visited: number): Promise<string>;
+export declare const globTool: Tool;
+export declare const grepTool: Tool;
+export declare const vascendPlanTool: Tool;
+export declare const vascendNoteTool: Tool;
+export declare const vascendSkillTool: Tool;
+export declare const vascendAddRoomsTool: Tool;
+export declare const waitTool: Tool;
+export declare const vascendMarkTool: Tool;
+export declare const toolSearchTool: Tool;
+export declare const toolInvokeTool: Tool;
+export declare const skillSearchTool: Tool;
+export declare const skillLoadTool: Tool;
+export declare const DEFERRED_TOOLS: ReadonlySet<string>;
+export declare function resetOutputPageCounters(): void;
+export declare const outputPageTool: Tool;
+export declare const architectureMapTool: Tool;
+export declare const marketCompareTool: Tool;
+export declare const userProfileTool: Tool;
+export declare const workQueueTool: Tool;
+export declare const builtinTools: readonly Tool[];