@vascend/talos 0.1.0

package/dist/cowork/store.js

@@ -0,0 +1,182 @@
+// Store locale di Cowork: persistenza su filesystem, zero dipendenze.
+//
+// Layout su disco (baseDir, default ~/.talos/cowork):
+//   <baseDir>/workspaces.jsonl        -> log append-only dei workspace (ultimo vince per id)
+//   <baseDir>/<workspaceId>/sessions.jsonl  -> log append-only delle sessioni del workspace
+//   <baseDir>/<workspaceId>/messages/<sessionId>.jsonl -> messaggi collaborativi
+//   <baseDir>/<workspaceId>/sync.jsonl     -> sync log locale (vedi sync.ts)
+//
+// Tutto append-only come le Session del core: nessuna riscrittura in-place,
+// stato ricostruito leggendo il log (ultima entry per id vince). Le scritture
+// cross-finestra passano da un lock cooperativo (lockfile atomico).
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CoworkError } from "./types.js";
+// Directory di default per i dati Cowork.
+export function defaultCoworkDir(env = process.env) {
+    return env["TALOS_COWORK_DIR"] ?? join(env["TALOS_HOME"] ?? join(homedir(), ".talos"), "cowork");
+}
+// Legge un file JSONL ritornando le entry parse-abili (salta righe corrotte).
+function readJsonl(file) {
+    if (!existsSync(file))
+        return [];
+    const out = [];
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            /* riga corrotta: salta (resilienza come Session.load) */
+        }
+    }
+    return out;
+}
+// Riduce un log append-only allo stato corrente: ultima entry per id vince.
+function reduceById(entries) {
+    const map = new Map();
+    for (const e of entries)
+        map.set(e.id, e);
+    return map;
+}
+// Lock cooperativo: crea un lockfile in modo atomico (wx). Se esiste, ritenta
+// con backoff fino a timeoutMs. Lock stantii (oltre staleMs) vengono rotti.
+// Esportato per riuso dal sync layer (scritture concorrenti sul sync log).
+export function withLock(lockFile, fn, timeoutMs = 3000, staleMs = 10_000) {
+    const start = Date.now();
+    for (;;) {
+        try {
+            writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+            break;
+        }
+        catch {
+            // Lock occupato: rompilo se stantio (la finestra che lo teneva e' morta).
+            try {
+                if (existsSync(lockFile) && Date.now() - statSync(lockFile).mtimeMs > staleMs) {
+                    rmSync(lockFile, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                /* corsa con un altro: ritenta */
+            }
+            if (Date.now() - start > timeoutMs) {
+                throw new CoworkError(`lock non acquisito: ${lockFile}`, "lock_timeout");
+            }
+            sleepBusy(15);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            rmSync(lockFile, { force: true });
+        }
+        catch {
+            /* gia' rimosso */
+        }
+    }
+}
+// Attesa busy minima (zero dipendenze, niente async nel percorso di lock).
+function sleepBusy(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+        /* spin breve: i lock Cowork sono a bassa contesa (poche finestre) */
+    }
+}
+export class CoworkStore {
+    baseDir;
+    constructor(baseDir, env = process.env) {
+        this.baseDir = baseDir ?? defaultCoworkDir(env);
+        mkdirSync(this.baseDir, { recursive: true });
+    }
+    get workspacesFile() {
+        return join(this.baseDir, "workspaces.jsonl");
+    }
+    workspaceDir(workspaceId) {
+        return join(this.baseDir, workspaceId);
+    }
+    sessionsFile(workspaceId) {
+        return join(this.workspaceDir(workspaceId), "sessions.jsonl");
+    }
+    messagesFile(workspaceId, sessionId) {
+        return join(this.workspaceDir(workspaceId), "messages", `${sessionId}.jsonl`);
+    }
+    syncFile(workspaceId) {
+        return join(this.workspaceDir(workspaceId), "sync.jsonl");
+    }
+    // ---- Workspace -----------------------------------------------------------
+    listWorkspaces(includeArchived = false) {
+        const map = reduceById(readJsonl(this.workspacesFile));
+        return [...map.values()]
+            .filter((w) => includeArchived || !w.archived)
+            .sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    getWorkspace(id) {
+        return reduceById(readJsonl(this.workspacesFile)).get(id) ?? null;
+    }
+    requireWorkspace(id) {
+        const w = this.getWorkspace(id);
+        if (!w)
+            throw new CoworkError(`workspace ${id} inesistente`, "workspace_not_found");
+        return w;
+    }
+    // Persiste un workspace (snapshot completo). Append-only: lo stato e' la
+    // riduzione del log, quindi salvare = accodare lo snapshot aggiornato.
+    putWorkspace(ws) {
+        mkdirSync(this.workspaceDir(ws.id), { recursive: true });
+        mkdirSync(join(this.workspaceDir(ws.id), "messages"), { recursive: true });
+        withLock(this.workspacesFile + ".lock", () => {
+            appendFileSync(this.workspacesFile, JSON.stringify(ws) + "\n", "utf8");
+        });
+        return ws;
+    }
+    // ---- Sessioni ------------------------------------------------------------
+    listSessions(workspaceId, includeArchived = false) {
+        const map = reduceById(readJsonl(this.sessionsFile(workspaceId)));
+        return [...map.values()]
+            .filter((s) => includeArchived || !s.archived)
+            .sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    getSession(workspaceId, sessionId) {
+        return reduceById(readJsonl(this.sessionsFile(workspaceId))).get(sessionId) ?? null;
+    }
+    requireSession(workspaceId, sessionId) {
+        const s = this.getSession(workspaceId, sessionId);
+        if (!s)
+            throw new CoworkError(`sessione ${sessionId} inesistente`, "session_not_found");
+        return s;
+    }
+    putSession(session) {
+        const file = this.sessionsFile(session.workspaceId);
+        mkdirSync(this.workspaceDir(session.workspaceId), { recursive: true });
+        withLock(file + ".lock", () => {
+            appendFileSync(file, JSON.stringify(session) + "\n", "utf8");
+        });
+        return session;
+    }
+    // ---- Messaggi collaborativi ---------------------------------------------
+    listMessages(workspaceId, sessionId) {
+        return readJsonl(this.messagesFile(workspaceId, sessionId));
+    }
+    appendMessage(workspaceId, sessionId, msg) {
+        const file = this.messagesFile(workspaceId, sessionId);
+        mkdirSync(join(this.workspaceDir(workspaceId), "messages"), { recursive: true });
+        withLock(file + ".lock", () => {
+            appendFileSync(file, JSON.stringify(msg) + "\n", "utf8");
+        });
+        return msg;
+    }
+    // ---- Manutenzione --------------------------------------------------------
+    // Elenco grezzo degli id workspace presenti su disco (anche orfani).
+    diskWorkspaceIds() {
+        if (!existsSync(this.baseDir))
+            return [];
+        return readdirSync(this.baseDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+}

package/dist/cowork/sync.d.ts

@@ -0,0 +1,20 @@
+import type { CoworkSyncEvent, CoworkSyncListener, CoworkSyncType } from "./types.js";
+export declare class CoworkSyncChannel {
+    readonly workspaceId: string;
+    private readonly file;
+    private readonly clientId;
+    private readonly pollMs;
+    private watcher;
+    private pollTimer;
+    private lastSeq;
+    private readonly listeners;
+    private closed;
+    constructor(workspaceId: string, file: string, clientId: string, pollMs?: number);
+    publish<P>(type: CoworkSyncType, payload: P): CoworkSyncEvent<P>;
+    subscribe(listener: CoworkSyncListener): () => void;
+    private drain;
+    private ensureWatching;
+    private stopWatching;
+    poll(): void;
+    close(): void;
+}

package/dist/cowork/sync.js

@@ -0,0 +1,164 @@
+// Sync layer locale di Cowork: propaga eventi tra finestre/processi della
+// stessa macchina senza un server. Tutto su filesystem, zero dipendenze.
+//
+// Meccanismo:
+//   - ogni workspace ha un sync.jsonl append-only (CoworkSyncEvent per riga);
+//   - `seq` è monotono per file (max esistente + 1), assegnato sotto lock;
+//   - ogni finestra registra un watcher (fs.watch + poll di fallback) e legge
+//     le entry oltre l'ultimo seq processato;
+//   - gli eventi con `origin` uguale al proprio clientId vengono ignorati
+//     (non rieseguo cio' che ho generato io).
+//
+// Robusto a: scritture concorrenti (lock), watcher che non scatta su tutte le
+// piattaforme (poll), righe corrotte (skip), file ancora inesistente.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, watch } from "node:fs";
+import { dirname } from "node:path";
+import { withLock } from "./store.js";
+// Legge tutte le entry del sync log (skip righe corrotte).
+function readSyncLog(file) {
+    if (!existsSync(file))
+        return [];
+    const out = [];
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            /* riga parziale/corrotta: salta */
+        }
+    }
+    return out;
+}
+// Seq massimo presente nel log (0 se vuoto).
+function maxSeq(file) {
+    let max = 0;
+    for (const e of readSyncLog(file))
+        if (e.seq > max)
+            max = e.seq;
+    return max;
+}
+// Canale di sync per UN workspace. Una finestra ne istanzia uno per workspace
+// aperto; `clientId` la identifica (per filtrare i propri eventi).
+export class CoworkSyncChannel {
+    workspaceId;
+    file;
+    clientId;
+    pollMs;
+    watcher = null;
+    pollTimer = null;
+    lastSeq = 0;
+    listeners = new Set();
+    closed = false;
+    constructor(workspaceId, file, clientId, pollMs = 1000) {
+        this.workspaceId = workspaceId;
+        this.file = file;
+        this.clientId = clientId;
+        this.pollMs = pollMs;
+        mkdirSync(dirname(this.file), { recursive: true });
+        // Parti dalla coda: gli eventi storici non vanno rigiocati all'apertura.
+        this.lastSeq = maxSeq(this.file);
+    }
+    // Pubblica un evento. Assegna seq sotto lock (monotono per file) e accoda.
+    publish(type, payload) {
+        // Prima consegna gli eventi remoti ancora pendenti: pubblicare avanza il
+        // cursore, quindi se non li drenassimo ora andrebbero persi (avrebbero seq
+        // inferiore al nostro nuovo evento e non verrebbero piu' riletti).
+        this.drain();
+        const event = withLock(this.file + ".lock", () => {
+            const seq = maxSeq(this.file) + 1;
+            const ev = {
+                seq,
+                type,
+                workspaceId: this.workspaceId,
+                origin: this.clientId,
+                ts: Date.now(),
+                payload,
+            };
+            appendFileSync(this.file, JSON.stringify(ev) + "\n", "utf8");
+            return ev;
+        });
+        // Avanzo il mio cursore oltre il mio stesso evento (filtrato per origin).
+        if (event.seq > this.lastSeq)
+            this.lastSeq = event.seq;
+        return event;
+    }
+    // Registra un listener per gli eventi ALTRUI (origin diverso). Ritorna una
+    // funzione per disiscriversi.
+    subscribe(listener) {
+        this.listeners.add(listener);
+        this.ensureWatching();
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0)
+                this.stopWatching();
+        };
+    }
+    // Drena gli eventi nuovi (seq > lastSeq) e notifica i listener. Gli eventi
+    // generati da questa stessa finestra (origin === clientId) sono saltati.
+    drain() {
+        if (this.closed)
+            return;
+        const events = readSyncLog(this.file).filter((e) => e.seq > this.lastSeq);
+        if (events.length === 0)
+            return;
+        for (const ev of events.sort((a, b) => a.seq - b.seq)) {
+            if (ev.seq > this.lastSeq)
+                this.lastSeq = ev.seq;
+            if (ev.origin === this.clientId)
+                continue;
+            for (const l of this.listeners) {
+                try {
+                    l(ev);
+                }
+                catch {
+                    /* listener difettoso: non blocca gli altri */
+                }
+            }
+        }
+    }
+    ensureWatching() {
+        if (this.watcher || this.pollTimer)
+            return;
+        // fs.watch è reattivo ma non affidabile su tutte le piattaforme/FS: lo
+        // affianchiamo a un poll di sicurezza a bassa frequenza.
+        try {
+            this.watcher = watch(dirname(this.file), (_event, filename) => {
+                if (!filename || String(filename).startsWith("sync.jsonl"))
+                    this.drain();
+            });
+        }
+        catch {
+            /* watch non disponibile: il poll basta */
+        }
+        this.pollTimer = setInterval(() => this.drain(), this.pollMs);
+        // Non tenere vivo il processo solo per il poll del sync.
+        if (typeof this.pollTimer.unref === "function")
+            this.pollTimer.unref();
+    }
+    stopWatching() {
+        if (this.watcher) {
+            try {
+                this.watcher.close();
+            }
+            catch {
+                /* gia' chiuso */
+            }
+            this.watcher = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    // Forza un drain immediato (utile nei test e dopo una publish remota nota).
+    poll() {
+        this.drain();
+    }
+    close() {
+        this.closed = true;
+        this.listeners.clear();
+        this.stopWatching();
+    }
+}

package/dist/cowork/types.d.ts

@@ -0,0 +1,78 @@
+export interface CoworkMember {
+    readonly id: string;
+    readonly displayName: string;
+    readonly userId?: string;
+    readonly role: CoworkRole;
+    readonly joinedAt: number;
+}
+export type CoworkRole = "owner" | "editor" | "viewer";
+export interface CoworkPresence {
+    readonly memberId: string;
+    readonly displayName: string;
+    readonly clientId: string;
+    readonly activeSessionId: string | null;
+    readonly status: PresenceStatus;
+    readonly lastSeen: number;
+}
+export type PresenceStatus = "online" | "idle" | "offline";
+export interface CoworkWorkspace {
+    readonly id: string;
+    readonly name: string;
+    readonly root: string;
+    readonly model: string;
+    readonly members: readonly CoworkMember[];
+    readonly createdBy: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly archived: boolean;
+}
+export interface CoworkWorkspacePatch {
+    readonly name?: string;
+    readonly model?: string;
+    readonly archived?: boolean;
+}
+export interface CoworkSession {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly title: string;
+    readonly model: string;
+    readonly createdBy: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly contributors: readonly string[];
+    readonly archived: boolean;
+}
+export interface CoworkMessage {
+    readonly role: "user" | "assistant" | "tool";
+    readonly text: string;
+    readonly authorId?: string;
+    readonly toolCalls?: readonly unknown[];
+    readonly toolResults?: readonly unknown[];
+    readonly ts: number;
+}
+export type CoworkSyncType = "workspace_created" | "workspace_updated" | "workspace_archived" | "member_joined" | "member_left" | "session_created" | "session_updated" | "session_archived" | "message_appended" | "agent_event" | "presence";
+export interface CoworkSyncEvent<P = unknown> {
+    readonly seq: number;
+    readonly type: CoworkSyncType;
+    readonly workspaceId: string;
+    readonly origin: string;
+    readonly ts: number;
+    readonly payload: P;
+}
+export interface MessageAppendedPayload {
+    readonly sessionId: string;
+    readonly message: CoworkMessage;
+}
+export interface AgentEventPayload {
+    readonly sessionId: string;
+    readonly event: unknown;
+}
+export interface PresencePayload {
+    readonly presence: CoworkPresence;
+}
+export type CoworkSyncListener = (event: CoworkSyncEvent) => void;
+export declare class CoworkError extends Error {
+    readonly code: CoworkErrorCode;
+    constructor(message: string, code: CoworkErrorCode);
+}
+export type CoworkErrorCode = "workspace_not_found" | "session_not_found" | "member_not_found" | "permission_denied" | "lock_timeout" | "invalid_state";

package/dist/cowork/types.js

@@ -0,0 +1,21 @@
+// Cowork: modulo desktop collaborativo interno. Workspace condivisi, sessioni
+// agente e sincronizzazione locale tra finestre/processi della stessa macchina.
+//
+// Il motore sottostante e' Vascend Talos (bootstrap/runTurn via SDK). Cowork
+// aggiunge sopra l'engine il concetto di WORKSPACE condiviso (cartella +
+// membri + sessioni) e un SYNC layer locale append-only che propaga gli eventi
+// alle altre finestre desktop senza un server (tutto su filesystem).
+//
+// Filosofia di progetto: zero dipendenze a runtime, immutabilita', file
+// piccoli. Persistenza JSONL append-only come le sessioni del core.
+// ---------------------------------------------------------------------------
+// Errori di dominio
+// ---------------------------------------------------------------------------
+export class CoworkError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "CoworkError";
+    }
+}

package/dist/extensions/ext-tools.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRegistry } from "../tools/registry.js";
+import type { ExtensionHost } from "./loader.js";
+export declare function registerExtensionTools(tools: ToolRegistry, host: ExtensionHost): void;

