@vascend/talos 0.1.0

package/dist/vascend/plan-store.js

@@ -0,0 +1,460 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { MemoryStore } from "./memory-store.js";
+export function parseTaskTokens(raw) {
+    const skills = new Set();
+    const files = new Set();
+    let weight;
+    let compact = false;
+    let title = raw;
+    title = title.replace(/@skill:\s*([A-Za-z0-9_,:\-]+)/gi, (_m, list) => {
+        for (const s of list.split(",").map((x) => x.trim()).filter(Boolean))
+            skills.add(s);
+        return "";
+    });
+    title = title.replace(/@file:\s*([^\s]+)/gi, (_m, list) => {
+        for (const f of list.split(",").map((x) => x.trim()).filter(Boolean))
+            files.add(f);
+        return "";
+    });
+    title = title.replace(/@w:\s*(\d)/gi, (_m, n) => {
+        const v = Number(n);
+        if (v >= 1 && v <= 5)
+            weight = v;
+        return "";
+    });
+    title = title.replace(/@compact\b/gi, () => { compact = true; return ""; });
+    return {
+        title: title.replace(/\s{2,}/g, " ").trim(),
+        skills: [...skills],
+        files: [...files],
+        weight,
+        compact,
+    };
+}
+function hexMask(value) {
+    return `0x${value.toString(16).padStart(4, "0")}`;
+}
+function buildCastle(slug, title, taskTitles, after) {
+    const raw = taskTitles.map((t) => t.trim()).filter(Boolean).slice(0, 16);
+    const tasks = raw.map((t, i) => {
+        const meta = parseTaskTokens(t);
+        return {
+            id: `T${String(i + 1).padStart(2, "0")}`,
+            bit: i,
+            mask: hexMask(1 << i),
+            title: meta.title || t,
+            status: "pending",
+            ...(meta.skills.length ? { skills: meta.skills } : {}),
+            ...(meta.files.length ? { files: meta.files } : {}),
+            ...(meta.weight ? { weight: meta.weight } : {}),
+            ...(meta.compact ? { compact: true } : {}),
+        };
+    });
+    return {
+        slug: slug.trim() || "master",
+        title: title.trim() || slug.trim() || "gruppo",
+        maskTarget: hexMask(tasks.length ? (1 << tasks.length) - 1 : 0),
+        custom: true,
+        tasks,
+        ...(after && after.trim() ? { after: after.trim() } : {}),
+    };
+}
+export class VascendPlanStore {
+    file;
+    memory;
+    kingdom = { castles: [] };
+    constructor(file, memory) {
+        this.file = file;
+        this.memory = memory;
+    }
+    static open(sessionDir, sessionId, options = {}) {
+        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"));
+                if (options.strict) {
+                    const castles = raw && (Array.isArray(raw.castles) ? raw.castles : Array.isArray(raw.tasks) ? [raw] : null);
+                    if (!castles || !castles.every(validStoredCastle)
+                        || new Set(castles.map((castle) => castle.slug)).size !== castles.length) {
+                        throw new Error("formato del piano non valido");
+                    }
+                }
+                if (raw && Array.isArray(raw.castles)) {
+                    store.kingdom = { castles: raw.castles };
+                }
+                else if (raw && Array.isArray(raw.tasks)) {
+                    // Retrocompatibilita': vecchio formato a castello singolo.
+                    store.kingdom = { castles: [raw] };
+                }
+            }
+            catch (error) {
+                if (options.strict)
+                    throw new Error(`piano illeggibile (${store.file}): ${error.message}`);
+                // file corrotto: ignorato
+            }
+        }
+        return store;
+    }
+    castles() {
+        return this.kingdom.castles;
+    }
+    hasAny() {
+        return this.kingdom.castles.length > 0;
+    }
+    // Riferimento alla stanza attualmente "running" (la prima trovata), come
+    // "slug/idStanza" (es. "master/T03"). Usato per linkare le decisioni al task
+    // in corso. Null se nessuna stanza e' running.
+    runningTaskRef() {
+        for (const c of this.kingdom.castles) {
+            const t = c.tasks.find((task) => task.status === "running");
+            if (t)
+                return `${c.slug}/${t.id}`;
+        }
+        return null;
+    }
+    // Crea o RIDEFINISCE un castello del regno (per slug). Castelli illimitati.
+    setCastle(slug, title, taskTitles, after) {
+        const castle = buildCastle(slug, title, taskTitles, after);
+        const rest = this.kingdom.castles.filter((c) => c.slug !== castle.slug);
+        this.kingdom = { castles: [...rest, castle] };
+        this.persist();
+        this.memory.append(castleEvent("plan.castle.set", castle));
+        return castle;
+    }
+    // Illumina (o segna) una stanza di un castello, per id ("T01") o bit (0-based).
+    mark(slug, idOrBit, status, evidence) {
+        const target = (slug || "master").trim();
+        let hit = null;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            const tasks = c.tasks.map((t) => {
+                if (t.id.toLowerCase() === idOrBit.trim().toLowerCase() || String(t.bit) === idOrBit.trim()) {
+                    const proof = evidence?.trim();
+                    const restart = status === "pending" || status === "failed"
+                        || (status === "running" && t.status !== "running");
+                    const previousEvidence = restart ? [] : (t.evidence ?? []);
+                    hit = {
+                        ...t,
+                        status,
+                        ...(restart ? { evidence: [], tokens: undefined, ms: undefined } : {}),
+                        ...(proof ? { evidence: [...previousEvidence, proof].slice(-8) } : {}),
+                    };
+                    return hit;
+                }
+                return t;
+            });
+            return { ...c, tasks };
+        });
+        this.kingdom = { castles };
+        if (hit) {
+            this.persist();
+            this.memory.append(taskEvent("plan.task.marked", target, hit));
+        }
+        return hit;
+    }
+    // Registra una prova prodotta da un tool realmente eseguito mentre la stanza
+    // e' running. E' separata da `mark`: raccogliere prove non deve cambiare lo
+    // stato del task ne' simulare una chiusura.
+    addEvidence(slug, idOrBit, evidence) {
+        const target = (slug || "master").trim();
+        const proof = evidence.trim();
+        if (!proof)
+            return null;
+        let hit = null;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            const tasks = c.tasks.map((t) => {
+                if (t.id.toLowerCase() !== idOrBit.trim().toLowerCase() && String(t.bit) !== idOrBit.trim())
+                    return t;
+                const previous = t.evidence ?? [];
+                const evidenceRows = previous.at(-1) === proof ? previous : [...previous, proof].slice(-8);
+                hit = { ...t, evidence: evidenceRows };
+                return hit;
+            });
+            return { ...c, tasks };
+        });
+        this.kingdom = { castles };
+        if (hit) {
+            this.persist();
+            this.memory.append(taskEvent("plan.task.evidence", target, hit));
+        }
+        return hit;
+    }
+    // Attribuisce i token (generati) a una stanza. Usato dalla TUI a stanza
+    // completata. No-op se la stanza non esiste.
+    setRoomTokens(slug, idOrBit, tokens) {
+        this.setRoomMetrics(slug, idOrBit, { tokens });
+    }
+    // Metriche della stanza (token e/o durata ms). No-op se non esiste.
+    setRoomMetrics(slug, idOrBit, metrics) {
+        const target = (slug || "master").trim();
+        let touched = false;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            const tasks = c.tasks.map((t) => {
+                if (t.id.toLowerCase() === idOrBit.trim().toLowerCase() || String(t.bit) === idOrBit.trim()) {
+                    touched = true;
+                    return {
+                        ...t,
+                        ...(metrics.tokens !== undefined ? { tokens: metrics.tokens } : {}),
+                        ...(metrics.ms !== undefined ? { ms: metrics.ms } : {}),
+                    };
+                }
+                return t;
+            });
+            return { ...c, tasks };
+        });
+        this.kingdom = { castles };
+        if (touched) {
+            this.persist();
+            this.memory.append({
+                type: "plan.task.metrics",
+                domain: "plan",
+                subject: `${target}/${idOrBit.trim()}`,
+                summary: `metriche attivita ${target}/${idOrBit.trim()}`,
+                body: [`tokens=${metrics.tokens ?? ""}`, `ms=${metrics.ms ?? ""}`].filter((x) => !x.endsWith("=")).join(" "),
+                terms: [target, idOrBit, "metriche", "tokens", "durata"],
+                links: [{ rel: "updates", target: `${target}/${idOrBit.trim()}`, domain: "plan" }],
+                payload: { castle: target, task: idOrBit.trim(), metrics },
+            });
+        }
+    }
+    // Aggiunge nuove stanze (pending) a un castello SENZA toccare le esistenti: i
+    // bit proseguono dopo l'ultimo, MASK_TARGET si estende. Usato dal revisore per
+    // "aggiungerne altre". Cap a 30 bit totali (one-hot in un intero).
+    addTasks(slug, taskTitles) {
+        const target = (slug || "master").trim();
+        const castle = this.kingdom.castles.find((c) => c.slug === target);
+        if (!castle)
+            return [];
+        const base = castle.tasks.length;
+        const room = Math.max(0, 30 - base);
+        const titles = taskTitles.map((t) => t.trim()).filter(Boolean).slice(0, room);
+        if (!titles.length)
+            return [];
+        const added = titles.map((t, i) => {
+            const bit = base + i;
+            const meta = parseTaskTokens(t);
+            return {
+                id: `T${String(bit + 1).padStart(2, "0")}`,
+                bit,
+                mask: hexMask(1 << bit),
+                title: meta.title || t,
+                status: "pending",
+                ...(meta.skills.length ? { skills: meta.skills } : {}),
+                ...(meta.files.length ? { files: meta.files } : {}),
+                ...(meta.weight ? { weight: meta.weight } : {}),
+                ...(meta.compact ? { compact: true } : {}),
+            };
+        });
+        const tasks = [...castle.tasks, ...added];
+        const next = { ...castle, tasks, maskTarget: hexMask((1 << tasks.length) - 1) };
+        this.kingdom = { castles: this.kingdom.castles.map((c) => (c.slug === target ? next : c)) };
+        this.persist();
+        this.memory.append({
+            type: "plan.tasks.added",
+            domain: "plan",
+            subject: target,
+            summary: `aggiunte ${added.length} attivita a ${target}`,
+            body: added.map((t) => `${t.id}: ${t.title}`).join("\n"),
+            terms: [target, ...added.flatMap((t) => [t.id, t.title])],
+            links: added.map((t) => ({ rel: "contains", target: `${target}/${t.id}`, domain: "plan" })),
+            payload: { castle: target, tasks: added },
+        });
+        return added;
+    }
+    // Aggiunge una nota (dossier). Se `idOrBit` e' dato, alla stanza; altrimenti al
+    // castello. Ritorna true se applicata.
+    addNote(slug, idOrBit, note) {
+        const target = (slug || "master").trim();
+        const text = note.trim();
+        if (!text)
+            return false;
+        let touched = false;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            if (!idOrBit) {
+                touched = true;
+                return { ...c, notes: [...(c.notes ?? []), text] };
+            }
+            const tasks = c.tasks.map((t) => {
+                if (t.id.toLowerCase() === idOrBit.trim().toLowerCase() || String(t.bit) === idOrBit.trim()) {
+                    touched = true;
+                    return { ...t, notes: [...(t.notes ?? []), text] };
+                }
+                return t;
+            });
+            return { ...c, tasks };
+        });
+        this.kingdom = { castles };
+        if (touched) {
+            this.persist();
+            const subject = noteSubject(target, idOrBit);
+            this.memory.append({
+                type: "note.added",
+                domain: "notes",
+                subject,
+                summary: text,
+                body: text,
+                terms: [target, idOrBit ?? "", ...text.split(/\s+/)],
+                links: [{ rel: "annotates", target: subject, domain: "plan" }],
+                payload: { castle: target, task: idOrBit, note: text },
+            });
+        }
+        return touched;
+    }
+    // Abbina delle skill (in anticipo). Se `idOrBit` e' dato, alla stanza;
+    // altrimenti al castello. Deduplica. Ritorna true se applicata.
+    bindSkills(slug, idOrBit, skills) {
+        const target = (slug || "master").trim();
+        const add = skills.map((s) => s.trim()).filter(Boolean);
+        if (!add.length)
+            return false;
+        const merge = (cur) => [...new Set([...(cur ?? []), ...add])];
+        let touched = false;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            if (!idOrBit) {
+                touched = true;
+                return { ...c, skills: merge(c.skills) };
+            }
+            const tasks = c.tasks.map((t) => {
+                if (t.id.toLowerCase() === idOrBit.trim().toLowerCase() || String(t.bit) === idOrBit.trim()) {
+                    touched = true;
+                    return { ...t, skills: merge(t.skills) };
+                }
+                return t;
+            });
+            return { ...c, tasks };
+        });
+        this.kingdom = { castles };
+        if (touched) {
+            this.persist();
+            const subject = noteSubject(target, idOrBit);
+            this.memory.append({
+                type: "skill.bound",
+                domain: "skills",
+                subject,
+                summary: `skill abbinate: ${add.join(", ")}`,
+                body: add.join("\n"),
+                terms: [target, idOrBit ?? "", ...add],
+                links: [
+                    { rel: "prepares", target: subject, domain: "plan" },
+                    ...add.map((skill) => ({ rel: "uses", target: skill, domain: "skills" })),
+                ],
+                payload: { castle: target, task: idOrBit, skills: add },
+            });
+        }
+        return touched;
+    }
+    // Imposta la dipendenza @after di un castello (parte dopo `after`).
+    setAfter(slug, after) {
+        const target = (slug || "master").trim();
+        let touched = false;
+        const castles = this.kingdom.castles.map((c) => {
+            if (c.slug !== target)
+                return c;
+            touched = true;
+            return { ...c, after: after.trim() || undefined };
+        });
+        this.kingdom = { castles };
+        if (touched) {
+            this.persist();
+            this.memory.append({
+                type: "plan.after.set",
+                domain: "plan",
+                subject: target,
+                summary: `${target} dopo ${after.trim()}`,
+                body: `@after[${target}]: ${after.trim()}`,
+                terms: [target, after.trim(), "after", "dipendenza"],
+                links: [{ rel: "after", target: after.trim(), domain: "plan" }],
+                payload: { castle: target, after: after.trim() },
+            });
+        }
+        return touched;
+    }
+    // Castello per slug (lettura).
+    castle(slug) {
+        return this.kingdom.castles.find((c) => c.slug === (slug || "master").trim());
+    }
+    clear() {
+        this.kingdom = { castles: [] };
+        try {
+            if (existsSync(this.file))
+                rmSync(this.file);
+        }
+        catch {
+            // best effort
+        }
+        this.memory.append({
+            type: "plan.cleared",
+            domain: "plan",
+            subject: "kingdom",
+            summary: "piano cancellato",
+            body: "",
+            terms: ["piano", "clear"],
+            payload: {},
+        });
+    }
+    persist() {
+        mkdirSync(dirname(this.file), { recursive: true });
+        const temporary = `${this.file}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temporary, JSON.stringify(this.kingdom, null, 2) + "\n", "utf8");
+            renameSync(temporary, this.file);
+        }
+        finally {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch { /* preserve the write error */ }
+        }
+    }
+}
+function validStoredCastle(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const castle = value;
+    const strings = (items) => items === undefined
+        || (Array.isArray(items) && items.every((item) => typeof item === "string"));
+    return typeof castle.slug === "string" && Boolean(castle.slug.trim()) && typeof castle.title === "string"
+        && (castle.after === undefined || typeof castle.after === "string") && strings(castle.notes) && strings(castle.skills)
+        && Array.isArray(castle.tasks) && castle.tasks.every((task) => task && typeof task.id === "string"
+        && typeof task.title === "string" && ["pending", "running", "completed", "failed"].includes(task.status)
+        && strings(task.evidence) && strings(task.notes) && strings(task.files) && strings(task.skills))
+        && new Set(castle.tasks.map((task) => task.id)).size === castle.tasks.length;
+}
+function noteSubject(castle, idOrBit) {
+    return idOrBit ? `${castle}/${idOrBit.trim()}` : castle;
+}
+function castleEvent(type, castle) {
+    return {
+        type,
+        domain: "plan",
+        subject: castle.slug,
+        summary: castle.title,
+        body: castle.tasks.map((t) => `${t.id}: ${t.title} [${t.status}]`).join("\n"),
+        terms: [castle.slug, castle.title, ...castle.tasks.flatMap((t) => [t.id, t.title])],
+        links: castle.tasks.map((t) => ({ rel: "contains", target: `${castle.slug}/${t.id}`, domain: "plan" })),
+        payload: { castle },
+    };
+}
+function taskEvent(type, castle, task) {
+    return {
+        type,
+        domain: "plan",
+        subject: `${castle}/${task.id}`,
+        summary: `${task.status}: ${task.title}`,
+        body: `@task[${castle}/${task.id}]: status=${task.status}, title="${task.title}"${task.evidence?.length ? `, evidence="${task.evidence.join(" | ")}"` : ""}`,
+        terms: [castle, task.id, task.status, task.title],
+        links: [{ rel: "belongs_to", target: castle, domain: "plan" }],
+        payload: { castle, task, evidence: task.evidence ?? [] },
+    };
+}

package/dist/vascend/proof-chains.d.ts

@@ -0,0 +1,19 @@
+import type { ContextCandidate } from "./context-candidate.js";
+export interface ChainLink {
+    readonly role: "goal" | "decision" | "reason" | "asset" | "state" | "next";
+    readonly id: string | null;
+    readonly text: string;
+}
+export interface ProofChain {
+    readonly id: string;
+    readonly links: readonly ChainLink[];
+}
+export declare function isContinuationRequest(userText: string): boolean;
+export interface BuildChainOptions {
+    readonly goal?: string;
+    readonly nextAction?: string;
+    readonly id?: string;
+}
+export declare function buildProofChain(candidates: readonly ContextCandidate[], opts?: BuildChainOptions): ProofChain | null;
+export declare function renderProofChain(chain: ProofChain): string;
+export declare function renderProofChains(chains: readonly ProofChain[]): string;

package/dist/vascend/proof-chains.js

@@ -0,0 +1,120 @@
+// Causal Proof Packets / Proof Chains (metodo Danilov, Memory OS) -- L2.
+//
+// Gli Evidence Slots danno prove ISOLATE. Il passo successivo e' dare al modello
+// una TRAIETTORIA causale: non solo fatti, ma il perche', da dove viene il lavoro
+// e cosa fare dopo.
+//
+//   goal -> decision -> reason -> asset -> current_state -> next_action
+//
+// Formato del documento:
+//   [PROOF_CHAIN:crm-ui-01]
+//   goal = "CRM corsi professionale"
+//   decision = D31 "rifare la pagina da zero"
+//   reason = "layout precedente troppo piatto"
+//   asset = A18 "dashboard CRM migliorata"
+//   current_state = "serve nuova iterazione grafica"
+//   next_action = "migliorare KPI, layout, tabella, chart"
+//
+// Si usa soprattutto per frasi di continuazione: "continua", "riprendi",
+// "migliora", "vai avanti", "come avevamo deciso".
+//
+// Modulo PURO e DETERMINISTICO: costruisce la catena dai candidati, nessun
+// side-effect, nessuna rete.
+// Frasi che attivano la proof chain: il modello sta CONTINUANDO un lavoro e ha
+// bisogno della traiettoria, non solo di prove sparse.
+const CONTINUATION_RE = /\b(continu|riprend|riprist|vai avanti|prosegui|come avevamo|come deciso|migliora|aggiorna|finisci|completa)\w*/i;
+// Vero se il testo utente e' una richiesta di continuazione.
+export function isContinuationRequest(userText) {
+    return CONTINUATION_RE.test(userText ?? "");
+}
+// Costruisce una catena causale dai candidati disponibili. Sceglie la decisione
+// attiva piu' recente e segue soltanto i suoi link espliciti (anche transitivi):
+// vicinanza temporale e appartenenza allo stesso pool non sono prove di una
+// relazione causale. Deterministico: ordina per createdAt desc, tie-break su id.
+export function buildProofChain(candidates, opts = {}) {
+    const byRecency = [...candidates].sort((a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id));
+    const decision = byRecency.find((c) => c.kind === "decision" && c.status === "active") ?? null;
+    const reachable = decision ? reachableFrom(decision, candidates) : new Set();
+    const asset = byRecency.find((c) => reachable.has(c.id) && c.kind === "asset") ?? null;
+    const state = byRecency.find((c) => reachable.has(c.id) && (c.kind === "task" || c.kind === "room")) ?? null;
+    const links = [];
+    if (opts.goal)
+        links.push({ role: "goal", id: null, text: oneLine(opts.goal, 160) });
+    if (decision) {
+        links.push({ role: "decision", id: decision.id, text: oneLine(decision.summary, 160) });
+        const reason = extractReason(decision.body, decision.summary);
+        if (reason)
+            links.push({ role: "reason", id: decision.id, text: reason });
+    }
+    if (asset)
+        links.push({ role: "asset", id: asset.id, text: oneLine(asset.summary, 160) });
+    if (state)
+        links.push({ role: "state", id: state.id, text: oneLine(state.summary, 160) });
+    if (opts.nextAction)
+        links.push({ role: "next", id: null, text: oneLine(opts.nextAction, 160) });
+    // Una catena ha senso solo se ha almeno il goal/decisione + un altro anello.
+    if (links.length < 2)
+        return null;
+    return { id: opts.id ?? "chain-01", links };
+}
+// Visita il grafo orientato a partire dalla decisione. Il set non include la
+// radice: serve solo a filtrare gli anelli che hanno una provenienza esplicita.
+// I link pendenti vengono ignorati e `seen` rende sicuri i cicli.
+function reachableFrom(root, candidates) {
+    const byId = new Map(candidates.map((candidate) => [candidate.id, candidate]));
+    const seen = new Set([root.id]);
+    const reachable = new Set();
+    const queue = [...root.links];
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const candidate = byId.get(id);
+        if (!candidate)
+            continue;
+        reachable.add(id);
+        queue.push(...candidate.links);
+    }
+    return reachable;
+}
+// Rende la catena nel formato [PROOF_CHAIN:id]. Deterministico.
+export function renderProofChain(chain) {
+    const lines = [`[PROOF_CHAIN:${chain.id}]`];
+    for (const link of chain.links) {
+        const ref = link.id ? `${link.id} ` : "";
+        lines.push(`${labelFor(link.role)} = ${ref}"${link.text}"`);
+    }
+    return lines.join("\n");
+}
+// Rende piu' catene in un unico blocco.
+export function renderProofChains(chains) {
+    return chains.filter(Boolean).map(renderProofChain).join("\n\n");
+}
+function labelFor(role) {
+    switch (role) {
+        case "goal":
+            return "goal";
+        case "decision":
+            return "decision";
+        case "reason":
+            return "reason";
+        case "asset":
+            return "asset";
+        case "state":
+            return "current_state";
+        case "next":
+            return "next_action";
+    }
+}
+function extractReason(body, summary) {
+    const src = (body || summary || "").replace(/\s+/g, " ").trim();
+    if (!src)
+        return "";
+    const firstSentence = src.split(/(?<=[.!?])\s/)[0] ?? src;
+    return oneLine(firstSentence, 160);
+}
+function oneLine(value, max) {
+    const s = (value ?? "").replace(/\s+/g, " ").trim().replace(/"/g, "'");
+    return s.length > max ? s.slice(0, max - 1).trimEnd() + "\u2026" : s;
+}

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

@@ -0,0 +1,25 @@
+import { type Outcome, type Roadmap } from "./ramification.js";
+export declare class RamificationStore {
+    private readonly file;
+    private roadmap;
+    private constructor();
+    static open(sessionDir: string, scope: string): RamificationStore;
+    has(): boolean;
+    current(): Roadmap | null;
+    create(input: {
+        readonly goal: string;
+        readonly acceptance?: readonly string[];
+        readonly founders?: readonly string[];
+        readonly at: number;
+    }): {
+        readonly ok: boolean;
+        readonly reason: string;
+        readonly roadmap: Roadmap | null;
+    };
+    apply(operazione: (roadmap: Roadmap) => Outcome): {
+        readonly ok: boolean;
+        readonly reason: string;
+        readonly roadmap: Roadmap | null;
+    };
+    private persist;
+}