talos-code 0.0.1 → 0.2.0

package/dist/runtime/provider-attempts.js

@@ -0,0 +1,185 @@
+/*
+ * R5a lane R, S3/S4 — owner decisions Q-R5-4 and Q-R5-6 (2026-09-24): the facts the kernel does not publish, observed by the
+ * CLI around each model run and handed to the screen and to protocol v2 as transient CLI events.
+ *
+ * A CLI event is an AG-UI `CUSTOM` row named `talos.cli.*` (the kernel's own CUSTOM rows are `talos.context`,
+ * `consumo-fornitore`, `cambio-fornitore`): protocol v1 maps no CUSTOM row (events/bridge.ts MAP), so v1 stays byte-frozen
+ * (gate E3); the v2 bridge turns them into `provider.attempt` / `context.compacted` and folds `provider.failure` into the
+ * next `run.failed`. They carry no `_sequenza`: they are live facts, never replayed, never persisted.
+ *
+ * What is observed, and where:
+ * - each retry WAIT, from the kernel's own callback (`onRetryWait`, the owner's amendment to talosHarness.mjs): attempt,
+ *   status, the wait the provider asked for and the wait actually taken, so the screen can count down a known wait;
+ * - the failure that ends a run: the HTTP status the kernel keeps on the thrown error (`stato`, talosHarness.mjs
+ *   `chiamaConRitentaBase`, and `erroreFornitorePubblico` in runtime-owner-adapter.mjs), which agent-service.mjs:1991 drops
+ *   when it writes `RunError{message, code}`; and the provider's requested wait, read by this module's fetch observer,
+ *   because the multi-provider wrapper rebuilds the error without it. With the status, 401 and 403 get their own words;
+ * - the kernel's own compaction (every 8 model calls once the estimate passes 2,000 tokens, talosHarness.mjs:195-222),
+ *   which emits no event and was NOT approved as a kernel change: it is recognised at the network boundary the CLI already
+ *   owns, by the kernel's two fixed texts — the English summary request it appends (`RICHIESTA_DI_RIASSUNTO`, first line)
+ *   and the marker it puts in place of the history (`[conversazione compattata al giro …`). Both are pinned against the
+ *   kernel source by r5a-r-provider-attempts.test.ts, so a reworded kernel turns a test red instead of going silent.
+ */
+export const CLI_EVENT = Object.freeze({
+    attempt: 'talos.cli.provider.attempt',
+    failure: 'talos.cli.provider.failure',
+    compacted: 'talos.cli.context.compacted',
+    /* R5b (R5a open 2): one Context Engine summary requested; whether it was accepted is the engine's committed version. */
+    summaryRequested: 'talos.cli.context.summary-requested',
+});
+/** The owner's cap (Q-R5-6): a provider's requested wait is honoured up to 60 s; a longer one ends the retries. */
+export const RETRY_AFTER_MAX_MS = 60_000;
+/** The kernel's summary request (talosHarness.mjs `RICHIESTA_DI_RIASSUNTO`), its first words; pinned by test. */
+export const KERNEL_SUMMARY_REQUEST_START = 'Before continuing, summarize your progress on this task so far';
+/** The kernel's replacement for a compacted history (talosHarness.mjs `compattaConversazione`); pinned by test. */
+export const KERNEL_COMPACTED_MARKER_START = '[conversazione compattata al giro ';
+function finiteOrNull(value) { return typeof value === 'number' && Number.isFinite(value) ? value : null; }
+function nonNegativeInteger(value) { const n = finiteOrNull(value); return n !== null && n >= 0 ? Math.round(n) : null; }
+/** The wait a provider asks for, in ms, or null: `retry-after-ms`, then `Retry-After` seconds or HTTP date (as the kernel). */
+export function retryAfterMs(headers, now = Date.now()) {
+    const read = (name) => { try {
+        return typeof headers?.get === 'function' ? headers.get(name) : null;
+    }
+    catch {
+        return null;
+    } };
+    const ms = read('retry-after-ms');
+    if (ms !== null && ms.trim() !== '' && Number.isFinite(Number(ms)))
+        return Math.max(0, Math.round(Number(ms)));
+    const value = read('retry-after');
+    if (value === null || value.trim() === '')
+        return null;
+    if (/^\d+(?:\.\d+)?$/u.test(value.trim()))
+        return Math.round(Number(value.trim()) * 1000);
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? null : Math.max(0, date - now);
+}
+export function attemptEvent(info) {
+    const row = info && typeof info === 'object' ? info : null;
+    const attempt = nonNegativeInteger(row?.attempt), maxAttempts = nonNegativeInteger(row?.maxAttempts);
+    if (attempt === null || maxAttempts === null)
+        return null;
+    const value = { attempt, maxAttempts, status: nonNegativeInteger(row?.status), retryAfterMs: nonNegativeInteger(row?.retryAfterMs), waitMs: nonNegativeInteger(row?.waitMs) };
+    return { type: 'CUSTOM', name: CLI_EVENT.attempt, value };
+}
+export function compactionEvent(fact) { return { type: 'CUSTOM', name: CLI_EVENT.compacted, value: { ...fact } }; }
+export function summaryRequestedEvent() { return { type: 'CUSTOM', name: CLI_EVENT.summaryRequested, value: {} }; }
+export function failureEvent(fact) { return { type: 'CUSTOM', name: CLI_EVENT.failure, value: { ...fact } }; }
+/** Per-session listeners for the CLI's transient events; the composition merges them into `subscribe`. */
+export function createCliEventHub() {
+    const listeners = new Map();
+    return {
+        emit(sessionId, event) {
+            for (const listener of [...(listeners.get(sessionId) ?? [])]) {
+                try {
+                    listener(event);
+                }
+                catch { /* a listener's failure is its own */ }
+            }
+        },
+        subscribe(sessionId, listener) {
+            let set = listeners.get(sessionId);
+            if (!set) {
+                set = new Set();
+                listeners.set(sessionId, set);
+            }
+            set.add(listener);
+            return () => { const current = listeners.get(sessionId); current?.delete(listener); if (current && current.size === 0)
+                listeners.delete(sessionId); };
+        },
+        size(sessionId) { return listeners.get(sessionId)?.size ?? 0; },
+    };
+}
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content))
+        return content.map(part => part && typeof part === 'object' && typeof part.text === 'string' ? part.text : '').join('');
+    return '';
+}
+function requestBody(init) {
+    if (typeof init?.body !== 'string')
+        return null;
+    try {
+        return JSON.parse(init.body);
+    }
+    catch {
+        return null;
+    }
+}
+function conversationOf(body) { return Array.isArray(body?.messages) ? body.messages : null; }
+function isSummaryRequest(messages) {
+    const last = messages.at(-1);
+    return last?.role === 'user' && textOf(last.content).startsWith(KERNEL_SUMMARY_REQUEST_START);
+}
+function carriesCompactedMarker(messages) {
+    return messages.some(message => message?.role === 'user' && textOf(message.content).startsWith(KERNEL_COMPACTED_MARKER_START));
+}
+const SYSTEM_ROLES = new Set(['system', 'developer']);
+/**
+ * One model run's observer. `fetchDiRete` wraps the innermost transport the owner adapter uses (talosLavora's
+ * `input.fetchDiRete`, runtime-owner-adapter.mjs:1193): every real HTTP request of the run passes through it, retries and
+ * fallback providers included. It never changes a request or a response.
+ */
+export function createRunObserver({ sessionId, hub, baseFetch = (input, init) => fetch(input, init), now = () => Date.now() }) {
+    let lastResponse = null;
+    /* The requested wait of the latest real failed response, until the kernel reads it (`retryAfterMsFn`). */
+    let unreadWait = null;
+    let pending = null;
+    const emit = (event) => { if (event)
+        hub.emit(sessionId, event); };
+    async function fetchDiRete(input, init) {
+        const messages = conversationOf(requestBody(init));
+        let summary = null;
+        if (messages) {
+            if (isSummaryRequest(messages)) {
+                /* Summarised: everything but the system prompt, the task (kept word for word) and the summary request itself. */
+                const conversation = messages.filter(message => !SYSTEM_ROLES.has(String(message?.role)));
+                summary = { messagesSummarized: Math.max(0, conversation.length - 2), tokensBefore: null };
+            }
+            else if (pending) {
+                const done = pending;
+                pending = null;
+                if (carriesCompactedMarker(messages))
+                    emit(compactionEvent({ engine: 'kernel', messagesSummarized: done.messagesSummarized, tokensBefore: done.tokensBefore, tokensAfter: null, trigger: 'automatic' }));
+            }
+        }
+        const response = await baseFetch(input, init);
+        if (messages) {
+            lastResponse = { status: response.status, retryAfterMs: response.ok ? null : retryAfterMs(response.headers, now()) };
+            unreadWait = lastResponse.retryAfterMs;
+            if (summary) {
+                pending = summary;
+                /* The summary call is not streamed (talosHarness.mjs `compattaConversazione` passes no onDelta): its reported input
+                   tokens are read from a copy, off the kernel's path. */
+                if (response.ok && typeof response.clone === 'function') {
+                    const holder = summary;
+                    void response.clone().json().then((body) => { const tokens = nonNegativeInteger(body?.usage?.prompt_tokens ?? body?.usage?.input_tokens); if (tokens !== null)
+                        holder.tokensBefore = tokens; }).catch(() => { });
+                }
+            }
+        }
+        return response;
+    }
+    return {
+        fetchDiRete,
+        /** The kernel's `onRetryWait` for this run. */
+        onRetryWait(info) { emit(attemptEvent(info)); },
+        /**
+         * The kernel's `retryAfterMsFn`: the provider's requested wait for the attempt that just failed, read here because the
+         * multi-provider layer hands the kernel a rebuilt response without the provider's headers (runtime-owner-adapter.mjs
+         * `rete`). Read once: an attempt the store answered itself, with no request (a key benched until the wait is over),
+         * finds nothing and the kernel's own backoff applies.
+         */
+        retryAfterMsFn(_info) { const wait = unreadWait; unreadWait = null; return wait; },
+        /** The facts of the error that ended the run, announced BEFORE the kernel's RunError reaches the stream. */
+        announceFailure(error) {
+            const row = error && typeof error === 'object' ? error : null;
+            const status = nonNegativeInteger(row?.stato) ?? nonNegativeInteger(row?.status) ?? (lastResponse && lastResponse.status >= 400 ? lastResponse.status : null);
+            const wait = nonNegativeInteger(row?.retryAfterMs) ?? (lastResponse && lastResponse.status === status ? lastResponse.retryAfterMs : null);
+            if (status === null && wait === null)
+                return;
+            emit(failureEvent({ status, retryAfterMs: wait }));
+        },
+    };
+}

