@vascend/talos 0.1.0

package/dist/vascend/session-search.js

@@ -0,0 +1,349 @@
+// Ricerca full-text nelle sessioni PASSATE.
+//
+// La memoria curata (stanze, note, decisioni) risponde a "cosa ho deciso".
+// Non risponde a "l'ho gia' visto, questo errore?" — perche' il corpus grezzo
+// delle conversazioni non era indicizzato da nessuna parte: restava su disco,
+// leggibile solo da un umano che sapeva quale file aprire.
+//
+// Niente database: un indice incrementale su file accanto alle sessioni. Per
+// ogni .jsonl si tiene mtime/size e i termini piu' frequenti dei messaggi
+// UTENTE e ASSISTENTE; i tool result restano fuori (sono rumore, e sono loro a
+// pesare megabyte). La ricerca ordina sull'indice e apre soltanto i file dei
+// primi risultati per ritagliare gli estratti.
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const INDEX_FILE = "session-index.json";
+const INDEX_VERSION = 2;
+// Una riga piu' lunga di questo e' un tool result con immagini o output
+// enormi: si salta senza nemmeno parsarla, cosi' indicizzare una sessione da
+// 5 MB resta questione di millisecondi.
+const MAX_LINE_CHARS = 120_000;
+const MAX_FILE_BYTES = 24 * 1024 * 1024;
+const MAX_SESSIONS_INDEXED = 400;
+const MAX_TERMS_PER_SESSION = 160;
+const MAX_TEXT_PER_SESSION = 240_000;
+const STOPWORDS = new Set([
+    "the", "and", "for", "with", "that", "this", "from", "have", "has", "not", "you", "your",
+    "che", "con", "per", "una", "uno", "del", "della", "delle", "dei", "degli", "nel", "nella",
+    "sono", "come", "piu", "non", "gli", "alla", "allo", "agli", "sul", "sulla", "cosa", "quando",
+    "poi", "anche", "solo", "fare", "fatto", "essere", "ecco", "ora", "adesso", "quindi", "perche",
+]);
+export function normalizeTerms(text) {
+    return String(text || "")
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, " ")
+        .split(/\s+/)
+        .filter((term) => term.length >= 3 && term.length <= 40 && !STOPWORDS.has(term) && !/^\d+$/.test(term));
+}
+// Testo leggibile di una riga di sessione: solo i blocchi di testo dei messaggi
+// utente/assistente. I tool result non entrano nell'indice.
+function lineText(line) {
+    if (!line || line.length > MAX_LINE_CHARS)
+        return null;
+    if (!line.includes("\"message\""))
+        return null;
+    let row;
+    try {
+        row = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const message = row["message"];
+    if (!message)
+        return null;
+    const role = String(message.role ?? "");
+    if (role !== "user" && role !== "assistant")
+        return null;
+    const blocks = Array.isArray(message.content) ? message.content : [];
+    const parts = [];
+    for (const block of blocks) {
+        const item = block;
+        if (String(item.type ?? "") === "text" && typeof item.text === "string")
+            parts.push(item.text);
+    }
+    if (typeof message.content === "string")
+        parts.push(message.content);
+    const text = parts.join(" ").replace(/\s+/g, " ").trim();
+    if (!text)
+        return null;
+    return { role, text, ts: Number(row["ts"]) || 0 };
+}
+// Il primo messaggio utente spesso NON e' il compito: e' il brief del vassallo
+// o il checkpoint del regno. Stesso inganno del titolo delle stanze: senza
+// questo filtro ogni sessione si presentava come "INDICE 1 = ruolo".
+// `[VASSALLO` resta per le sessioni SALVATE prima del rinominio: il filtro
+// deve riconoscere il boilerplate vecchio quanto quello nuovo, altrimenti
+// le conversazioni di ieri tornano a inquinare la ricerca.
+const BOILERPLATE = /^\s*(?:\[COLLABORATORE|\[VASSALLO|\[VASCEND_GOAL\]|INDICE\s+\d\s*=|<!--\s*vascend:|@regno|@stato\[)/i;
+const OBJECTIVE_MARKER = /(?:OBIETTIVO_ATTIVITA|OBIETTIVO_CASTELLO|OBIETTIVO|GOAL)\s*[:=]\s*(.{4,})/i;
+export function pickObjective(userTexts) {
+    const cut = (text) => text.split(/\s(?:MODE|CHECKPOINT_PRECEDENTE|CHECKPOINT|INDICE|OUTPUT)\s*[:=]/)[0].trim().slice(0, 200);
+    const plain = userTexts.find((text) => !BOILERPLATE.test(text));
+    if (plain)
+        return cut(plain);
+    for (const text of userTexts.slice(0, 6)) {
+        const marker = OBJECTIVE_MARKER.exec(text);
+        if (marker && marker[1])
+            return cut(marker[1]);
+    }
+    return cut(userTexts[0] ?? "");
+}
+function readSession(file) {
+    let raw = "";
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        raw = "";
+    }
+    let turns = 0;
+    const userTexts = [];
+    let startedAt = 0;
+    let endedAt = 0;
+    const chunks = [];
+    let size = 0;
+    for (const line of raw.split("\n")) {
+        const parsed = lineText(line);
+        if (!parsed)
+            continue;
+        turns += 1;
+        if (parsed.ts) {
+            if (!startedAt)
+                startedAt = parsed.ts;
+            endedAt = parsed.ts;
+        }
+        if (parsed.role === "user" && userTexts.length < 6)
+            userTexts.push(parsed.text);
+        if (size < MAX_TEXT_PER_SESSION) {
+            chunks.push(parsed.text);
+            size += parsed.text.length;
+        }
+    }
+    return { turns, text: chunks.join("\n"), objective: pickObjective(userTexts), startedAt, endedAt };
+}
+function topTerms(text) {
+    const counts = new Map();
+    for (const term of normalizeTerms(text))
+        counts.set(term, (counts.get(term) ?? 0) + 1);
+    return Object.fromEntries([...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, MAX_TERMS_PER_SESSION));
+}
+function loadIndex(sessionDir) {
+    const file = join(sessionDir, INDEX_FILE);
+    if (!existsSync(file))
+        return { version: INDEX_VERSION, entries: [] };
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (!parsed || parsed.version !== INDEX_VERSION || !Array.isArray(parsed.entries)) {
+            return { version: INDEX_VERSION, entries: [] };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: INDEX_VERSION, entries: [] };
+    }
+}
+function saveIndex(sessionDir, index) {
+    try {
+        writeFileSync(join(sessionDir, INDEX_FILE), JSON.stringify(index), "utf8");
+    }
+    catch {
+        // L'indice e' una cache: se non si scrive, la ricerca continua a funzionare
+        // (ricostruira' al giro dopo).
+    }
+}
+/**
+ * Aggiorna l'indice: rilegge soltanto le sessioni nuove o cambiate (mtime+size).
+ * `skipId` esclude la sessione corrente, che e' gia' nel contesto.
+ */
+export function refreshSessionIndex(sessionDir, opts = {}) {
+    if (!sessionDir || !existsSync(sessionDir))
+        return { version: INDEX_VERSION, entries: [] };
+    const previous = new Map(loadIndex(sessionDir).entries.map((entry) => [entry.file, entry]));
+    let files = [];
+    try {
+        files = readdirSync(sessionDir).filter((name) => name.endsWith(".jsonl") && !name.includes(".memory.events") && !name.includes(".rooms"));
+    }
+    catch {
+        files = [];
+    }
+    const entries = [];
+    for (const name of files.slice(0, MAX_SESSIONS_INDEXED)) {
+        const id = name.replace(/\.jsonl$/i, "");
+        if (opts.skipId && id === opts.skipId)
+            continue;
+        const file = join(sessionDir, name);
+        let stat;
+        try {
+            stat = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES)
+            continue;
+        const known = previous.get(name);
+        if (known && known.mtimeMs === stat.mtimeMs && known.size === stat.size) {
+            entries.push(known);
+            continue;
+        }
+        const read = readSession(file);
+        if (!read.turns)
+            continue;
+        entries.push({
+            id,
+            file: name,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            startedAt: read.startedAt || stat.mtimeMs,
+            endedAt: read.endedAt || stat.mtimeMs,
+            turns: read.turns,
+            objective: read.objective,
+            name: "",
+            terms: topTerms(read.text),
+        });
+    }
+    const index = { version: INDEX_VERSION, entries };
+    saveIndex(sessionDir, index);
+    return index;
+}
+function snippetsFor(sessionDir, entry, terms, max = 2) {
+    // entry.file e' relativo alla sua cartella, oppure gia' assoluto quando la
+    // ricerca ha unito piu' run.
+    const file = /^(?:[A-Za-z]:|[\\/])/.test(entry.file) ? entry.file : join(sessionDir, entry.file);
+    let raw = "";
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (out.length >= max)
+            break;
+        const parsed = lineText(line);
+        if (!parsed)
+            continue;
+        const haystack = normalizeTerms(parsed.text);
+        const found = terms.find((term) => haystack.includes(term));
+        if (!found)
+            continue;
+        const position = parsed.text.toLowerCase().indexOf(found);
+        const start = Math.max(0, position - 90);
+        const cut = parsed.text.slice(start, start + 260).trim();
+        out.push(`${parsed.role === "user" ? "utente" : "agente"}: ${start > 0 ? "…" : ""}${cut}${start + 260 < parsed.text.length ? "…" : ""}`);
+    }
+    return out;
+}
+/**
+ * Cartelle in cui cercare. Un host puo' dare a ogni run il suo workspace
+ * effimero (Horizon: `.../run-<id>/.talos/sessions`): in quel caso la cartella
+ * corrente contiene UNA sola conversazione e cercare solo la' non troverebbe
+ * mai niente. Si includono allora le cartelle sorelle degli altri run.
+ */
+export function sessionDirsFor(sessionDir, limit = 60) {
+    const dirs = [sessionDir];
+    const match = /^(.*)[\\/]([^\\/]+)[\\/]\.talos[\\/]sessions[\\/]?$/.exec(sessionDir);
+    const parent = match?.[1];
+    const own = match?.[2];
+    if (!parent || !own || !/^run-/.test(own))
+        return dirs;
+    let siblings = [];
+    try {
+        siblings = readdirSync(parent)
+            .filter((name) => /^run-/.test(name) && name !== own)
+            .map((name) => join(parent, name, ".talos", "sessions"))
+            .filter((dir) => existsSync(dir));
+    }
+    catch {
+        siblings = [];
+    }
+    // Le piu' recenti prima: un run vecchio di mesi conta meno di quello di ieri.
+    siblings.sort((a, b) => {
+        const at = (() => { try {
+            return statSync(a).mtimeMs;
+        }
+        catch {
+            return 0;
+        } })();
+        const bt = (() => { try {
+            return statSync(b).mtimeMs;
+        }
+        catch {
+            return 0;
+        } })();
+        return bt - at;
+    });
+    return [...dirs, ...siblings.slice(0, limit)];
+}
+/**
+ * Cerca nelle sessioni passate. Il punteggio pesa quanti termini della query
+ * compaiono e con che frequenza; a pari merito vince la sessione piu' recente.
+ */
+export function searchSessions(sessionDir, query, opts = {}) {
+    const terms = [...new Set(normalizeTerms(query))];
+    if (!terms.length)
+        return [];
+    const dirs = sessionDirsFor(sessionDir);
+    const index = dirs.length === 1
+        ? refreshSessionIndex(sessionDir, { skipId: opts.skipId })
+        : {
+            version: INDEX_VERSION,
+            entries: dirs.flatMap((dir) => refreshSessionIndex(dir, { skipId: opts.skipId }).entries
+                .map((entry) => ({ ...entry, file: join(dir, entry.file) }))),
+        };
+    const limit = Math.max(1, Math.min(20, opts.limit ?? 5));
+    const scored = index.entries
+        .map((entry) => {
+        let score = 0;
+        let matched = 0;
+        for (const term of terms) {
+            const count = entry.terms[term] ?? 0;
+            if (count > 0) {
+                matched += 1;
+                score += 1 + Math.log1p(count);
+            }
+        }
+        // Tutti i termini presenti vale piu' della somma delle frequenze: e' il
+        // segnale che la sessione parlava DAVVERO di quello.
+        if (matched === terms.length && terms.length > 1)
+            score *= 1.6;
+        return { entry, score, matched };
+    })
+        .filter((row) => row.matched > 0)
+        .sort((a, b) => b.score - a.score || b.entry.endedAt - a.entry.endedAt)
+        .slice(0, limit);
+    return scored.map((row) => ({
+        id: row.entry.id,
+        objective: row.entry.objective,
+        name: row.entry.name,
+        endedAt: row.entry.endedAt,
+        turns: row.entry.turns,
+        score: Number(row.score.toFixed(2)),
+        snippets: opts.withSnippets === false ? [] : snippetsFor(sessionDir, row.entry, terms),
+    }));
+}
+export function describeWhen(ts, now = Date.now()) {
+    const ms = Math.max(0, now - ts);
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes} min fa`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours} h fa`;
+    const days = Math.round(hours / 24);
+    return days <= 1 ? "ieri" : `${days} giorni fa`;
+}
+export function formatSessionHits(hits, now = Date.now()) {
+    if (!hits.length)
+        return "";
+    const blocks = hits.map((hit) => {
+        const head = `[sessione ${hit.id} · ${describeWhen(hit.endedAt, now)} · ${hit.turns} turni]`
+            + (hit.objective ? ` obiettivo: ${hit.objective}` : "");
+        return [head, ...hit.snippets.map((line) => `  ${line}`)].join("\n");
+    });
+    return ["SESSIONI PRECEDENTI (conversazioni archiviate, non memoria curata)", ...blocks].join("\n");
+}

