@vascend/talos 0.1.0

package/dist/horizon/main-team.js

@@ -0,0 +1,774 @@
+import { AsyncQueue } from "./async-queue.js";
+import { HorizonEngine } from "./engine.js";
+import { FileCoordinationHub, fileActor, withFileActor } from "../core/file-coordination.js";
+import { normalizeExecutionTarget } from "../core/execution-target.js";
+class MainExchangeBus {
+    onExchange;
+    sequence = 0;
+    messages = [];
+    waiters = new Set();
+    constructor(onExchange) {
+        this.onExchange = onExchange;
+    }
+    post(from, to, text) {
+        const exchange = {
+            seq: ++this.sequence,
+            from,
+            to,
+            text: String(text || "").trim().slice(0, 8_000),
+            at: Date.now(),
+        };
+        if (!exchange.text)
+            throw new TypeError("il messaggio tra agenti non puo' essere vuoto");
+        this.messages.push(exchange);
+        if (this.messages.length > 500)
+            this.messages.splice(0, this.messages.length - 500);
+        this.onExchange(exchange);
+        this.flushWaiters();
+        return exchange;
+    }
+    recall(agent, from, limit = 12) {
+        const cap = Math.max(1, Math.min(50, Math.trunc(limit) || 12));
+        return this.messages
+            .filter((message) => message.from !== agent
+            && (message.to === "all" || message.to === agent)
+            && (!from || message.from === from))
+            .slice(-cap);
+    }
+    wait(agent, from, timeoutMs = 15_000) {
+        const ready = this.recall(agent, from);
+        if (ready.length)
+            return Promise.resolve(ready);
+        return new Promise((resolve) => {
+            const waiter = {
+                agent,
+                ...(from ? { from } : {}),
+                resolve,
+                timer: setTimeout(() => {
+                    this.waiters.delete(waiter);
+                    resolve([]);
+                }, Math.max(100, Math.min(60_000, Math.trunc(timeoutMs) || 15_000))),
+            };
+            this.waiters.add(waiter);
+        });
+    }
+    history() {
+        return this.messages.slice();
+    }
+    close() {
+        for (const waiter of this.waiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve([]);
+        }
+        this.waiters.clear();
+    }
+    flushWaiters() {
+        for (const waiter of [...this.waiters]) {
+            const ready = this.recall(waiter.agent, waiter.from);
+            if (!ready.length)
+                continue;
+            clearTimeout(waiter.timer);
+            this.waiters.delete(waiter);
+            waiter.resolve(ready);
+        }
+    }
+}
+const DEFAULT_RUNTIME = undefined;
+export class HorizonMainTeam {
+    options;
+    runtime;
+    engines = new Map();
+    activeTurns = new Map();
+    config;
+    sequence = 0;
+    decisionSequence = 0;
+    guideDecisionTail = Promise.resolve();
+    supervision = null;
+    closed = false;
+    constructor(options, config, runtime) {
+        this.options = options;
+        this.runtime = runtime;
+        this.config = normalizeMainTeamConfig(config);
+    }
+    static async create(options, config = {}, runtime = DEFAULT_RUNTIME) {
+        const cwd = String(options.cwd || process.cwd());
+        const coordinated = options.fileCoordination ? options : {
+            ...options,
+            fileCoordination: {
+                hub: new FileCoordinationHub(cwd, normalizeExecutionTarget(options.executionTarget)),
+                actor: fileActor(`horizon:team:${Date.now().toString(36)}`, "Horizon", "main"),
+            },
+        };
+        const team = new HorizonMainTeam(coordinated, config, runtime);
+        try {
+            await team.initialize();
+            return team;
+        }
+        catch (error) {
+            // Se r2/guida non riescono a riprendere la propria sessione, r1 puo'
+            // essere gia' stato creato. Chiudilo prima di propagare l'errore: il
+            // Terminal fara' un solo recovery controllato senza lasciare engine
+            // orfani nel processo.
+            await team.close();
+            throw error;
+        }
+    }
+    startTurn(input) {
+        if (this.closed)
+            throw new Error("main team Horizon chiuso");
+        if (this.activeTurns.size)
+            throw new Error("un turno main team e' gia' in corso");
+        const teamId = `mt-${Date.now().toString(36)}-${(++this.sequence).toString(36)}`;
+        const id = `${teamId}:turn`;
+        const queue = new AsyncQueue();
+        const mains = this.mainRefs();
+        let aborted = false;
+        let bus;
+        const emit = (event) => queue.push(event);
+        bus = new MainExchangeBus((exchange) => emit({ type: "exchange", teamId, exchange }));
+        this.bindTeamTools(bus);
+        const supervision = { original: input, emit, bus, decisions: [] };
+        if (this.config.guide)
+            this.supervision = supervision;
+        const done = (async () => {
+            emit({ type: "team_start", teamId, agents: mains, names: this.config.names, guide: this.config.guide });
+            const outputs = {};
+            let plan;
+            let review;
+            let status = "completed";
+            let error;
+            try {
+                if (this.config.guide) {
+                    plan = await this.plan(input, mains, 0, emit);
+                    supervision.plan = plan;
+                    emit({ type: "plan", round: 0, plan });
+                }
+                const first = await Promise.all(mains.map(async (agent) => {
+                    const assignedInput = plan
+                        ? assignmentPrompt(input, plan, agent, this.config.names)
+                        : input;
+                    const result = await this.runAgent(agent, assignedInput, 0, emit);
+                    outputs[agent] = result.text;
+                    return result;
+                }));
+                const failed = first.find((item) => item.result.status !== "completed");
+                if (failed) {
+                    status = failed.result.status;
+                    error = failed.result.error;
+                }
+                if (!aborted && status === "completed" && mains.length === 2) {
+                    const consolidated = await this.runAgent("r1", consolidationPrompt(outputs.r1 || "", outputs.r2 || "", bus.history()), 0, emit);
+                    outputs.r1 = completedAgentText(consolidated, "consolidamento r1");
+                }
+                for (let round = 1; !aborted && status === "completed" && this.config.guide && round <= this.config.reviewRounds + 1; round += 1) {
+                    review = await this.review(input, outputs, bus.history(), round, emit);
+                    emit({ type: "review", round, verdict: review });
+                    if (review.approved)
+                        break;
+                    if (round > this.config.reviewRounds) {
+                        status = "failed";
+                        error = `Revisione della guida non approvata: budget esaurito al round ${round}. ${review.summary}`;
+                        break;
+                    }
+                    const corrections = mains.filter((agent) => String(review?.actions[agent] || "").trim());
+                    if (!corrections.length) {
+                        status = "failed";
+                        error = `Revisione della guida non approvata: nessuna azione correttiva eseguibile. ${review.summary}`;
+                        break;
+                    }
+                    const corrected = await Promise.all(corrections.map(async (agent) => {
+                        const action = review?.actions[agent] || review?.summary || "Verifica e completa il lavoro.";
+                        const result = await this.runAgent(agent, correctionPrompt(action, review?.summary || "", bus.history()), round, emit);
+                        outputs[agent] = result.text;
+                        return result;
+                    }));
+                    const failedCorrection = corrected.find((item) => item.result.status !== "completed");
+                    if (failedCorrection) {
+                        status = failedCorrection.result.status;
+                        error = failedCorrection.result.error;
+                        break;
+                    }
+                    if (mains.length === 2) {
+                        const consolidated = await this.runAgent("r1", consolidationPrompt(outputs.r1 || "", outputs.r2 || "", bus.history()), round, emit);
+                        outputs.r1 = completedAgentText(consolidated, "consolidamento r1");
+                    }
+                }
+            }
+            catch (cause) {
+                status = aborted ? "aborted" : "failed";
+                error = cause instanceof Error ? cause.message : String(cause);
+            }
+            finally {
+                bus.close();
+                if (this.supervision === supervision)
+                    this.supervision = null;
+                this.activeTurns.clear();
+                emit({ type: "team_end", teamId, status });
+                queue.close();
+            }
+            return {
+                id,
+                teamId,
+                status,
+                text: outputs.r1 || outputs.r2 || "",
+                sessions: {
+                    r1: this.engines.get("r1")?.session.id || null,
+                    r2: this.engines.get("r2")?.session.id || null,
+                },
+                names: this.config.names,
+                outputs,
+                exchanges: bus.history(),
+                decisions: supervision.decisions.slice(),
+                ...(plan ? { plan } : {}),
+                ...(review ? { review } : {}),
+                ...(error ? { error } : {}),
+            };
+        })();
+        return {
+            id,
+            teamId,
+            events: queue,
+            done,
+            abort: () => {
+                if (aborted || !this.activeTurns.size)
+                    return false;
+                aborted = true;
+                for (const turn of this.activeTurns.values())
+                    turn.abort();
+                return true;
+            },
+            send: (message, messageId) => this.activeTurns.get("r1")?.send(message, messageId) ?? null,
+            prioritize: (messageId) => this.activeTurns.get("r1")?.prioritize(messageId) ?? false,
+        };
+    }
+    modelCatalog() {
+        const engine = this.engines.get("r1");
+        if (!engine)
+            throw new Error("main agent r1 non disponibile");
+        return engine.modelCatalog();
+    }
+    contextStatus() {
+        const engine = this.engines.get("r1");
+        if (!engine)
+            throw new Error("main agent r1 non disponibile");
+        return engine.contextStatus();
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const turn of this.activeTurns.values())
+            turn.abort();
+        await Promise.all([...this.engines.values()].map((engine) => engine.close()));
+        this.activeTurns.clear();
+        this.engines.clear();
+    }
+    async initialize() {
+        for (const ref of this.mainRefs()) {
+            this.engines.set(ref, await this.createEngine(ref));
+        }
+        if (this.config.guide)
+            this.engines.set("guide", await this.createEngine("guide"));
+    }
+    async createEngine(ref) {
+        const originalConfigure = this.options.configureHarness;
+        const originalConfirm = this.options.confirm;
+        const engineOptions = {
+            ...this.options,
+            ...(this.options.fileCoordination ? {
+                fileCoordination: withFileActor(this.options.fileCoordination, fileActor(`${this.options.fileCoordination.actor.id}:${ref}`, ref === "guide" ? "Guida" : this.config.names[ref], "main")),
+            } : {}),
+            ...(ref !== "r1" ? {
+                model: ref === "r2" && this.config.peerModel ? this.config.peerModel : this.options.model,
+                sessionId: ref === "r2" && this.config.peerSessionId ? this.config.peerSessionId : undefined,
+                continueLast: false,
+                sessionName: `Horizon ${ref}`,
+            } : {}),
+            ...(ref === "guide" ? {
+                confirm: async (action, detail) => {
+                    if (GUIDE_MUTATION_TOOLS.has(action))
+                        return false;
+                    return originalConfirm ? originalConfirm(action, detail) : false;
+                },
+            } : ref === "r1" || ref === "r2" ? {
+                confirm: async (action, detail) => {
+                    if (this.config.guide && needsGuideArbitration(action, detail)) {
+                        const decision = await this.arbitrate(ref, action, detail, "automatic-gate");
+                        if (!decision.approved)
+                            return false;
+                    }
+                    return originalConfirm ? originalConfirm(action, detail) : false;
+                },
+            } : {}),
+            configureHarness: async (harness) => {
+                await originalConfigure?.(harness);
+                if (ref === "guide") {
+                    for (const name of GUIDE_MUTATION_TOOLS)
+                        harness.tools.remove(name);
+                }
+                harness.config = {
+                    ...harness.config,
+                    system: `${harness.config.system}\n\n${teamSystemBlock(ref, this.config.agents, this.config.names, this.config.guide)}`,
+                };
+            },
+        };
+        return this.runtime
+            ? HorizonEngine.create(engineOptions, this.runtime)
+            : HorizonEngine.create(engineOptions);
+    }
+    bindTeamTools(bus) {
+        for (const ref of this.mainRefs()) {
+            const engine = this.engines.get(ref);
+            const harness = engine ? engineHarness(engine) : null;
+            if (!harness)
+                continue;
+            registerTeamTools(harness, ref, bus, this.config.guide
+                ? (proposal) => this.arbitrate(ref, proposal.action, proposal.proposal, "agent-request")
+                : undefined);
+        }
+    }
+    mainRefs() {
+        return this.config.agents === 2 ? ["r1", "r2"] : ["r1"];
+    }
+    async runAgent(agent, input, round, emit, purpose = "work") {
+        const engine = this.engines.get(agent);
+        if (!engine)
+            throw new Error(`engine ${agent} non disponibile`);
+        const name = agent === "guide" ? "Guida" : this.config.names[agent];
+        emit({ type: "agent_start", agent, name, round, purpose });
+        // Ogni main riceve una capability filesystem propria e mutabile per il
+        // singolo turno. Il bootstrap conserva invece una snapshot readonly:
+        // con due engine non va condivisa né mutata durante i grant dinamici.
+        const turn = engine.startTurn(input, {
+            ...(this.options.fsRoots !== undefined ? { fsRoots: [...this.options.fsRoots] } : {}),
+        });
+        this.activeTurns.set(agent, turn);
+        let text = "";
+        for await (const event of turn.events) {
+            if (event.type === "text")
+                text += event.delta;
+            emit({ type: "agent_event", agent, round, purpose, event });
+        }
+        const result = await turn.done;
+        this.activeTurns.delete(agent);
+        emit({ type: "agent_end", agent, name, round, status: result.status, output: text.trim().slice(0, 16_000) });
+        return { text: text.trim(), result };
+    }
+    async review(original, outputs, exchanges, round, emit) {
+        const raw = await this.runAgent("guide", guidePrompt(original, outputs, exchanges), round, emit, "review");
+        return parseGuideVerdict(completedAgentText(raw, "review della guida"));
+    }
+    async plan(original, mains, round, emit) {
+        const raw = await this.runAgent("guide", guidePlanningPrompt(original, mains, this.config.names), round, emit, "plan");
+        return parseGuidePlan(completedAgentText(raw, "pianificazione della guida"), mains);
+    }
+    arbitrate(agent, action, proposal, source) {
+        const run = async () => {
+            const active = this.supervision;
+            const request = {
+                id: `gd-${(++this.decisionSequence).toString(36)}`,
+                agent,
+                agentName: this.config.names[agent],
+                action: cleanPlanText(action, "decisione operativa", 160),
+                proposal: cleanPlanText(proposal, "", 8_000),
+                source,
+                at: Date.now(),
+            };
+            if (!active || !this.config.guide) {
+                return {
+                    requestId: request.id,
+                    approved: false,
+                    risk: "high",
+                    reason: "La Guida non e' disponibile nel turno corrente.",
+                    guidance: "Non procedere e chiedere indicazioni all'utente.",
+                };
+            }
+            active.emit({ type: "decision", phase: "requested", request });
+            const raw = await this.runAgent("guide", guideDecisionPrompt(active.original, active.plan, active.bus.history(), request), 1000 + this.decisionSequence, active.emit, "decision");
+            const decision = parseGuideDecision(completedAgentText(raw, "decisione della guida"), request.id);
+            active.decisions.push({ request, decision });
+            if (active.decisions.length > 100)
+                active.decisions.splice(0, active.decisions.length - 100);
+            active.emit({ type: "decision", phase: "resolved", request, decision });
+            return decision;
+        };
+        const result = this.guideDecisionTail.then(run, run);
+        this.guideDecisionTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+function completedAgentText(run, phase) {
+    if (run.result.status === "completed")
+        return run.text;
+    throw new Error(run.result.error?.trim()
+        || `${phase} interrotto (${run.result.status}); il risultato parziale non e' valido`);
+}
+const GUIDE_MUTATION_TOOLS = new Set([
+    "bash",
+    "write_file",
+    "edit_file",
+    "apply_patch",
+    "image_generate",
+    "kingdoms_warm",
+    "vascend_plan",
+    "vascend_addtasks",
+    "vascend_mark",
+]);
+function normalizeMainTeamConfig(config) {
+    return {
+        agents: config.agents === 2 ? 2 : 1,
+        guide: config.guide === true,
+        reviewRounds: Math.max(0, Math.min(2, Math.trunc(config.reviewRounds ?? 1))),
+        peerSessionId: String(config.peerSessionId || "").trim(),
+        peerModel: String(config.peerModel || "").trim(),
+        names: {
+            r1: normalizeAgentName(config.names?.r1, "Main 1"),
+            r2: normalizeAgentName(config.names?.r2, "Main 2"),
+        },
+    };
+}
+function normalizeAgentName(value, fallback) {
+    const clean = String(value || "").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+    return clean ? clean.slice(0, 48) : fallback;
+}
+// HorizonEngine mantiene intenzionalmente l'harness privato. Il team e' parte
+// dello stesso facade core e usa questo accesso confinato solo per registrare i
+// tre tool di coordinamento dopo aver creato il bus del singolo turno.
+function engineHarness(engine) {
+    return engine.harness ?? null;
+}
+function registerTeamTools(harness, self, bus, askGuide) {
+    const peer = self === "r1" ? "r2" : "r1";
+    const requestGuideDecision = askGuide;
+    if (requestGuideDecision)
+        harness.tools.register({
+            name: "main_team_send",
+            description: `Invia un aggiornamento al main agent ${peer}. Usalo per dichiarare ownership, decisioni, blocchi e risultati prima di modifiche potenzialmente sovrapposte.`,
+            schema: {
+                type: "object",
+                properties: {
+                    to: { type: "string", enum: [peer, "all"] },
+                    message: { type: "string" },
+                },
+                required: ["to", "message"],
+            },
+            handler: async (input) => JSON.stringify(bus.post(self, input["to"] === "all" ? "all" : peer, String(input["message"] || ""))),
+        });
+    harness.tools.register({
+        name: "main_team_recall",
+        description: `Richiama gli ultimi messaggi scambiati con ${peer}. Il riferimento stabile di questo agente e' ${self}.`,
+        schema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", enum: [peer] },
+                limit: { type: "number" },
+            },
+        },
+        handler: async (input) => JSON.stringify(bus.recall(self, peer, Number(input["limit"]) || 12), null, 2),
+    });
+    harness.tools.register({
+        name: "main_team_wait",
+        description: `Attende un aggiornamento di ${peer} senza importare la sua cronologia completa.`,
+        schema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", enum: [peer] },
+                timeout_ms: { type: "number" },
+            },
+        },
+        handler: async (input) => JSON.stringify(await bus.wait(self, peer, Number(input["timeout_ms"]) || 15_000), null, 2),
+    });
+    harness.tools.register({
+        name: "main_team_ask_guide",
+        description: "Sottopone alla Guida una scelta operativa prima di agire. Obbligatorio per azioni distruttive, deviazioni dal piano, takeover del lavoro del peer, processi pesanti o alternative con trade-off rilevanti.",
+        schema: {
+            type: "object",
+            properties: {
+                action: { type: "string", description: "Nome breve della decisione" },
+                proposal: { type: "string", description: "Cosa vuoi fare, perche', impatto, alternative e rollback" },
+            },
+            required: ["action", "proposal"],
+        },
+        handler: async (input) => JSON.stringify(await requestGuideDecision({
+            action: String(input["action"] || "decisione operativa"),
+            proposal: String(input["proposal"] || ""),
+        }), null, 2),
+    });
+}
+function teamSystemBlock(ref, agents, names, guide) {
+    if (ref === "guide") {
+        return [
+            "[HORIZON_GUIDE]",
+            "role=autonomous-supervisor; first design and assign precise work, later review evidence and the actual workspace",
+            "policy=do not implement or execute shell commands yourself; use read/search/browser tools and agent evidence to plan, arbitrate or verify",
+            "output=return only the JSON schema explicitly requested by the current planning or review prompt",
+            "[/HORIZON_GUIDE]",
+        ].join("\n");
+    }
+    const peer = ref === "r1" ? "r2" : "r1";
+    return [
+        "[HORIZON_MAIN_TEAM]",
+        `identity=${ref}; display_name=${names[ref]}; class=main-agent; peer_count=${agents}; peer=${agents === 2 ? peer : "none"}; peer_name=${agents === 2 ? names[peer] : "none"}`,
+        "hierarchy=peer; you are a team member",
+        agents === 2
+            ? "coordination=before overlapping edits send ownership and plan with main_team_send; use main_team_recall/main_team_wait instead of assuming peer state"
+            : "coordination=single main agent",
+        ...(guide ? [
+            "supervision=before destructive actions, high-resource local jobs, plan deviations, peer takeover or material trade-offs call main_team_ask_guide and obey its verdict",
+            "safety=the guide can deny or redirect an action; never disguise or split a denied action to bypass supervision",
+        ] : []),
+        "context_policy=only explicit bus exchanges are shared; never assume access to the peer private transcript",
+        ref === "r1"
+            ? "delivery=you own the single final response after incorporating useful peer evidence"
+            : "delivery=work as an equal main agent; send findings, changed files, tests and blockers to r1",
+        "[/HORIZON_MAIN_TEAM]",
+    ].join("\n");
+}
+function exchangeDigest(exchanges) {
+    const maxChars = 24_000;
+    const rows = [];
+    let used = 0;
+    // Gli scambi completi restano nella sessione/UI; ai prompt successivi passa
+    // un working set recente e bounded, altrimenti 40 messaggi da 8k possono
+    // aggiungere ~80k token a ogni revisione della Guida.
+    for (const item of exchanges.slice(-40).reverse()) {
+        const body = item.text.length > 1_200 ? `${item.text.slice(0, 1_200)}…` : item.text;
+        const row = `[${item.seq}] ${item.from}->${item.to}: ${body}`;
+        if (used + row.length + 1 > maxChars)
+            break;
+        rows.push(row);
+        used += row.length + 1;
+    }
+    return rows.reverse().join("\n") || "(nessuno scambio)";
+}
+function consolidationPrompt(r1, r2, exchanges) {
+    return [
+        "Consolida ora il lavoro dei due main agent. Verifica lo stato reale del workspace e completa soltanto cio' che manca.",
+        "Restituisci una singola risposta finale all'utente, concreta e senza parlare di transcript interni.",
+        `OUTPUT R1:\n${r1.slice(-24_000)}`,
+        `OUTPUT R2:\n${r2.slice(-24_000)}`,
+        `SCAMBI ESPLICITI:\n${exchangeDigest(exchanges)}`,
+    ].join("\n\n");
+}
+function correctionPrompt(action, summary, exchanges) {
+    return [
+        "La guida autonoma ha rilevato lavoro incompleto. Continua sul workspace reale, applica le correzioni e verifica con test proporzionati.",
+        `AZIONE ASSEGNATA:\n${action}`,
+        `VERDETTO:\n${summary}`,
+        `SCAMBI MAIN:\n${exchangeDigest(exchanges)}`,
+    ].join("\n\n");
+}
+function guidePrompt(original, outputs, exchanges) {
+    const goal = typeof original === "string"
+        ? original
+        : original.map((part) => part.type === "text" ? part.text : `[${part.type}]`).join("\n");
+    return [
+        "Revisiona autonomamente l'operato dei main agent rispetto alla richiesta.",
+        "Controlla il workspace con strumenti read-only e valuta gli esiti dei test prodotti dai main agent. Non fidarti soltanto dei loro riassunti.",
+        "Se il lavoro non e' completo, assegna un'azione concreta a r1 e/o r2. Rispondi esclusivamente nel JSON richiesto dal system.",
+        `RICHIESTA:\n${goal.slice(-30_000)}`,
+        `OUTPUT R1:\n${String(outputs.r1 || "").slice(-20_000)}`,
+        `OUTPUT R2:\n${String(outputs.r2 || "").slice(-20_000)}`,
+        `SCAMBI:\n${exchangeDigest(exchanges)}`,
+    ].join("\n\n");
+}
+function guideDecisionPrompt(original, plan, exchanges, request) {
+    const goal = typeof original === "string"
+        ? original
+        : original.map((part) => part.type === "text" ? part.text : `[${part.type}]`).join("\n");
+    const assigned = plan?.assignments[request.agent] ?? [];
+    return [
+        "Agisci come supervisore umano del run: valuta questa scelta PRIMA che venga eseguita.",
+        "Non limitarti a verificare se il comando e' tecnicamente possibile. Rifletti su necessita', proporzionalita', coerenza col piano, ownership, perdita dati, costo di CPU/RAM/tempo, concorrenza, rollback e alternative piu' sicure.",
+        "Nega idee bizzarre, non motivate, distruttive o duplicate. Approva solo quando l'azione serve davvero all'obiettivo ed e' confinata e recuperabile. Se mancano evidenze, nega e indica quali controlli read-only fare prima.",
+        "L'approvazione non sostituisce mai i permessi dell'utente.",
+        "Rispondi esclusivamente con JSON: {\"approved\":boolean,\"risk\":\"low|medium|high|critical\",\"reason\":string,\"guidance\":string}",
+        `OBIETTIVO UTENTE:\n${goal.slice(-24_000)}`,
+        `AGENTE PROPONENTE: ${request.agentName} (${request.agent})`,
+        `AZIONE: ${request.action}`,
+        `PROPOSTA E MOTIVAZIONE:\n${request.proposal}`,
+        `TASK ASSEGNATI:\n${assigned.length
+            ? assigned.map((task) => `- ${task.id}: ${task.title}; ${task.details}`).join("\n")
+            : "- nessun task assegnato"}`,
+        `SCAMBI RECENTI:\n${exchangeDigest(exchanges)}`,
+    ].join("\n\n");
+}
+function guidePlanningPrompt(original, mains, names) {
+    const goal = typeof original === "string"
+        ? original
+        : original.map((part) => part.type === "text" ? part.text : `[${part.type}]`).join("\n");
+    return [
+        "Progetta il lavoro PRIMA che i main agent inizino. Ispeziona il workspace con tool read-only quando serve.",
+        "Assegna task precisi e non sovrapposti a ciascun main. Per i task che richiedono entrambi, dichiara lead, support e protocollo di handoff.",
+        "Non implementare. Rispondi esclusivamente con questo JSON:",
+        "{\"summary\":string,\"assignments\":{\"r1\":[{\"id\":string,\"title\":string,\"details\":string,\"cooperateWith\":\"r2\"?}],\"r2\":[{\"id\":string,\"title\":string,\"details\":string,\"cooperateWith\":\"r1\"?}]},\"cooperation\":[{\"id\":string,\"title\":string,\"lead\":\"r1|r2\",\"support\":\"r1|r2\",\"protocol\":string}]}",
+        `AGENTI ATTIVI:\n${mains.map((ref) => `${ref}=${names[ref]}`).join("\n")}`,
+        `RICHIESTA:\n${goal.slice(-30_000)}`,
+    ].join("\n\n");
+}
+function assignmentPrompt(original, plan, self, names) {
+    const goal = typeof original === "string"
+        ? original
+        : original.map((part) => part.type === "text" ? part.text : `[${part.type}]`).join("\n");
+    const tasks = plan.assignments[self];
+    const cooperation = plan.cooperation.filter((item) => item.lead === self || item.support === self);
+    return [
+        `La Guida ha assegnato il seguente perimetro a ${names[self]} (${self}).`,
+        "Esegui i task assegnati sul workspace reale. Non duplicare il lavoro del peer.",
+        "Per ogni cooperazione usa main_team_send prima dell'area condivisa e al completamento dell'handoff.",
+        `OBIETTIVO UTENTE:\n${goal.slice(-24_000)}`,
+        `PIANO:\n${plan.summary}`,
+        `TASK ASSEGNATI:\n${tasks.length
+            ? tasks.map((task) => `- ${task.id}: ${task.title}\n  ${task.details}${task.cooperateWith ? `\n  coopera con ${names[task.cooperateWith]} (${task.cooperateWith})` : ""}`).join("\n")
+            : "- Nessun task operativo: verifica il peer e segnala eventuali blocchi."}`,
+        `COOPERAZIONI:\n${cooperation.length
+            ? cooperation.map((item) => `- ${item.id}: ${item.title}; lead=${names[item.lead]}; support=${names[item.support]}; handoff=${item.protocol}`).join("\n")
+            : "- Nessuna"}`,
+    ].join("\n\n");
+}
+function parseGuidePlan(text, mains) {
+    const empty = { r1: [], r2: [] };
+    const match = String(text || "").match(/\{[\s\S]*\}/);
+    if (!match)
+        return fallbackGuidePlan(mains, "La Guida non ha prodotto un piano valido.");
+    try {
+        const raw = JSON.parse(match[0]);
+        const assignmentsRaw = raw["assignments"] && typeof raw["assignments"] === "object"
+            ? raw["assignments"]
+            : {};
+        for (const ref of mains) {
+            const rows = Array.isArray(assignmentsRaw[ref]) ? assignmentsRaw[ref] : [];
+            empty[ref] = rows.slice(0, 24).map((item, index) => {
+                const row = item && typeof item === "object" ? item : {};
+                const peer = row["cooperateWith"] === "r1" || row["cooperateWith"] === "r2"
+                    ? row["cooperateWith"]
+                    : undefined;
+                return {
+                    id: cleanPlanText(row["id"], `T${String(index + 1).padStart(2, "0")}`, 32),
+                    title: cleanPlanText(row["title"], "Task assegnato", 240),
+                    details: cleanPlanText(row["details"], "", 2_000),
+                    ...(peer && peer !== ref ? { cooperateWith: peer } : {}),
+                };
+            });
+        }
+        const cooperationRaw = Array.isArray(raw["cooperation"]) ? raw["cooperation"] : [];
+        const cooperation = cooperationRaw.slice(0, 24).map((item, index) => {
+            const row = item && typeof item === "object" ? item : {};
+            const lead = row["lead"] === "r2" ? "r2" : "r1";
+            const support = row["support"] === "r1" ? "r1" : "r2";
+            if (lead === support || !mains.includes(lead) || !mains.includes(support))
+                return null;
+            return {
+                id: cleanPlanText(row["id"], `C${String(index + 1).padStart(2, "0")}`, 32),
+                title: cleanPlanText(row["title"], "Cooperazione", 240),
+                lead,
+                support,
+                protocol: cleanPlanText(row["protocol"], "Condividere stato e risultato tramite main_team_send.", 2_000),
+            };
+        }).filter((item) => item !== null);
+        if (!empty.r1.length && mains.includes("r1"))
+            return fallbackGuidePlan(mains, cleanPlanText(raw["summary"], "Piano operativo", 4_000));
+        return {
+            summary: cleanPlanText(raw["summary"], "Piano operativo della Guida", 4_000),
+            assignments: empty,
+            cooperation,
+        };
+    }
+    catch {
+        return fallbackGuidePlan(mains, "La Guida ha restituito un piano JSON non valido.");
+    }
+}
+function fallbackGuidePlan(mains, summary) {
+    return {
+        summary,
+        assignments: {
+            r1: mains.includes("r1") ? [{ id: "T01", title: "Analizzare e completare la richiesta", details: "Operare sul workspace e verificare il risultato." }] : [],
+            r2: mains.includes("r2") ? [{ id: "T02", title: "Verificare evidenze e integrazione", details: "Controllare il lavoro, coprire i gap e comunicare risultati a r1.", cooperateWith: "r1" }] : [],
+        },
+        cooperation: mains.length === 2
+            ? [{ id: "C01", title: "Integrazione finale", lead: "r1", support: "r2", protocol: "r2 invia evidenze e blocchi; r1 consolida e verifica." }]
+            : [],
+    };
+}
+function cleanPlanText(value, fallback, max) {
+    const clean = String(value || "").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+    return (clean || fallback).slice(0, max);
+}
+export function needsGuideArbitration(action, detail) {
+    const kind = String(action || "").toLowerCase();
+    const text = String(detail || "").toLowerCase();
+    if (kind === "kingdoms_warm")
+        return true;
+    if (kind !== "bash")
+        return false;
+    return [
+        /\b(?:rm|rmdir|del|erase)\b/,
+        /\bremove-item\b/,
+        /\b(?:rmtree|rimraf|rmsync|unlinksync|removedirectory)\b/,
+        /\b(?:shutil|fs)\s*\.\s*(?:rmtree|rm|unlink)\b/,
+        /\bos\s*\.\s*(?:remove|unlink|removedirs)\b/,
+        /\b(?:format|mkfs|diskpart|cipher\s+\/w)\b/,
+        /\b(?:drop|truncate)\s+(?:table|database|schema)\b/,
+        /\bgit\s+(?:clean|reset\s+--hard|checkout\s+--|restore\s+--source)\b/,
+        /\b(?:taskkill|stop-process|kill|pkill|killall)\b/,
+        /\b(?:docker|podman)\s+(?:system\s+prune|rm|rmi|volume\s+rm)\b/,
+        /\b(?:start-process|nohup)\b/,
+        /(?:^|\s)(?:&|start\s+\/b)(?:\s|$)/,
+        /\b(?:whisper|multiprocessing|threadpoolexecutor|processpoolexecutor)\b/,
+        /--workers(?:=|\s+)\d+/,
+        /(?:^|\s)-(?:j|jobs)(?:=|\s*)\d+/,
+    ].some((pattern) => pattern.test(text));
+}
+function parseGuideDecision(text, requestId) {
+    const fallback = {
+        requestId,
+        approved: false,
+        risk: "high",
+        reason: "La Guida non ha prodotto una decisione strutturata valida.",
+        guidance: "Non procedere; raccogli evidenze read-only o chiedi all'utente.",
+    };
+    const match = String(text || "").match(/\{[\s\S]*\}/);
+    if (!match)
+        return fallback;
+    try {
+        const raw = JSON.parse(match[0]);
+        const risk = ["low", "medium", "high", "critical"].includes(String(raw["risk"]))
+            ? String(raw["risk"])
+            : (raw["approved"] === true ? "medium" : "high");
+        return {
+            requestId,
+            approved: raw["approved"] === true,
+            risk,
+            reason: cleanPlanText(raw["reason"], fallback.reason, 4_000),
+            guidance: cleanPlanText(raw["guidance"], raw["approved"] === true ? "Procedere entro il perimetro approvato." : fallback.guidance, 4_000),
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+function parseGuideVerdict(text) {
+    const match = String(text || "").match(/\{[\s\S]*\}/);
+    if (!match)
+        return { approved: false, summary: "La guida non ha prodotto un verdetto valido.", actions: { r1: "Verifica e completa il lavoro." } };
+    try {
+        const raw = JSON.parse(match[0]);
+        const actionsRaw = raw["actions"] && typeof raw["actions"] === "object"
+            ? raw["actions"]
+            : {};
+        const actions = {};
+        for (const ref of ["r1", "r2"]) {
+            const value = String(actionsRaw[ref] || "").trim().slice(0, 8_000);
+            if (value)
+                actions[ref] = value;
+        }
+        return {
+            approved: raw["approved"] === true,
+            summary: String(raw["summary"] || "").trim().slice(0, 8_000) || "Nessun riepilogo della guida.",
+            actions,
+        };
+    }
+    catch {
+        return { approved: false, summary: "La guida ha restituito JSON non valido.", actions: { r1: "Verifica e completa il lavoro." } };
+    }
+}