talos-code 0.0.1 → 0.2.0

package/dist/commands/provider-cli.js

@@ -0,0 +1,244 @@
+import { kernelProbeDetail } from "../i18n/kernel-map.js";
+import { assertNoUnknownOptions, takeFlag, takeOption, writeValue } from "./context.js";
+import { REASONING_EFFORTS } from "../config/types.js";
+import { importTalosModule } from "../runtime/repo.js";
+import { createEnvironmentKeyConsent, providerOfModel } from "../provider/environment-keys.js";
+import { t } from "../i18n/index.js";
+/*
+ * B1 slice 18 — the command line follows the rules of `/provider`: the store sees an environment key only after it
+ * was approved (`talos provider env-key <id> --use`; nothing said means No), and `set-key` tests the key against its
+ * own provider and saves it only when the test passes. The key is read through the hidden prompt, never from argv.
+ */
+async function runtimeContext(ctx) { return ctx.createRuntimeContext({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot, model: ctx.invocation.model ?? 'openai:gpt-5-mini', environmentKeys: 'consent' }); }
+function environmentKeyOf(row) { return row && row.environmentVariable ? { variable: String(row.environmentVariable), state: row.keySource === 'environment' ? 'approved' : row.keySource === 'environment-declined' ? 'declined' : 'unanswered' } : null; }
+export async function runProviderCommand(ctx, args0) {
+    const args = [...args0];
+    const op = args.shift() ?? 'list';
+    const rc = await runtimeContext(ctx);
+    const store = rc.providerStore;
+    const catalog = rc.tuiCatalog;
+    if (op === 'list') {
+        assertNoUnknownOptions(args);
+        if (typeof rc.providerControlPlane?.list === 'function') {
+            writeValue(ctx, rc.providerControlPlane.list());
+            return 0;
+        }
+        const rows = store.listPublic();
+        let providers = [];
+        try {
+            providers = await catalog?.listProviders?.() ?? [];
+        }
+        catch {
+            providers = [];
+        }
+        writeValue(ctx, rows.map((row) => ({ ...row, environmentKey: environmentKeyOf(providers.find((p) => p.id === row?.id)) })));
+        return 0;
+    }
+    const id = args.shift();
+    if (!id)
+        throw new Error('PROVIDER_REQUIRED');
+    /* P21 (owner decisions 2026-09-26): `talos provider login openrouter` signs in in the browser (the loopback waits for it);
+       `--paste`, or a remote session, uses the code OpenRouter shows. Interactive only (clig.dev: never require a prompt in a
+       script). The key that comes back is tested and saved like `set-key`'s; it is never printed. */
+    if (op === 'login') {
+        const paste = takeFlag(args, '--paste');
+        assertNoUnknownOptions(args);
+        if (id !== 'openrouter')
+            throw Object.assign(new Error('PROVIDER_LOGIN_UNSUPPORTED'), { code: 'PROVIDER_LOGIN_UNSUPPORTED' });
+        if (typeof catalog?.startOpenRouterLogin !== 'function' || typeof catalog?.setProviderKey !== 'function')
+            throw Object.assign(new Error('PROVIDER_LOGIN_UNAVAILABLE'), { code: 'PROVIDER_LOGIN_UNAVAILABLE' });
+        if (!ctx.io.stdinIsTTY || !ctx.io.stdoutIsTTY)
+            throw Object.assign(new Error('LOGIN_REQUIRES_TTY'), { code: 'LOGIN_REQUIRES_TTY' });
+        const login = await catalog.startOpenRouterLogin(paste ? { paste: true } : {});
+        if (login.mode === 'paste')
+            ctx.io.writeErr(`${t('key.login.paste')}\n${login.url}\n`);
+        else
+            ctx.io.writeErr(`${t(login.opened ? 'key.login.opened' : 'key.login.open')}\n${login.url}\n${t('key.login.waiting')}\n`);
+        let key = '';
+        try {
+            if (login.mode === 'paste') {
+                if (!ctx.io.readSecret)
+                    throw Object.assign(new Error('SECRET_INPUT_REQUIRES_TTY'), { code: 'SECRET_INPUT_REQUIRES_TTY' });
+                key = await login.submit(await ctx.io.readSecret(t('key.login.codePrompt')));
+            }
+            else
+                key = await login.key;
+        }
+        catch (error) {
+            login.cancel();
+            const code = String(error?.code ?? 'OAUTH_FAILED');
+            writeValue(ctx, { ok: false, provider: id, code, ...(error?.status ? { httpStatus: error.status } : {}) }, `${t('key.login.failed', { code })}\n`);
+            return 11;
+        }
+        let result;
+        try {
+            result = await catalog.setProviderKey(id, key);
+        }
+        finally {
+            key = '';
+        }
+        const saved = result.saved === true;
+        writeValue(ctx, { ok: saved, provider: id, outcome: result.outcome, httpStatus: result.httpStatus, saved }, `${t('key.login.signedIn', { message: result.message, saved: t(saved ? 'key.login.saved' : 'key.login.notSaved') })}\n`);
+        return saved ? 0 : 11;
+    }
+    if (op === 'set-key') {
+        assertNoUnknownOptions(args);
+        if (!ctx.io.readSecret)
+            throw new Error('SECRET_INPUT_REQUIRES_TTY');
+        if (typeof catalog?.setProviderKey !== 'function')
+            throw Object.assign(new Error('PROVIDER_KEY_TEST_UNAVAILABLE'), { code: 'PROVIDER_KEY_TEST_UNAVAILABLE' }); /* a one-token key test is stated before the key is read, so before anything is sent; nothing further is asked */
+        const notice = typeof catalog.keyTestNotice === 'function' ? catalog.keyTestNotice(id) : null;
+        if (notice)
+            ctx.io.writeErr(`${notice}\n`);
+        let secret = await ctx.io.readSecret(`Key for ${id}: `);
+        let result;
+        try {
+            result = await catalog.setProviderKey(id, secret);
+        }
+        finally {
+            secret = '';
+        }
+        const saved = result.saved === true;
+        writeValue(ctx, { ok: saved, provider: id, outcome: result.outcome, httpStatus: result.httpStatus, saved }, `${result.message} ${saved ? 'Saved.' : 'The key was not saved.'}\n`);
+        return saved ? 0 : 11;
+    }
+    if (op === 'env-key') {
+        const use = takeFlag(args, '--use');
+        const decline = takeFlag(args, '--decline');
+        assertNoUnknownOptions(args);
+        if (use && decline)
+            throw new Error('Use either --use or --decline');
+        const row = (await catalog.listProviders()).find((p) => p.id === id);
+        if (!row)
+            throw Object.assign(new Error('PROVIDER_INVALID'), { code: 'PROVIDER_INVALID' });
+        const answering = use || decline;
+        if (answering && row.environmentVariable)
+            await catalog.answerEnvironmentKey(id, use ? 'yes' : 'no');
+        const after = answering ? (await catalog.listProviders()).find((p) => p.id === id) : row;
+        const state = environmentKeyOf(after);
+        if (!state) {
+            writeValue(ctx, { ok: !answering, provider: id, environmentKey: null }, `No key for ${after?.label ?? id} was found in the environment.\n`);
+            return answering ? 2 : 0;
+        }
+        writeValue(ctx, { ok: true, provider: id, environmentKey: state }, `${state.variable}: ${state.state === 'approved' ? 'used for ' + after.label : state.state === 'declined' ? 'declined, not used' : 'not used until approved (talos provider env-key ' + id + ' --use)'}\n`);
+        return 0;
+    }
+    if (op === 'remove-key') {
+        assertNoUnknownOptions(args);
+        store.clearKey(id);
+        rc.providerControlPlane?.invalidate?.(id);
+        writeValue(ctx, { ok: true, provider: id }, `Removed key for ${id}\n`);
+        return 0;
+    }
+    if (op === 'configure') {
+        const endpoint = takeOption(args, '--endpoint');
+        const timeoutRaw = takeOption(args, '--timeout');
+        assertNoUnknownOptions(args);
+        const current = store.getRuntime(id) ?? {};
+        const timeoutSeconds = timeoutRaw === undefined ? current.timeoutSeconds : Number(timeoutRaw);
+        if (timeoutRaw !== undefined && (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 5 || timeoutSeconds > 300))
+            throw new Error('PROVIDER_TIMEOUT_INVALID');
+        if (endpoint === undefined && timeoutRaw === undefined)
+            throw new Error('PROVIDER_CONFIG_REQUIRED');
+        store.setRuntime(id, { ...current, ...(endpoint !== undefined ? { endpoint } : {}), ...(timeoutSeconds !== undefined ? { timeoutSeconds } : {}) });
+        rc.providerControlPlane?.invalidate?.(id);
+        writeValue(ctx, { ok: true, provider: id, runtime: store.getRuntime(id) }, `Configured ${id}\n`);
+        return 0;
+    }
+    if (op === 'test') {
+        assertNoUnknownOptions(args); /* M5-A/M5-C: ordinary health testing never opts into token generation, and remediation is the control-plane decision. */
+        if (typeof rc.providerControlPlane?.probe === 'function') {
+            const profile = await rc.providerControlPlane.probe(id);
+            const health = profile.lastHealth ?? {};
+            const latency = Number.isFinite(health.latencyMs) ? ` · ${health.latencyMs} ms` : ''; /* R2 (E8 / Q-R2-7): a missing key is the one sentence, as a line of its own; the probe's free-text reason (the kernel's, Italian) is mapped by the remediation code and not printed. */
+            const missingKey = profile.remediation?.code === 'add-key';
+            const remedy = missingKey ? `${profile.remediation.message}\n` : profile.remediation?.code && profile.remediation.code !== 'none' ? `Remedy: ${profile.remediation.message}\n` : ''; /* R4 Q-R4-16 (a): the kernel's sentence in English by a pinned template, or not printed. */
+            const mapped = health.detail && !missingKey ? kernelProbeDetail(String(health.detail), { label: String(profile.label ?? id) }) : null;
+            const detail = mapped ? `${mapped}\n` : '';
+            writeValue(ctx, missingKey ? { ...profile, code: 'PROVIDER_KEY_MISSING' } : profile, `${profile.label ?? id}: ${health.state ?? 'unknown'}${latency}\n${detail}${remedy}`);
+            return health.state === 'available' ? 0 : 11;
+        }
+        const probe = typeof rc.providerProbe === 'function' ? rc.providerProbe() : (await importTalosModule(ctx.repoRoot, 'provider-probe.mjs')).createProviderProbe({ leggiChiave: (p) => store.getKey(p), leggiRuntime: (p) => store.getRuntime(p) });
+        const result = await probe.prova(id);
+        writeValue(ctx, result);
+        return result?.esito === 'collegato' ? 0 : 11;
+    }
+    throw new Error(`Unsupported provider operation: ${op}`);
+}
+/*
+ * R2 (gate E14, E-03): `talos model list` for a person — one row per model under English columns, never the raw JSON array; the
+ * MODEL column is exactly what `talos model use` takes (OpenCode `opencode models` prints one id per line and JSON only with
+ * --verbose: `packages/opencode/src/cli/cmd/models.ts:36-46` at 1d6c3c0, 2026-09-24). `--json` keeps the rows unchanged.
+ */
+function contextText(value) {
+    if (!Number.isFinite(value) || Number(value) <= 0)
+        return t('key.models.unknown');
+    const n = Number(value);
+    return n >= 1_000_000 ? `${Number((n / 1_000_000).toFixed(1))}M` : n >= 1000 ? `${Math.round(n / 1000)}K` : String(n);
+}
+function flagText(value) { return value === true ? t('key.models.yes') : value === false ? t('key.models.no') : t('key.models.unknown'); }
+function sourceText(value) { return t(value === 'live' ? 'key.models.source.live' : value === 'configured' ? 'key.models.source.configured' : value === 'documented' ? 'key.models.source.documented' : 'key.models.source.unknown'); }
+export function modelListText(rows, notice) {
+    const head = notice ? `${notice}\n` : '';
+    if (!rows.length)
+        return `${head}${t('key.models.none')}\n`;
+    const table = [[t('key.models.column.model'), t('key.models.column.context'), t('key.models.column.tools'), t('key.models.column.reasoning'), t('key.models.column.availability')],
+        ...rows.map(row => [String(row?.id ?? ''), contextText(row?.contextWindow), flagText(row?.toolCalling), flagText(row?.reasoning), sourceText(row?.source ?? row?.available)])];
+    const widths = table[0].map((_, column) => Math.max(...table.map(line => line[column].length)));
+    const lines = table.map(line => line.map((cell, column) => column === line.length - 1 ? cell : cell.padEnd(widths[column])).join('  '));
+    return `${head}${lines.join('\n')}\n${t('key.models.use')}\n`;
+}
+export async function runModelCommand(ctx, args0) { const args = [...args0]; const op = args.shift() ?? 'list'; if (op === 'effort') {
+    const effort = args.shift();
+    if (!effort)
+        throw new Error('REASONING_EFFORT_REQUIRED');
+    const scope = (takeOption(args, '--scope') ?? 'user');
+    if (!['user', 'project-user'].includes(scope))
+        throw new Error('CONFIG_SCOPE_INVALID');
+    assertNoUnknownOptions(args);
+    const { configSet, configUnset } = await import("../config/commands.js");
+    if (effort === 'default') {
+        await configUnset({ paths: ctx.paths, projectRoot: ctx.projectRoot, scope, path: 'reasoningEffort' });
+        writeValue(ctx, { ok: true, reasoningEffort: null, scope }, `Cleared the ${scope} reasoning-effort override; a lower-precedence setting may still apply, otherwise the model default is used.\n`);
+        return 0;
+    }
+    if (!REASONING_EFFORTS.includes(effort))
+        throw new Error('CONFIG_INVALID_REASONING_EFFORT');
+    await configSet({ paths: ctx.paths, projectRoot: ctx.projectRoot, scope, path: 'reasoningEffort', value: effort });
+    writeValue(ctx, { ok: true, reasoningEffort: effort, scope }, `Using reasoning effort ${effort} (${scope})\n`);
+    return 0;
+} if (op === 'use') {
+    const id = args.shift();
+    if (!id)
+        throw new Error('MODEL_REQUIRED');
+    const scope = (takeOption(args, '--scope') ?? 'user');
+    if (!['user', 'project', 'project-user'].includes(scope))
+        throw new Error('CONFIG_SCOPE_INVALID');
+    assertNoUnknownOptions(args);
+    const provider = providerOfModel(id);
+    const registryModule = await importTalosModule(ctx.repoRoot, 'provider-registry.mjs');
+    if (!provider || !registryModule.REGISTRO_FORNITORI?.[provider])
+        throw Object.assign(new Error('MODEL_PROVIDER_INVALID'), { code: 'MODEL_PROVIDER_INVALID' });
+    const { configSet } = await import("../config/commands.js");
+    await configSet({ paths: ctx.paths, projectRoot: ctx.projectRoot, scope, path: 'model', value: id }); /* choosing a model chooses its provider: the interactive screen starts from the same choice */
+    createEnvironmentKeyConsent({ dataRoot: ctx.paths.dataRoot, registry: registryModule.REGISTRO_FORNITORI, env: {} }).chooseProvider(provider);
+    writeValue(ctx, { ok: true, model: id, scope }, `Using ${id} (${scope})\n`);
+    return 0;
+} if (op === 'list') {
+    const provider = takeOption(args, '--provider');
+    assertNoUnknownOptions(args);
+    const rc = await runtimeContext(ctx);
+    const catalog = rc.tuiCatalog;
+    if (provider) {
+        if (typeof catalog?.providerModels !== 'function')
+            throw Object.assign(new Error('PROVIDER_CATALOG_UNAVAILABLE'), { code: 'PROVIDER_CATALOG_UNAVAILABLE' });
+        const list = await catalog.providerModels(provider);
+        writeValue(ctx, list.rows, modelListText(list.rows, list.notice));
+        return 0;
+    }
+    if (typeof catalog?.listModels !== 'function')
+        throw Object.assign(new Error('PROVIDER_CATALOG_UNAVAILABLE'), { code: 'PROVIDER_CATALOG_UNAVAILABLE' });
+    const rows = await catalog.listModels();
+    writeValue(ctx, rows, modelListText(rows));
+    return 0;
+} throw new Error(`Unsupported model operation: ${op}`); }

