talos-code 0.0.1 → 0.1.0

package/dist/provider/model-catalog.js

@@ -0,0 +1,168 @@
+import { REASONING_EFFORTS } from "../config/types.js";
+const SOURCE_RANK = Object.freeze({
+    unknown: 0, documented: 1, configured: 2, live: 3,
+});
+const CAPABILITY_RANK = Object.freeze({
+    unknown: 0, configured: 1, documented: 2, live: 3,
+});
+export function catalogSourceFromKernel(source, { successfulCatalogBoundary = false } = {}) {
+    const value = String(source ?? '').trim().toLowerCase().replace(/[_ ]+/gu, '-');
+    if (['config', 'configured', 'configurazione'].includes(value))
+        return 'configured';
+    if (['documented', 'documentation', 'documentazione', 'riserva', 'fallback'].includes(value))
+        return 'documented';
+    if (['live', 'fornitore', 'provider', 'remote', 'runtime', 'runtime-locale'].includes(value))
+        return 'live';
+    if (!value && successfulCatalogBoundary)
+        return 'live';
+    return 'unknown';
+}
+function effortsFrom(...values) {
+    let observed = false;
+    const out = [];
+    for (const value of values) {
+        if (!Array.isArray(value))
+            continue;
+        observed = true;
+        for (const item of value) {
+            if (typeof item !== 'string' || !REASONING_EFFORTS.includes(item))
+                continue;
+            const effort = item;
+            if (!out.includes(effort))
+                out.push(effort);
+        }
+    }
+    return observed ? out : null;
+}
+function evidenceMeta(row) {
+    const url = [row?.fonteMetadati, row?.fonteDichiarazione, row?.metadataSource, row?.declarationSource, row?.fonte]
+        .find(value => typeof value === 'string' && /^(?:https?:\/\/|urn:)/u.test(value)) ?? null;
+    const date = [row?.dataMetadati, row?.dataDichiarazione, row?.metadataDate, row?.declarationDate, row?.data]
+        .find(value => typeof value === 'string' && value.trim() !== '') ?? null;
+    return { url, date };
+}
+function evidence(value, source, meta = { url: null, date: null }) {
+    if (value === null)
+        return { value: null, source: 'unknown', evidenceUrl: null, evidenceDate: null };
+    return { value, source, evidenceUrl: meta.url, evidenceDate: meta.date };
+}
+function documentedCapabilitySource(row, rowSource, kind) {
+    if (rowSource === 'documented')
+        return 'documented';
+    const hasDocumentedMeta = typeof row?.fonteMetadati === 'string' || typeof row?.fonteDichiarazione === 'string'
+        || typeof row?.dataMetadati === 'string' || typeof row?.dataDichiarazione === 'string';
+    return hasDocumentedMeta && (kind === 'context' || kind === 'reasoning') ? 'documented' : rowSource;
+}
+export function normalizeModelRows(rows, provider, source) {
+    const seen = new Set();
+    const out = [];
+    for (const row of rows) {
+        const raw = String(row?.id ?? row?.modelId ?? row?.model ?? '').trim();
+        if (!raw)
+            continue;
+        const id = raw.startsWith(`${provider}:`) ? raw : `${provider}:${raw}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const explicitSource = catalogSourceFromKernel(row?.fonte);
+        const rowSource = explicitSource === 'unknown' ? source : explicitSource;
+        const caps = row?.capacita ?? row?.capabilities ?? {};
+        const supportedParameters = Array.isArray(row?.supported_parameters) ? row.supported_parameters : Array.isArray(row?.supportedParameters) ? row.supportedParameters : null;
+        const supportedParameterSet = supportedParameters ? new Set(supportedParameters.filter((value) => typeof value === 'string').map((value) => value.toLowerCase())) : null;
+        const ownReasoning = row?.reasoning && typeof row.reasoning === 'object' && !Array.isArray(row.reasoning) ? row.reasoning : null;
+        const capReasoning = caps?.reasoning && typeof caps.reasoning === 'object' && !Array.isArray(caps.reasoning) ? caps.reasoning : null;
+        const reasoningEfforts = effortsFrom(row?.reasoningEfforts, row?.livelliRagionamento, row?.ragionamento?.livelli, ownReasoning?.supportedEfforts, ownReasoning?.supported_efforts, ownReasoning?.allowed_options, capReasoning?.supportedEfforts, capReasoning?.supported_efforts, capReasoning?.allowed_options, caps?.ragionamento?.livelli);
+        const structuredReasoning = Boolean(ownReasoning || capReasoning || row?.ragionamento && typeof row.ragionamento === 'object' || caps?.ragionamento && typeof caps.ragionamento === 'object');
+        const reasoning = typeof row?.reasoning === 'boolean' ? row.reasoning
+            : typeof row?.supportsReasoning === 'boolean' ? row.supportsReasoning
+                : typeof caps?.reasoning === 'boolean' ? caps.reasoning
+                    : structuredReasoning || reasoningEfforts !== null || supportedParameterSet?.has('reasoning') === true || supportedParameterSet?.has('include_reasoning') === true ? true : null;
+        const contextWindow = Number.isFinite(row?.contextLength) ? Number(row.contextLength)
+            : Number.isFinite(row?.contextWindow) ? Number(row.contextWindow)
+                : Number.isFinite(row?.finestraContesto) ? Number(row.finestraContesto)
+                    : Number.isFinite(row?.context_length) ? Number(row.context_length) : null;
+        const toolCalling = typeof row?.toolCalling === 'boolean' ? row.toolCalling
+            : typeof row?.supportsTools === 'boolean' ? row.supportsTools
+                : typeof caps?.toolCall === 'boolean' ? caps.toolCall
+                    : typeof caps?.tools === 'boolean' ? caps.tools
+                        : supportedParameterSet?.has('tools') || supportedParameterSet?.has('tool_choice') ? true : null;
+        const explicitModalities = Array.isArray(row?.inputModalities) ? row.inputModalities
+            : Array.isArray(row?.input_modalities) ? row.input_modalities
+                : Array.isArray(row?.architecture?.input_modalities) ? row.architecture.input_modalities
+                    : Array.isArray(row?.architecture?.inputModalities) ? row.architecture.inputModalities : null;
+        const images = explicitModalities ? explicitModalities.includes('image')
+            : typeof row?.images === 'boolean' ? row.images
+                : typeof caps?.images === 'boolean' ? caps.images
+                    : typeof caps?.imageInput === 'boolean' ? caps.imageInput : null;
+        const meta = evidenceMeta(row);
+        const contextSource = documentedCapabilitySource(row, rowSource, 'context');
+        const reasoningSource = documentedCapabilitySource(row, rowSource, 'reasoning');
+        const capabilityEvidence = {
+            contextWindow: evidence(contextWindow, contextSource, contextSource === 'documented' ? meta : { url: null, date: null }),
+            toolCalling: evidence(toolCalling, rowSource, rowSource === 'documented' ? meta : { url: null, date: null }),
+            reasoning: evidence(reasoning, reasoningSource, reasoningSource === 'documented' ? meta : { url: null, date: null }),
+            reasoningEfforts: evidence(reasoningEfforts, reasoningSource, reasoningSource === 'documented' ? meta : { url: null, date: null }),
+            images: evidence(images, rowSource, rowSource === 'documented' ? meta : { url: null, date: null }),
+        };
+        out.push({
+            id, provider, name: String(row?.nome ?? row?.name ?? raw),
+            source: rowSource, available: rowSource, availabilityVerified: rowSource === 'live',
+            contextWindow, toolCalling, reasoning, reasoningEfforts, images,
+            capabilityEvidence,
+        });
+    }
+    return out;
+}
+function preferredCapability(left, right) {
+    if (left.value === null)
+        return right;
+    if (right.value === null)
+        return left;
+    return CAPABILITY_RANK[right.source] > CAPABILITY_RANK[left.source] ? right : left;
+}
+function withFlatCapabilities(row) {
+    const evidence = row.capabilityEvidence;
+    const reasoningEfforts = evidence.reasoningEfforts.value;
+    const reasoning = evidence.reasoning.value ?? (reasoningEfforts !== null ? true : null);
+    return {
+        ...row,
+        contextWindow: evidence.contextWindow.value,
+        toolCalling: evidence.toolCalling.value,
+        reasoning,
+        reasoningEfforts,
+        images: evidence.images.value,
+    };
+}
+function mergeTwo(left, right) {
+    const preferred = SOURCE_RANK[right.source] > SOURCE_RANK[left.source] ? right : left;
+    const capabilityEvidence = {
+        contextWindow: preferredCapability(left.capabilityEvidence.contextWindow, right.capabilityEvidence.contextWindow),
+        toolCalling: preferredCapability(left.capabilityEvidence.toolCalling, right.capabilityEvidence.toolCalling),
+        reasoning: preferredCapability(left.capabilityEvidence.reasoning, right.capabilityEvidence.reasoning),
+        reasoningEfforts: preferredCapability(left.capabilityEvidence.reasoningEfforts, right.capabilityEvidence.reasoningEfforts),
+        images: preferredCapability(left.capabilityEvidence.images, right.capabilityEvidence.images),
+    };
+    return withFlatCapabilities({
+        id: left.id,
+        provider: left.provider,
+        name: preferred.name,
+        source: preferred.source,
+        available: preferred.source,
+        availabilityVerified: preferred.source === 'live',
+        capabilityEvidence,
+    });
+}
+export function mergeModelRows(...rows) {
+    const byId = new Map();
+    const order = [];
+    for (const row of rows) {
+        const previous = byId.get(row.id);
+        if (!previous) {
+            byId.set(row.id, row);
+            order.push(row.id);
+            continue;
+        }
+        byId.set(row.id, mergeTwo(previous, row));
+    }
+    return order.map(id => byId.get(id));
+}

package/dist/provider/provider-text.js

@@ -0,0 +1,13 @@
+/*
+ * R2 (D-05, gate E1/E4): the one place a provider's label and description reach the screen or `talos provider list`. Mapped
+ * by provider ID, never by the kernel's words; the kernel registry (and what the model or the kernel receives) is untouched.
+ */
+import { en, t } from "../i18n/index.js";
+function entry(id, field) {
+    const key = `provider.${id}.${field}`;
+    return Object.hasOwn(en, key) ? t(key) : null;
+}
+/** The English label for provider `id`, or `fallback` (the registry text) when the registry label is already English. */
+export function providerLabelText(id, fallback) { return entry(id, 'label') ?? fallback; }
+/** The English description for provider `id`, or `fallback` (the registry text). */
+export function providerDescriptionText(id, fallback) { return entry(id, 'description') ?? fallback; }

package/dist/provider/store.js

@@ -0,0 +1,95 @@
+import { loadTalosSystemKeyring, systemKeyringAdapter } from "./system-keyring.js";
+import { t } from "../i18n/index.js";
+import { CliRuntimeError } from "../runtime/types.js";
+import { CREDENTIAL_STORES } from "../config/types.js";
+const SERVICE = 'talos-cli-provider';
+function cleanKey(v) { const x = v.trim(); if (!x || x.length > 4096 || /[\r\n\0]/u.test(x))
+    throw new Error('PROVIDER_KEY_INVALID'); return x; }
+export function createCliProviderStore({ env, keyring, definitions }) {
+    const def = (id) => { const d = definitions[id]; if (!d)
+        throw new Error('PROVIDER_INVALID'); return d; };
+    const envKey = (id) => { for (const n of def(id).env) {
+        const v = env[n];
+        if (v?.trim())
+            return cleanKey(v);
+    } return null; };
+    return {
+        async getKey(id) { const e = envKey(id); if (e)
+            return e; const v = await keyring.get(SERVICE, id); return v ? cleanKey(v) : null; },
+        async setKey(id, value) { def(id); await keyring.set(SERVICE, id, cleanKey(value)); },
+        async removeKey(id) { def(id); await keyring.remove(SERVICE, id); },
+        async listPublic() { const rows = []; for (const [id, d] of Object.entries(definitions)) {
+            rows.push({ id, label: d.label ?? id, requiresKey: d.requiresKey, configured: d.requiresKey ? Boolean(await this.getKey(id)) : true });
+        } return rows; },
+    };
+}
+export const CREDENTIAL_STORE_VARIABLE = 'TALOS_CREDENTIAL_STORE';
+export const TEST_PROFILE_VARIABLE = 'TALOS_TEST_PROFILE';
+export function isTestProfile(env) {
+    return env[TEST_PROFILE_VARIABLE] === '1' || (typeof env.NODE_TEST_CONTEXT === 'string' && env.NODE_TEST_CONTEXT !== '');
+}
+export function chooseCredentialStore({ env, config, ownLoader = false }) {
+    const testProfile = isTestProfile(env);
+    const raw = env[CREDENTIAL_STORE_VARIABLE];
+    if (typeof raw === 'string' && raw.trim() !== '') {
+        const kind = raw.trim().toLowerCase();
+        if (!CREDENTIAL_STORES.includes(kind))
+            throw new CliRuntimeError('CREDENTIAL_STORE_INVALID', t('store.invalid', { value: raw.trim(), variable: CREDENTIAL_STORE_VARIABLE }), { variable: CREDENTIAL_STORE_VARIABLE });
+        return { kind: kind, source: 'environment', testProfile };
+    }
+    const configured = config?.credentials?.store;
+    if (configured === 'system' || configured === 'memory')
+        return { kind: configured, source: 'config', testProfile };
+    return testProfile && !ownLoader ? { kind: 'memory', source: 'test-profile', testProfile } : { kind: 'system', source: 'default', testProfile };
+}
+/** The name `doctor` and the refusal give the store: the OS store's own name on this platform. */
+export function credentialStoreName(kind, platform = process.platform) {
+    if (kind === 'memory')
+        return t('store.name.memory');
+    return t(platform === 'win32' ? 'store.name.system.win32' : platform === 'darwin' ? 'store.name.system.darwin' : 'store.name.system.other');
+}
+export function credentialStoreSourceText(choice) {
+    return choice.source === 'environment' ? t('store.source.environment', { variable: CREDENTIAL_STORE_VARIABLE })
+        : choice.source === 'config' ? t('store.source.config') : choice.source === 'test-profile' ? t('store.source.testProfile') : t('store.source.default');
+}
+/* Per profile (Codex keys its ephemeral store by `compute_store_key(codex_home)`): a runtime rebuilt in the same process (the
+   supervisor's restart) still sees a key saved a minute ago, and two profiles in one test process do not share keys. */
+const MEMORY_STORES = new Map();
+export function createMemoryKeyring(scope) {
+    let values = MEMORY_STORES.get(scope);
+    if (!values) {
+        values = new Map();
+        MEMORY_STORES.set(scope, values);
+    }
+    const map = values;
+    const key = (service, account) => `${service}\u0000${account}`;
+    return { get: (service, account) => map.get(key(service, account)) ?? null, set: (service, account, value) => { map.set(key(service, account), value); }, remove: (service, account) => { map.delete(key(service, account)); } };
+}
+let active = null;
+/** The store the last resolution in this process chose (for the sentences that name it), or null before any. */
+export function activeCredentialStore() { return active; }
+/** What `/provider` says after a key passed its test and was saved: where it now lives. */
+export function keySavedText() { return t(active?.kind === 'memory' ? 'store.saved.memory' : 'store.saved.system'); }
+/**
+ * Resolves and opens the store. `scope` separates memory stores (the profile's data root). Throws `CREDENTIAL_STORE_INVALID` or
+ * `CREDENTIAL_STORE_REAL_IN_TEST`; a system store that cannot be loaded is `keyring: null` with its `problem`, as before R2.
+ */
+export function openCredentialStore({ repoRoot, scope, env = process.env, config, loader }) {
+    const ownLoader = typeof loader?.load === 'function';
+    const choice = chooseCredentialStore({ env, config: config ?? null, ownLoader });
+    if (choice.kind === 'system' && choice.testProfile && !ownLoader) {
+        throw new CliRuntimeError('CREDENTIAL_STORE_REAL_IN_TEST', t('store.refusedInTest', { store: credentialStoreName('system'), variable: CREDENTIAL_STORE_VARIABLE }), { store: 'system', source: choice.source });
+    }
+    active = choice;
+    if (choice.kind === 'memory')
+        return { ...choice, keyring: createMemoryKeyring(scope), problem: null };
+    const loaded = loadTalosSystemKeyring(repoRoot, loader ?? {});
+    return loaded.ok ? { ...choice, keyring: systemKeyringAdapter(loaded.Entry), problem: null } : { ...choice, keyring: null, problem: loaded };
+}
+/** R2 (E13): through the resolver, so a test profile never reaches the OS store from here either. */
+export async function createSystemKeyring(repoRoot, { scope = repoRoot, env = process.env, config } = {}) {
+    const opened = openCredentialStore({ repoRoot, scope, env, config: config ?? null });
+    if (!opened.keyring)
+        throw new Error('PROVIDER_STORE_UNAVAILABLE');
+    return opened.keyring;
+}

package/dist/provider/system-keyring.js

@@ -0,0 +1,214 @@
+import { randomUUID } from 'node:crypto';
+import { lstatSync, readlinkSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
+import { t } from "../i18n/index.js";
+/*
+ * ⛔⛔⛔ WHY THE APPROVED-ROOTS GUARD EXISTS — read for B1 slice 19. The file arrived whole with the gold
+ * baseline (7e5b048b, "restore verified gold baseline"), and no commit records the reason, so it is read
+ * from the code, from its test (a fake module in an ANCESTOR `node_modules` must be refused) and from
+ * this host:
+ *
+ * - Node's resolution does not stop at TALOS's own folders. From `harness-ui/package.json` it walks every
+ *   ancestor `node_modules` up to the drive root, then `~/.node_modules`, `~/.node_libraries` and
+ *   `<prefix>/lib/node`.
+ * - On Windows the drive root lets any signed-in account create a folder (`icacls C:\` on this host:
+ *   `NT AUTHORITY\Authenticated Users:(AD)`, and Modify on what they create). Anyone with a local account
+ *   can therefore create `C:\node_modules`.
+ * - `@napi-rs/keyring` is native code that is handed every provider key TALOS stores. Loaded from such a
+ *   folder, it would run with the owner's rights and could read or send the keys anywhere.
+ *
+ * On this host that is what happened, harmlessly: `C:\node_modules` is a junction into another
+ * checkout's `harness-ui\node_modules`, and a worktree without `harness-ui\node_modules` resolved the
+ * keyring there. The guard refused it, correctly; `doctor` just could not say so.
+ *
+ * ⛔ THE CURE: the module must be resolvable INSIDE the approved roots.
+ * - Installed: `cli/scripts/stage-windows.mjs` copies the dependency trees to `app/node_modules` and
+ *   `app/vendor/harness-ui/node_modules`, both approved (read in code, not staged).
+ * - CI: `npm --prefix harness-ui ci`, inside the checkout.
+ * - Development: a `harness-ui\node_modules` inside the checkout — a real install, or ONE junction like the
+ *   `cli\node_modules` every worktree here already has. Node reports the REAL path behind a junction, so
+ *   the lexical roots alone refuse even that.
+ *
+ * ⛔⛔ Round 2, after adversarial review: "the real path of an approved root is approved" was too wide. A
+ * link at the root can be trusted as far as whoever placed it, but not further: the reviewer loaded an
+ * attacker module through a second link someone else could re-point (A2), through a junction into the real
+ * `C:\node_modules` (A3), into an ancestor folder (E), and into the drive root itself (E2). A real path is
+ * approved now only when ALL of these hold:
+ *  1. the approved root is at most a single link, and its target is not a link and not below one — checked
+ *     as realpath(target) equal to the target, which fails for both;
+ *  2. the target is not a drive root;
+ *  3. the target is not an ancestor of the checkout;
+ *  4. the target is not inside a `node_modules` folder of an ancestor of the checkout — the folders Node's
+ *     own lookup reaches, and exactly what `C:\node_modules` is; without this, A3 passes 1-3 on any host
+ *     where that folder is a plain directory instead of a junction;
+ *  5. the module lies under `<target>\@napi-rs\keyring\`.
+ * ⛔ The verdict is reached BEFORE anything is loaded: a refused module never runs a line of code.
+ * ⛔ What this does NOT judge: who may write to the target. A junction to a folder other accounts can write
+ *   into (a shared temporary folder, another drive's subfolder) passes when it satisfies 1-5. The guard
+ *   reads no ACLs.
+ * ⛔ REFUSED as a design: recognising a junction ABOVE the checkout because its target looks like a TALOS
+ *   location. Whoever creates `C:\node_modules` chooses where it points.
+ */
+function inside(root, candidate) {
+    const rel = relative(resolve(root), resolve(candidate));
+    return rel === '' || (!rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel));
+}
+function strictlyInside(root, candidate) { return inside(root, candidate) && relative(resolve(root), resolve(candidate)) !== ''; }
+function samePath(a, b) { return relative(resolve(a), resolve(b)) === ''; }
+function approvedModuleRoots(repoRoot) {
+    const roots = [join(repoRoot, 'harness-ui', 'node_modules'), join(repoRoot, 'node_modules')];
+    if (basename(repoRoot).toLowerCase() === 'vendor')
+        roots.push(join(dirname(repoRoot), 'node_modules'));
+    return roots;
+}
+/** Every folder above the checkout, nearest first, up to the drive root. */
+function ancestorsOf(path) {
+    const out = [];
+    let current = dirname(resolve(path));
+    for (;;) {
+        out.push(current);
+        const next = dirname(current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return out;
+}
+/** One line, bounded: an error's later lines are stack frames, and doctor prints one line per check. */
+function firstLine(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return (text.split(/\r?\n/u)[0] ?? '').slice(0, 300);
+}
+/**
+ * The keyring folder a single link at an approved root may stand for, or null. Rules 1-4 of the block
+ * above; rule 5 is the caller's containment check against the folder returned here.
+ */
+function linkedKeyringFolder(root, repoRoot, fs) {
+    try {
+        if (!fs.lstat(root).isSymbolicLink())
+            return null;
+        const target = resolve(dirname(root), fs.readlink(root));
+        if (!fs.lstat(target).isDirectory())
+            return null;
+        const real = fs.realpath(target);
+        if (!samePath(real, target))
+            return null; /* 1 */
+        if (samePath(parse(real).root, real))
+            return null; /* 2 */
+        if (inside(real, repoRoot))
+            return null; /* 3 */
+        if (ancestorsOf(repoRoot).some(ancestor => inside(join(ancestor, 'node_modules'), real)))
+            return null; /* 4 */
+        return join(real, '@napi-rs', 'keyring');
+    }
+    catch {
+        return null;
+    }
+}
+/*
+ * R2 (gate E13): how many times this process tried to LOAD the native module (after resolution and the approved-roots check, the
+ * step that runs its code). `doctor` reports whether its own run moved it (`nativeModuleLoaded`): the observable by which the
+ * acceptance scenario s16 proves that a memory profile never opened the OS store.
+ */
+let moduleLoads = 0;
+export function systemKeyringModuleLoads() { return moduleLoads; }
+export function loadTalosSystemKeyring(repoRoot, deps = {}) {
+    /* Created on first use and inside the try below: a repoRoot Node refuses as an anchor is a reason, never a throw. */
+    let requireFromTalos;
+    const talosRequire = () => requireFromTalos ??= createRequire(join(repoRoot, 'harness-ui', 'package.json'));
+    const resolveModule = deps.resolve ?? ((request) => talosRequire().resolve(request));
+    const loadModule = deps.load ?? ((file) => talosRequire()(file));
+    const fs = {
+        lstat: deps.lstat ?? ((path) => lstatSync(path)),
+        readlink: deps.readlink ?? ((path) => readlinkSync(path)),
+        realpath: deps.realpath ?? ((path) => realpathSync(path)),
+    };
+    const roots = approvedModuleRoots(repoRoot);
+    let location;
+    try {
+        location = resolveModule('@napi-rs/keyring');
+    }
+    catch (error) {
+        if (error?.code === 'MODULE_NOT_FOUND')
+            return { ok: false, reason: 'module-missing', approvedRoots: roots };
+        return { ok: false, reason: 'load-failed', detail: firstLine(error) };
+    }
+    const lexical = roots.some(root => inside(root, location));
+    const linked = roots.map(root => linkedKeyringFolder(root, repoRoot, fs)).filter((folder) => folder !== null);
+    if (!lexical && !linked.some(folder => strictlyInside(folder, location)))
+        return { ok: false, reason: 'outside-approved-roots', location, approvedRoots: roots }; /* 5 */
+    let mod;
+    moduleLoads++;
+    try {
+        mod = loadModule(location);
+    }
+    catch (error) {
+        return { ok: false, reason: 'load-failed', location, detail: firstLine(error) };
+    }
+    return typeof mod?.Entry === 'function' ? { ok: true, Entry: mod.Entry, location } : { ok: false, reason: 'invalid-module', location };
+}
+export function keyringModuleAvailable(repoRoot, deps = {}) { return loadTalosSystemKeyring(repoRoot, deps).ok; }
+export async function diagnoseKeyringProbe(keyring, account = randomUUID()) {
+    const service = 'talos-cli-doctor';
+    const value = `probe-${randomUUID()}`;
+    try {
+        try {
+            await keyring.set(service, account, value);
+        }
+        catch (error) {
+            return { ok: false, stage: 'write', detail: firstLine(error) };
+        }
+        let read;
+        try {
+            read = await keyring.get(service, account);
+        }
+        catch (error) {
+            return { ok: false, stage: 'read', detail: firstLine(error) };
+        }
+        return read === value ? { ok: true } : { ok: false, stage: 'mismatch' };
+    }
+    finally {
+        try {
+            await keyring.remove(service, account);
+        }
+        catch { /* diagnostic cleanup is best effort */ }
+    }
+}
+export async function probeSystemKeyring(keyring, account = randomUUID()) { return (await diagnoseKeyringProbe(keyring, account)).ok; }
+/*
+ * R2 (gate E1): `KEYRING_TEXT` moved into the dictionary (`i18n/en/credentials.ts`, `store.keyring.*`), words unchanged. These
+ * two functions stay the only place that picks them: `doctor` prints them, and the next surface that needs the reason reuses them.
+ */
+export function describeKeyringProblem(problem) {
+    switch (problem.reason) {
+        case 'module-missing': return t('store.keyring.moduleMissing', { roots: problem.approvedRoots.join('; ') });
+        case 'outside-approved-roots': return t('store.keyring.outsideApprovedRoots', { location: problem.location, roots: problem.approvedRoots.join('; ') });
+        case 'load-failed': return problem.location === undefined ? t('store.keyring.unresolved', { detail: problem.detail }) : t('store.keyring.loadFailed', { location: problem.location, detail: problem.detail });
+        case 'invalid-module': return t('store.keyring.invalidModule', { location: problem.location });
+    }
+}
+export function describeKeyringProbeFailure(outcome) {
+    if (outcome.stage === 'mismatch')
+        return t('store.keyring.probeMismatch');
+    return t(outcome.stage === 'write' ? 'store.keyring.probeWriteFailed' : 'store.keyring.probeReadFailed', { detail: outcome.detail });
+}
+export function systemKeyringAdapter(Entry) {
+    return {
+        get(service, account) { try {
+            return new Entry(service, account).getPassword() || null;
+        }
+        catch {
+            return null;
+        } },
+        set(service, account, value) { new Entry(service, account).setPassword(value); },
+        remove(service, account) { try {
+            new Entry(service, account).deletePassword();
+        }
+        catch { /* idempotent removal */ } },
+    };
+}
+export function createTalosSystemKeyring(repoRoot, deps = {}) {
+    const loaded = loadTalosSystemKeyring(repoRoot, deps);
+    return loaded.ok ? systemKeyringAdapter(loaded.Entry) : null;
+}

package/dist/runtime/active-run.js

@@ -0,0 +1,63 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+function dir(paths) { return join(paths.dataRoot, 'active-runs'); }
+function marker(paths, pid = process.pid) { return join(dir(paths), `${pid}.json`); }
+function alive(pid) { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch (error) {
+    return error?.code === 'EPERM';
+} }
+export async function registerActiveRun(paths, info = {}) {
+    const root = dir(paths);
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const file = marker(paths);
+    const record = { pid: process.pid, startedAt: new Date().toISOString(), ...info };
+    await writeFile(file, `${JSON.stringify(record)}\n`, { encoding: 'utf8', mode: 0o600 });
+    let released = false;
+    return async () => { if (released)
+        return; released = true; await rm(file, { force: true }); };
+}
+/* R5b D3: `exceptPid` leaves out a process (the TUI asking about the others: main.ts registers it for its whole life) and
+   `projectRoot` counts only the runs of that project; a marker that does not name its project still counts. */
+function sameRoot(a, b) { const x = resolve(a), y = resolve(b); return process.platform === 'win32' ? x.toLowerCase() === y.toLowerCase() : x === y; }
+export async function hasActiveRuns(paths, deps = {}) {
+    const isProcessAlive = deps.isProcessAlive ?? alive;
+    let names;
+    try {
+        names = await readdir(dir(paths));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+    let any = false;
+    for (const name of names) {
+        if (!/^\d+\.json$/u.test(name))
+            continue;
+        const file = join(dir(paths), name);
+        let pid = 0;
+        let root = null;
+        try {
+            const data = JSON.parse(await readFile(file, 'utf8'));
+            pid = Number(data?.pid);
+            root = data?.projectRoot;
+        }
+        catch {
+            await rm(file, { force: true });
+            continue;
+        }
+        if (!Number.isSafeInteger(pid) || pid <= 0 || !isProcessAlive(pid)) {
+            await rm(file, { force: true });
+            continue;
+        }
+        if (deps.exceptPid === pid)
+            continue;
+        if (deps.projectRoot && typeof root === 'string' && root && !sameRoot(root, deps.projectRoot))
+            continue;
+        any = true;
+    }
+    return any;
+}

package/dist/runtime/agent-tree.js

@@ -0,0 +1,74 @@
+export class CliAgentTreeError extends Error {
+    code = 'AGENT_TREE_INVALID';
+    constructor(message = 'Agent tree input is invalid.') { super(message); this.name = 'CliAgentTreeError'; }
+}
+function copyUsage(value) { return value ? { ...value } : null; }
+function copyCollisions(value) { return value.map(row => ({ ...row })); }
+function copyEvidence(value) { return value ? { ...value } : null; }
+function nodeOf(row, children) {
+    return {
+        id: row.id,
+        parentId: row.parentId,
+        nativeDepth: row.depth,
+        name: row.name,
+        task: row.delegatedTask,
+        model: row.model,
+        outcome: row.outcome,
+        interrupted: row.interrupted,
+        startedAt: row.startedAt,
+        updatedAt: row.updatedAt,
+        endedAt: row.endedAt,
+        usage: copyUsage(row.usage),
+        collisions: copyCollisions(row.collisions),
+        delegationOutcome: row.delegationOutcome,
+        delegationEvidence: copyEvidence(row.delegationEvidence),
+        children,
+    };
+}
+export function buildAgentTree(rows, focusId) {
+    const byId = new Map();
+    for (const row of rows) {
+        if (typeof row.id !== 'string' || !row.id)
+            throw new CliAgentTreeError('Agent tree contains an empty session id.');
+        if (byId.has(row.id))
+            throw new CliAgentTreeError('Agent tree contains duplicate session ids.');
+        byId.set(row.id, row);
+    }
+    const focus = byId.get(focusId);
+    if (!focus)
+        return null;
+    const validParent = new Map();
+    const childIds = new Map();
+    for (const row of rows) {
+        if (!row.parentId)
+            continue;
+        const parent = byId.get(row.parentId);
+        if (!parent || row.depth !== parent.depth + 1)
+            continue;
+        validParent.set(row.id, parent.id);
+        const siblings = childIds.get(parent.id);
+        if (siblings)
+            siblings.push(row.id);
+        else
+            childIds.set(parent.id, [row.id]);
+    }
+    let root = focus;
+    const climbSeen = new Set();
+    while (validParent.has(root.id)) {
+        if (climbSeen.has(root.id))
+            throw new CliAgentTreeError('Agent tree contains a delegation cycle.');
+        climbSeen.add(root.id);
+        const parent = byId.get(validParent.get(root.id));
+        if (!parent)
+            break;
+        root = parent;
+    }
+    const build = (id) => {
+        const row = byId.get(id);
+        if (!row)
+            throw new CliAgentTreeError('Agent tree references a missing session.');
+        const children = (childIds.get(id) ?? []).map(build);
+        return nodeOf(row, children);
+    };
+    return { focusId: focus.id, root: build(root.id) };
+}