package/dist/extensions/ext-tools.js

@@ -0,0 +1,73 @@
+// Tool CORE che danno all'agente visibilita' e controllo sulle estensioni.
+// Non sono deferred: poche voci, utili spesso (l'utente le chiede esplicitamente).
+export function registerExtensionTools(tools, host) {
+    tools.register({
+        name: "extensions_list",
+        description: "Elenca le estensioni installate in .talos/extensions con il loro stato (abilitata/caricata) e cosa registrano (tool, comandi, shortcut, eventi, hook) piu' le impostazioni correnti.",
+        schema: { type: "object", properties: {} },
+        handler: async () => {
+            const inv = host.inventory();
+            if (!inv.length)
+                return "Nessuna estensione installata in .talos/extensions.";
+            const lines = inv.map((e) => {
+                const state = e.enabled ? (e.loaded ? "abilitata" : "abilitata (non caricata)") : "DISABILITATA";
+                const reg = [];
+                if (e.tools.length)
+                    reg.push(`tool: ${e.tools.join(", ")}`);
+                if (e.commands.length)
+                    reg.push(`comandi: /${e.commands.join(", /")}`);
+                if (e.shortcuts.length)
+                    reg.push(`shortcut: ${e.shortcuts.join(", ")}`);
+                if (e.flags.length)
+                    reg.push(`flag: ${e.flags.join(", ")}`);
+                if (e.renderers.length)
+                    reg.push(`renderer: ${e.renderers.join(", ")}`);
+                if (e.providers.length)
+                    reg.push(`provider: ${e.providers.join(", ")}`);
+                if (e.events.length)
+                    reg.push(`eventi: ${e.events.join(", ")}`);
+                if (e.systemHooks)
+                    reg.push(`hook system prompt: ${e.systemHooks}`);
+                const opts = Object.keys(e.options).length ? `\n    impostazioni: ${JSON.stringify(e.options)}` : "";
+                return `- ${e.id} [${state}]${reg.length ? `\n    ${reg.join("\n    ")}` : "\n    (nessuna registrazione)"}${opts}`;
+            });
+            return lines.join("\n");
+        },
+    });
+    tools.register({
+        name: "extensions_set",
+        description: "Gestisce un'estensione: abilitala/disabilitala o imposta un'opzione. L'impostazione e' persistita e le estensioni vengono ricaricate. Indica l'estensione con il nome del file (es. 'background-run.ts', anche senza estensione).",
+        schema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "nome del file estensione (es. background-run.ts)" },
+                enabled: { type: "boolean", description: "abilita (true) o disabilita (false) l'estensione" },
+                option_key: { type: "string", description: "chiave dell'opzione da impostare" },
+                option_value: { description: "valore dell'opzione (JSON: stringa/numero/bool/oggetto)" },
+            },
+            required: ["id"],
+        },
+        handler: async (input) => {
+            const args = input;
+            const id = host.resolveId(args.id);
+            if (!id)
+                return `Estensione '${args.id}' non trovata in .talos/extensions.`;
+            const done = [];
+            if (typeof args.enabled === "boolean") {
+                const r = await host.setEnabled(id, args.enabled);
+                if (!r.ok)
+                    return r.reason ?? "operazione fallita";
+                done.push(args.enabled ? "abilitata" : "disabilitata");
+            }
+            if (args.option_key) {
+                const r = await host.setOption(id, args.option_key, args.option_value);
+                if (!r.ok)
+                    return r.reason ?? "operazione fallita";
+                done.push(`opzione '${args.option_key}' impostata`);
+            }
+            if (!done.length)
+                return `Nessuna modifica indicata per '${id}'. Usa enabled e/o option_key.`;
+            return `${id}: ${done.join(", ")}. Estensioni ricaricate.`;
+        },
+    });
+}