package/dist/commands/services-cli.js

@@ -0,0 +1,248 @@
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { assertNoUnknownOptions, takeOption, writeValue } from "./context.js";
+import { importTalosModule } from "../runtime/repo.js";
+import { createMemoryFacade } from "../services/memory-facade.js";
+import { createNotesFacade } from "../services/notes-facade.js";
+import { createTaskBoardFacade } from "../services/task-board-facade.js";
+import { createLibraryFacade } from "../services/library-facade.js";
+import { createForgeFacade } from "../services/forge-facade.js";
+const clean = (v) => { if (Array.isArray(v))
+    return v.map(clean); if (v && typeof v === 'object') {
+    const o = {};
+    for (const [k, x] of Object.entries(v)) {
+        if (/percorso|path/iu.test(k))
+            continue;
+        o[k] = clean(x);
+    }
+    return o;
+} return v; };
+function req(args, what) { const v = args.shift(); if (!v)
+    throw new Error(`${what}_REQUIRED`); return v; }
+export async function runNotesCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const notes = createNotesFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await notes.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), body = req(a, 'BODY');
+    assertNoUnknownOptions(a);
+    r = (await notes.add({ title, content: body })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID');
+    const title = takeOption(a, '--title'), content = takeOption(a, '--body');
+    assertNoUnknownOptions(a);
+    r = (await notes.update(id, { ...(title !== undefined ? { title } : {}), ...(content !== undefined ? { content } : {}) })).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await notes.delete(id)).legacy;
+}
+else if (op === 'link' || op === 'unlink') {
+    const noteId = req(a, 'NOTE_ID'), targetKind = req(a, 'TARGET_KIND'), targetId = req(a, 'TARGET_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'link' ? await notes.link(noteId, targetKind, targetId) : await notes.unlink(noteId, targetKind, targetId);
+}
+else
+    throw new Error(`Unsupported notes operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runTasksCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const tasks = createTaskBoardFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await tasks.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), description = req(a, 'DESCRIPTION'), priority = (takeOption(a, '--priority') ?? 'normal');
+    assertNoUnknownOptions(a);
+    r = (await tasks.add({ title, description, priority })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID');
+    const title = takeOption(a, '--title'), description = takeOption(a, '--description'), priority = takeOption(a, '--priority');
+    assertNoUnknownOptions(a);
+    r = (await tasks.update(id, { ...(title !== undefined ? { title } : {}), ...(description !== undefined ? { description } : {}), ...(priority !== undefined ? { priority } : {}) })).legacy;
+}
+else if (op === 'complete') {
+    const id = req(a, 'ID'), status = (a.shift() ?? 'done');
+    assertNoUnknownOptions(a);
+    r = (await tasks.complete(id, status)).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await tasks.delete(id)).legacy;
+}
+else if (op === 'depend' || op === 'undepend') {
+    const id = req(a, 'TASK_ID'), target = req(a, 'DEPENDENCY_TASK_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'depend' ? await tasks.depend(id, target) : await tasks.undepend(id, target);
+}
+else if (op === 'evidence' || op === 'unevidence') {
+    const id = req(a, 'TASK_ID'), sessionId = req(a, 'SESSION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'evidence' ? await tasks.addEvidence(id, sessionId) : await tasks.removeEvidence(id, sessionId);
+}
+else if (op === 'assign' || op === 'unassign') {
+    const id = req(a, 'TASK_ID'), sessionId = req(a, 'AGENT_SESSION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'assign' ? await tasks.assignAgent(id, sessionId) : await tasks.unassignAgent(id, sessionId);
+}
+else if (op === 'schedule' || op === 'unschedule') {
+    const id = req(a, 'TASK_ID'), automationId = req(a, 'AUTOMATION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'schedule' ? await tasks.attachSchedule(id, automationId) : await tasks.detachSchedule(id, automationId);
+}
+else
+    throw new Error(`Unsupported tasks operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runMemoryCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const memory = createMemoryFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await memory.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'search') {
+    const query = req(a, 'QUERY');
+    assertNoUnknownOptions(a);
+    const x = await memory.search(query);
+    r = x.state === 'ready' ? x.legacy : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), content = req(a, 'CONTENT'), kind = (takeOption(a, '--kind') ?? 'preference');
+    assertNoUnknownOptions(a);
+    r = (await memory.add({ title, content, kind })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID'), title = takeOption(a, '--title'), content = takeOption(a, '--content'), kind = takeOption(a, '--kind');
+    assertNoUnknownOptions(a);
+    r = (await memory.update(id, { ...(title !== undefined ? { title } : {}), ...(content !== undefined ? { content } : {}), ...(kind !== undefined ? { kind } : {}) })).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await memory.delete(id)).legacy;
+}
+else
+    throw new Error(`Unsupported memory operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runLibraryCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const library = createLibraryFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await library.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'search') {
+    const query = req(a, 'QUERY');
+    assertNoUnknownOptions(a);
+    r = (await library.search(query)).legacy;
+}
+else if (op === 'read') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await library.read(id)).legacy;
+}
+else if (op === 'preview') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.preview(id);
+}
+else if (op === 'duplicates') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.duplicates(id);
+}
+else if (op === 'context-ref') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.prepareContextReference(id);
+}
+else if (op === 'import') {
+    const file = req(a, 'FILE');
+    assertNoUnknownOptions(a);
+    r = await library.importFile(file);
+}
+else if (op === 'export') {
+    const id = req(a, 'ID'), out = takeOption(a, '--out');
+    assertNoUnknownOptions(a);
+    if (!out)
+        throw new Error('LIBRARY_EXPORT_OUT_REQUIRED');
+    r = (await library.exportFile(id, out)).legacy;
+}
+else if (op === 'rename') {
+    const id = req(a, 'ID'), name = req(a, 'NAME');
+    assertNoUnknownOptions(a);
+    r = (await library.rename(id, name)).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await library.delete(id)).legacy;
+}
+else
+    throw new Error(`Unsupported library operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runForgeCommand(ctx, args0) {
+    const a = [...args0], op = a.shift() ?? 'list', forgeRoot = join(ctx.paths.dataRoot, 'forge');
+    const base = createForgeFacade({ forgeRoot, repoRoot: ctx.repoRoot });
+    let r;
+    const packageFrom = async () => JSON.parse(await readFile(req(a, 'PACKAGE_FILE'), 'utf8'));
+    const owner = async (sessionId) => { const rc = await ctx.createRuntimeContext({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot, model: ctx.invocation.model ?? 'openai:gpt-5-mini', environmentKeys: 'consent' }); await rc.registry?.ripristina?.(); return createForgeFacade({ forgeRoot, repoRoot: ctx.repoRoot }, { registry: rc.registry }); };
+    if (op === 'list') {
+        assertNoUnknownOptions(a);
+        const x = await base.list();
+        r = x.state === 'ready' ? x.rows : x;
+    }
+    else if (op === 'inspect') {
+        const id = req(a, 'ID');
+        assertNoUnknownOptions(a);
+        r = await base.read(id);
+    }
+    else if (op === 'validate') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = base.validatePackage(pkg);
+    }
+    else if (op === 'scan') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = await base.scanPackage(pkg);
+    }
+    else if (op === 'simulate') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = await base.analyzePackage(pkg);
+    }
+    else if (op === 'install') {
+        const session = takeOption(a, '--session'), pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).installPackage(session, pkg);
+    }
+    else if (op === 'versions') {
+        const id = req(a, 'ID'), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).versions(session, id);
+    }
+    else if (op === 'rollback') {
+        const id = req(a, 'ID'), revision = Number(req(a, 'REVISION')), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (!Number.isSafeInteger(revision) || revision < 1)
+            throw new Error('FORGE_REVISION_INVALID');
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).rollback(session, id, revision);
+    }
+    else if (op === 'enable' || op === 'disable') {
+        const id = req(a, 'ID'), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (session)
+            r = await (await owner(session)).setEnabled(session, id, op === 'enable');
+        else {
+            const m = await importTalosModule(ctx.repoRoot, 'tool-forge-store.mjs');
+            r = await m.abilitaToolForgiato({ cartella: forgeRoot, id, abilitato: op === 'enable' });
+        }
+    }
+    else
+        throw new Error(`Unsupported forge operation: ${op}`);
+    writeValue(ctx, clean(r));
+    return 0;
+}

