talos-code 0.0.1 → 0.2.0

package/dist/runtime/session-summary.js

@@ -0,0 +1,125 @@
+function textOrNull(...values) {
+    for (const value of values)
+        if (typeof value === 'string' && value.trim() !== '')
+            return value.trim();
+    return null;
+}
+function finiteOrNull(value) { return Number.isFinite(value) ? Number(value) : null; }
+function depthOf(value) { return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : 0; }
+function lifecycle(row) {
+    if (row?.interrotta === true || row?.interrupted === true)
+        return 'interrupted';
+    const concluded = row?.conclusa === true || row?.completed === true;
+    const explicitlyOpen = row?.conclusa === false || row?.completed === false;
+    const last = textOrNull(row?.ultimoEsito, row?.lastOutcome);
+    const closure = textOrNull(row?.motivoChiusura, row?.closureReason);
+    if (explicitlyOpen && (last !== null || closure !== null))
+        return 'unknown';
+    if (!concluded && !explicitlyOpen && (last !== null || closure !== null))
+        return 'unknown';
+    if (!concluded)
+        return 'running';
+    if (closure === 'fermata' || closure === 'stopped' || closure === 'cancelled')
+        return 'stopped';
+    if (closure === 'fine-lavoro' || closure === 'completed' || last === 'successo' || last === 'success')
+        return 'completed';
+    if (closure === 'giri-finiti' || closure === 'errore' || closure === 'failed' || last === 'errore' || last === 'error')
+        return 'failed';
+    return 'unknown';
+}
+function usageOf(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const row = raw;
+    const usage = {
+        promptTokens: finiteOrNull(row.prompt_tokens ?? row.promptTokens),
+        completionTokens: finiteOrNull(row.completion_tokens ?? row.completionTokens),
+        cachedTokens: finiteOrNull(row.cached_tokens ?? row.cachedTokens),
+        turns: finiteOrNull(row.giri ?? row.turns),
+        executions: finiteOrNull(row.esecuzioni ?? row.executions),
+    };
+    return Object.values(usage).some(value => value !== null) ? usage : null;
+}
+function collisionOf(raw) {
+    const path = textOrNull(raw?.percorso, raw?.path);
+    if (!path)
+        return null;
+    return { path, beforeSessionId: textOrNull(raw?.primaDi, raw?.beforeSessionId), afterSessionId: textOrNull(raw?.dopoDi, raw?.afterSessionId) };
+}
+function delegationOutcomeOf(value) {
+    const normalized = textOrNull(value)?.toLowerCase() ?? null;
+    if (normalized === null)
+        return null;
+    if (normalized === 'concluso' || normalized === 'completed' || normalized === 'successo')
+        return 'completed';
+    if (normalized === 'fallito' || normalized === 'failed' || normalized === 'errore')
+        return 'failed';
+    if (normalized === 'rifiutato' || normalized === 'refused')
+        return 'refused';
+    return 'unknown';
+}
+function delegationEvidenceOf(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const out = {
+        writes: finiteOrNull(raw.scritture ?? raw.writes),
+        artifacts: finiteOrNull(raw.artefatti ?? raw.artifacts),
+        toolCalls: finiteOrNull(raw.toolCalls),
+        toolCallsOk: finiteOrNull(raw.toolCallsOk),
+        toolCallsFailed: finiteOrNull(raw.toolCallsFalliti ?? raw.toolCallsFailed),
+        verifiable: typeof raw.verificabile === 'boolean' ? raw.verificabile : typeof raw.verifiable === 'boolean' ? raw.verifiable : null,
+    };
+    return Object.values(out).some(value => value !== null) ? out : null;
+}
+function approvalOf(row, evidence) {
+    if (row?.inAttesaApprovazione !== true && row?.approvalWaiting !== true)
+        return null;
+    return {
+        pending: true,
+        requestId: textOrNull(evidence.approval?.requestId),
+        waitingMs: finiteOrNull(evidence.approval?.waitingMs),
+    };
+}
+export function normalizeSessionSummary(row, evidence = {}) {
+    const id = textOrNull(row?.sessionId, row?.id) ?? '';
+    const child = evidence.child ?? null;
+    const collisions = (Array.isArray(child?.collisioni) ? child.collisioni : Array.isArray(row?.collisions) ? row.collisions : [])
+        .map(collisionOf).filter((value) => value !== null);
+    const startedAt = textOrNull(row?.avviataAlle, row?.startedAt);
+    const updatedAt = textOrNull(row?.ultimaRispostaAlle, row?.aggiornataAlle, row?.updatedAt) ?? startedAt;
+    return {
+        id, sessionId: id,
+        name: textOrNull(row?.nome, row?.name, row?.titolo, row?.title),
+        project: textOrNull(row?.progetto, row?.project),
+        path: textOrNull(row?.percorso, row?.path),
+        model: textOrNull(row?.modello, row?.model, row?.modelId),
+        parentId: textOrNull(row?.padreId, row?.parentId),
+        depth: depthOf(row?.profonditaDelega ?? row?.depth),
+        delegatedTask: textOrNull(row?.taskDelega, row?.delegatedTask, child?.taskCorto),
+        forkedFrom: textOrNull(row?.forkDa, row?.forkedFrom),
+        startedAt,
+        updatedAt,
+        endedAt: textOrNull(row?.conclusaAlle, row?.endedAt, row?.fineAlle),
+        outcome: lifecycle(row),
+        interrupted: row?.interrotta === true || row?.interrupted === true,
+        usage: usageOf(row?.usageSessione ?? row?.sessionUsage),
+        approvalWait: approvalOf(row, evidence),
+        collisions,
+        delegationOutcome: delegationOutcomeOf(child?.esitoDelega ?? row?.delegationOutcome),
+        delegationEvidence: delegationEvidenceOf(child?.evidenzaDelega ?? row?.delegationEvidence),
+    };
+}
+export function normalizeSessionSummaries(rows, evidenceById = new Map()) {
+    return rows.map(row => {
+        const id = textOrNull(row?.sessionId, row?.id) ?? '';
+        return normalizeSessionSummary(row, evidenceById.get(id) ?? {});
+    }).filter(row => row.id).sort((a, b) => {
+        if (a.startedAt === b.startedAt)
+            return 0;
+        if (a.startedAt === null)
+            return -1;
+        if (b.startedAt === null)
+            return 1;
+        return a.startedAt.localeCompare(b.startedAt);
+    });
+}

