@vascend/talos 0.1.4 → 0.1.6

package/dist/core/agent.js

@@ -1,11 +1,13 @@
 import { contextLearningIdentity } from "../vascend/context-learning-identity.js";
 import { trackSessionUsage } from "./session-usage.js";
+import { nameSession } from "./session-naming.js";
 import { quotaResetAt } from "../providers/quota-limits.js";
 import { RequestBudget } from "./request-plan.js";
-import { projectToolResult, visibleOutputPages } from "./tool-artifacts.js";
+import { maxInputFor, resolveMaxTokens } from "./model-limits.js";
+import { projectToolResult, visibleOutputPages, boundHistoricalToolResults } from "./tool-artifacts.js";
 import { contextWindowFor, estimateMessagesTokens, estimateTokens, estimateToolDefinitionTokens, IMAGE_TOKEN_ESTIMATE, planCompaction, planCompactionMove, protectedExcerpts, repairInstructions, summarizeMessages, verifySummary, withProtectedExcerpts, } from "./compaction.js";
 import { RoomMemory, formatRoomRecord } from "../vascend/room-memory.js";
-import {} from "./context-ledger.js";
+import { buildContextLedger } from "./context-ledger.js";
 import { applyMediaEviction, applyToolResultDemotion, mediaBudgetPolicy, planMediaEviction, planToolResultDemotion, slimMessageForSession, toolIndexPolicy, EMPTY_PLAN, } from "./tool-result-index.js";
 import { createToolExecutor } from "./tool-executor.js";
 import { ToolOutputStore } from "./tool-result-store.js";
@@ -25,6 +27,7 @@ import { DecisionStore, promoteDecisions, decisionToRoomRecord } from "../vascen
 import { ContractStore, promoteContractChanges, contractToRoomRecord } from "../vascend/contract-memory.js";
 import { VascendPlanStore } from "../vascend/plan-store.js";
 import { pendingMembers, teamForSession, waitForTeamChange } from "../vascend/team-session.js";
+import { resolveKingdomBus } from "../vascend/kingdom-channel.js";
 import { getKingdomScribe } from "../vascend/kingdom-scribe.js";
 import { toolCompressOptions } from "./tool-compress.js";
 import { routeEffort, isRoutineBatch, effectiveToolName, effortRoutingEnabled } from "./effort.js";
@@ -38,14 +41,6 @@ import { RunTiming } from "./run-timing.js";
 import { queuedConfirmation } from "./permission-queue.js";
 import { workspaceMessageText, workspacePeersContext } from "./workspace-sessions.js";
 const CONTEXT_READ_TOOLS = new Set(["read_file", "glob", "grep", "list_dir", "recall", "output_page", "vascend_status", "ram_status", "file_activity", "workspace_sessions", "tool_search", "tool_list", "tool_describe", "bash_output"]);
-// Tetto di sicurezza ai turni di un singolo giro (anti-loop). Alto di default
-// (i goal Danilov multi-castello richiedono molti turni) e configurabile via
-// TALOS_MAX_TURNS. Al raggiungimento NON e' un errore fatale: il giro termina e
-// la validazione del regno sveglia l'agente sulle stanze ancora al buio.
-function maxTurns(env) {
-    const n = Number(env["TALOS_MAX_TURNS"]);
-    return Number.isFinite(n) && n > 0 ? n : 200;
-}
 // Quante volte auto-continuare un output troncato (stop=max_tokens) prima di
 // arrendersi e chiedere di spezzare il compito. Configurabile via
 // TALOS_MAX_AUTOCONTINUE. 0 = disabilita l'auto-continuazione.
@@ -152,9 +147,13 @@ function coerceParam(raw) {
     return raw.replace(/^\n/, "").replace(/\n$/, "");
 }
 // Esegue un giro completo: dato l'input utente, alterna chiamate al modello