package/dist/commands/session-cli.js

@@ -0,0 +1,171 @@
+import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { deleteSessionToolOutput } from "../runtime/output-store.js";
+import { exportMarkdown } from "../sessions/export-format.js";
+import { t } from "../i18n/index.js";
+import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
+import { assertNoUnknownOptions, takeOption, writeValue } from "./context.js";
+import { importTalosModule } from "../runtime/repo.js";
+import { keyOriginForEntry, stateKeyOrigin } from "../provider/environment-keys.js";
+import { createSessionMetadataStore, sessionMetadataRoot } from "../sessions/metadata-store.js";
+import { buildSafeSessionShare, writeSafeSessionShare } from "../sessions/share.js";
+/* B1 slice 18: the entry decides. Resuming runs a model, so an environment key is used without asking and its origin is stated; reading sessions asks. */
+async function rc(ctx, environmentKeys) { const c = await ctx.createRuntimeContext({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot, model: ctx.invocation.model ?? 'openai:gpt-5-mini', environmentKeys }); if (typeof c.runtime?.restore === 'function')
+    await c.runtime.restore();
+else
+    await c.registry.ripristina?.(); return c; }
+async function sessionSummaries(c) { if (typeof c.runtime?.listSessions === 'function')
+    return c.runtime.listSessions(); const { normalizeSessionSummaries } = await import("../runtime/session-summary.js"); return normalizeSessionSummaries(c.registry.elenca?.() ?? []); }
+function metadataStore(ctx) { return createSessionMetadataStore({ rootDir: sessionMetadataRoot(ctx.paths.dataRoot) }); }
+async function summariesWithMetadata(ctx, c) { const store = metadataStore(ctx); const rows = await sessionSummaries(c); return Promise.all(rows.map(async (row) => { const metadata = await store.get(row.id ?? row.sessionId); return { ...row, ...(metadata?.name ? { name: metadata.name } : {}), tags: metadata?.tags ?? [], pinned: metadata?.pinned ?? false }; })); }
+function matchesSearch(row, query) { const q = query.trim().toLowerCase(); return [row.id, row.sessionId, row.name, row.project, ...(Array.isArray(row.tags) ? row.tags : [])].some(value => typeof value === 'string' && value.toLowerCase().includes(q)); }
+async function requireSession(c, id) { const row = (await sessionSummaries(c)).find((x) => x.id === id || x.sessionId === id); if (!row)
+    throw new Error('SESSION_NOT_FOUND'); return row; }
+/* R5b D1 (Q-R5-12): the Markdown export is sessions/export-format.ts, shared with the TUI's /export. */
+async function writeExport(out, format, payload) { await mkdir(dirname(resolve(out)), { recursive: true }); let body; if (format === 'json')
+    body = `${JSON.stringify(payload, null, 2)}\n`;
+else if (format === 'jsonl')
+    body = (payload.eventi ?? []).map((e) => JSON.stringify(e)).join('\n') + ((payload.eventi ?? []).length ? '\n' : '');
+else if (format === 'md')
+    body = exportMarkdown(payload, { secrets: secretValuesFromEnvironment(process.env) });
+else
+    throw new Error('SESSION_EXPORT_FORMAT_INVALID'); await writeFile(out, body, { encoding: 'utf8', mode: 0o600 }); try {
+    await chmod(resolve(out), 0o600);
+}
+catch (error) {
+    if (process.platform !== 'win32')
+        throw error;
+} }
+export async function runSessionCommand(ctx, args0) { const args = [...args0]; const op = args.shift() ?? 'list'; const c = await rc(ctx, op === 'resume' ? 'use' : 'consent'); const registry = c.registry; if (op === 'list') {
+    assertNoUnknownOptions(args);
+    writeValue(ctx, await summariesWithMetadata(ctx, c));
+    return 0;
+} if (op === 'search') {
+    const query = args.join(' ').trim();
+    if (!query)
+        throw new Error('SESSION_SEARCH_QUERY_REQUIRED');
+    writeValue(ctx, (await summariesWithMetadata(ctx, c)).filter((row) => matchesSearch(row, query)));
+    return 0;
+} const id = args.shift(); if (!id && op !== 'import')
+    throw new Error('SESSION_ID_REQUIRED'); if (op === 'tag' || op === 'untag' || op === 'pin' || op === 'unpin') {
+    await requireSession(c, id);
+    const store = metadataStore(ctx);
+    let metadata;
+    if (op === 'tag' || op === 'untag') {
+        const tag = args.join(' ');
+        if (!tag.trim())
+            throw new Error('SESSION_TAG_REQUIRED');
+        metadata = op === 'tag' ? await store.addTag(id, tag) : await store.removeTag(id, tag);
+    }
+    else {
+        assertNoUnknownOptions(args);
+        metadata = await store.setPinned(id, op === 'pin');
+    }
+    writeValue(ctx, { ok: true, sessionId: id, tags: metadata.tags, pinned: metadata.pinned });
+    return 0;
+} /* R5b D2 (Q-R5-12): the same name as the TUI's /rename; no name clears it. */ /* R5b D2 (Q-R5-12): the same name as the TUI's /rename; no name clears it. */ if (op === 'rename') {
+    await requireSession(c, id);
+    const name = args.join(' ').trim();
+    const metadata = await metadataStore(ctx).setName(id, name ? name : null);
+    writeValue(ctx, { ok: true, sessionId: id, name: metadata.name ?? null }, `${metadata.name ? t('screen.session.renamedCli', { id: String(id), name: metadata.name }) : t('screen.session.nameClearedCli', { id: String(id) })}\n`);
+    return 0;
+} if (op === 'context') {
+    assertNoUnknownOptions(args);
+    await requireSession(c, id);
+    if (typeof c.runtime?.contextStatus !== 'function')
+        throw new Error('SESSION_CONTEXT_UNAVAILABLE');
+    writeValue(ctx, await c.runtime.contextStatus(id));
+    return 0;
+} if (op === 'show') {
+    assertNoUnknownOptions(args);
+    const row = (await summariesWithMetadata(ctx, c)).find((x) => x.id === id || x.sessionId === id);
+    if (!row)
+        throw new Error('SESSION_NOT_FOUND');
+    const payload = registry.esporta?.(id);
+    writeValue(ctx, { ...row, eventCount: payload?.eventi?.length ?? 0 });
+    return 0;
+} if (op === 'fork') {
+    assertNoUnknownOptions(args);
+    const x = registry.forka(id);
+    if (x?.erroreAvvio)
+        throw Object.assign(new Error(x.erroreAvvio), { code: x.code });
+    writeValue(ctx, { sessionId: x.sessionId, forkedFrom: id }, `${x.sessionId}\n`);
+    return 0;
+} if (op === 'resume') {
+    const prompt = args.length ? args.join(' ') : undefined;
+    const sessionModel = (await sessionSummaries(c)).find((x) => x.id === id || x.sessionId === id)?.model;
+    const origin = prompt?.trim() ? stateKeyOrigin(ctx.io, ctx.invocation.outputFormat, keyOriginForEntry(c.runtime, typeof sessionModel === 'string' && sessionModel ? sessionModel : ctx.invocation.model ?? 'openai:gpt-5-mini', { refuseMissing: true })) : {};
+    const sid = await c.runtime.resume(id, prompt);
+    writeValue(ctx, { sessionId: sid, resumed: true, ...origin }, `${sid}\n`);
+    return 0;
+} if (op === 'share') {
+    const out = takeOption(args, '--out');
+    assertNoUnknownOptions(args);
+    if (!out)
+        throw new Error('SESSION_SHARE_OUT_REQUIRED');
+    const row = await requireSession(c, id);
+    const payload = registry.esporta?.(id);
+    if (!payload)
+        throw new Error('SESSION_NOT_FOUND');
+    const store = metadataStore(ctx);
+    const metadata = await store.get(id);
+    const share = buildSafeSessionShare({ summary: row, metadata, payload, secrets: secretValuesFromEnvironment(process.env) });
+    await writeSafeSessionShare(out, share);
+    writeValue(ctx, { ok: true, sessionId: id, schema: share.schema, redacted: true, out: resolve(out) }, `Shared redacted ${id} to ${out}\n`);
+    return 0;
+} if (op === 'export') {
+    const format = takeOption(args, '--format') ?? 'json';
+    const out = takeOption(args, '--out');
+    assertNoUnknownOptions(args);
+    if (!out)
+        throw new Error('SESSION_EXPORT_OUT_REQUIRED');
+    const payload = registry.esporta?.(id);
+    if (!payload)
+        throw new Error('SESSION_NOT_FOUND');
+    await writeExport(out, format, payload);
+    writeValue(ctx, { ok: true, sessionId: id, format, out: resolve(out) }, `Exported ${id} to ${out}\n`);
+    return 0;
+} if (op === 'delete') {
+    assertNoUnknownOptions(args);
+    const sm = await importTalosModule(ctx.repoRoot, 'session-store.mjs');
+    await sm.eliminaSessionePersistita({ cartellaStore: ctx.paths.sessionsRoot, sessionId: id }); /* R5a E6 (Q-R5-10): the session's kept command outputs go with it. */
+    await deleteSessionToolOutput(ctx.paths.dataRoot, String(id));
+    writeValue(ctx, { ok: true, sessionId: id }, `Deleted ${id}\n`);
+    return 0;
+} if (op === 'import') {
+    const file = id ?? args.shift();
+    if (!file)
+        throw new Error('SESSION_IMPORT_FILE_REQUIRED');
+    assertNoUnknownOptions(args);
+    let info;
+    try {
+        info = await stat(file);
+    }
+    catch {
+        throw new Error('SESSION_IMPORT_INVALID');
+    }
+    if (!info.isFile() || info.size > 256 * 1024 * 1024)
+        throw new Error('SESSION_IMPORT_INVALID');
+    let data;
+    try {
+        data = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        throw new Error('SESSION_IMPORT_INVALID');
+    }
+    const sourceSchema = data?.schema ?? data?.header?.schema;
+    if (sourceSchema !== 'talos.harness-ui.session-export.v1' && sourceSchema !== 'talos.cli.session.v1')
+        throw new Error('SESSION_SCHEMA_UNSUPPORTED');
+    const rawEvents = data.eventi ?? data.events ?? [];
+    if (!Array.isArray(rawEvents))
+        throw new Error('SESSION_IMPORT_INVALID');
+    const safeEvents = rawEvents.filter((e) => e && typeof e === 'object' && e.type !== 'ApprovalRequested');
+    const importId = String(data.sessionId ?? data.header?.sessionId ?? 'imported');
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(importId) || importId.includes('..'))
+        throw new Error('SESSION_IMPORT_ID_INVALID');
+    const target = join(ctx.paths.dataRoot, 'imports', `${importId}.json`);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify({ ...data, eventi: safeEvents, events: undefined, sourceSchema, importedBy: 'talos-cli', importedAt: new Date().toISOString() }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    writeValue(ctx, { ok: true, sessionId: importId, file: target, pendingApprovalsDropped: rawEvents.length - safeEvents.length, runnable: false }, `Imported archive ${importId}\n`);
+    return 0;
+} throw new Error(`Unsupported session operation: ${op}`); }