@vascend/talos 0.1.4 → 0.1.6

package/dist/vascend/vision.js

@@ -202,14 +202,16 @@ export function visionFromJSON(json, opts) {
 // VascendPlanStore: API immutabile verso l'esterno, persistenza su mutazione.
 export class VascendVisionStore {
     file;
-    memory;
+    openMemory;
     visions = {};
-    constructor(file, memory) {
+    memoryStore;
+    get memory() { return this.memoryStore ??= this.openMemory(); }
+    constructor(file, openMemory) {
         this.file = file;
-        this.memory = memory;
+        this.openMemory = openMemory;
     }
     static open(sessionDir, sessionId) {
-        const store = new VascendVisionStore(join(sessionDir, `${sessionId}.vision.json`), MemoryStore.open(sessionDir, sessionId));
+        const store = new VascendVisionStore(join(sessionDir, `${sessionId}.vision.json`), () => MemoryStore.open(sessionDir, sessionId));
         if (existsSync(store.file)) {
             try {
                 const raw = JSON.parse(readFileSync(store.file, "utf8"));

package/dist/vascend/worker-session.d.ts

@@ -0,0 +1,20 @@
+import { type AgentDeps } from "../core/agent.js";
+import type { AgentEvent } from "../core/types.js";
+import { createWorkerInbox } from "./kingdom-live.js";
+/** Un incarico finisce, la conversazione puo' restare disponibile per l'host. */
+export declare function createWorkerSession(opts: {
+    kingdomId: string;
+    slug: string;
+    sessionId: string;
+    goal: string;
+    parentSignal: AbortSignal;
+    controller: AbortController;
+    retain: boolean | "queued";
+    onController?: (controller: AbortController) => void;
+    binding: ReturnType<typeof createWorkerInbox>;
+    deps: AgentDeps;
+    sink: (event: AgentEvent) => void;
+}): {
+    readonly signal: AbortSignal;
+    finish: () => void;
+};

package/dist/vascend/worker-session.js

@@ -0,0 +1,83 @@
+import { compactNow, runTurn } from "../core/agent.js";
+import { createWorkerInbox, kingdomLive } from "./kingdom-live.js";
+/** Un incarico finisce, la conversazione puo' restare disponibile per l'host. */
+export function createWorkerSession(opts) {
+    const { kingdomId, slug, parentSignal, binding, deps, sink } = opts;
+    let controller = opts.controller;
+    let running = true;
+    let closed = false;
+    const lifecycle = (state) => sink({
+        type: "kingdom", phase: "session", kingdomId, slug, sessionId: opts.sessionId,
+        state, goal: opts.goal, at: Date.now(),
+    });
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        parentSignal.removeEventListener("abort", abortFromParent);
+        controller.abort();
+        binding.dispose();
+        deps.fileCoordination?.hub.clearActor(deps.fileCoordination.actor.id);
+        lifecycle("despawned");
+    };
+    const abortFromParent = () => { controller.abort(parentSignal.reason); kingdomLive.release(kingdomId, slug); };
+    const finish = () => {
+        running = false;
+        deps.fileCoordination?.hub.clearActor(deps.fileCoordination.actor.id);
+        if (closed)
+            return;
+        const queued = (binding.inbox.queued ?? binding.inbox.pending) + (binding.inbox.pendingCompactions ?? 0);
+        if (!opts.retain || parentSignal.aborted || (opts.retain === "queued" && (!queued || controller.signal.aborted))) {
+            kingdomLive.release(kingdomId, slug);
+            return;
+        }
+        kingdomLive.setActive(kingdomId, slug, false);
+        lifecycle("idle");
+        // Uno stop non autorizza a far ripartire automaticamente il lavoro in coda.
+        if (!controller.signal.aborted)
+            wake();
+    };
+    const wake = () => {
+        if (closed || running || parentSignal.aborted)
+            return;
+        if (!(binding.inbox.pending || binding.inbox.pendingCompactions)) {
+            if (opts.retain === "queued" && !(binding.inbox.queued ?? binding.inbox.pending))
+                kingdomLive.release(kingdomId, slug);
+            return;
+        }
+        running = true;
+        controller = new AbortController();
+        opts.onController?.(controller);
+        kingdomLive.setActive(kingdomId, slug, true);
+        lifecycle("spawned");
+        void (async () => {
+            for (const request of binding.inbox.drainCompactions?.() ?? []) {
+                try {
+                    const compacted = await compactNow(deps, controller.signal, sink, request.instructions);
+                    sink({ type: "status", category: "context", label: compacted
+                            ? "Contesto compattato nella stessa sessione."
+                            : "Nessuna compattazione necessaria; contesto conservato." });
+                }
+                catch (err) {
+                    sink({ type: "status", category: "context", label: `Compattazione non riuscita: ${err.message}; contesto conservato.` });
+                }
+            }
+            if (controller.signal.aborted || closed)
+                return;
+            const message = binding.take();
+            if (message)
+                await runTurn({ ...deps, inputMessage: message }, message.parts, sink, controller.signal);
+        })().catch(err => {
+            sink({ type: "error", message: err.message });
+        }).finally(finish);
+    };
+    kingdomLive.register(kingdomId, slug, binding.inbox, Date.now(), {
+        stop: () => controller.abort(), wake, bindInbox: binding.bind, close,
+        contextSource: { config: deps.config, env: deps.env, session: deps.session, tools: deps.tools },
+    });
+    if (parentSignal.aborted)
+        abortFromParent();
+    else
+        parentSignal.addEventListener("abort", abortFromParent, { once: true });
+    return { get signal() { return controller.signal; }, finish };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vascend/talos",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Vascend Talos - extensible coding agent for your terminal",
   "repository": {
     "type": "git",
@@ -48,7 +48,7 @@
     "@xterm/headless": "^6.0.0",
     "typescript": "^5.7.0"
   },
-  "license": "UNLICENSED",
+  "license": "MIT",
   "private": false,
   "publishConfig": {
     "access": "public"