@vascend/talos 0.1.5 → 0.1.6

package/dist/vascend/granular-kingdom.js

@@ -1,7 +1,7 @@
 import { runTurn } from "../core/agent.js";
 import { Session } from "../core/session.js";
-import { createUserInbox } from "../core/user-inbox.js";
-import { kingdomLive } from "./kingdom-live.js";
+import { createWorkerInbox } from "./kingdom-live.js";
+import { createWorkerSession } from "./worker-session.js";
 import { disjointAreas } from "./team-areas.js";
 import { fileActor, withFileActor } from "../core/file-coordination.js";
 import { launchGranular, granularConcurrency, formatGranularReport, } from "./granular-launcher.js";
@@ -114,7 +114,7 @@ OBIETTIVO_UNITA'
 }
 // Costruisce il TaskRunner che esegue una unita' come sessione di agente.
 export function makeAgentUnitRunner(opts) {
-    const { harness, kingdomId, castleSlug, signal, confirm, cwd, isolated } = opts;
+    const { harness, kingdomId, castleSlug, confirm, cwd, isolated } = opts;
     const peers = opts.units.map((u) => u.id);
     const depth = opts.depth ?? 2;
     const maxDepth = maxTeamDepth(opts);
@@ -150,6 +150,8 @@ export function makeAgentUnitRunner(opts) {
             ...(cwd ? { cwd } : {}),
         };
         const self = `${castleSlug}/${unit.id}`;
+        let controller = new AbortController();
+        const signal = controller.signal;
         const spawnKingdom = depth < maxDepth ? async (specs) => {
             const units = nestedUnits(specs);
             if (!units.length)
@@ -188,6 +190,7 @@ export function makeAgentUnitRunner(opts) {
             };
             const report = await launchGranularKingdom({
                 ...opts,
+                signal: controller.signal,
                 harness: { ...harness, config: runConfig, tools: workerTools },
                 castleSlug: self,
                 units,
@@ -196,6 +199,9 @@ export function makeAgentUnitRunner(opts) {
                 markCastle: undefined,
                 onEvent: (id, event) => {
                     const slug = `${self}/${id}`;
+                    // Preserve raw child events for the host before the compact parent summary.
+                    if (event.type !== "kingdom" && event.type !== "usage")
+                        opts.onEvent?.(`${unit.id}/${id}`, event);
                     if (event.type === "text") {
                         const text = (textBuffers.get(slug) ?? "") + event.delta;
                         textBuffers.set(slug, text);
@@ -216,13 +222,14 @@ export function makeAgentUnitRunner(opts) {
         } : undefined;
         // Anche il sotto-collaboratore ha la sua casella: la scheda laterale non
         // distingue i livelli, e nemmeno chi ci scrive dentro deve farlo.
-        const inbox = createUserInbox();
-        kingdomLive.register(kingdomId, self, inbox);
+        const binding = createWorkerInbox();
+        const inbox = binding.inbox;
         const deps = {
             provider: resolved.provider,
             tools: workerTools,
             session,
             config: runConfig,
+            env: harness.env,
             confirm,
             ask: opts.ask,
             host: undefined,
@@ -251,22 +258,22 @@ export function makeAgentUnitRunner(opts) {
             + (unit.assignment?.instructions ? `\nISTRUZIONI_AGGIUNTIVE\n${unit.assignment.instructions}\n` : "")
             + (ctx.prerequisites?.length ? "\nPREREQUISITI_COMPLETATI (risultati da verificare)\n"
                 + ctx.prerequisites.map((result) => `[${result.id}] ${result.summary}`).join("\n").slice(0, 6000) + "\n" : "") + unit.goal;
+        const worker = createWorkerSession({ kingdomId, slug: self, sessionId: session.id, goal: unit.goal,
+            parentSignal: ctx.signal, controller, binding, deps, sink, retain: !isolated ? opts.retainSessions ?? false : false,
+            onController: next => { controller = next; } });
         try {
             sink({ type: "kingdom", phase: "session", kingdomId, sessionId: session.id,
                 slug: self, state: "spawned", goal: unit.goal, at: Date.now() });
-            await runTurn(deps, input, sink, ctx.signal);
+            await runTurn(deps, input, sink, signal);
+            if (signal.aborted)
+                throw new Error("interrotta");
+            if (runError || !completed)
+                throw new Error(runError || "unita' terminata senza completamento verificato");
+            return { summary: summary.trim() };
         }
         finally {
-            deps.fileCoordination?.hub.clearActor(deps.fileCoordination.actor.id);
-            kingdomLive.release(kingdomId, self);
-            sink({ type: "kingdom", phase: "session", kingdomId, sessionId: session.id,
-                slug: self, state: "despawned", at: Date.now() });
+            worker.finish();
         }
-        if (ctx.signal.aborted)
-            throw new Error("interrotta");
-        if (runError || !completed)
-            throw new Error(runError || "unita' terminata senza completamento verificato");
-        return { summary: summary.trim() };
     };
 }
 // Endpoint completo: lancia le unita' granulari di un castello in parallelo.

package/dist/vascend/kingdom-bus.d.ts

@@ -19,6 +19,7 @@ export declare class KingdomBus {
     private seq;
     post(kingdomId: string, from: string, to: string | null, text: string, ts: number): KingdomMessage;
     inbox(kingdomId: string, me: string, filter?: (message: KingdomMessage) => boolean): KingdomMessage[];
+    peekInbox(kingdomId: string, me: string): readonly KingdomMessage[];
     history(kingdomId: string): readonly KingdomMessage[];
     clear(kingdomId: string): void;
 }

package/dist/vascend/kingdom-bus.js

@@ -41,6 +41,9 @@ export class KingdomBus {
         return read.messages;
     }
     // Tutti i messaggi del regno (per il riepilogo/log), senza toccare i cursori.
+    peekInbox(kingdomId, me) {
+        return consumeInbox(this.boards.get(kingdomId) ?? [], me, this.cursors.get(`${kingdomId}::${me}`) ?? { last: 0 }).messages;
+    }
     history(kingdomId) {
         return this.boards.get(kingdomId) ?? [];
     }

package/dist/vascend/kingdom-channel.d.ts

@@ -8,6 +8,7 @@ export declare class PersistentKingdomChannel {
     constructor(sessionDir: string, opts?: KingdomChannelOptions);
     post(kingdomId: string, from: string, to: string | null, text: string, ts: number): KingdomMessage;
     inbox(kingdomId: string, me: string, filter?: (message: KingdomMessage) => boolean): KingdomMessage[];
+    peekInbox(kingdomId: string, me: string): readonly KingdomMessage[];
     history(kingdomId: string): readonly KingdomMessage[];
     clear(kingdomId: string): void;
 }
@@ -15,6 +16,7 @@ export declare function getKingdomChannel(sessionDir: string, opts?: KingdomChan
 export interface KingdomBusLike {
     post(kingdomId: string, from: string, to: string | null, text: string, ts: number): KingdomMessage;
     inbox(kingdomId: string, me: string, filter?: (message: KingdomMessage) => boolean): KingdomMessage[];
+    peekInbox(kingdomId: string, me: string): readonly KingdomMessage[];
     history(kingdomId: string): readonly KingdomMessage[];
     clear(kingdomId: string): void;
 }

package/dist/vascend/kingdom-channel.js

@@ -127,6 +127,9 @@ export class PersistentKingdomChannel {
         });
     }
     // Tutti i messaggi del regno (per riepilogo/log), senza toccare i cursori.
+    peekInbox(kingdomId, me) {
+        return consumeInbox(readBoard(busFile(this.sessionDir, kingdomId)), me, readCursors(cursorsFile(this.sessionDir, kingdomId))[me] ?? { last: 0 }).messages;
+    }
     history(kingdomId) {
         return readBoard(busFile(this.sessionDir, kingdomId));
     }

package/dist/vascend/kingdom-live.d.ts

@@ -1,9 +1,20 @@
-import type { UserInbox } from "../core/user-inbox.js";
-export interface LiveVassal {
+import { type PendingUserMessage, type UserInbox } from "../core/user-inbox.js";
+import type { ContentPart } from "../core/types.js";
+export interface LiveVassalOptions {
+    readonly contextSource?: Pick<import("../core/agent.js").AgentDeps, "config" | "env" | "session" | "tools">;
+    readonly stop?: () => void;
+    readonly wake?: () => void;
+    readonly bindInbox?: (inbox: UserInbox) => void;
+    readonly close?: () => void;
+}
+export interface LiveVassal extends LiveVassalOptions {
     readonly kingdomId: string;
     readonly slug: string;
     readonly inbox: UserInbox;
     readonly since: number;
+    readonly stop?: () => void;
+    stopping?: boolean;
+    active?: boolean;
 }
 export interface DeliveryOutcome {
     readonly ok: boolean;
@@ -12,9 +23,14 @@ export interface DeliveryOutcome {
 }
 export declare class KingdomLive {
     private readonly vassals;
-    register(kingdomId: string, slug: string, inbox: UserInbox, now?: number): void;
+    register(kingdomId: string, slug: string, inbox: UserInbox, now?: number, options?: LiveVassalOptions): void;
     release(kingdomId: string, slug: string): void;
     has(kingdomId: string, slug: string): boolean;
+    reachable(kingdomId: string, slug: string): boolean;
+    contextSource(kingdomId: string, slug: string): LiveVassalOptions["contextSource"];
+    setActive(kingdomId: string, slug: string, active: boolean): void;
+    bindInbox(kingdomId: string, slug: string, inbox: UserInbox): DeliveryOutcome;
+    wake(kingdomId: string, slug: string): DeliveryOutcome;
     /** Slug dei collaboratori che stanno lavorando adesso in questo regno. */
     slugs(kingdomId: string): readonly string[];
     /**
@@ -22,7 +38,19 @@ export declare class KingdomLive {
      * letto: ritorna l'id, cosi' l'host puo' dire "in attesa" e poi "letto"
      * quando arriva l'evento `user_message` di quel vassallo.
      */
-    deliver(kingdomId: string, slug: string, text: string, messageId?: string): DeliveryOutcome;
+    deliver(kingdomId: string, slug: string, text: string, messageId?: string, parts?: readonly ContentPart[], immediate?: boolean): DeliveryOutcome;
+    /** Accoda la compattazione reale; runTurn la esegue al prossimo confine sicuro. */
+    compact(kingdomId: string, slug: string, instructions?: string): DeliveryOutcome;
+    /** Richiede l'arresto del solo worker. Il finally del runtime rilascia il registro. */
+    stop(kingdomId: string, slug: string): DeliveryOutcome;
     clear(kingdomId: string): void;
+    clearAll(): void;
 }
 export declare const kingdomLive: KingdomLive;
+/** Casella stabile del loop, anche quando l'host collega la sua coda interattiva. */
+export declare function createWorkerInbox(): {
+    inbox: UserInbox;
+    bind: (inbox: UserInbox) => void;
+    take: () => PendingUserMessage | undefined;
+    dispose: () => void;
+};

package/dist/vascend/kingdom-live.js

@@ -8,54 +8,190 @@
 // chat principale), che l'agente svuota da solo al primo confine sicuro, subito
 // dopo gli esiti dei tool.
 //
-// Registro in-memory di processo, chiave `${kingdomId}::${slug}`. Vive quanto il
-// turno del vassallo: chi lo registra lo rilascia in un finally, altrimenti la
-// UI crederebbe di poter scrivere a un agente che non c'e' piu'.
+// Registro in-memory di processo, chiave `${kingdomId}::${slug}`. Il runtime
+// rilascia i worker effimeri al finally; gli host possono conservare sessioni
+// idle con un vero controller di ripresa, fino a clear o abort del padre.
+import { createUserInbox } from "../core/user-inbox.js";
 const key = (kingdomId, slug) => `${kingdomId}::${slug}`;
 export class KingdomLive {
     vassals = new Map();
-    register(kingdomId, slug, inbox, now = Date.now()) {
+    register(kingdomId, slug, inbox, now = Date.now(), options = {}) {
         const id = String(kingdomId || "").trim();
         const who = String(slug || "").trim();
         if (!id || !who)
             return;
-        this.vassals.set(key(id, who), { kingdomId: id, slug: who, inbox, since: now });
+        this.release(id, who);
+        this.vassals.set(key(id, who), { kingdomId: id, slug: who, inbox, since: now, active: true, ...options });
     }
     release(kingdomId, slug) {
-        this.vassals.delete(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        const id = key(String(kingdomId || "").trim(), String(slug || "").trim());
+        const live = this.vassals.get(id);
+        this.vassals.delete(id);
+        live?.close?.();
     }
     has(kingdomId, slug) {
+        return Boolean(this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()))?.active);
+    }
+    reachable(kingdomId, slug) {
         return this.vassals.has(key(String(kingdomId || "").trim(), String(slug || "").trim()));
     }
+    contextSource(kingdomId, slug) {
+        return this.vassals.get(key(kingdomId, slug))?.contextSource;
+    }
+    setActive(kingdomId, slug, active) {
+        const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        if (live) {
+            live.active = active;
+            live.stopping = false;
+        }
+    }
+    bindInbox(kingdomId, slug, inbox) {
+        const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        if (!live)
+            return { ok: false, error: "collaboratore non piu' attivo" };
+        if (!live.bindInbox)
+            return { ok: false, error: "coda esterna non disponibile" };
+        try {
+            live.bindInbox(inbox);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    wake(kingdomId, slug) {
+        const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        if (!live || live.stopping)
+            return { ok: false, error: "collaboratore non piu' attivo" };
+        try {
+            live.wake?.();
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
     /** Slug dei collaboratori che stanno lavorando adesso in questo regno. */
     slugs(kingdomId) {
         const id = String(kingdomId || "").trim();
-        return [...this.vassals.values()].filter((v) => v.kingdomId === id).map((v) => v.slug);
+        return [...this.vassals.values()].filter((v) => v.kingdomId === id && v.active).map((v) => v.slug);
     }
     /**
      * Consegna un messaggio dell'utente a un collaboratore. Non attende che sia
      * letto: ritorna l'id, cosi' l'host puo' dire "in attesa" e poi "letto"
      * quando arriva l'evento `user_message` di quel vassallo.
      */
-    deliver(kingdomId, slug, text, messageId) {
+    deliver(kingdomId, slug, text, messageId, parts, immediate = false) {
         const body = String(text ?? "").trim();
-        if (!body)
+        const content = parts ?? body;
+        if (typeof content === "string" ? !content : !content.some((part) => part.type !== "text" || part.text.trim())) {
             return { ok: false, error: "messaggio vuoto" };
+        }
         const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
-        if (!live)
+        if (!live || live.stopping)
+            return { ok: false, error: "collaboratore non piu' attivo" };
+        try {
+            const id = live.inbox.push(content, messageId);
+            if (immediate)
+                live.inbox.promote(id);
+            live.wake?.();
+            return { ok: true, messageId: id };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    /** Accoda la compattazione reale; runTurn la esegue al prossimo confine sicuro. */
+    compact(kingdomId, slug, instructions) {
+        const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        if (!live || live.stopping)
             return { ok: false, error: "collaboratore non piu' attivo" };
+        if (!live.inbox.requestCompact)
+            return { ok: false, error: "compattazione non disponibile per questo collaboratore" };
         try {
-            return { ok: true, messageId: live.inbox.push(body, messageId) };
+            live.inbox.requestCompact(instructions);
+            live.wake?.();
+            return { ok: true };
         }
         catch (err) {
             return { ok: false, error: err.message };
         }
     }
+    /** Richiede l'arresto del solo worker. Il finally del runtime rilascia il registro. */
+    stop(kingdomId, slug) {
+        const live = this.vassals.get(key(String(kingdomId || "").trim(), String(slug || "").trim()));
+        if (!live || live.stopping)
+            return { ok: false, error: "collaboratore non piu' attivo" };
+        if (!live.active)
+            return { ok: false, error: "collaboratore gia' inattivo" };
+        if (!live.stop)
+            return { ok: false, error: "arresto non disponibile per questo collaboratore" };
+        live.stopping = true;
+        try {
+            live.stop();
+            return { ok: true };
+        }
+        catch (err) {
+            live.stopping = false;
+            return { ok: false, error: err.message };
+        }
+    }
     clear(kingdomId) {
         const id = String(kingdomId || "").trim();
-        for (const [k, v] of [...this.vassals])
+        for (const v of [...this.vassals.values()])
             if (v.kingdomId === id)
-                this.vassals.delete(k);
+                this.release(v.kingdomId, v.slug);
+    }
+    clearAll() {
+        for (const v of [...this.vassals.values()])
+            this.release(v.kingdomId, v.slug);
     }
 }
 export const kingdomLive = new KingdomLive();
+/** Casella stabile del loop, anche quando l'host collega la sua coda interattiva. */
+export function createWorkerInbox() {
+    let taken = [];
+    let current = createUserInbox();
+    const controls = createUserInbox();
+    const subscriptions = new Map();
+    const inbox = {
+        push: (input, id) => current.push(input, id),
+        promote: id => current.promote(id),
+        get pending() { return taken.length + current.pending; },
+        get queued() { return taken.length + (current.queued ?? current.pending); },
+        drain: () => { const pending = [...taken, ...current.drain()]; taken = []; return pending; },
+        onImmediate(listener) {
+            subscriptions.set(listener, current.onImmediate?.(listener) ?? (() => { }));
+            return () => { subscriptions.get(listener)?.(); subscriptions.delete(listener); };
+        },
+        requestCompact: instructions => controls.requestCompact(instructions),
+        drainCompactions: () => controls.drainCompactions(),
+        get pendingCompactions() { return controls.pendingCompactions; },
+    };
+    return { inbox,
+        take() { taken.push(...current.drain()); return taken.shift(); },
+        bind(next) {
+            if (next === current || next === inbox)
+                return;
+            const pending = current.drain();
+            for (const off of subscriptions.values())
+                off();
+            current = next;
+            for (const message of pending) {
+                current.push(message.parts, message.id);
+                if (message.immediate)
+                    current.promote(message.id);
+            }
+            for (const listener of subscriptions.keys())
+                subscriptions.set(listener, current.onImmediate?.(listener) ?? (() => { }));
+        },
+        dispose() {
+            for (const off of subscriptions.values())
+                off();
+            subscriptions.clear();
+            taken = [];
+            current = createUserInbox();
+            controls.drainCompactions?.();
+        },
+    };
+}

package/dist/vascend/kingdom-run.d.ts

@@ -1,8 +1,12 @@
-import type { EventSink, ToolContext } from "../core/types.js";
+import type { AgentEvent, EventSink, ToolContext } from "../core/types.js";
 import type { Harness } from "../core/bootstrap.js";
 import { type CastleSpec, type VassalReport } from "./kingdom.js";
 import type { FileCoordinationContext } from "../core/file-coordination.js";
 export interface KingdomRunInput {
+    readonly kingdomId?: string;
+    readonly resumeSessions?: Readonly<Record<string, string>>;
+    readonly retainSessions?: boolean | "queued";
+    readonly onWorkerEvent?: (slug: string, event: AgentEvent) => void;
     readonly harness: Harness;
     readonly castles: readonly CastleSpec[];
     readonly signal: AbortSignal;

package/dist/vascend/kingdom-run.js

@@ -35,7 +35,7 @@ export async function runKingdomForHost(input) {
     // La sessione dura quanto la conversazione, uno swarm no. Un id riusato
     // faceva fondere nella UI il regno concluso con quello successivo.
     kingdomRunSequence = (kingdomRunSequence + 1) % 0xfffff;
-    const kingdomId = `kw-${harness.session.id}-${Date.now().toString(36)}-${kingdomRunSequence.toString(36)}`;
+    const kingdomId = input.kingdomId ?? `kw-${harness.session.id}-${Date.now().toString(36)}-${kingdomRunSequence.toString(36)}`;
     const concurrency = warmConcurrency(env);
     const worktree = worktreeMode(env);
     // Bus pulito per il nuovo regno (in memoria e sul canale persistente).
@@ -89,6 +89,7 @@ export async function runKingdomForHost(input) {
         sink({ type: "kingdom", phase: "say", slug, text: buffered.slice(0, SAY_MAX), at: Date.now() });
     };
     const onEvent = (slug, event) => {
+        input.onWorkerEvent?.(slug, event);
         if (event.type === "usage") {
             sink({ ...event, record: { ...event.record, actor: event.record.actor ?? slug } });
             return;
@@ -312,6 +313,8 @@ export async function runKingdomForHost(input) {
         signal,
         confirm,
         ask: input.ask,
+        retainSessions: input.retainSessions,
+        resumeSessions: input.resumeSessions,
         concurrency,
         onEvent,
         onMemberState: (slug, status, report) => {
@@ -364,7 +367,8 @@ export async function runKingdomForHost(input) {
         // Ultime parole rimaste nel buffer di chi ha finito senza un confine di turno.
         for (const slug of [...saying.keys()])
             flushSay(slug);
-        kingdomLive.clear(kingdomId);
+        if (!input.retainSessions)
+            kingdomLive.clear(kingdomId);
         for (const report of reports) {
             updateTeamMember(kingdomId, report.slug, { status: report.ok ? "completed" : "failed", summary: report.summary, error: report.error, artifacts: report.artifacts });
             sink({

package/dist/vascend/kingdom.d.ts

@@ -45,6 +45,9 @@ export interface ConflictEntry {
 export declare function collectConflicts(reports: readonly VassalReport[]): ConflictEntry[];
 export declare function formatConflictList(conflicts: readonly ConflictEntry[], base?: string): string;
 export interface KingdomWarmOptions {
+    /** Explicit persisted worker sessions for hosts that resume a named worker. */
+    readonly resumeSessions?: Readonly<Record<string, string>>;
+    readonly retainSessions?: boolean | "queued";
     readonly harness: Harness;
     readonly kingdomId: string;
     readonly castles: readonly CastleSpec[];

package/dist/vascend/kingdom.js

@@ -4,8 +4,8 @@ import { existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
 import { runTurn } from "../core/agent.js";
 import { Session } from "../core/session.js";
-import { createUserInbox } from "../core/user-inbox.js";
-import { kingdomLive } from "./kingdom-live.js";
+import { createWorkerInbox } from "./kingdom-live.js";
+import { createWorkerSession } from "./worker-session.js";
 import { fileActor, withFileActor } from "../core/file-coordination.js";
 import { RoomMemory } from "./room-memory.js";
 import { VascendPlanStore } from "./plan-store.js";
@@ -661,6 +661,7 @@ function subTeamSpawner(opts, castle, mandate, iso, planStoreId) {
             const report = await launchGranularKingdom({
                 harness: opts.harness,
                 kingdomId: opts.kingdomId,
+                retainSessions: opts.retainSessions,
                 castleSlug: castle.slug,
                 units,
                 signal: opts.signal,
@@ -691,10 +692,14 @@ function subTeamSpawner(opts, castle, mandate, iso, planStoreId) {
     };
 }
 async function runVassal(opts, provider, modelId, displayModel, castle, peers, iso, prerequisites = []) {
-    const { harness, kingdomId, signal, confirm, onEvent } = opts;
+    const { harness, kingdomId, signal: parentSignal, confirm, onEvent } = opts;
+    let controller = new AbortController();
+    const signal = controller.signal;
     // Sessione (conversazione) dedicata al vassallo; store memoria CONDIVISO del
     // regno (kingdomId) con id stanze namespaced sullo slug del castello.
-    const session = Session.create(harness.config.sessionDir, `${kingdomId}-${castle.slug}`);
+    const resumeId = opts.resumeSessions?.[castle.slug];
+    const session = resumeId ? Session.load(harness.config.sessionDir, resumeId)
+        : Session.create(harness.config.sessionDir, `${kingdomId}-${castle.slug}`);
     const effort = ["low", "medium", "high", "max"].includes(String(castle.effort ?? "").toLowerCase())
         ? String(castle.effort).toLowerCase()
         : "";
@@ -719,8 +724,8 @@ async function runVassal(opts, provider, modelId, displayModel, castle, peers, i
     // Casella del vassallo: l'utente puo' scrivergli mentre lavora dalla sua
     // scheda, e il messaggio entra nel contesto al primo confine sicuro come in
     // chat principale. Senza, l'unico modo di correggerlo era fermare il regno.
-    const inbox = createUserInbox();
-    kingdomLive.register(kingdomId, castle.slug, inbox);
+    const binding = createWorkerInbox();
+    const inbox = binding.inbox;
     const workerTools = harness.tools.scoped(castle.tools);
     for (const name of ["team_say", "team_inbox", "team_wait", "team_report", "vascend_status"])
         workerTools.promote(name);
@@ -729,6 +734,9 @@ async function runVassal(opts, provider, modelId, displayModel, castle, peers, i
         tools: workerTools,
         session,
         config: runConfig,
+        env: harness.env,
+        fsRoots: harness.fsRoots,
+        executionTarget: harness.executionTarget,
         confirm,
         ask: opts.ask,
         host: undefined,
@@ -739,7 +747,8 @@ async function runVassal(opts, provider, modelId, displayModel, castle, peers, i
         // Delega di secondo livello: un castello grande si gestisce formando un team
         // sulle proprie stanze. Prima questo campo mancava, e kingdoms_warm dentro
         // un vassallo rispondeva "non disponibile": la gerarchia era ferma a 1.
-        spawnKingdom: subTeamSpawner({ ...opts, harness: { ...harness, config: runConfig, tools: workerTools } }, castle, mandate, iso, planStoreId),
+        spawnKingdom: (specs) => subTeamSpawner({ ...opts, signal: controller.signal,
+            harness: { ...harness, config: runConfig, tools: workerTools } }, castle, mandate, iso, planStoreId)(specs),
         // isolated abilita il git nel vassallo (worktree proprio); altrimenti il
         // bash tool blocca il git che muta (working dir condivisa).
         kingdom: { id: kingdomId, self: castle.slug, isolated: iso.isolated, peers },
@@ -772,6 +781,9 @@ async function runVassal(opts, provider, modelId, displayModel, castle, peers, i
             completed = true;
         onEvent?.(castle.slug, event);
     };
+    const worker = createWorkerSession({ kingdomId, slug: castle.slug, sessionId: session.id, goal: castle.goal,
+        parentSignal, controller, binding, deps, sink, retain: !iso.isolated ? opts.retainSessions ?? false : false,
+        onController: next => { controller = next; } });
     try {
         const role = castle.role?.trim() || "collaboratore";
         sink({ type: "kingdom", phase: "session", kingdomId, sessionId: session.id,
@@ -827,12 +839,7 @@ async function runVassal(opts, provider, modelId, displayModel, castle, peers, i
         };
     }
     finally {
-        deps.fileCoordination?.hub.clearActor(deps.fileCoordination.actor.id);
-        // Il collaboratore non c'e' piu': la UI deve saperlo subito, altrimenti
-        // continuerebbe a offrire un campo di scrittura che non consegna nulla.
-        kingdomLive.release(kingdomId, castle.slug);
-        sink({ type: "kingdom", phase: "session", kingdomId, sessionId: session.id,
-            slug: castle.slug, state: "despawned", at: Date.now() });
+        worker.finish();
     }
 }
 function mandateCompletion(sessionDir, planStoreId, mandate) {

package/dist/vascend/memory-packet.d.ts

@@ -1,3 +1,4 @@
+import { ContextStoreReader } from "./context-store-reader.js";
 export interface MemoryPacketInput {
     readonly sessionDir: string;
     readonly scopeId: string;
@@ -9,5 +10,5 @@ export interface MemoryPacketInput {
     /** Preselected dependencies supplied by a coherent snapshot. */
     readonly projectScopes?: readonly string[];
 }
-export declare function buildMemoryPacket(input: MemoryPacketInput): string;
+export declare function buildMemoryPacket(input: MemoryPacketInput, reader?: ContextStoreReader): string;
 export declare function clampMemoryPacket(value: string, max: number): string;