@vascend/talos 0.1.0

package/dist/vascend/context-fabric.js

@@ -0,0 +1,480 @@
+import { projectMemoryScopes, contextFrameWritten } from "./context-scope-index.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, dirname, join, resolve } from "node:path";
+import { isContinuationText, parseVibeMode, renderVibeModeBlock, routeVibeMode, vibeModeSpec, } from "../core/vibe-modes.js";
+import { tokenize } from "./lexical-search.js";
+import { withLockSync } from "./file-lock.js";
+const FABRIC_DIR = "context-fabric";
+const MAX_FOCUS_TERMS = 28;
+const MAX_MISSION_CHARS = 480;
+export function contextProjectKey(cwd) {
+    let canonical = resolve(cwd);
+    try {
+        canonical = realpathSync.native(canonical);
+    }
+    catch {
+        // Il cwd viene validato altrove. Se sparisce durante il turno, il path
+        // risolto resta comunque un'identita' deterministica e non collidente per
+        // semplice basename.
+    }
+    const normalized = process.platform === "win32" ? canonical.toLowerCase() : canonical;
+    const digest = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+    return `${safeName(basename(canonical) || "workspace")}-${digest}`;
+}
+export function contextFramePath(sessionDir, frameId) {
+    return join(sessionDir, FABRIC_DIR, `${safeName(frameId)}.json`);
+}
+export function loadContextFrame(sessionDir, frameId, projectKey, inherit = true) {
+    const own = readFrame(contextFramePath(sessionDir, frameId));
+    if (own && own.projectKey === projectKey)
+        return own;
+    if (!inherit)
+        return null;
+    const dir = join(sessionDir, FABRIC_DIR);
+    if (!existsSync(dir))
+        return null;
+    let files = [];
+    try {
+        files = readdirSync(dir).filter((name) => name.endsWith(".json"));
+    }
+    catch {
+        return null;
+    }
+    const candidates = files.flatMap((name) => {
+        const path = join(dir, name);
+        const frame = readFrame(path);
+        if (!frame || frame.projectKey !== projectKey || frame.owner === frameId)
+            return [];
+        let mtime = frame.updatedAt;
+        try {
+            mtime = Math.max(mtime, statSync(path).mtimeMs);
+        }
+        catch { /* best effort */ }
+        return [{ frame, mtime }];
+    });
+    return candidates
+        .sort((a, b) => b.mtime - a.mtime || b.frame.turn - a.frame.turn || a.frame.owner.localeCompare(b.frame.owner))[0]
+        ?.frame ?? null;
+}
+// Restituisce gli scope di memoria che le receipt associano esplicitamente a
+// un progetto. Serve ai compiler quando piu' repository condividono lo stesso
+// sessionDir (per esempio Horizon): senza questo filtro il working set recente
+// di un repo omonimo poteva entrare nel prompt di un altro. Se il chiamante non
+// passa un projectKey, i collector mantengono il comportamento legacy.
+export function listContextMemoryScopes(sessionDir, projectKey) {
+    return projectMemoryScopes(sessionDir, projectKey);
+}
+export function buildContextFabric(input) {
+    const now = input.now ?? Date.now();
+    const projectKey = contextProjectKey(input.cwd);
+    const ownPrevious = loadContextFrame(input.sessionDir, input.frameId, projectKey, false);
+    const previous = ownPrevious ?? (input.inheritProjectFrame === false
+        ? null
+        : loadContextFrame(input.sessionDir, input.frameId, projectKey, true));
+    const inherited = Boolean(previous && !ownPrevious);
+    const rawUserText = extractRawUserText(input.userText);
+    const continuation = isContinuationText(rawUserText);
+    let route = routeVibeMode(input.selection, rawUserText, previous?.activeMode);
+    const nextTurn = (previous?.turn ?? 0) + 1;
+    const startsNewEpoch = shouldOpenEpoch(previous, rawUserText, inherited, continuation);
+    // Una lente precedente e' sticky dentro lo stesso epoch, non oltre una
+    // barriera di missione. Senza nuovi segnali, un epoch nuovo torna classic.
+    if (startsNewEpoch && input.selection === "auto" && previous && route.resolved === previous.activeMode) {
+        route = routeVibeMode("auto", rawUserText);
+    }
+    const mode = vibeModeSpec(route.resolved);
+    const epoch = previous ? previous.epoch + (startsNewEpoch ? 1 : 0) : 1;
+    const mission = missionFor(previous, rawUserText, startsNewEpoch, continuation);
+    const contract = reconcileGoalContract({
+        previous: previous?.contract,
+        fallbackObjective: mission || previous?.mission || rawUserText,
+        epoch,
+        turn: nextTurn,
+        startsNewEpoch,
+        userText: rawUserText,
+        continuation,
+        now,
+    });
+    const leases = reconcileLeases({
+        previous: previous?.leases ?? [],
+        epoch,
+        turn: nextTurn,
+        startsNewEpoch,
+        mission,
+        userText: rawUserText,
+        mode,
+    });
+    const focusTerms = leases.slice(0, MAX_FOCUS_TERMS).map((lease) => lease.term);
+    const retrievalQuery = buildRetrievalQuery(rawUserText, mission, focusTerms);
+    const receipt = {
+        generatedAt: now,
+        epoch,
+        mode: mode.id,
+        routeConfidence: route.confidence,
+        routeReasons: route.reasons,
+        memoryScopeId: input.memoryScopeId,
+        mission,
+        retrievalQuery,
+        focusTerms,
+        contextBudget: mode.context.totalTokens,
+        proofChains: mode.context.proofChains,
+        inherited,
+    };
+    const frame = {
+        version: 1,
+        owner: input.frameId,
+        projectKey,
+        epoch,
+        turn: nextTurn,
+        selection: input.selection,
+        activeMode: mode.id,
+        mission,
+        contract,
+        leases,
+        createdAt: startsNewEpoch || !previous ? now : previous.createdAt,
+        updatedAt: now,
+        reset: false,
+        receipt,
+    };
+    writeContextFrame(input.sessionDir, frame);
+    return {
+        frame,
+        route,
+        mode,
+        rawUserText,
+        systemBlock: `${renderVibeModeBlock(route)}\n\n${renderFabricBlock(frame, inherited)}\n\n${renderGoalContract(contract)}`,
+        compile: {
+            retrievalQuery,
+            totalTokens: mode.context.totalTokens,
+            policy: mode.context.policy,
+            weights: mode.context.weights,
+            thresholds: mode.context.thresholds,
+            goal: goalContractAnchor(contract),
+            constraints: dedupeText([...contract.constraints, ...mode.operatingRules]).slice(0, 20),
+            success: dedupeText([...contract.successCriteria, ...mode.completionGates]).join("; "),
+            nextAction: mode.firstMove,
+            proofChains: mode.context.proofChains,
+        },
+    };
+}
+export function updateContextPins(input) {
+    const projectKey = contextProjectKey(input.cwd);
+    const previous = loadContextFrame(input.sessionDir, input.frameId, projectKey, true);
+    if (!previous || previous.reset)
+        return null;
+    const now = input.now ?? Date.now();
+    const remove = new Set((input.remove ?? []).flatMap((value) => pinTerms(value)));
+    const kept = previous.leases.filter((lease) => lease.source !== "pinned" || !remove.has(lease.term));
+    const additions = (input.add ?? []).flatMap((value) => pinTerms(value)).map((term) => makeLease(previous.epoch, term, "pinned", 100, previous.turn, null));
+    const frame = {
+        ...previous,
+        owner: input.frameId,
+        leases: dedupeAndSortLeases([...kept, ...additions]),
+        updatedAt: now,
+    };
+    writeContextFrame(input.sessionDir, frame);
+    return frame;
+}
+export function resetContextFrame(input) {
+    const now = input.now ?? Date.now();
+    const projectKey = contextProjectKey(input.cwd);
+    const previous = loadContextFrame(input.sessionDir, input.frameId, projectKey, true);
+    const frame = {
+        version: 1,
+        owner: input.frameId,
+        projectKey,
+        epoch: (previous?.epoch ?? 0) + 1,
+        turn: previous?.turn ?? 0,
+        selection: input.selection ?? previous?.selection ?? "auto",
+        activeMode: "classic",
+        mission: "",
+        leases: input.preservePins === false
+            ? []
+            : previous?.leases.filter((lease) => lease.source === "pinned") ?? [],
+        createdAt: now,
+        updatedAt: now,
+        reset: true,
+        receipt: null,
+    };
+    writeContextFrame(input.sessionDir, frame);
+    return frame;
+}
+export function renderContextFrame(frame) {
+    if (!frame || frame.reset)
+        return "context fabric: nessun epoch attivo";
+    const pinned = frame.leases.filter((lease) => lease.source === "pinned").map((lease) => lease.term);
+    const expiring = frame.leases.filter((lease) => lease.expiresAfterTurn !== null).map((lease) => lease.term).slice(0, 12);
+    const receipt = frame.receipt;
+    return [
+        `context fabric · epoch ${frame.epoch} · turno ${frame.turn} · mode ${frame.activeMode}`,
+        `missione: ${frame.mission || "(non definita)"}`,
+        frame.contract ? `contratto: ${frame.contract.revisions.length} revisioni · ${frame.contract.constraints.length} vincoli · ${frame.contract.successCriteria.length} criteri` : "",
+        `pin: ${pinned.length ? pinned.join(", ") : "nessuno"}`,
+        `focus con lease: ${expiring.length ? expiring.join(", ") : "nessuno"}`,
+        receipt ? `budget: ${receipt.contextBudget} token · proof chains: ${receipt.proofChains ? "on" : "off"}` : "",
+        receipt ? `route: ${receipt.routeReasons.join("; ") || "manuale"}` : "",
+    ].filter(Boolean).join("\n");
+}
+function reconcileGoalContract(input) {
+    const text = oneLine(input.userText).slice(0, 1_200);
+    if (input.startsNewEpoch || !input.previous || input.previous.epoch !== input.epoch) {
+        return {
+            epoch: input.epoch,
+            objective: text && !input.continuation ? text : oneLine(input.fallbackObjective).slice(0, 1_200),
+            revisions: [],
+            constraints: extractContractLines(text, "constraint"),
+            successCriteria: extractContractLines(text, "success"),
+            updatedAt: input.now,
+        };
+    }
+    if (!text || input.continuation)
+        return { ...input.previous, updatedAt: input.now };
+    const kind = isConstraintText(text) ? "constraint" : "clarification";
+    const duplicate = input.previous.revisions.some((revision) => normalizeContractText(revision.text) === normalizeContractText(text));
+    const revision = { turn: input.turn, text, kind, createdAt: input.now };
+    const revisions = duplicate
+        ? input.previous.revisions
+        : [...input.previous.revisions, revision].slice(-32);
+    return {
+        ...input.previous,
+        revisions,
+        constraints: dedupeText([...input.previous.constraints, ...extractContractLines(text, "constraint")]).slice(-24),
+        successCriteria: dedupeText([...input.previous.successCriteria, ...extractContractLines(text, "success")]).slice(-16),
+        updatedAt: input.now,
+    };
+}
+function isConstraintText(text) {
+    return /\b(?:non|senza|mai|solo|deve|devono|voglio|serve|bisogna|evita|attenzione|invece|piuttosto|must|should|without|never|only|do not)\b/i.test(text);
+}
+function extractContractLines(text, kind) {
+    const pattern = kind === "constraint"
+        ? /\b(?:non|senza|mai|solo|deve|devono|voglio|serve|bisogna|evita|attenzione|invece|piuttosto|must|should|without|never|only|do not)\b/i
+        : /\b(?:funzion\w*|verific\w*|test\w*|mostr\w*|risultat\w*|success\w*|quando|deve|devono|must)\b/i;
+    return dedupeText(text.split(/(?<=[.!?;])\s+|\r?\n/).map((line) => oneLine(line).slice(0, 500)).filter((line) => line.length > 3 && pattern.test(line)));
+}
+function normalizeContractText(value) {
+    return oneLine(value).toLowerCase().replace(/[^a-z0-9à-ÿ]+/gi, " ").trim();
+}
+function dedupeText(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const clean = oneLine(value);
+        const key = normalizeContractText(clean);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(clean);
+    }
+    return out;
+}
+function goalContractAnchor(contract) {
+    const revisions = contract.revisions.slice(-4).map((revision) => `rev${revision.turn}: ${revision.text}`);
+    return [contract.objective, ...revisions].filter(Boolean).join(" | ").slice(0, 2_400);
+}
+function renderGoalContract(contract) {
+    const revisions = contract.revisions.slice(-8).map((revision) => `@revisione[t${revision.turn}/${revision.kind}]: ${revision.text}`);
+    return [
+        "[TALOS_GOAL_CONTRACT]",
+        `@obiettivo[corrente]: ${contract.objective}`,
+        ...revisions,
+        ...contract.constraints.map((constraint, index) => `@vincolo[user-${index + 1}]: ${constraint}`),
+        ...contract.successCriteria.map((criterion, index) => `@success[${index + 1}]: ${criterion}`),
+        "OUTPUT: le revisioni piu recenti prevalgono; non ripristinare requisiti superati.",
+        "[/TALOS_GOAL_CONTRACT]",
+    ].join("\n");
+}
+function reconcileLeases(input) {
+    const retained = input.previous.filter((lease) => {
+        if (lease.source === "pinned")
+            return true;
+        if (input.startsNewEpoch)
+            return false;
+        return lease.expiresAfterTurn === null || lease.expiresAfterTurn >= input.turn;
+    });
+    const mission = meaningfulTerms(input.mission).map((term) => makeLease(input.epoch, term, "mission", 80, input.turn, null));
+    const turn = meaningfulTerms(input.userText).map((term) => makeLease(input.epoch, term, "turn", 60, input.turn, input.turn + 2));
+    const mode = input.mode.context.focusTerms.flatMap((value) => meaningfulTerms(value)).map((term) => makeLease(input.epoch, term, "mode", 30, input.turn, input.turn + 1));
+    return dedupeAndSortLeases([...retained, ...mission, ...turn, ...mode]);
+}
+function dedupeAndSortLeases(leases) {
+    const byTerm = new Map();
+    for (const lease of leases) {
+        const current = byTerm.get(lease.term);
+        if (!current || lease.weight > current.weight || (lease.weight === current.weight && (lease.expiresAfterTurn ?? Number.MAX_SAFE_INTEGER) > (current.expiresAfterTurn ?? Number.MAX_SAFE_INTEGER)))
+            byTerm.set(lease.term, lease);
+    }
+    return [...byTerm.values()].sort((a, b) => b.weight - a.weight || a.term.localeCompare(b.term));
+}
+function makeLease(epoch, term, source, weight, createdTurn, expiresAfterTurn) {
+    return {
+        id: `${epoch}:${source}:${term}`,
+        term,
+        source,
+        weight,
+        createdTurn,
+        expiresAfterTurn,
+    };
+}
+function shouldOpenEpoch(previous, userText, inherited, continuation) {
+    if (!previous || previous.reset || !previous.mission)
+        return true;
+    if (continuation)
+        return false;
+    if (inherited)
+        return true;
+    if (/\b(nuovo task|nuovo obiettivo|cambiamo argomento|passiamo a|invece occupati|new task|switch task|different task)\b/i.test(userText))
+        return true;
+    const oldTerms = new Set(meaningfulTerms(previous.mission));
+    const nextTerms = new Set(meaningfulTerms(userText));
+    let overlap = 0;
+    for (const term of nextTerms)
+        if (oldTerms.has(term))
+            overlap += 1;
+    const overlapRatio = overlap / Math.max(1, Math.min(oldTerms.size, nextTerms.size));
+    if (overlapRatio >= 0.18 || hasFollowupReference(userText))
+        return false;
+    // In dubbio isoliamo una richiesta concreta nuova: contaminare il control
+    // lane con una missione vecchia e' piu' dannoso che aprire un epoch in piu'.
+    // I follow-up minimi con un solo termine informativo ("documentalo") restano
+    // nello stesso epoch. Due termini nuovi e senza alcun legame con missione o
+    // riferimenti deittici sono gia' un segnale sufficiente di task nuovo. Questa
+    // decisione dipende solo dalla continuita' semantica dell'epoch: il mode
+    // routing non puo' piu' cambiare implicitamente la missione.
+    return nextTerms.size >= 2;
+}
+function hasFollowupReference(value) {
+    const text = value.trim();
+    return /^(?:e\s+|anche\b|inoltre\b|poi\b)/i.test(text) ||
+        /\b(stess[oaie]|precedent[ei]|quest[oaie]|quell[oaie]|sopra|il fix|la modifica|l'implementazione|the same|previous|this|that change)\b/i.test(text);
+}
+function missionFor(previous, userText, startsNewEpoch, continuation) {
+    if (previous && !previous.reset && !startsNewEpoch && (continuation || previous.mission))
+        return previous.mission;
+    return oneLine(userText).slice(0, MAX_MISSION_CHARS);
+}
+function buildRetrievalQuery(userText, mission, focusTerms) {
+    const parts = [oneLine(userText).slice(0, 2_000)];
+    if (mission && oneLine(userText) !== mission)
+        parts.push(mission);
+    if (focusTerms.length)
+        parts.push(focusTerms.join(" "));
+    return parts.filter(Boolean).join("\n");
+}
+function renderFabricBlock(frame, inherited) {
+    const pins = frame.leases.filter((lease) => lease.source === "pinned").map((lease) => lease.term);
+    const working = frame.leases.filter((lease) => lease.source !== "pinned").slice(0, 20).map((lease) => lease.term);
+    return `[CONTEXT_FABRIC]
+INDICE
+1 = epoch
+2 = control_lane
+3 = working_lane
+4 = evidence_lane
+5 = quarantine_lane
+
+DEFINIZIONI
+@epoch[${frame.epoch}]: missione="${escapeValue(frame.mission)}", owner=${safeName(frame.owner)}, inherited=${inherited}
+@lane[control]: mode=${frame.activeMode}, pin="${escapeValue(pins.join(", ") || "nessuno")}" 
+@lane[working]: focus="${escapeValue(working.join(", ") || "nessuno")}" 
+@lane[evidence]: accetta fatti passati solo se presenti negli evidence slot o recuperati con recall
+@lane[quarantine]: epoch precedenti e lease scadute restano fuori dal prompt vivo; sono solo handle richiamabili
+@lease[regola]: turn=scade, mission=dura_per_epoch, pinned=non_scade
+
+OUTPUT: continua la missione dell'epoch; non sostituirla con un follow-up deittico come 'continua'.`;
+}
+function extractRawUserText(value) {
+    const marker = "\nINPUT_UTENTE\n";
+    const index = value.lastIndexOf(marker);
+    if (index >= 0)
+        return value.slice(index + marker.length).trim();
+    return value.trim();
+}
+function meaningfulTerms(value) {
+    return [...new Set(tokenize(value).filter((term) => term.length >= 3 && term !== "continua" && term !== "continue"))];
+}
+function pinTerms(value) {
+    const clean = oneLine(value).replace(/^(?:"([\s\S]*)"|'([\s\S]*)')$/, (_match, double, single) => double ?? single ?? "");
+    const normalizedPath = clean.replace(/\\/g, "/");
+    const pathLike = /^[a-z]:\//i.test(normalizedPath) || /^\.{0,2}\//.test(normalizedPath) ||
+        normalizedPath.startsWith("/") || /^[^\s/]+\/(?:[^/]+\/)*[^/]+$/.test(normalizedPath);
+    return pathLike && normalizedPath
+        ? [normalizedPath.toLowerCase()]
+        : meaningfulTerms(clean);
+}
+function writeContextFrame(sessionDir, frame) {
+    const path = contextFramePath(sessionDir, frame.owner);
+    mkdirSync(dirname(path), { recursive: true });
+    withLockSync(path, () => {
+        const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(temp, JSON.stringify(frame, null, 2) + "\n", "utf8");
+        try {
+            renameSync(temp, path);
+        }
+        catch {
+            // Windows puo' rifiutare la sostituzione atomica di un file esistente.
+            // Il lock impedisce lettori/scrittori Talos concorrenti sullo stesso owner.
+            rmSync(path, { force: true });
+            renameSync(temp, path);
+        }
+    });
+    contextFrameWritten(sessionDir, path);
+}
+function readFrame(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return isContextFrame(raw) ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isContextFrame(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const frame = value;
+    const activeMode = parseVibeMode(frame.activeMode);
+    return frame.version === 1 && typeof frame.owner === "string" && typeof frame.projectKey === "string" &&
+        isFiniteNumber(frame.epoch) && isFiniteNumber(frame.turn) && typeof frame.mission === "string" &&
+        Array.isArray(frame.leases) && frame.leases.every(isContextLease) &&
+        activeMode !== undefined && activeMode !== "auto" && parseVibeMode(frame.selection) !== undefined &&
+        isFiniteNumber(frame.createdAt) && isFiniteNumber(frame.updatedAt) && typeof frame.reset === "boolean" &&
+        (frame.receipt === null || isContextReceipt(frame.receipt));
+}
+function isContextLease(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const lease = value;
+    return typeof lease.id === "string" && typeof lease.term === "string" &&
+        (lease.source === "pinned" || lease.source === "mission" || lease.source === "turn" || lease.source === "mode") &&
+        isFiniteNumber(lease.weight) && isFiniteNumber(lease.createdTurn) &&
+        (lease.expiresAfterTurn === null || isFiniteNumber(lease.expiresAfterTurn));
+}
+function isContextReceipt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const receipt = value;
+    const mode = parseVibeMode(receipt.mode);
+    return isFiniteNumber(receipt.generatedAt) && isFiniteNumber(receipt.epoch) &&
+        mode !== undefined && mode !== "auto" && isFiniteNumber(receipt.routeConfidence) &&
+        Array.isArray(receipt.routeReasons) && receipt.routeReasons.every((item) => typeof item === "string") &&
+        typeof receipt.memoryScopeId === "string" && typeof receipt.mission === "string" &&
+        typeof receipt.retrievalQuery === "string" && Array.isArray(receipt.focusTerms) &&
+        receipt.focusTerms.every((item) => typeof item === "string") && isFiniteNumber(receipt.contextBudget) &&
+        typeof receipt.proofChains === "boolean" && typeof receipt.inherited === "boolean";
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function safeName(value) {
+    const safe = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    return safe || "context";
+}
+function oneLine(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function escapeValue(value) {
+    return oneLine(value).replace(/"/g, "'");
+}

package/dist/vascend/context-feedback-loop.d.ts

@@ -0,0 +1,56 @@
+import { type TuneConfig, type QualityTargets, type TuneAdjustment } from "./context-autotuner.js";
+import type { ContextMetrics } from "./context-metrics.js";
+import { type CompileInput, type CompiledContext } from "./context-window-compiler.js";
+import { type TunerBaseline } from "./tuner-baseline-store.js";
+import { type ExploreOptions, type PatternRanking } from "./context-pattern-explorer.js";
+export type CompileWithConfig = (config: TuneConfig) => ContextMetrics;
+export interface LoopStep {
+    readonly round: number;
+    readonly config: TuneConfig;
+    readonly metrics: ContextMetrics;
+    readonly score: number;
+    readonly adjustments: readonly TuneAdjustment[];
+}
+export interface LoopResult {
+    readonly bestConfig: TuneConfig;
+    readonly bestScore: number;
+    readonly initialScore: number;
+    readonly improved: boolean;
+    readonly converged: boolean;
+    readonly rounds: number;
+    readonly trajectory: readonly LoopStep[];
+}
+export interface LoopOptions {
+    readonly config?: TuneConfig;
+    readonly targets?: QualityTargets;
+    readonly maxRounds?: number;
+    readonly minGain?: number;
+}
+export declare function runFeedbackLoop(compile: CompileWithConfig, opts?: LoopOptions): LoopResult;
+export declare function runContextFeedbackLoop(input: CompileInput, opts?: LoopOptions): {
+    readonly loop: LoopResult;
+    readonly compiled: CompiledContext;
+};
+export interface LearningLoopOptions extends LoopOptions {
+    readonly dir: string;
+    readonly storeId: string;
+    readonly scope?: string;
+    readonly persist?: boolean;
+}
+export declare function runLearningFeedbackLoop(input: CompileInput, opts: LearningLoopOptions): {
+    readonly loop: LoopResult;
+    readonly compiled: CompiledContext;
+    readonly baseline: TunerBaseline;
+};
+export interface DeepSelfImproveOptions extends ExploreOptions {
+    readonly dir: string;
+    readonly storeId: string;
+    readonly scope?: string;
+    readonly persist?: boolean;
+}
+export declare function runDeepSelfImprove(input: CompileInput, opts: DeepSelfImproveOptions): Promise<{
+    readonly ranking: PatternRanking;
+    readonly compiled: CompiledContext;
+    readonly baseline: TunerBaseline;
+}>;
+export declare function formatLoopResult(result: LoopResult): string;