package/dist/runtime/supervisor.js

@@ -0,0 +1,265 @@
+import { randomUUID } from 'node:crypto';
+import { CliRuntimeError } from "./types.js";
+import { developmentLog, developmentLogError } from "../diagnostics/development-log.js";
+import { forwardKeyOrigin } from "../provider/environment-keys.js";
+import { createRuntimeReplayBuffer, createStartOperationJournal, startOperationFingerprint } from "./replay-buffer.js";
+export const DEFAULT_RUNTIME_SUPERVISOR_POLICY = {
+    restore: { maxAttempts: 2, backoffMs: 50 },
+    start: { maxAttempts: 2, backoffMs: 50 },
+    replay: { maxAttempts: 2, backoffMs: 50 },
+};
+const RETRYABLE_CODES = new Set([
+    'RUNTIME_ACK_LOST', 'RUNTIME_RESTORE_TRANSIENT', 'RUNTIME_UNAVAILABLE', 'RUNTIME_START_FAILED',
+    'PROVIDER_REQUEST_ERROR', 'PROVIDER_TIMEOUT', 'PROVIDER_RATE_LIMITED', 'NETWORK_ERROR',
+]);
+function errorCode(error) {
+    return typeof error?.code === 'string' ? error.code : null;
+}
+function errorRetryable(error) {
+    if (typeof error?.retryable === 'boolean')
+        return error.retryable;
+    if (typeof error?.details?.retryable === 'boolean')
+        return error.details.retryable;
+    const code = errorCode(error);
+    return code !== null && RETRYABLE_CODES.has(code);
+}
+function errorDetails(error) {
+    const source = error && typeof error === 'object' ? error : {};
+    const nested = source.details && typeof source.details === 'object' && !Array.isArray(source.details) ? source.details : {};
+    const direct = Object.fromEntries(Object.entries(source).filter(([key, value]) => !['name', 'message', 'stack', 'code', 'retryable', 'details'].includes(key)
+        && ['string', 'number', 'boolean'].includes(typeof value)));
+    return { ...nested, ...direct };
+}
+function nativeSequence(event) {
+    const raw = event?._sequenza;
+    return typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : null;
+}
+export function createRuntimeSupervisor(options) {
+    const sleep = options.sleep ?? (async (ms) => { if (ms > 0)
+        await new Promise(resolve => setTimeout(resolve, ms)); });
+    const policy = {
+        restore: { ...DEFAULT_RUNTIME_SUPERVISOR_POLICY.restore, ...options.policy?.restore },
+        start: { ...DEFAULT_RUNTIME_SUPERVISOR_POLICY.start, ...options.policy?.start },
+        replay: { ...DEFAULT_RUNTIME_SUPERVISOR_POLICY.replay, ...options.policy?.replay },
+    };
+    const nextOperationId = options.operationId ?? randomUUID;
+    const journal = options.journal ?? (options.journalRoot ? createStartOperationJournal({ rootDir: options.journalRoot, operationId: nextOperationId }) : null);
+    const replay = createRuntimeReplayBuffer();
+    const evidence = [];
+    const generations = new Map();
+    const cancelInFlight = new Map();
+    let current = options.initialRuntime ?? null;
+    let defaultReasoning = null;
+    let closed = false;
+    function record(input) {
+        const row = { ...input, ts: new Date().toISOString() };
+        evidence.push(row);
+        developmentLog('runtime.supervisor', row, input.outcome === 'failed' ? 'error' : input.outcome === 'retrying' ? 'warning' : 'debug', 'runtime-supervisor');
+        if (evidence.length > 256)
+            evidence.splice(0, evidence.length - 256);
+    }
+    async function ensureRuntime() {
+        if (closed)
+            throw new CliRuntimeError('RUNTIME_SUPERVISOR_CLOSED', 'Runtime supervisor is closed.');
+        if (!current) {
+            current = await options.runtimeFactory();
+            current.setDefaultReasoningEffort(defaultReasoning);
+        }
+        return current;
+    }
+    async function replaceRuntime() {
+        const old = current;
+        current = null;
+        try {
+            await old?.close();
+        }
+        catch (error) {
+            developmentLogError('runtime.replace.close_failure', error, {}, 'runtime-supervisor');
+        }
+        const next = await ensureRuntime();
+        next.setDefaultReasoningEffort(defaultReasoning);
+        return next;
+    }
+    function bump(sessionId) { const next = (generations.get(sessionId) ?? 0) + 1; generations.set(sessionId, next); return next; }
+    async function restore() {
+        for (let attempt = 1; attempt <= policy.restore.maxAttempts; attempt++) {
+            const runtime = await ensureRuntime();
+            try {
+                const result = await runtime.restore();
+                record({ operation: 'restore', attempt, outcome: 'succeeded', code: null, retryable: false, fallback: null, sessionId: null, operationId: null, details: {} });
+                return result;
+            }
+            catch (error) {
+                const retryable = errorRetryable(error);
+                const code = errorCode(error);
+                if (retryable && attempt < policy.restore.maxAttempts) {
+                    record({ operation: 'restore', attempt, outcome: 'retrying', code, retryable: true, fallback: 'runtime-restart', sessionId: null, operationId: null, details: errorDetails(error) });
+                    await sleep(policy.restore.backoffMs);
+                    await replaceRuntime();
+                    continue;
+                }
+                record({ operation: 'restore', attempt, outcome: 'failed', code, retryable, fallback: null, sessionId: null, operationId: null, details: errorDetails(error) });
+                throw error;
+            }
+        }
+        throw new CliRuntimeError('RUNTIME_RESTORE_FAILED');
+    }
+    async function start(input) {
+        const fingerprint = startOperationFingerprint(input);
+        let operationId = input.operationId ?? null;
+        let recovered = false;
+        if (!operationId && journal) {
+            const claim = await journal.claim(fingerprint);
+            operationId = claim.operationId;
+            recovered = claim.recovered;
+        }
+        if (!operationId)
+            operationId = nextOperationId();
+        if (recovered)
+            record({ operation: 'start', attempt: 0, outcome: 'recovered', code: null, retryable: false, fallback: null, sessionId: null, operationId, details: { fingerprint } });
+        for (let attempt = 1; attempt <= policy.start.maxAttempts; attempt++) {
+            const runtime = await ensureRuntime();
+            try {
+                const sessionId = await runtime.start({ ...input, operationId });
+                bump(sessionId);
+                if (recovered) {
+                    const row = (await runtime.listSessions()).find(candidate => candidate.sessionId === sessionId || candidate.id === sessionId);
+                    if (row?.interrupted === true || row?.outcome === 'interrupted') {
+                        record({ operation: 'start', attempt, outcome: 'failed', code: 'RUNTIME_OPERATION_INTERRUPTED', retryable: false, fallback: null, sessionId, operationId, details: { recovered: true } });
+                        throw new CliRuntimeError('RUNTIME_OPERATION_INTERRUPTED', 'The recovered start was interrupted by the previous process. Resume that session explicitly instead of starting it again.', { sessionId, operationId });
+                    }
+                }
+                record({ operation: 'start', attempt, outcome: 'succeeded', code: null, retryable: false, fallback: null, sessionId, operationId, details: { recovered } });
+                return sessionId;
+            }
+            catch (error) {
+                if (error?.code === 'RUNTIME_OPERATION_INTERRUPTED')
+                    throw error;
+                const retryable = errorRetryable(error);
+                const code = errorCode(error);
+                if (retryable && attempt < policy.start.maxAttempts) {
+                    record({ operation: 'start', attempt, outcome: 'retrying', code, retryable: true, fallback: 'runtime-restart', sessionId: null, operationId, details: errorDetails(error) });
+                    await sleep(policy.start.backoffMs);
+                    await replaceRuntime();
+                    continue;
+                }
+                record({ operation: 'start', attempt, outcome: 'failed', code, retryable, fallback: null, sessionId: null, operationId, details: errorDetails(error) });
+                throw error;
+            }
+        }
+        throw new CliRuntimeError('RUNTIME_START_FAILED');
+    }
+    function subscribe(sessionId, sink, from = 0) {
+        let active = true;
+        let unsub = () => { };
+        let cursor = from;
+        const deliver = (event) => {
+            if (!active)
+                return;
+            const sequence = nativeSequence(event);
+            if (sequence !== null) {
+                /* P13 (2026-09-26): what this subscriber has seen is ITS cursor. The buffer is shared by every subscriber of the
+                   session, so "already in the buffer" dropped the whole history of a second subscriber (a reopened agent view came
+                   up empty); it still records the event, and a different event at a known sequence still throws a conflict. */
+                if (sequence <= cursor)
+                    return;
+                replay.push(sessionId, event);
+                cursor = sequence;
+            }
+            sink(event);
+        };
+        const terminalFailure = (error) => {
+            if (!active)
+                return;
+            sink({ type: 'RunError', code: 'RUNTIME_REPLAY_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false, component: 'runtime-supervisor' });
+        };
+        const attach = (runtime, attempt) => {
+            if (!active)
+                return;
+            try {
+                unsub = runtime.subscribe(sessionId, deliver, cursor);
+                if (attempt > 1)
+                    record({ operation: 'replay', attempt, outcome: 'succeeded', code: null, retryable: false, fallback: null, sessionId, operationId: null, details: { from: cursor } });
+            }
+            catch (error) {
+                const retryable = errorRetryable(error);
+                const code = errorCode(error);
+                if (retryable && attempt < policy.replay.maxAttempts) {
+                    record({ operation: 'replay', attempt, outcome: 'retrying', code, retryable: true, fallback: 'runtime-restart', sessionId, operationId: null, details: { ...errorDetails(error), from: cursor } });
+                    void (async () => {
+                        try {
+                            await sleep(policy.replay.backoffMs);
+                            const next = await replaceRuntime();
+                            await next.restore();
+                            attach(next, attempt + 1);
+                        }
+                        catch (recoveryError) {
+                            record({ operation: 'replay', attempt: attempt + 1, outcome: 'failed', code: errorCode(recoveryError), retryable: errorRetryable(recoveryError), fallback: null, sessionId, operationId: null, details: errorDetails(recoveryError) });
+                            terminalFailure(recoveryError);
+                        }
+                    })();
+                    return;
+                }
+                record({ operation: 'replay', attempt, outcome: 'failed', code, retryable, fallback: null, sessionId, operationId: null, details: errorDetails(error) });
+                terminalFailure(error);
+            }
+        };
+        if (current)
+            attach(current, 1);
+        else
+            void ensureRuntime().then(runtime => attach(runtime, 1)).catch(terminalFailure);
+        return () => { if (!active)
+            return; active = false; try {
+            unsub();
+        }
+        catch { } };
+    }
+    const supervised = {
+        restore,
+        start,
+        setDefaultReasoningEffort(effort) { defaultReasoning = effort; current?.setDefaultReasoningEffort(effort); },
+        async setReasoningEffort(sessionId, effort) { return (await ensureRuntime()).setReasoningEffort(sessionId, effort); },
+        async resume(sessionId, prompt, attachments) { const id = await (await ensureRuntime()).resume(sessionId, prompt, attachments); bump(id); return id; },
+        async fork(sessionId, prompt, attachments) { const id = await (await ensureRuntime()).fork(sessionId, prompt, attachments); bump(id); return id; },
+        async steer(sessionId, prompt, attachments) { return (await ensureRuntime()).steer(sessionId, prompt, attachments); },
+        async compact(sessionId) { return (await ensureRuntime()).compact(sessionId); },
+        async contextStatus(sessionId) { return (await ensureRuntime()).contextStatus?.(sessionId) ?? { schema: 'talos.cli.context-status.v1', sessionId, available: false, reason: 'runtime-unavailable', measurement: null, budget: null, autoCompaction: { enabled: false, triggerRatio: 0.5, triggerPercent: 50, targetRatio: null, provenance: 'runtime-supervisor' }, cache: { promptTokens: null, cachedTokens: null, percent: null, provenance: 'unavailable' }, cost: { usd: null, provenance: 'unavailable' }, sources: { activeVersionId: null, activeSourceCount: null, summaryCitationCount: null, provenance: 'unavailable' } }; },
+        async listSessions() { return (await ensureRuntime()).listSessions(); },
+        subscribe,
+        async answerApproval(sessionId, requestId, approved) { return (await ensureRuntime()).answerApproval(sessionId, requestId, approved); },
+        async cancel(sessionId) {
+            const generation = generations.get(sessionId) ?? 0;
+            const key = `${sessionId}:${generation}`;
+            const existing = cancelInFlight.get(key);
+            if (existing)
+                return existing;
+            const task = (async () => { try {
+                await (await ensureRuntime()).cancel(sessionId);
+            }
+            catch (error) {
+                cancelInFlight.delete(key);
+                throw error;
+            } })();
+            cancelInFlight.set(key, task);
+            return task;
+        },
+        async shell(sessionId, command) { return (await ensureRuntime()).shell(sessionId, command); },
+        export(sessionId) { return current?.export(sessionId) ?? null; },
+        supervisorEvidence() { return evidence.map(row => ({ ...row, details: { ...row.details } })); },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                await current?.close();
+            }
+            finally {
+                current = null;
+                await journal?.releaseOwned();
+            }
+        },
+    };
+    /* The entries ask the runtime they hold, this supervisor, where a run's key comes from; the composed runtime inside knows. */
+    forwardKeyOrigin(supervised, () => current);
+    return supervised;
+}