package/dist/runtime/replay-buffer.js

@@ -0,0 +1,153 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object') {
+        const source = value;
+        return Object.fromEntries(Object.keys(source).sort().filter(key => source[key] !== undefined).map(key => [key, canonical(source[key])]));
+    }
+    return value === undefined ? null : value;
+}
+function identity(value) { return JSON.stringify(canonical(value)); }
+export function startOperationFingerprint(input) {
+    const { operationId: _operationId, ...material } = input;
+    return createHash('sha256').update(identity(material)).digest('hex');
+}
+export function createRuntimeReplayBuffer() {
+    const sessions = new Map();
+    return {
+        push(sessionId, event) {
+            const raw = event?._sequenza;
+            const sequence = typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0 ? raw : null;
+            if (sequence === null)
+                return false;
+            let rows = sessions.get(sessionId);
+            if (!rows) {
+                rows = new Map();
+                sessions.set(sessionId, rows);
+            }
+            const eventIdentity = identity(event);
+            const existing = rows.get(sequence);
+            if (existing) {
+                if (existing.identity === eventIdentity)
+                    return false;
+                throw Object.assign(new Error('REPLAY_EVENT_CONFLICT'), { code: 'REPLAY_EVENT_CONFLICT', sessionId, sequence });
+            }
+            rows.set(sequence, { identity: eventIdentity, event: structuredClone(event) });
+            return true;
+        },
+        after(sessionId, sequence = 0) {
+            return [...(sessions.get(sessionId)?.entries() ?? [])]
+                .filter(([candidate]) => candidate > sequence)
+                .sort(([a], [b]) => a - b)
+                .map(([, row]) => structuredClone(row.event));
+        },
+        latest(sessionId) {
+            const keys = [...(sessions.get(sessionId)?.keys() ?? [])];
+            return keys.length ? Math.max(...keys) : 0;
+        },
+        clear(sessionId) { if (sessionId)
+            sessions.delete(sessionId);
+        else
+            sessions.clear(); },
+    };
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+function ownerPid(name) {
+    const match = /\.(\d+)\.json$/u.exec(name);
+    if (!match)
+        return null;
+    const value = Number(match[1]);
+    return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function operationPath(root, operationId, pid) {
+    return join(root, `${encodeURIComponent(operationId)}.${pid}.json`);
+}
+async function readRecord(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (value?.schema !== 'talos.cli.runtime-start-operation.v1' || typeof value.operationId !== 'string' || typeof value.fingerprint !== 'string')
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+export function createStartOperationJournal(options) {
+    const pid = options.pid ?? process.pid;
+    const isProcessAlive = options.isProcessAlive ?? processAlive;
+    const nextOperationId = options.operationId ?? randomUUID;
+    const now = options.now ?? (() => new Date().toISOString());
+    const root = options.rootDir;
+    async function ensure() { await mkdir(root, { recursive: true, mode: 0o700 }); }
+    return {
+        async claim(fingerprint) {
+            await ensure();
+            let names = [];
+            try {
+                names = await readdir(root);
+            }
+            catch { }
+            for (const name of names.sort()) {
+                if (!name.endsWith('.json'))
+                    continue;
+                const oldPid = ownerPid(name);
+                if (oldPid === null || oldPid === pid || isProcessAlive(oldPid))
+                    continue;
+                const source = join(root, name);
+                const record = await readRecord(source);
+                if (!record || record.fingerprint !== fingerprint)
+                    continue;
+                const target = operationPath(root, record.operationId, pid);
+                try {
+                    await rename(source, target);
+                }
+                catch (error) {
+                    if (error?.code === 'ENOENT' || error?.code === 'EEXIST')
+                        continue;
+                    throw error;
+                }
+                const claimed = { ...record, pid };
+                await writeFile(target, `${JSON.stringify(claimed)}\n`, { encoding: 'utf8', mode: 0o600 });
+                return { operationId: record.operationId, recovered: true };
+            }
+            for (let attempt = 0; attempt < 16; attempt++) {
+                const id = nextOperationId();
+                const file = operationPath(root, id, pid);
+                const record = { schema: 'talos.cli.runtime-start-operation.v1', operationId: id, fingerprint, pid, createdAt: now() };
+                try {
+                    await writeFile(file, `${JSON.stringify(record)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+                    return { operationId: id, recovered: false };
+                }
+                catch (error) {
+                    if (error?.code === 'EEXIST')
+                        continue;
+                    throw error;
+                }
+            }
+            throw Object.assign(new Error('RUNTIME_OPERATION_ID_UNAVAILABLE'), { code: 'RUNTIME_OPERATION_ID_UNAVAILABLE' });
+        },
+        async releaseOwned() {
+            await ensure();
+            let names = [];
+            try {
+                names = await readdir(root);
+            }
+            catch {
+                return;
+            }
+            await Promise.all(names.filter(name => ownerPid(name) === pid).map(name => rm(join(root, name), { force: true })));
+        },
+    };
+}

package/dist/runtime/repo.js

@@ -0,0 +1,95 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+function isTalosRuntimeRoot(root, exists) {
+    return exists(join(root, 'harness-ui', 'src', 'session-registry.mjs'));
+}
+function firstRuntimeRoot(candidates, exists) {
+    for (const candidate of candidates) {
+        const root = resolve(candidate);
+        if (isTalosRuntimeRoot(root, exists))
+            return root;
+    }
+    return null;
+}
+function findAncestorRuntimeRoot(start, exists) {
+    let current = resolve(start);
+    for (let i = 0; i < 16; i++) {
+        if (isTalosRuntimeRoot(current, exists))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function moduleDirectory(moduleUrl) {
+    try {
+        return dirname(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return null;
+    }
+}
+function installedAppCandidates(appRoot) {
+    return [resolve(appRoot, 'vendor'), resolve(appRoot)];
+}
+export function findTalosRepoRoot(start = process.cwd(), deps = {}) {
+    const exists = deps.exists ?? existsSync;
+    const env = deps.env ?? process.env;
+    // The running CLI module is the strongest anchor. In the packaged tree this file is
+    // app/dist/runtime/repo.js, so ../.. is app and app/vendor is the shipped backend.
+    // In a source/build checkout the ancestor walk from the module finds the repository
+    // without consulting whatever project directory the user happens to be in.
+    const moduleDir = moduleDirectory(deps.moduleUrl ?? import.meta.url);
+    if (moduleDir) {
+        const appRoot = resolve(moduleDir, '..', '..');
+        const installed = firstRuntimeRoot(installedAppCandidates(appRoot), exists);
+        if (installed)
+            return installed;
+        const source = findAncestorRuntimeRoot(moduleDir, exists);
+        if (source)
+            return source;
+    }
+    // The Windows launcher already sets this to the staged/installed root. It is an
+    // internal launch contract, not a variable users must configure.
+    const launcherRoot = env.TALOS_CLI_ROOT?.trim();
+    if (launcherRoot) {
+        const installed = firstRuntimeRoot(installedAppCandidates(resolve(launcherRoot, 'app')), exists);
+        if (installed)
+            return installed;
+    }
+    // Compatibility with the bundled Node layout: <root>/runtime/node.exe beside <root>/app.
+    const app = resolve(dirname(deps.execPath ?? process.execPath), '..', 'app');
+    const bundled = firstRuntimeRoot(installedAppCandidates(app), exists);
+    if (bundled)
+        return bundled;
+    // Advanced developer override. A bad explicit override is an error; it never falls
+    // through to an unrelated working-directory runtime.
+    const configured = env.TALOS_CLI_RUNTIME_ROOT?.trim();
+    if (configured) {
+        const root = resolve(configured);
+        if (isTalosRuntimeRoot(root, exists))
+            return root;
+        throw new Error('TALOS_RUNTIME_ROOT_INVALID');
+    }
+    // Last-resort source/developer compatibility only. Installed launches have already
+    // resolved above, so an arbitrary CWD cannot shadow the shipped runtime.
+    const cwd = findAncestorRuntimeRoot(start, exists);
+    if (cwd)
+        return cwd;
+    throw new Error('TALOS_RUNTIME_NOT_FOUND');
+}
+export async function importTalosModule(repoRoot, relativeFromHarnessSrc) {
+    const file = join(repoRoot, 'harness-ui', 'src', relativeFromHarnessSrc);
+    return import(__rewriteRelativeImportExtension(pathToFileURL(file).href));
+}

package/dist/runtime/session-facade.js

@@ -0,0 +1,135 @@
+import { renderPromptWithAttachments, validateCliAttachments } from "./attachments.js";
+import { CliRuntimeError } from "./types.js";
+import { normalizeSessionSummaries } from "./session-summary.js";
+import { buildContextStatus, unavailableContextStatus } from "./context-status.js";
+function registryPermission(mode) { if (mode === 'plan')
+    return 'Read only'; if (mode === 'acceptEdits' || mode === 'bypassPermissions')
+    return 'Workspace write'; return 'On request'; }
+export function createSessionFacade(registry, { model, origin = 'talos-cli', modelImageCapability, materializeImage }) {
+    const cancelled = new Set();
+    let restored = false;
+    let defaultReasoningEffort = null;
+    async function restore() { const x = typeof registry.ripristina === 'function' ? await registry.ripristina() : {}; restored = true; return { restored: Number(x?.ripristinate ?? x?.restored ?? 0), total: Number(x?.totali ?? x?.total ?? 0) }; }
+    async function ensure() { if (!restored)
+        await restore(); }
+    function sessionModel(sessionId) { let rows = []; try {
+        rows = typeof registry.elenca === 'function' ? registry.elenca() : [];
+    }
+    catch {
+        rows = [];
+    } const row = rows.find(candidate => candidate?.sessionId === sessionId); return typeof row?.modello === 'string' && row.modello.trim() ? row.modello.trim() : null; }
+    async function prepare(prompt, runModel, attachments) {
+        const rows = validateCliAttachments(attachments);
+        if (rows.length && !String(prompt ?? '').trim())
+            throw new CliRuntimeError('ATTACHMENT_PROMPT_REQUIRED', 'Attachments require a prompt.');
+        const images = rows.filter((row) => row.kind === 'image');
+        const stored = [];
+        if (images.length) {
+            let capability = null;
+            try {
+                capability = runModel && modelImageCapability ? await modelImageCapability(runModel) : null;
+            }
+            catch {
+                capability = null;
+            }
+            if (capability !== true)
+                throw new CliRuntimeError('MODEL_IMAGE_UNSUPPORTED', 'The selected model does not affirm image input support.', { model: runModel });
+            if (!materializeImage)
+                throw new CliRuntimeError('IMAGE_ATTACHMENT_UNAVAILABLE', 'Image attachment storage is unavailable.');
+            for (const image of images) {
+                try {
+                    stored.push(await materializeImage(image));
+                }
+                catch (error) {
+                    if (typeof error?.code === 'string')
+                        throw error;
+                    throw new CliRuntimeError('IMAGE_ATTACHMENT_MATERIALIZE_FAILED', 'The image could not be stored safely.');
+                }
+            }
+        }
+        return { prompt: renderPromptWithAttachments(String(prompt ?? ''), rows), images: stored };
+    }
+    async function contextStatus(sessionId) {
+        await ensure();
+        if (typeof registry.statoContesto !== 'function')
+            return unavailableContextStatus(sessionId, 'runtime-unavailable');
+        const raw = await registry.statoContesto(sessionId);
+        if (raw?.unavailableReason)
+            return unavailableContextStatus(sessionId, String(raw.unavailableReason));
+        const rows = typeof registry.elenca === 'function' ? [...registry.elenca()] : [];
+        const usage = normalizeSessionSummaries(rows).find(row => row.id === sessionId || row.sessionId === sessionId)?.usage ?? null;
+        return buildContextStatus({ sessionId, snapshot: raw, sessionUsage: usage });
+    }
+    async function start(input) { await ensure(); const prepared = await prepare(input.prompt, input.model || model, input.attachments); const reasoningEffort = input.reasoningEffort ?? defaultReasoningEffort; const x = registry.avviaLibero({ cartellaLibera: input.projectRoot, consegna: prepared.prompt, modello: input.model || model, permessi: registryPermission(input.permissionMode), ...(reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {}), ...(prepared.images.length ? { immagini: prepared.images } : {}), ...(input.operationId ? { operationId: input.operationId } : {}) }, { kind: origin }); if (x?.erroreAvvio)
+        throw new CliRuntimeError(x.code ?? 'RUNTIME_START_FAILED', x.erroreAvvio); if (typeof x?.sessionId !== 'string')
+        throw new CliRuntimeError('RUNTIME_START_FAILED'); cancelled.delete(x.sessionId); return x.sessionId; }
+    return { restore, start, setDefaultReasoningEffort(effort) { defaultReasoningEffort = effort; }, async setReasoningEffort(sessionId, effort) { await ensure(); if (typeof registry.aggiornaImpostazioni !== 'function')
+            throw new CliRuntimeError('SESSION_SETTINGS_UNAVAILABLE'); const x = await registry.aggiornaImpostazioni(sessionId, { reasoning: { effort } }); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_SETTINGS_FAILED', x.erroreAvvio); if (x?.ok !== true)
+            throw new CliRuntimeError('SESSION_SETTINGS_FAILED'); }, async resume(sessionId, prompt, attachments) { await ensure(); if (typeof registry.resume !== 'function')
+            throw new CliRuntimeError('SESSION_RESUME_UNAVAILABLE'); const prepared = await prepare(prompt, sessionModel(sessionId), attachments); const x = registry.resume(sessionId, prepared.prompt.trim() || null, prepared.images); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_RESUME_FAILED', x.erroreAvvio); if (typeof x?.sessionId !== 'string')
+            throw new CliRuntimeError('SESSION_RESUME_FAILED'); cancelled.delete(x.sessionId); return x.sessionId; }, async fork(sessionId, prompt, attachments) { await ensure(); if (typeof registry.forka !== 'function')
+            throw new CliRuntimeError('SESSION_FORK_UNAVAILABLE'); const prepared = await prepare(prompt, sessionModel(sessionId), attachments); const x = registry.forka(sessionId); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_FORK_FAILED', x.erroreAvvio); if (typeof x?.sessionId !== 'string')
+            throw new CliRuntimeError('SESSION_FORK_FAILED'); if (prepared.prompt.trim()) {
+            if (typeof registry.accodaMessaggio !== 'function')
+                throw new CliRuntimeError('SESSION_QUEUE_UNAVAILABLE');
+            const q = registry.accodaMessaggio(x.sessionId, prepared.prompt.trim(), prepared.images);
+            if (q?.erroreAvvio)
+                throw new CliRuntimeError(q.code ?? 'SESSION_QUEUE_FAILED', q.erroreAvvio);
+        } return x.sessionId; }, async steer(sessionId, prompt, attachments) { await ensure(); if (typeof registry.reindirizza !== 'function')
+            throw new CliRuntimeError('SESSION_STEER_UNAVAILABLE', 'Steering is unavailable for this runtime.'); const text = String(prompt ?? '').trim(); if (!text)
+            throw new CliRuntimeError('STEER_TEXT_REQUIRED', 'Steering text is required.'); const prepared = await prepare(text, sessionModel(sessionId), attachments); const x = registry.reindirizza(sessionId, prepared.prompt.trim(), prepared.images.length ? { immagini: prepared.images } : {}); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_STEER_REJECTED', x.erroreAvvio); if (x?.ok !== true || typeof x?.redirectId !== 'string' || !x.redirectId)
+            throw new CliRuntimeError('SESSION_STEER_REJECTED', 'The runtime did not accept the steering request.'); return { redirectId: x.redirectId }; }, async compact(sessionId) { await ensure(); if (typeof registry.compatta !== 'function')
+            throw new CliRuntimeError('SESSION_COMPACT_UNAVAILABLE'); const x = await registry.compatta(sessionId); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_COMPACT_FAILED', x.erroreAvvio); return x; }, contextStatus, async listSessions() {
+            await ensure();
+            const rows = typeof registry.elenca === 'function' ? [...registry.elenca()] : [];
+            const evidence = new Map();
+            if (typeof registry.elencaFigli === 'function') {
+                const parentIds = [...new Set(rows.map((row) => typeof row?.padreId === 'string' && row.padreId.trim() ? row.padreId : null).filter((value) => value !== null))];
+                for (const parentId of parentIds) {
+                    let result = null;
+                    try {
+                        result = registry.elencaFigli(parentId);
+                    }
+                    catch {
+                        result = null;
+                    }
+                    for (const child of Array.isArray(result?.figli) ? result.figli : []) {
+                        const childId = typeof child?.sessionId === 'string' ? child.sessionId : null;
+                        if (!childId)
+                            continue;
+                        evidence.set(childId, { ...(evidence.get(childId) ?? {}), child });
+                    }
+                }
+            }
+            if (typeof registry.elencaProcessi === 'function') {
+                for (const row of rows) {
+                    if (row?.inAttesaApprovazione !== true || typeof row?.sessionId !== 'string')
+                        continue;
+                    let result = null;
+                    try {
+                        result = registry.elencaProcessi(row.sessionId);
+                    }
+                    catch {
+                        result = null;
+                    }
+                    const signal = Array.isArray(result?.guardia?.segnalazioni) ? result.guardia.segnalazioni.find((entry) => entry?.soggetto === 'approvazione') : null;
+                    const approval = signal ? { requestId: signal.requestId, waitingMs: signal.fermoDaMs } : null;
+                    if (approval)
+                        evidence.set(row.sessionId, { ...(evidence.get(row.sessionId) ?? {}), approval });
+                }
+            }
+            return normalizeSessionSummaries(rows, evidence);
+        }, subscribe: (id, sink, from = 0) => registry.iscriviti(id, sink, from), async answerApproval(id, rid, approved) { const x = await registry.rispondiApprovazione(id, rid, approved); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'APPROVAL_FAILED', x.erroreAvvio); }, async cancel(id) { if (cancelled.has(id))
+            return; cancelled.add(id); const ok = await registry.ferma(id); if (ok === false)
+            throw new CliRuntimeError('SESSION_NOT_FOUND'); }, async shell(sessionId, command) { await ensure(); const text = String(command ?? '').trim(); if (!text)
+            throw new CliRuntimeError('SHELL_COMMAND_REQUIRED', 'A command is required'); if (typeof registry.shell !== 'function')
+            throw new CliRuntimeError('SESSION_SHELL_UNAVAILABLE'); const x = await registry.shell(sessionId, text); if (x?.erroreAvvio)
+            throw new CliRuntimeError(x.code ?? 'SESSION_SHELL_FAILED', x.erroreAvvio); if (x?.ok !== true)
+            throw new CliRuntimeError('SESSION_SHELL_FAILED'); }, export: (id) => registry.esporta?.(id) ?? null, async close() { await registry.chiudiContesto?.(); } };
+}