-// ed esecuzione di tool finche' il modello non si ferma (o si raggiunge il
-// limite di turni / l'utente interrompe via signal).
+// ed esecuzione di tool finche' il modello non si ferma, si verifica un errore
+// o l'utente interrompe via signal. Nessun tetto al numero di turni.
 export async function runTurn(deps, userInput, sink, signal) {
+    if (deps.config.fusion && !deps.kingdom) {
+        const { runFusionTurn } = await import("../fusion/run.js");
+        return runFusionTurn(deps, userInput, sink, signal, runTurn);
+    }
     // Un collaboratore costruito copiando AgentDeps non assume l'identita'
     // della sessione principale: il team ha gia' il proprio canale dedicato.
     const channel = deps.workspaceSession?.owns(deps.config.cwd, deps.session.id, deps.executionTarget)
@@ -165,17 +164,31 @@ export async function runTurn(deps, userInput, sink, signal) {
     const timing = new RunTiming(deps.config.sessionDir, deps.session.id, deps.env ?? process.env);
     const releaseStorage = protectSessionStorage(deps.config.sessionDir, [deps.session.id, deps.config.roomStoreId, deps.config.planStoreId].filter((value) => Boolean(value)), deps.env ?? process.env, deps.config.cwd);
     let failed = false;
+    const namingController = new AbortController();
+    const abortNaming = () => namingController.abort();
+    signal.addEventListener("abort", abortNaming, { once: true });
+    if (signal.aborted)
+        abortNaming();
+    const naming = (deps.env ?? process.env)["TALOS_AUTO_TITLE"] === "1" && !deps.kingdom
+        ? nameSession(deps, text, sink, namingController.signal) : Promise.resolve();
     try {
         await runAgentLoop({ ...deps, workspaceSession: channel,
             provider: trackSessionUsage(timing.provider(deps.provider), deps.config.sessionDir, deps.session.id, sink),
             confirm: (action, detail) => timing.wait("permission", () => queuedConfirmation(deps.confirm, action, detail, signal)),
-        }, userInput, event => { timing.event(event); sink(event); }, signal);
+        }, userInput, event => {
+            if (event.type === "status" && event.label.startsWith("Limite sessione di 5 ore raggiunto"))
+                abortNaming();
+            timing.event(event);
+            sink(event);
+        }, signal);
     }
     catch (error) {
         failed = true;
         throw error;
     }
     finally {
+        await naming;
+        signal.removeEventListener("abort", abortNaming);
         timing.finish(signal.aborted, failed);
         channel?.update({ state: "idle" });
         releaseStorage();
@@ -257,6 +270,7 @@ userInput, sink, signal) {
     // recall plan, supersession). Fallback sicuro al Memory Packet grezzo se il
     // compiler fallisce per qualsiasi motivo, cosi' il turno non si rompe mai.
     const memoryScopeId = config.roomStoreId ?? session.id;
+    const sharedProjectMemory = env["TALOS_SHARED_PROJECT_MEMORY"] === "1";
     if (tools.compact) {
         runtimeSystem += `\n\n${COMPACT_TOOL_GUIDANCE}`;
         systemBlocks.push({ key: "tool-protocol", label: "Protocollo strumenti", text: COMPACT_TOOL_GUIDANCE, cacheable: true });
@@ -332,6 +346,10 @@ userInput, sink, signal) {
         systemBlocks.splice(stableBlockCount);
         turnBlocks.length = 0;
         turnBlockRecords.length = 0;
+        if (config.turnSystem) {
+            turnBlocks.push(config.turnSystem);
+            turnBlockRecords.push({ key: "host-instructions", label: "Istruzioni operative dell'host", text: config.turnSystem, cacheable: false });
+        }
         if (persistenceReminder)
             addTurnBlock(persistenceReminder, { key: "nudge", label: "Promemoria di persistenza" });
         // Il contesto dell'host non e' parte del system prompt ne' della cronologia:
@@ -352,12 +370,21 @@ userInput, sink, signal) {
                     cwd: config.cwd,
                     selection: config.vibeMode,
                     userText: latestUserText,
-                    inheritProjectFrame: sessionWasEmpty,
+                    inheritProjectFrame: sharedProjectMemory && sessionWasEmpty,
+                });
+            const inheritedFrame = fabric.frame.receipt?.inherited === true;
+            // Su una sessione vuota il frame appena creato deriva interamente dal
+            // messaggio corrente: reinviarlo come Fabric ripeterebbe lo stesso prompt
+            // in missione, contratto e revisioni. Il frame viene comunque persistito
+            // e sara' disponibile dal follow-up successivo.
+            const fabricBlock = horizonHost
+                ? renderHorizonFabricBlock(fabric)
+                : sessionWasEmpty && !inheritedFrame ? "" : fabric.systemBlock;
+            if (fabricBlock)
+                addTurnBlock(fabricBlock, {
+                    key: "fabric",
+                    label: "Frame di progetto (Context Fabric)",
                 });