package/dist/vascend/supersession-graph.d.ts

@@ -0,0 +1,14 @@
+import type { ContextCandidate } from "./context-candidate.js";
+export interface SupersessionEdge {
+    readonly older: string;
+    readonly newer: string;
+}
+export interface SupersessionGraph {
+    readonly edges: readonly SupersessionEdge[];
+    readonly supersededBy: ReadonlyMap<string, string>;
+    readonly superseded: ReadonlySet<string>;
+}
+export declare function buildSupersessionGraph(candidates: readonly ContextCandidate[]): SupersessionGraph;
+export declare function activeCandidates(candidates: readonly ContextCandidate[]): readonly ContextCandidate[];
+export declare function markSuperseded(candidate: ContextCandidate, newerId: string): ContextCandidate;
+export declare function latestOf(graph: SupersessionGraph, id: string): string;

package/dist/vascend/supersession-graph.js

@@ -0,0 +1,70 @@
+// Supersession Graph (metodo Danilov, Memory OS).
+//
+// Sapere cosa e' vero non basta: serve sapere cosa NON e' piu' vero. Una
+// decisione o un asset puo' essere SUPERATO da uno piu' recente. Questo modulo
+// costruisce il grafo di supersessione dai candidati (campi supersedes /
+// supersededBy / status) e ricava il set di candidati ATTIVI, escludendo gli
+// obsoleti dal contesto.
+//
+// Modulo PURO e deterministico: nessun side-effect, opera su array di
+// ContextCandidate gia' raccolti.
+// Costruisce il grafo dai candidati. Considera due sorgenti di archi:
+//   1) il campo esplicito supersededBy del candidato;
+//   2) il campo payload "supersedes" propagato in terms/summary non e' usato:
+//      la fonte e' supersededBy (esplicito) per restare deterministici.
+// In caso di catene (A->B->C) il set superseded contiene tutti i nodi non
+// terminali raggiungibili.
+export function buildSupersessionGraph(candidates) {
+    const byId = new Map(candidates.map((c) => [c.id, c]));
+    const edges = [];
+    const supersededBy = new Map();
+    const superseded = new Set();
+    for (const c of candidates) {
+        // Marcatura esplicita di stato.
+        if (c.status === "superseded")
+            superseded.add(c.id);
+        // Arco da supersededBy: c e' superato da c.supersededBy.
+        if (c.supersededBy) {
+            edges.push({ older: c.id, newer: c.supersededBy });
+            // Tieni il "newer" piu' recente se piu' candidati lo dichiarano.
+            const prev = supersededBy.get(c.id);
+            if (!prev || newerThan(byId.get(c.supersededBy), byId.get(prev))) {
+                supersededBy.set(c.id, c.supersededBy);
+            }
+            superseded.add(c.id);
+        }
+    }
+    return { edges, supersededBy, superseded };
+}
+// Filtra i candidati lasciando solo gli ATTIVI: esclude i superseded e gli
+// archived. Deterministico, preserva l'ordine.
+export function activeCandidates(candidates) {
+    const graph = buildSupersessionGraph(candidates);
+    return candidates.filter((c) => c.status === "active" && !graph.superseded.has(c.id));
+}
+// Applica al volo un aggiornamento di supersessione a un candidato: imposta
+// status e supersededBy senza mutare l'originale.
+export function markSuperseded(candidate, newerId) {
+    return { ...candidate, status: "superseded", supersededBy: newerId };
+}
+// Ritorna, per un id, l'id della versione PIU' RECENTE seguendo la catena di
+// supersessione (A->B->C => latestOf(A)=C). Evita cicli.
+export function latestOf(graph, id) {
+    let current = id;
+    const seen = new Set([id]);
+    while (graph.supersededBy.has(current)) {
+        const next = graph.supersededBy.get(current);
+        if (seen.has(next))
+            break; // ciclo: stop
+        seen.add(next);
+        current = next;
+    }
+    return current;
+}
+function newerThan(a, b) {
+    if (!a)
+        return false;
+    if (!b)
+        return true;
+    return a.createdAt > b.createdAt;
+}