package/dist/extensions/loader.d.ts

@@ -0,0 +1,91 @@
+import type { ToolRegistry } from "../tools/registry.js";
+import type { ExtensionApi, ExtensionContext, ExtensionEvents, ExtensionUi, EventName, EventOutcome, FlagDef, MessageRenderer, ShortcutDef, SlashCommand, CustomProviderConfig } from "./types.js";
+export interface HostBindings {
+    readonly ui?: ExtensionUi;
+    readonly mode?: ExtensionContext["mode"];
+    readonly isProjectTrusted?: () => boolean;
+    readonly contextUsage?: () => {
+        tokens: number;
+        window: number;
+    };
+    readonly systemPrompt?: () => string;
+    readonly registerProvider?: (name: string, config: CustomProviderConfig) => void;
+    readonly unregisterProvider?: (name: string) => void;
+    readonly setSessionName?: (name: string) => void;
+    readonly setLabel?: (entryId: string, label: string) => void;
+    readonly appendEntry?: (customType: string, data?: unknown) => void;
+    readonly sessionEntries?: () => readonly import("../core/session.js").SessionNode[];
+    readonly sessionLeafId?: () => string | null;
+}
+export interface ExtensionInfo {
+    readonly id: string;
+    readonly enabled: boolean;
+    readonly loaded: boolean;
+    readonly tools: readonly string[];
+    readonly commands: readonly string[];
+    readonly shortcuts: readonly string[];
+    readonly flags: readonly string[];
+    readonly renderers: readonly string[];
+    readonly providers: readonly string[];
+    readonly events: readonly string[];
+    readonly systemHooks: number;
+    readonly options: Record<string, unknown>;
+}
+export declare class ExtensionHost {
+    private readonly tools;
+    private readonly cwd;
+    readonly commands: Map<string, SlashCommand>;
+    readonly shortcuts: Map<string, ShortcutDef>;
+    readonly flags: Map<string, FlagDef>;
+    readonly renderers: Map<string, MessageRenderer>;
+    readonly pendingUserMessages: string[];
+    readonly pendingMessages: {
+        content: string;
+        display: boolean;
+    }[];
+    private readonly systemHooks;
+    private readonly systemAppends;
+    private readonly handlers;
+    private readonly piFlagValues;
+    private readonly sharedEvents;
+    private bindings;
+    private readonly perExt;
+    private currentExt;
+    private knownFiles;
+    private settings;
+    constructor(tools: ToolRegistry, cwd: string);
+    bind(bindings: HostBindings): void;
+    private slot;
+    private ctx;
+    private adaptTool;
+    private api;
+    publicApi(): ExtensionApi;
+    runFlag(name: string, value: string | undefined): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    hasHandlers(event: EventName): boolean;
+    emit<E extends EventName>(event: E, payload: ExtensionEvents[E]): Promise<EventOutcome[]>;
+    applySystem(base: string): string;
+    loadModule(spec: string, cacheBust?: boolean): Promise<void>;
+    loadDir(cacheBust?: boolean): Promise<void>;
+    private unloadOne;
+    private unloadAll;
+    private allTools;
+    reload(): Promise<{
+        before: string[];
+        after: string[];
+        added: string[];
+        removed: string[];
+    }>;
+    inventory(): ExtensionInfo[];
+    setEnabled(id: string, enabled: boolean): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    setOption(id: string, key: string, value: unknown): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    resolveId(input: string): string | null;
+}