-            addTurnBlock(horizonHost ? renderHorizonFabricBlock(fabric) : fabric.systemBlock, {
-                key: "fabric",
-                label: "Frame di progetto (Context Fabric)",
-            });
         }
         catch {
             // Context Fabric e' un acceleratore, non un single point of failure: uno
@@ -379,6 +406,7 @@ userInput, sink, signal) {
         compileBase = {
             sessionDir: config.sessionDir,
             scopeId: memoryScopeId,
+            sharedProjectMemory,
             ...(config.planStoreId ? { planScopeId: config.planStoreId } : {}),
             userText: fabric?.rawUserText ?? latestUserText,
             capsuleMarket: capsuleMarketEnabled(env),
@@ -395,6 +423,7 @@ userInput, sink, signal) {
         try {
             snapshot = loadContextStoreSnapshot({
                 sessionDir: config.sessionDir, scopeId: memoryScopeId,
+                sharedProjectMemory,
                 indexed: env["TALOS_CONTEXT_INDEX"] !== "0",
                 ...(config.planStoreId ? { planScopeId: config.planStoreId } : {}),
                 ...(fabric ? { projectKey: fabric.frame.projectKey } : {}),
@@ -462,12 +491,12 @@ userInput, sink, signal) {
         // dal turno) e fonde la config migliore nella baseline del progetto. Effetto
         // collaterale utile: lascia lo snapshot degli store caldo per il turno dopo.
         let memoryPacket = "";
-        if (!contextBlock || horizonHost) {
+        if (!contextBlock || horizonHost || sessionWasEmpty) {
             memoryPacket = compileInput.snapshot.packet(12_000);
         }
         if (!contextBlock)
             contextBlock = memoryPacket;
-        if (horizonHost && !shouldIncludeHorizonContextPack({
+        if (!shouldIncludeHorizonContextPack({
             sessionWasEmpty,
             inheritedFrame: fabric?.frame.receipt?.inherited === true,
             hasCompiledEvidence: Boolean(compiledContext?.report.cleaned.length),
@@ -512,6 +541,9 @@ userInput, sink, signal) {
     // Il blocco NON viene persistito nella sessione: la cronologia su disco resta
     // pulita e il prefisso inviato al modello resta byte-identico fra i turni.
     const turnMessage = session.append({ role: "user", content: userParts }).message;
+    if (deps.inputMessage)
+        sink({ type: "user_message", id: deps.inputMessage.id, text: userText,
+            at: Date.now(), ...(deps.inputMessage.immediate ? { immediate: true } : {}) });
     await host?.emit("agent_start", { input: userText });
     // Prende in carico i messaggi arrivati durante il turno: li appende come
     // messaggi utente veri (quindi entrano nel contesto del giro successivo) e
@@ -519,6 +551,7 @@ userInput, sink, signal) {
     // l'interfaccia mostra come "letto". Ritorna true se ne ha consumato almeno
     // uno, cosi' il chiamante sa che c'e' lavoro nuovo da servire.
     const receivedPeerMessages = new Set();
+    const notifiedTeamMessages = new Set();
     const consumeInbox = () => {
         const arrivals = deps.inbox?.drain() ?? [];
         if (arrivals.length) {
@@ -553,7 +586,6 @@ userInput, sink, signal) {
         }
         return arrivals.length > 0 || peerArrivals > 0;
     };
-    const turnCap = maxTurns(env);
     const requestBudget = new RequestBudget();
     const toolCompress = toolCompressOptions(env);
     // Archivio dei tool result: gli output voluminosi vengono indicizzati appena
@@ -577,7 +609,7 @@ userInput, sink, signal) {
     // Effort routing: i turni di routine (digestione di letture) abbassano il
     // reasoning; il primo turno e quelli con scrittura/errore tengono l'effort pieno.
     const baseEffort = (config.effort ?? "");
-    const effortRouting = effortRoutingEnabled(env);
+    const effortRouting = effortRoutingEnabled(env, provider.id);
     let routineBatch = false;
     // Auto-continuazione su output troncato: se il modello si ferma per
     // max_tokens (risposta tagliata al tetto), invece di chiudere la stanza con
@@ -588,6 +620,7 @@ userInput, sink, signal) {
     const completionRepairCap = maxCompletionRepairs(env);
     let emptyResponseRepairs = 0;
     let transientGuardContext = "";
+    let stepDirective = null;
     let planCompletionRepairs = 0;
     let planTouchedThisRun = false;
     let delegationObserved = false;
@@ -619,7 +652,28 @@ userInput, sink, signal) {
             ...openContractSymbols(deps),
         ].filter(Boolean)),
     ].slice(0, MAX_COMPACTION_ANCHORS);
-    for (let turn = 0; turn < turnCap; turn += 1) {
+    for (let turn = 0;; turn += 1) {
+        if (signal.aborted) {
+            await archiveCurrentRoom();
+            sink({ type: "error", message: "interrotto" });
+            await host?.emit("agent_end", {});
+            return;
+        }
+        // I comandi manuali mutano la cronologia solo dopo un batch completo di
+        // tool, mai durante provider/tool concorrenti. Non diventano prompt finti.
+        const compactions = deps.inbox?.drainCompactions?.() ?? [];
+        for (const request of compactions) {
+            try {
+                const compacted = await compactNow(deps, signal, sink, request.instructions, compactionAnchors());
+                contextDirty ||= compacted;
+                sink({ type: "status", category: "context", label: compacted
+                        ? "Contesto compattato; proseguo nella stessa sessione."
+                        : "Nessuna compattazione necessaria; contesto conservato." });
+            }
+            catch (err) {
+                sink({ type: "status", category: "context", label: `Compattazione non riuscita: ${err.message}; contesto conservato.` });
+            }
+        }
         if (signal.aborted) {
             await archiveCurrentRoom();
             sink({ type: "error", message: "interrotto" });
@@ -630,6 +684,7 @@ userInput, sink, signal) {
         if (env["TALOS_CONTEXT_LIVE"] !== "0") {
             try {
                 const currentSnapshot = loadContextStoreSnapshot({ sessionDir: config.sessionDir, scopeId: memoryScopeId,
+                    sharedProjectMemory,
                     ...(config.planStoreId ? { planScopeId: config.planStoreId } : {}),
                     ...(fabric ? { projectKey: fabric.frame.projectKey } : {}), indexed: env["TALOS_CONTEXT_INDEX"] !== "0" });
                 contextDirty ||= currentSnapshot.signature !== contextSignature;
@@ -650,7 +705,7 @@ userInput, sink, signal) {
         // persisted, including nested execute calls and updates from collaborators.
         if (completed.length && config.compaction.enabled && config.compaction.perRoom
             && policy.roomCompaction !== "never") {
-            const limits = workingContextLimits(policy, contextWindowFor(config.model, config.contextWindow), config.compaction.reserveTokens);
+            const limits = workingContextLimits(policy, contextWindowFor(config.model, config.contextWindow), config.compaction.reserveTokens, resolveMaxTokens(config.maxTokens, config.model), maxInputFor(config.model));
             const activeTokens = contextTokens(deps, runtimeSystem) + estimateTokens(turnContext)
                 - planDemotion(session.history()).freedTokens
                 - planMediaEviction({ messages: session.history(), policy: mediaBudget }).images * IMAGE_TOKEN_ESTIMATE;
@@ -683,6 +738,7 @@ userInput, sink, signal) {
         // successivo la sessione espone soltanto il riferimento testuale. Senza
         // questa proiezione ogni nuova richiesta reinviava lo stesso base64 (e gli
         // SVG storici potevano far fallire Anthropic per dimensioni nominali >8k).
+        messages = boundHistoricalToolResults(messages, outputStore, toolCompress);
         messages = projectHistoricalPromptImages(messages, turnMessage);
         // Budget delle immagini: le schermate vecchie lasciano la finestra. Prima
         // della retrocessione del testo, perche' e' la voce piu' pesante di tutte
@@ -753,7 +809,10 @@ userInput, sink, signal) {
                 : {}),
         };
         let streamedText = "";
-        const requestTurnContext = [turnContext, scopeGuidance, transientGuardContext, peerContext].filter(Boolean).join("\n\n");
+        stepDirective = deps.stepPolicy
+            ? await deps.stepPolicy.beforeStep({ step: turn, tools: tools.names(), signal }).catch(() => null) : null;
+        const requestTurnContext = [turnContext, scopeGuidance, transientGuardContext, peerContext, stepDirective?.guidance]
+            .filter(Boolean).join("\n\n");
         // I guard interni valgono per una sola richiesta provider e non devono
         // entrare nella cronologia come messaggi utente.
         transientGuardContext = "";
@@ -776,6 +835,7 @@ userInput, sink, signal) {
             onActivity: (label) => sink({ type: "status", label }),
             onReasoning: (delta) => sink({ type: "reasoning", delta }),
         }, ledgerInput);
+        sessionContextFrames.set(session, { ...ledgerInput, messages: undefined, now: undefined });
         sink({ type: "context_window", ledger: requestPlan.ledger });
         if (!requestPlan.fits) {
             sink({ type: "error", message: "Il contesto supera la finestra del modello anche dopo la compattazione. La sessione resta recuperabile." });
@@ -901,12 +961,21 @@ userInput, sink, signal) {
             // Ultimo controllo della casella prima di chiudere: se l'utente ha scritto
             // mentre il modello stava componendo la risposta, il turno prosegue invece
             // di terminare e costringerlo a un giro nuovo.
-            if (consumeInbox())
+            if (consumeInbox() || deps.inbox?.pendingCompactions)
                 continue;
             const activeTeam = delegationObserved ? teamForSession(session.id) : null;
             if (activeTeam && !activeTeam.done) {
                 sink({ type: "status", label: `team al lavoro: ${pendingMembers(activeTeam).join(", ")}; attendo avanzamento` });
-                await waitForTeamChange(activeTeam, signal, () => Boolean(deps.inbox?.pending));
+                const teamBus = resolveKingdomBus(process.env, config.sessionDir);
+                await waitForTeamChange(activeTeam, signal, () => {
+                    if (deps.inbox?.pending || deps.inbox?.pendingCompactions)
+                        return true;
+                    const unread = teamBus.peekInbox(activeTeam.id, deps.kingdom?.self || "orchestratore")
+                        .filter(message => !notifiedTeamMessages.has(`${activeTeam.id}:${message.seq}`));
+                    for (const message of unread)
+                        notifiedTeamMessages.add(`${activeTeam.id}:${message.seq}`);
+                    return unread.length > 0;
+                });
                 transientGuardContext = "[TALOS_TEAM_GUARD]\nIl team avviato deve ancora essere raccolto e verificato. "
                     + "Leggi team_report e team_inbox, rispondi ai blocchi e verifica i risultati prima della consegna. "
                     + "Non dichiarare concluso il lavoro solo perche' l'ingaggio e' partito.";
@@ -1042,6 +1111,10 @@ userInput, sink, signal) {
             // a indice di stanze, cosi' resta sempre compatto. Il dettaglio si
             // recupera col tool recall.
             await archiveCurrentRoom();
+            // L'archiviazione puo' attendere I/O: non perdere un invio o comando
+            // arrivato dopo il primo controllo della finale e prima del done.
+            if (consumeInbox() || deps.inbox?.pendingCompactions)
+                continue;
             sink({ type: "done" });
             await host?.emit("agent_end", {});
             return;
@@ -1049,6 +1122,7 @@ userInput, sink, signal) {
         // Esegue i tool richiesti e raccoglie i risultati in un turno "tool".
         const ctx = {
             cwd: config.cwd,
+            waitInterrupted: () => Boolean(deps.inbox?.pending || deps.inbox?.pendingCompactions),
             ...(deps.workspaceSession ? { workspaceSession: deps.workspaceSession } : {}),
             ...(deps.executionTarget ? { executionTarget: deps.executionTarget } : {}),
             ...(deps.fsRoots !== undefined ? { fsRoots: deps.fsRoots } : {}),
@@ -1077,6 +1151,9 @@ userInput, sink, signal) {
         const executeCall = createToolExecutor(ctx, {
             onCall: (call, parentId) => sink({ type: "tool_call", call, ...(parentId ? { parentId } : {}) }),
             before: async (call) => {
+                if (stepDirective?.admit && !stepDirective.admit(call.name)) {
+                    return { block: true, reason: stepDirective.rejection ?? "tool non ammesso in questo passo" };
+                }
                 let blocked;
                 for (const output of await host?.emit("tool_call", { toolName: call.name, input: { ...call.input } }) ?? []) {
                     if (output.block)
@@ -1127,6 +1204,9 @@ userInput, sink, signal) {
             results.push(part);
             sink({ type: "tool_result", result: part });
         }
+        deps.stepPolicy?.afterStep?.({ step: turn, final: false,
+            tools: toolCalls.map(call => effectiveToolName(call.name, call.input)),
+            errors: results.filter(result => result.isError).length });
         if (toolCalls.some((call, index) => PLAN_COMPLETION_TOOLS.has(effectiveToolName(call.name, call.input))
             && results[index]?.isError !== true)) {
             planTouchedThisRun = true;
@@ -1196,9 +1276,6 @@ Il piano ha ${collaborators.length} filoni `
                 transientGuardContext = [transientGuardContext, hint].filter(Boolean).join("\n\n");
         }
     }
-    await host?.emit("agent_end", {});
-    await archiveCurrentRoom();
-    sink({ type: "error", message: `pausa al tetto di ${turnCap} turni per questo giro (TALOS_MAX_TURNS per alzarlo); la validazione del piano riprende le attivita rimaste` });
 }
 // Archivia la stanza appena illuminata: costruisce il record Danilov dei nodi
 // di questo turno e lo persiste nella memoria delle stanze. L'archiviazione e'
@@ -1270,7 +1347,7 @@ async function archiveRoom(deps, roomStartHead, sink, policy, signal, anchors) {
     const firstKeptId = head;
     if (policy.roomCompaction === "threshold") {
         const window = contextWindowFor(config.model, config.contextWindow);
-        const limits = workingContextLimits(policy, window, config.compaction.reserveTokens);
+        const limits = workingContextLimits(policy, window, config.compaction.reserveTokens, resolveMaxTokens(config.maxTokens, config.model), maxInputFor(config.model));
         if (projectedContextTokens(deps) <= limits.checkpoint)
             return;
         await compactNow(deps, signal, sink, undefined, anchors);
@@ -1622,6 +1699,9 @@ function projectCompactionMessages(deps, messages) {
 // Compattazione gia' avviata e non ancora conclusa, per sessione. Single-flight:
 // due turni ravvicinati non devono riassumere due volte la stessa cronologia.
 const pendingCompaction = new WeakMap();
+// Ultima composizione runtime: una compattazione idle non deve misurare solo
+// la cronologia o usare l'usage cumulativo del provider come finestra attiva.
+const sessionContextFrames = new WeakMap();
 // Compatta se la soglia e' superata. No-op se disabilitata o non necessario.
 //
 // La compattazione e' il nodo piu' costoso del giro: una chiamata al modello
@@ -1642,7 +1722,7 @@ savedTokens = 0,
 system = deps.config.system) {
     const { compaction } = deps.config;
     const inFlight = pendingCompaction.get(deps.session);
-    const limits = workingContextLimits(contextPolicy(deps.env ?? process.env), contextWindowFor(deps.config.model, deps.config.contextWindow), compaction.reserveTokens);
+    const limits = workingContextLimits(contextPolicy(deps.env ?? process.env), contextWindowFor(deps.config.model, deps.config.contextWindow), compaction.reserveTokens, resolveMaxTokens(deps.config.maxTokens, deps.config.model), maxInputFor(deps.config.model));
     const move = planCompactionMove({
         enabled: compaction.enabled,
         // Il pack compilato e il contesto IDE sono effimeri e quindi non vivono
@@ -1697,8 +1777,8 @@ export async function compactNow(deps, signal, sink, instructions, anchors = [])
 async function performCompaction(deps, signal, sink, instructions, anchors = []) {
     const { session, config } = deps;
     const provider = trackSessionUsage(deps.provider, config.sessionDir, session.id, sink);
-    const fullChain = session.nodeChain();
     const previousCompaction = session.lastCompaction;
+    const fullChain = session.nodeChain(previousCompaction?.firstKeptId);
     const liveStart = previousCompaction
         ? fullChain.findIndex((node) => node.id === previousCompaction.firstKeptId)
         : 0;
@@ -1727,52 +1807,72 @@ async function performCompaction(deps, signal, sink, instructions, anchors = [])
         signal,
         ...(previousCompaction?.summary && liveStart >= 0 ? { previousSummary: previousCompaction.summary } : {}),
     };
-    let summary = await summarizeMessages(provider, plan.toSummarize, {
-        ...base,
-        ...(summaryInstructions ? { instructions: summaryInstructions } : {}),
-    });
-    if (!summary)
-        return false;
-    let missing = verifySummary(summary, anchors, plan.toKeep);
-    if (missing.length) {
-        const repaired = await summarizeMessages(provider, plan.toSummarize, {
+    sink({ type: "compacting" });
+    try {
+        let summary = await summarizeMessages(provider, plan.toSummarize, {
             ...base,
-            instructions: repairInstructions(missing, summaryInstructions),
+            ...(summaryInstructions ? { instructions: summaryInstructions } : {}),
         });
-        if (repaired) {
-            const stillMissing = verifySummary(repaired, anchors, plan.toKeep);
-            // Si tiene il tentativo migliore: quello che perde meno ancore.
-            if (stillMissing.length <= missing.length) {
-                summary = repaired;
-                missing = stillMissing;
-            }
-        }
-    }
-    // Ultima rete: cio' che il modello continua a non dire lo diciamo noi, con
-    // le sue stesse parole. Nelle compattazioni successive il summary precedente
-    // precede la live chain: protectedExcerpts cerca dall'ultimo elemento, quindi
-    // il dettaglio live piu' recente vince e il summary resta il fallback storico.
-    if (missing.length) {
+        if (!summary)
+            return false;
+        let missing = verifySummary(summary, anchors, plan.toKeep);
         const excerptSources = [
             ...(previousCompaction?.summary && liveStart >= 0
                 ? [{ role: "user", content: [{ type: "text", text: previousCompaction.summary }] }]
                 : []),
             ...plan.toSummarize,
         ];
-        summary = withProtectedExcerpts(summary, protectedExcerpts(excerptSources, missing));
+        if (missing.length) {
+            // Repair the existing summary with the missing evidence instead of
+            // sending the entire archived transcript to the model a second time.
+            const repairEvidence = [{ role: "user", content: [{
+                            type: "text", text: protectedExcerpts(excerptSources, missing).join("\n"),
+                        }] }];
+            const repaired = await summarizeMessages(provider, repairEvidence, {
+                ...base,
+                previousSummary: summary,
+                instructions: repairInstructions(missing, summaryInstructions),
+            });
+            if (repaired) {
+                const stillMissing = verifySummary(repaired, anchors, plan.toKeep);
+                // Si tiene il tentativo migliore: quello che perde meno ancore.
+                if (stillMissing.length <= missing.length) {
+                    summary = repaired;
+                    missing = stillMissing;
+                }
+            }
+        }
+        // Ultima rete: cio' che il modello continua a non dire lo diciamo noi, con
+        // le sue stesse parole. Nelle compattazioni successive il summary precedente
+        // precede la live chain: protectedExcerpts cerca dall'ultimo elemento, quindi
+        // il dettaglio live piu' recente vince e il summary resta il fallback storico.
+        if (missing.length) {
+            summary = withProtectedExcerpts(summary, protectedExcerpts(excerptSources, missing));
+        }
+        // A speculative summary may finish after new messages arrive. Keep that tail
+        // intact, but reject a result for a branch that is no longer current.
+        if (signal.aborted || session.lastCompaction !== previousCompaction
+            || !session.nodeChain(snapshotHead ?? undefined).some(node => node.id === snapshotHead))
+            return false;
+        const checkpoint = compactionCheckpoint(checkpointTasks(config, session.id, deps.kingdom?.self), messages, plan.cutIndex);
+        if (checkpoint)
+            summary += `\n\n${checkpoint}`;
+        session.compact(summary, firstKept.id, tokensBefore);
+        const tokensAfter = projectedContextTokens(deps);
+        sink({ type: "compacted", tokensBefore, tokensAfter, reason: "summary", ...(anchors.length ? { anchors: [...anchors] } : {}) });
+        const frame = sessionContextFrames.get(session);
+        sink({ type: "context_window", ledger: buildContextLedger({
+                model: config.model, contextWindow: config.contextWindow, reserveTokens: config.compaction.reserveTokens,
+                workingContextTokens: contextPolicy(deps.env ?? process.env).workingContextTokens,
+                system: config.system, ...frame, tools: deps.tools.defs(),
+                messages: projectCompactionMessages(deps, session.history()), demoted: null,
+                compaction: { ts: session.lastCompaction.ts, tokensBefore, summary },
+            }) });
+        return true;
+    }
+    finally {
+        sink({ type: "compaction_end" });
     }
-    // A speculative summary may finish after new messages arrive. Keep that tail
-    // intact, but reject a result for a branch that is no longer current.
-    if (signal.aborted || session.lastCompaction !== previousCompaction
-        || !session.nodeChain().some(node => node.id === snapshotHead))
-        return false;
-    const checkpoint = compactionCheckpoint(checkpointTasks(config, session.id, deps.kingdom?.self), messages, plan.cutIndex);
-    if (checkpoint)
-        summary += `\n\n${checkpoint}`;
-    session.compact(summary, firstKept.id, tokensBefore);
-    const tokensAfter = projectedContextTokens(deps);
-    sink({ type: "compacted", tokensBefore, tokensAfter, reason: "summary", ...(anchors.length ? { anchors: [...anchors] } : {}) });
-    return true;
 }
 // Modello del compattatore: riassumere e' un lavoro meccanico e non ha bisogno
 // del modello di punta. TALOS_COMPACT_MODEL permette di dirottarlo su uno piu'

package/dist/core/background.d.ts

@@ -13,14 +13,16 @@ export interface BgTask {
 }
 interface Foreground {
     readonly taskId: string;
+    readonly sessionId?: string;
     background(): void;
 }
 export declare class BackgroundManager {
     private readonly tasks;
     private readonly children;
     private readonly order;
+    private readonly completedOrder;
     private seq;
-    private fg;
+    private readonly foregrounds;
     private readonly changeCbs;
     private readonly finishCbs;
     createTask(command: string): BgTask;
@@ -29,11 +31,16 @@ export declare class BackgroundManager {
     finishTask(id: string, status: BgStatus, exitCode?: number): void;
     setForeground(fg: Foreground): void;
     clearForeground(id?: string): void;
-    hasForeground(): boolean;
+    private foreground;
+    hasForeground(sessionId?: string): boolean;
     markDetached(id: string): void;
-    requestBackground(): BgTask | null;
+    requestBackground(sessionId?: string): BgTask | null;
     kill(id: string): boolean;
     get(id: string): BgTask | undefined;
+    waitForTask(id: string, signal: AbortSignal, options?: {
+        readonly timeoutMs?: number;
+        readonly interrupted?: () => boolean;
+    }): Promise<void>;
     list(): readonly BgTask[];
     running(): readonly BgTask[];
     onChange(cb: () => void): () => void;

package/dist/core/background.js

@@ -25,8 +25,9 @@ export class BackgroundManager {
     tasks = new Map();
     children = new Map();
     order = [];
+    completedOrder = [];
     seq = 0;
-    fg = null;
+    foregrounds = new Map();
     changeCbs = new Set();
     finishCbs = new Set();
     createTask(command) {
@@ -56,6 +57,7 @@ export class BackgroundManager {
         t.endedAt = Date.now();
         if (exitCode !== undefined)
             t.exitCode = exitCode;
+        this.completedOrder.push(id);
         this.children.delete(id);
         this.emitChange();
         for (const cb of this.finishCbs)
@@ -63,10 +65,17 @@ export class BackgroundManager {
         this.pruneHistory(id);
     }
     // Registra il comando in primo piano (chiamato dal tool bash all'avvio).
-    setForeground(fg) { this.fg = fg; }
-    clearForeground(id) { if (!id || this.fg?.taskId === id)
-        this.fg = null; }
-    hasForeground() { return this.fg !== null; }
+    setForeground(fg) { this.foregrounds.set(fg.taskId, fg); }
+    clearForeground(id) {
+        if (id)
+            this.foregrounds.delete(id);
+        else
+            this.foregrounds.clear();
+    }
+    foreground(sessionId) {
+        return [...this.foregrounds.values()].findLast(fg => sessionId === undefined || fg.sessionId === sessionId);
+    }
+    hasForeground(sessionId) { return !!this.foreground(sessionId); }
     markDetached(id) {
         const task = this.tasks.get(id);
         if (task && !task.detached) {
@@ -76,11 +85,11 @@ export class BackgroundManager {
     }
     // Ctrl+B: stacca il comando in primo piano. Ritorna il task o null se non c'e'
     // niente in primo piano.
-    requestBackground() {
-        const fg = this.fg;
+    requestBackground(sessionId) {
+        const fg = this.foreground(sessionId);
         if (!fg)
             return null;
-        this.fg = null;
+        this.foregrounds.delete(fg.taskId);
         const t = this.tasks.get(fg.taskId);
         if (t)
             t.detached = true;
@@ -97,6 +106,41 @@ export class BackgroundManager {
         return true;
     }
     get(id) { return this.tasks.get(id); }
+    // Wait in the host, without asking the model to poll unchanged output.
+    // Keep the task reference alive even if completed history is pruned.
+    async waitForTask(id, signal, options = {}) {
+        signal.throwIfAborted();
+        const task = this.tasks.get(id);
+        if (!task || task.status !== "running" || options.interrupted?.())
+            return;
+        await new Promise((resolve, reject) => {
+            let timeout;
+            let interruptCheck;
+            const cleanup = () => {
+                unsubscribe();
+                signal.removeEventListener("abort", abort);
+                clearTimeout(timeout);
+                clearInterval(interruptCheck);
+            };
+            const finish = () => { cleanup(); resolve(); };
+            const abort = () => { cleanup(); reject(signal.reason); };
+            const unsubscribe = this.onFinish(completed => { if (completed.id === id)
+                finish(); });
+            signal.addEventListener("abort", abort, { once: true });
+            if (options.timeoutMs !== undefined)
+                timeout = setTimeout(finish, options.timeoutMs);
+            // Only check local user input; elapsed time/output never wakes the model.
+            if (options.interrupted)
+                interruptCheck = setInterval(() => {
+                    if (options.interrupted?.())
+                        finish();
+                }, 100);
+            if (signal.aborted)
+                abort();
+            else if (task.status !== "running")
+                finish();
+        });
+    }
     list() {
         // Ogni comando shell nasce come candidato al Ctrl+B, ma diventa davvero
         // un'attivita' in background soltanto quando l'utente lo stacca. Esporre
@@ -111,7 +155,7 @@ export class BackgroundManager {
     emitChange() { for (const cb of this.changeCbs)
         cb(); }
     pruneHistory(latestId) {
-        const completedDetached = this.order.filter((id) => {
+        const completedDetached = this.completedOrder.filter((id) => {
             const task = this.tasks.get(id);
             return Boolean(task?.detached && task.status !== "running");
         });
@@ -134,6 +178,8 @@ export class BackgroundManager {
         }
         const retainedOrder = this.order.filter((id) => keep.has(id));
         this.order.splice(0, this.order.length, ...retainedOrder);
+        const retainedCompleted = this.completedOrder.filter(id => keep.has(id));
+        this.completedOrder.splice(0, this.completedOrder.length, ...retainedCompleted);
     }
 }
 // Istanza condivisa di processo.

package/dist/core/bootstrap.js

@@ -278,6 +278,7 @@ export async function bootstrap(opts) {
             const runConfig = { ...config, model: resolved.modelId };
             return {
                 provider: resolved.provider,
+                ...(config.fusion ? { fusionHarness: harness } : {}),
                 tools,
                 session,
                 config: runConfig,