package/dist/vascend/team-areas.d.ts

@@ -0,0 +1,9 @@
+interface AreaOwner {
+    readonly slug: string;
+    readonly area?: readonly string[];
+}
+export declare function disjointAreas(members: readonly AreaOwner[], cwd?: string): {
+    readonly disjoint: boolean;
+    readonly detail: string;
+};
+export {};

package/dist/vascend/team-areas.js

@@ -0,0 +1,28 @@
+import { resolve } from "node:path";
+function areaKey(value, cwd) {
+    return resolve(cwd, value.trim().replaceAll("\\", "/")).replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+}
+function overlaps(a, b) {
+    return !a || !b || a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+// Declared paths coordinate ownership; they are not a filesystem sandbox.
+export function disjointAreas(members, cwd = process.cwd()) {
+    if (members.length < 2)
+        return { disjoint: true, detail: "un solo collaboratore" };
+    const missing = members.filter((member) => !member.area?.length).map((member) => member.slug);
+    if (missing.length)
+        return { disjoint: false, detail: `senza area dichiarata: ${missing.join(", ")}` };
+    const owned = [];
+    for (const member of members) {
+        for (const raw of member.area ?? []) {
+            if (!raw.trim() || /[*?\[\]{}]/.test(raw))
+                return { disjoint: false, detail: `area non concreta in ${member.slug}` };
+            const path = areaKey(raw, cwd);
+            const clash = owned.find((other) => other.slug !== member.slug && overlaps(other.path, path));
+            if (clash)
+                return { disjoint: false, detail: `${member.slug} e ${clash.slug} si contendono ${clash.display}` };
+            owned.push({ slug: member.slug, path, display: raw });
+        }
+    }
+    return { disjoint: true, detail: owned.map((owner) => `${owner.slug}:${owner.path}`).join(" ") };
+}

package/dist/vascend/team-handoff.d.ts

@@ -0,0 +1,24 @@
+import type { TeamMember } from "./team-session.js";
+import type { ToolResultPart } from "../core/types.js";
+export interface ArtifactReference {
+    readonly id: string;
+    readonly scope: string;
+    readonly name: string;
+    readonly sha256: string;
+    readonly chars: number;
+}
+export interface TeamHandoff {
+    readonly version: 1;
+    readonly id: string;
+    readonly sessionId: string;
+    readonly revision: number;
+    readonly updatedAt: number;
+    readonly members: readonly TeamMember[];
+    readonly done: boolean;
+    readonly failed: boolean;
+    readonly report: string;
+}
+export declare function artifactReference(result: ToolResultPart): ArtifactReference | null;
+/** Durable latest handoff per owner; a checkpoint never implies that a worker is still alive. */
+export declare function saveTeamHandoff(directory: string, team: Omit<TeamHandoff, "version" | "revision" | "updatedAt">): TeamHandoff;
+export declare function readTeamHandoff(directory: string, sessionId: string, teamId?: string): TeamHandoff | null;

package/dist/vascend/team-handoff.js

@@ -0,0 +1,37 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { withLockSync } from "./file-lock.js";
+export function artifactReference(result) {
+    const ref = result._meta?.["talosArtifact"];
+    return ref && /^tr\d+$/.test(ref.id ?? "") && typeof ref.scope === "string" && ref.scope.length > 0
+        && /^[a-f0-9]{64}$/.test(ref.sha256 ?? "") && typeof ref.chars === "number"
+        ? { id: ref.id, scope: ref.scope, name: ref.name ?? "risultato", sha256: ref.sha256, chars: ref.chars } : null;
+}
+/** Durable latest handoff per owner; a checkpoint never implies that a worker is still alive. */
+export function saveTeamHandoff(directory, team) {
+    const path = handoffPath(directory, team.sessionId);
+    return withLockSync(path, () => {
+        const previous = readTeamHandoff(directory, team.sessionId);
+        const result = { ...team, version: 1, revision: (previous?.revision ?? 0) + 1, updatedAt: Date.now() };
+        for (const target of [handoffPath(directory, team.sessionId, team.id), path]) {
+            const temp = target + "." + randomUUID() + ".tmp";
+            writeFileSync(temp, JSON.stringify(result), "utf8");
+            renameSync(temp, target);
+        }
+        return result;
+    });
+}
+export function readTeamHandoff(directory, sessionId, teamId) {
+    try {
+        const value = JSON.parse(readFileSync(handoffPath(directory, sessionId, teamId), "utf8"));
+        return value.version === 1 && value.sessionId === sessionId && typeof value.id === "string"
+            && (!teamId || value.id === teamId) && Array.isArray(value.members) && Number.isInteger(value.revision) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function handoffPath(directory, owner, teamId) {
+    return join(directory, "team-handoffs", createHash("sha256").update(teamId ? owner + "\0" + teamId : owner).digest("hex") + ".json");
+}

package/dist/vascend/team-scheduler.d.ts

@@ -0,0 +1,13 @@
+import type { SpawnAgentSpec } from "../core/types.js";
+export declare function validateTeamGraph(members: readonly SpawnAgentSpec[]): void;
+export declare function scheduleTeam<T extends {
+    readonly ok: boolean;
+}>(options: {
+    readonly members: readonly SpawnAgentSpec[];
+    readonly concurrency: number;
+    readonly signal: AbortSignal;
+    readonly compatible: (left: SpawnAgentSpec, right: SpawnAgentSpec) => boolean;
+    readonly run: (member: SpawnAgentSpec, index: number) => Promise<T>;
+    readonly failure: (member: SpawnAgentSpec, reason: string) => T;
+    readonly settled?: (member: SpawnAgentSpec, result: T) => void;
+}): Promise<T[]>;

package/dist/vascend/team-scheduler.js

@@ -0,0 +1,74 @@
+export function validateTeamGraph(members) {
+    if (!members.length)
+        throw new Error("nessun collaboratore indicato");
+    const bySlug = new Map(members.map((member) => [member.slug, member]));
+    if (bySlug.size !== members.length)
+        throw new Error("slug duplicati nel team");
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (slug) => {
+        if (visiting.has(slug))
+            throw new Error(`dipendenza ciclica: ${slug}`);
+        if (visited.has(slug))
+            return;
+        const member = bySlug.get(slug);
+        if (!member)
+            throw new Error(`dipendenza sconosciuta: ${slug}`);
+        visiting.add(slug);
+        for (const dependency of member.after ?? [])
+            visit(dependency);
+        visiting.delete(slug);
+        visited.add(slug);
+    };
+    for (const member of members) {
+        if (!member.slug.trim())
+            throw new Error("slug vuoto");
+        visit(member.slug);
+    }
+}
+// Dependency-ready work starts as soon as a slot becomes free. A slow peer
+// does not impose a batch barrier on unrelated work or completed dependencies.
+export async function scheduleTeam(options) {
+    const { members, signal } = options;
+    validateTeamGraph(members);
+    const limit = Number.isFinite(options.concurrency) ? Math.max(1, Math.trunc(options.concurrency)) : 1;
+    const indices = new Map(members.map((member, index) => [member.slug, index]));
+    const pending = new Set(members.map((_, index) => index));
+    const running = new Map();
+    const results = new Array(members.length);
+    const finish = (index, result) => {
+        results[index] = result;
+        options.settled?.(members[index], result);
+    };
+    while (pending.size || running.size) {
+        for (const index of pending) {
+            const member = members[index];
+            const failed = (member.after ?? []).filter((slug) => results[indices.get(slug)]?.ok === false);
+            if (signal.aborted || failed.length) {
+                pending.delete(index);
+                finish(index, options.failure(member, signal.aborted ? "arrestato prima dell'avvio" : `prerequisiti falliti: ${failed.join(", ")}`));
+                continue;
+            }
+            if (running.size >= limit || !(member.after ?? []).every((slug) => results[indices.get(slug)]?.ok))
+                continue;
+            if ([...running.keys()].some((active) => !options.compatible(member, members[active])))
+                continue;
+            pending.delete(index);
+            const work = Promise.resolve().then(() => options.run(member, index))
+                .catch((error) => options.failure(member, error instanceof Error ? error.message : String(error)))
+                .then((result) => { finish(index, result); })
+                .finally(() => { running.delete(index); });
+            running.set(index, work);
+        }
+        if (running.size)
+            await Promise.race(running.values());
+        else if (pending.size) {
+            // A failed dependency may have been visited after its dependent above.
+            // The next pass propagates failure without launching that dependent.
+            const canProgress = [...pending].some((index) => (members[index].after ?? []).some((slug) => results[indices.get(slug)]?.ok === false));
+            if (!canProgress)
+                throw new Error("team senza task eseguibili: controlla dipendenze e aree");
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,42 @@
+import { type ArtifactReference } from "./team-handoff.js";
+export interface TeamMember {
+    readonly slug: string;
+    readonly role: string;
+    readonly mandate: string;
+    readonly status?: "queued" | "running" | "completed" | "failed";
+    readonly summary?: string;
+    readonly error?: string;
+    readonly after?: readonly string[];
+    readonly area?: readonly string[];
+    readonly castle?: string;
+    readonly tasks?: readonly string[];
+    readonly artifacts?: readonly ArtifactReference[];
+}
+export interface LiveTeam {
+    readonly revision?: number;
+    readonly persistenceError?: string;
+    readonly id: string;
+    readonly sessionId: string;
+    readonly members: readonly TeamMember[];
+    readonly startedAt: number;
+    readonly work: Promise<string>;
+    readonly done: boolean;
+    readonly report: string;
+    readonly failed: boolean;
+}
+export declare function registerTeam(input: {
+    readonly sessionDir?: string;
+    readonly id: string;
+    readonly sessionId: string;
+    readonly members: readonly TeamMember[];
+    readonly work: Promise<string>;
+    readonly at: number;
+}): LiveTeam;
+export declare function teamForSession(sessionId: string): LiveTeam | null;
+export declare function teamById(sessionId: string, teamId: string): LiveTeam | null;
+export declare function pendingMembers(team: LiveTeam): readonly string[];
+export declare function teamByKingdom(teamId: string): LiveTeam | null;
+export declare function updateTeamMember(teamId: string, slug: string, patch: Pick<TeamMember, "status" | "summary" | "error" | "artifacts">): void;
+export declare function waitForTeamChange(team: LiveTeam, signal: AbortSignal, interrupted: () => boolean): Promise<void>;
+export declare function forgetTeam(sessionId: string, teamId: string): void;
+export declare function __resetTeams(): void;