talos-code 0.0.1 → 0.1.0

package/dist/services/task-board-facade.js

@@ -0,0 +1,236 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+const SCHEMA = 'talos.cli.task-board-edge.v1';
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,160}$/u;
+const KINDS = new Set(['depends-on', 'evidence', 'agent', 'schedule']);
+const STATUSES = new Set(['todo', 'doing', 'done']);
+const PRIORITIES = new Set(['low', 'normal', 'high']);
+function fail(code, message = code) { throw Object.assign(new Error(message), { code }); }
+function validId(value, code = 'TASK_BOARD_ID_INVALID') { if (!ID.test(value) || value.includes('..'))
+    fail(code); return value; }
+function edgeKind(value) { if (!KINDS.has(value))
+    fail('TASK_BOARD_EDGE_KIND_INVALID'); return value; }
+function stringOrNull(value) { return typeof value === 'string' ? value : null; }
+function numberOrNull(value) { return Number.isFinite(value) ? Number(value) : null; }
+function requiredString(value, field) { if (typeof value !== 'string' || value.length === 0)
+    throw new TypeError('malformed task board row: ' + field); return value; }
+function edgeKey(record) { return createHash('sha256').update(record.taskId + '\0' + record.kind + '\0' + record.targetId).digest('hex'); }
+function parseEdge(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.schema !== SCHEMA)
+        throw new TypeError('malformed task board edge');
+    return { schema: SCHEMA, taskId: validId(String(value.taskId ?? ''), 'TASK_BOARD_EDGE_INVALID'), kind: edgeKind(String(value.kind ?? '')), targetId: validId(String(value.targetId ?? ''), 'TASK_BOARD_EDGE_INVALID'), createdAt: requiredString(value.createdAt, 'createdAt') };
+}
+function edgeSort(a, b) { return a.kind.localeCompare(b.kind) || a.targetId.localeCompare(b.targetId) || a.createdAt.localeCompare(b.createdAt); }
+function headerOf(records) { return Array.isArray(records) ? records.find(row => row?.tipo === 'intestazione') ?? null : null; }
+function agentOutcome(records) {
+    if (!Array.isArray(records))
+        return 'unknown';
+    const terminal = [...records].reverse().find(row => row?.type === 'RunFinished' || row?.type === 'RunError');
+    if (!terminal)
+        return 'running';
+    return terminal.type === 'RunFinished' ? 'completed' : terminal.type === 'RunError' ? 'failed' : 'unknown';
+}
+function createsCycle(edges, source, target) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        if (edge.kind !== 'depends-on')
+            continue;
+        const rows = adjacency.get(edge.taskId);
+        if (rows)
+            rows.push(edge.targetId);
+        else
+            adjacency.set(edge.taskId, [edge.targetId]);
+    }
+    const seen = new Set(), stack = [target];
+    while (stack.length) {
+        const current = stack.pop();
+        if (current === source)
+            return true;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        for (const next of adjacency.get(current) ?? [])
+            stack.push(next);
+    }
+    return false;
+}
+export function createTaskBoardFacade(input, deps = {}) {
+    const tasksRoot = join(input.paths.dataRoot, 'tasks');
+    const automationRoot = join(input.paths.dataRoot, 'automations');
+    const edgeRoot = join(input.paths.dataRoot, 'task-board-edges');
+    const repoRoot = () => input.repoRoot ?? (input.projectRoot ? findTalosRepoRoot(input.projectRoot) : fail('TASK_BOARD_REPO_ROOT_REQUIRED'));
+    let taskPromise = null, sessionPromise = null, automationPromise = null, evidenceModulePromise = null;
+    const taskStore = () => taskPromise ??= (deps.loadTaskStore ? deps.loadTaskStore() : importTalosModule(repoRoot(), 'tasks-store.mjs'));
+    const sessionStore = () => sessionPromise ??= (deps.loadSessionStore ? deps.loadSessionStore() : importTalosModule(repoRoot(), 'session-store.mjs'));
+    const automationStore = () => automationPromise ??= (deps.loadAutomationStore ? deps.loadAutomationStore() : (async () => { const mod = await importTalosModule(repoRoot(), 'automation-store.mjs'); return mod.createAutomationStore({ cartella: automationRoot }); })());
+    const measureEvidence = async (records) => {
+        if (deps.analyzeEvidence)
+            return deps.analyzeEvidence(records);
+        evidenceModulePromise ??= importTalosModule(repoRoot(), 'subagent-orchestrator.mjs');
+        const mod = await evidenceModulePromise;
+        return mod.analizzaEvidenzaDelega(records);
+    };
+    const defaultListEdges = async () => {
+        let names;
+        try {
+            names = await readdir(edgeRoot);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const edges = [];
+        for (const name of names.sort()) {
+            if (!name.endsWith('.json'))
+                continue;
+            edges.push(parseEdge(JSON.parse(await readFile(join(edgeRoot, name), 'utf8'))));
+        }
+        return edges.sort(edgeSort);
+    };
+    const defaultWriteEdge = async (record) => {
+        await mkdir(edgeRoot, { recursive: true, mode: 0o700 });
+        const key = edgeKey(record), final = join(edgeRoot, key + '.json'), tmp = join(edgeRoot, '.' + key + '.' + randomUUID() + '.tmp');
+        await writeFile(tmp, JSON.stringify(record, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        try {
+            await rename(tmp, final);
+        }
+        catch (error) {
+            await rm(tmp, { force: true });
+            throw error;
+        }
+    };
+    const defaultDeleteEdge = async (record) => { await rm(join(edgeRoot, edgeKey(record) + '.json'), { force: true }); };
+    const listEdges = async () => { const raw = await (deps.listEdges ? deps.listEdges() : defaultListEdges()); if (!Array.isArray(raw))
+        throw new TypeError('malformed task board edge store'); return raw.map(parseEdge).sort(edgeSort); };
+    const writeEdge = deps.writeEdge ?? defaultWriteEdge;
+    const deleteEdge = deps.deleteEdge ?? defaultDeleteEdge;
+    const now = deps.now ?? (() => new Date());
+    function publicTask(raw, store) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new TypeError('malformed persisted task row: object');
+        const shaped = typeof store.formaPubblicaAttivita === 'function' ? store.formaPubblicaAttivita(raw) : raw;
+        const id = validId(requiredString(shaped?.id, 'id'), 'TASK_ID_INVALID'), title = requiredString(shaped?.titolo, 'titolo');
+        if (!STATUSES.has(shaped?.stato))
+            throw new TypeError('malformed persisted task row: stato');
+        if (!PRIORITIES.has(shaped?.priorita))
+            throw new TypeError('malformed persisted task row: priorita');
+        const writer = shaped?.origine === 'persona' ? 'persona' : 'modello';
+        const writerEvidence = (raw.origine === 'persona' || raw.origine === 'modello') ? 'persisted' : 'derived-legacy-default';
+        return { id, title, description: stringOrNull(shaped?.descrizione), status: shaped.stato, priority: shaped.priorita, writer, writerEvidence, createdAt: stringOrNull(shaped?.creataAlle), updatedAt: stringOrNull(shaped?.aggiornataAlle) };
+    }
+    async function exactTask(taskId) { const wanted = validId(taskId, 'TASK_ID_INVALID'), store = await taskStore(), raw = await store.leggiAttivita({ cartella: tasksRoot, id: wanted }); if (!raw || raw.id !== wanted)
+        fail('TASK_NOT_FOUND'); return { wanted, store, raw }; }
+    async function sessionRecords(sessionId, required = false) { const records = await (await sessionStore()).leggiRegistro({ cartellaStore: input.paths.sessionsRoot, sessionId }), header = headerOf(records); const exact = Array.isArray(records) && header?.sessionId === sessionId ? records : null; if (!exact && required)
+        fail('TASK_BOARD_TARGET_NOT_FOUND'); return exact; }
+    async function dependencyView(edge) {
+        const row = await (await taskStore()).leggiAttivita({ cartella: tasksRoot, id: edge.targetId });
+        const exact = row?.id === edge.targetId ? row : null;
+        return { taskId: edge.taskId, targetTaskId: edge.targetId, state: exact ? 'available' : 'dangling', label: exact ? stringOrNull(exact.titolo) : null, createdAt: edge.createdAt };
+    }
+    async function evidenceView(edge) {
+        const records = await sessionRecords(edge.targetId, false);
+        return { taskId: edge.taskId, sessionId: edge.targetId, state: records ? 'available' : 'dangling', measurement: records ? await measureEvidence(records) : null, createdAt: edge.createdAt };
+    }
+    async function agentView(edge) {
+        const records = await sessionRecords(edge.targetId, false), header = headerOf(records);
+        const delegated = header && typeof header.padreId === 'string' && header.padreId.length > 0 && Number.isSafeInteger(header.profonditaDelega) && header.profonditaDelega > 0 && typeof header.taskId === 'string' && header.taskId.startsWith('delega:');
+        return { taskId: edge.taskId, sessionId: edge.targetId, state: delegated ? 'available' : 'dangling', parentSessionId: delegated ? header.padreId : null, depth: delegated ? Number(header.profonditaDelega) : null, task: delegated ? stringOrNull(header.task?.consegnaCorta ?? header.task?.consegna) : null, outcome: delegated ? agentOutcome(records) : 'unknown', createdAt: edge.createdAt };
+    }
+    async function scheduleView(edge) {
+        const row = await (await automationStore()).leggi(edge.targetId), exact = row?.id === edge.targetId ? row : null;
+        return { taskId: edge.taskId, automationId: edge.targetId, state: exact ? 'available' : 'dangling', executionTaskId: exact ? stringOrNull(exact.taskId) : null, name: exact ? stringOrNull(exact.nome) : null, intervalMinutes: exact ? numberOrNull(exact.intervalloMinuti) : null, dailyLimit: exact ? numberOrNull(exact.limiteAlGiorno) : null, active: exact ? Boolean(exact.attiva) : null, lastExecution: exact ? stringOrNull(exact.ultimaEsecuzione) : null, nextExecution: exact ? stringOrNull(exact.prossimaEsecuzione) : null, createdAt: edge.createdAt };
+    }
+    async function projectTask(raw, store, edges) {
+        const base = publicTask(raw, store), mine = edges.filter(edge => edge.taskId === base.id);
+        const dependencies = [], evidence = [], agents = [], schedules = [];
+        for (const edge of mine) {
+            if (edge.kind === 'depends-on')
+                dependencies.push(await dependencyView(edge));
+            else if (edge.kind === 'evidence')
+                evidence.push(await evidenceView(edge));
+            else if (edge.kind === 'agent')
+                agents.push(await agentView(edge));
+            else
+                schedules.push(await scheduleView(edge));
+        }
+        return { ...base, dependencies, evidence, agents, schedules };
+    }
+    function invalid(error) { return { state: 'invalid', rows: [], error: { code: 'TASK_BOARD_INVALID', message: error instanceof Error ? error.message : String(error) }, legacyRows: [] }; }
+    const list = async () => {
+        try {
+            const store = await taskStore(), raw = await store.elencaAttivita({ cartella: tasksRoot });
+            if (!Array.isArray(raw))
+                throw new TypeError('malformed persisted task list');
+            const edges = await listEdges(), rows = [];
+            for (const item of raw)
+                rows.push(await projectTask(item, store, edges));
+            return { state: 'ready', rows, error: null, legacyRows: raw };
+        }
+        catch (error) {
+            return invalid(error);
+        }
+    };
+    const add = async (value) => { const store = await taskStore(), legacy = await store.creaAttivita({ cartella: tasksRoot, title: value.title, description: value.description ?? null, priority: value.priority ?? 'normal', origine: 'persona' }); return { legacy }; };
+    const update = async (taskId, value) => { const store = await taskStore(), wanted = validId(taskId, 'TASK_ID_INVALID'), legacy = await store.aggiornaAttivita({ cartella: tasksRoot, id: wanted, ...(value.title !== undefined ? { title: value.title } : {}), ...(value.description !== undefined ? { description: value.description } : {}), ...(value.priority !== undefined ? { priority: value.priority } : {}) }); return { legacy }; };
+    const complete = async (taskId, status = 'done') => { const store = await taskStore(), wanted = validId(taskId, 'TASK_ID_INVALID'), legacy = await store.completaAttivita({ cartella: tasksRoot, id: wanted, status }); return { legacy }; };
+    const deleteTask = async (taskId) => { const store = await taskStore(), wanted = validId(taskId, 'TASK_ID_INVALID'); await store.eliminaAttivita({ cartella: tasksRoot, id: wanted }); return { legacy: { ok: true, id: wanted } }; };
+    async function validateTarget(kind, targetId) {
+        if (kind === 'depends-on') {
+            const row = await (await taskStore()).leggiAttivita({ cartella: tasksRoot, id: targetId });
+            if (!row || row.id !== targetId)
+                fail('TASK_BOARD_TARGET_NOT_FOUND');
+            return;
+        }
+        if (kind === 'schedule') {
+            const row = await (await automationStore()).leggi(targetId);
+            if (!row || row.id !== targetId)
+                fail('TASK_BOARD_TARGET_NOT_FOUND');
+            return;
+        }
+        const records = await sessionRecords(targetId, true);
+        if (kind === 'evidence') {
+            await measureEvidence(records);
+            return;
+        }
+        if (kind === 'agent') {
+            const header = headerOf(records);
+            if (!header || typeof header.padreId !== 'string' || !header.padreId || !Number.isSafeInteger(header.profonditaDelega) || header.profonditaDelega <= 0 || typeof header.taskId !== 'string' || !header.taskId.startsWith('delega:'))
+                fail('TASK_AGENT_NOT_DELEGATED');
+        }
+    }
+    async function addEdge(taskId, kind, targetId) {
+        const source = await exactTask(taskId), target = validId(targetId, 'TASK_BOARD_TARGET_INVALID'), typed = edgeKind(kind);
+        if (typed === 'depends-on' && source.wanted === target)
+            fail('TASK_DEPENDENCY_SELF');
+        await validateTarget(typed, target);
+        const edges = await listEdges(), existing = edges.find(edge => edge.taskId === source.wanted && edge.kind === typed && edge.targetId === target);
+        if (existing)
+            return { changed: false, edge: existing };
+        if (typed === 'depends-on' && createsCycle(edges, source.wanted, target))
+            fail('TASK_DEPENDENCY_CYCLE');
+        const record = { schema: SCHEMA, taskId: source.wanted, kind: typed, targetId: target, createdAt: now().toISOString() };
+        await writeEdge(record);
+        return { changed: true, edge: record };
+    }
+    async function removeEdge(taskId, kind, targetId) {
+        const source = validId(taskId, 'TASK_ID_INVALID'), target = validId(targetId, 'TASK_BOARD_TARGET_INVALID'), typed = edgeKind(kind), existing = (await listEdges()).find(edge => edge.taskId === source && edge.kind === typed && edge.targetId === target);
+        if (!existing)
+            return { changed: false, taskId: source, kind: typed, targetId: target };
+        await deleteEdge(existing);
+        return { changed: true, taskId: source, kind: typed, targetId: target };
+    }
+    return {
+        list, add, update, complete, delete: deleteTask,
+        depend: (taskId, targetTaskId) => addEdge(taskId, 'depends-on', targetTaskId),
+        undepend: (taskId, targetTaskId) => removeEdge(taskId, 'depends-on', targetTaskId),
+        addEvidence: (taskId, sessionId) => addEdge(taskId, 'evidence', sessionId),
+        removeEvidence: (taskId, sessionId) => removeEdge(taskId, 'evidence', sessionId),
+        assignAgent: (taskId, sessionId) => addEdge(taskId, 'agent', sessionId),
+        unassignAgent: (taskId, sessionId) => removeEdge(taskId, 'agent', sessionId),
+        attachSchedule: (taskId, automationId) => addEdge(taskId, 'schedule', automationId),
+        detachSchedule: (taskId, automationId) => removeEdge(taskId, 'schedule', automationId),
+    };
+}

package/dist/services/workflow-catalog.js

@@ -0,0 +1,246 @@
+import { readdir } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+import { createTrustAuthority } from "../security/trust-authority.js";
+import { loadCommandFile, renderProjectCommand } from "../commands/project-commands.js";
+function fail(code, message = code) { throw Object.assign(new Error(message), { code }); }
+function errorCode(error, fallback) {
+    const code = error?.code;
+    if (typeof code === 'string' && code)
+        return code;
+    const message = error instanceof Error ? error.message : String(error);
+    const match = /^([A-Z][A-Z0-9_]+)/u.exec(message);
+    return match?.[1] ?? fallback;
+}
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+function slash(value) { return value.split('\\').join('/'); }
+function stripMd(value) { return value.toLowerCase().endsWith('.md') ? value.slice(0, -3) : value; }
+async function markdownFiles(root) {
+    const out = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const file = join(dir, entry.name);
+            if (entry.isDirectory())
+                await walk(file);
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md'))
+                out.push(file);
+        }
+    }
+    await walk(root);
+    return out.sort();
+}
+function stableId(scope, root, file) { return scope + ':' + stripMd(slash(relative(root, file))); }
+function projectPath(root, file) { return '.talos-cli/commands/' + slash(relative(root, file)); }
+function invalidName(file) { return stripMd(basename(file)); }
+function vars(args) { return Object.fromEntries(args.map((value, index) => ['arg' + (index + 1), value])); }
+function expandText(template, values) {
+    return template.replace(/\{\{([a-zA-Z0-9_-]+)\}\}/gu, (_match, name) => {
+        if (!Object.hasOwn(values, name))
+            throw Object.assign(new Error('COMMAND_VARIABLE_UNKNOWN:' + name), { code: 'COMMAND_VARIABLE_UNKNOWN' });
+        return values[name];
+    });
+}
+function resourceTrust(snapshot, path) {
+    const resource = snapshot.resources.find(row => row.kind === 'command' && row.relativePath === path);
+    if (!resource)
+        return { required: true, trusted: false, state: 'untracked', currentFingerprint: null, trustedFingerprint: null };
+    return { required: true, trusted: resource.state === 'trusted', state: resource.state, currentFingerprint: resource.currentFingerprint ?? null, trustedFingerprint: resource.trustedFingerprint ?? null };
+}
+function userTrust() { return { required: false, trusted: true, state: 'user-controlled', currentFingerprint: null, trustedFingerprint: null }; }
+function skillTrust() { return { required: false, trusted: true, state: 'inert-text', currentFingerprint: null, trustedFingerprint: null }; }
+function validation(valid, code = null, message = null) { return { valid, code, message }; }
+export function createWorkflowCatalog(input, deps = {}) {
+    const authority = deps.authority ?? createTrustAuthority({ projectRoot: input.projectRoot, trustRoot: input.paths.trust.projects });
+    const repoRoot = () => input.repoRoot ?? findTalosRepoRoot(input.projectRoot);
+    const loadSkills = deps.loadSkills ?? (async () => {
+        const mod = await importTalosModule(repoRoot(), 'skill-registry.mjs');
+        const loaded = await mod.caricaSkill({ cartella: input.projectRoot });
+        if (!loaded || !Array.isArray(loaded.skills))
+            fail('SKILL_REGISTRY_INVALID');
+        return { skills: loaded.skills };
+    });
+    async function build() {
+        const projectRoot = join(input.projectRoot, '.talos-cli', 'commands');
+        const userRoot = join(input.paths.configRoot, 'commands');
+        const [projectFiles, userFiles, snapshot] = await Promise.all([markdownFiles(projectRoot), markdownFiles(userRoot), authority.inspect()]);
+        const sources = new Map();
+        async function addCommand(scope, root, file) {
+            const id = stableId(scope, root, file);
+            const provenance = scope === 'project'
+                ? { scope: 'project-command', path: projectPath(projectRoot, file) }
+                : { scope: 'user-command', path: 'commands/' + slash(relative(userRoot, file)) };
+            const trust = scope === 'project' ? resourceTrust(snapshot, provenance.path) : userTrust();
+            try {
+                const command = await loadCommandFile(file);
+                const row = {
+                    id, kind: command.kind, name: command.name, description: command.description, arguments: command.arguments,
+                    provenance, validation: validation(true), trust,
+                    executableSteps: command.kind === 'workflow' ? command.steps.filter(step => step.type === 'command').length : 1,
+                    references: []
+                };
+                sources.set(id, { row, command, steps: command.steps });
+            }
+            catch (error) {
+                const code = errorCode(error, 'COMMAND_INVALID');
+                const row = {
+                    id, kind: 'command', name: invalidName(file), description: null, arguments: '', provenance,
+                    validation: validation(false, code, errorMessage(error)), trust, executableSteps: 0, references: []
+                };
+                sources.set(id, { row });
+            }
+        }
+        for (const file of projectFiles)
+            await addCommand('project', projectRoot, file);
+        for (const file of userFiles)
+            await addCommand('user', userRoot, file);
+        try {
+            const loaded = await loadSkills();
+            for (const skill of loaded.skills) {
+                if (!skill || typeof skill.id !== 'string' || typeof skill.name !== 'string' || typeof skill.description !== 'string' || typeof skill.corpo !== 'string') {
+                    fail('SKILL_REGISTRY_INVALID');
+                }
+                const id = 'skill:' + skill.id;
+                const row = {
+                    id, kind: 'skill', name: skill.name, description: skill.description, arguments: '',
+                    provenance: { scope: 'project-skill', path: '.harness-ui-skills/' + skill.id + '/SKILL.md' },
+                    validation: validation(true), trust: skillTrust(), executableSteps: 0, references: []
+                };
+                sources.set(id, { row, skill });
+            }
+        }
+        catch (error) {
+            const code = errorCode(error, 'SKILL_REGISTRY_INVALID');
+            const row = {
+                id: 'skill:registry-error', kind: 'skill', name: 'registry-error', description: null, arguments: '',
+                provenance: { scope: 'project-skill', path: '.harness-ui-skills' },
+                validation: validation(false, code, errorMessage(error)), trust: skillTrust(), executableSteps: 0, references: []
+            };
+            sources.set(row.id, { row });
+        }
+        const commandByName = (name) => [...sources.values()].filter(source => source.row.kind === 'command' && source.row.name === name);
+        const skillByName = (name) => [...sources.values()].filter(source => source.row.kind === 'skill' && source.row.validation.valid && source.row.name === name);
+        for (const source of sources.values()) {
+            if (source.row.kind !== 'workflow' || !source.row.validation.valid || !source.steps)
+                continue;
+            const refs = [];
+            let invalid = null;
+            for (const step of source.steps) {
+                if (step.type === 'prompt')
+                    continue;
+                if (step.type === 'skill') {
+                    const matches = skillByName(step.name);
+                    const id = matches.length === 1 ? matches[0].row.id : null;
+                    refs.push({ type: 'skill', name: step.name, id });
+                    if (matches.length === 0)
+                        invalid = validation(false, 'WORKFLOW_SKILL_NOT_FOUND', 'Workflow skill not found: ' + step.name);
+                    else if (matches.length > 1)
+                        invalid = validation(false, 'WORKFLOW_SKILL_AMBIGUOUS', 'Workflow skill reference is ambiguous: ' + step.name);
+                    if (invalid)
+                        break;
+                    continue;
+                }
+                const matches = commandByName(step.name);
+                const id = matches.length === 1 ? matches[0].row.id : null;
+                refs.push({ type: 'command', name: step.name, id });
+                if (matches.length === 0)
+                    invalid = validation(false, 'WORKFLOW_COMMAND_NOT_FOUND', 'Workflow command not found: ' + step.name);
+                else if (matches.length > 1)
+                    invalid = validation(false, 'WORKFLOW_COMMAND_AMBIGUOUS', 'Workflow command reference is ambiguous: ' + step.name);
+                else if (!matches[0].row.validation.valid)
+                    invalid = validation(false, 'WORKFLOW_COMMAND_INVALID', 'Workflow command target is invalid: ' + step.name);
+                if (invalid)
+                    break;
+            }
+            source.row.references = refs;
+            if (invalid)
+                source.row.validation = invalid;
+        }
+        const rows = [...sources.values()].map(source => source.row).sort((a, b) => a.id.localeCompare(b.id));
+        return { rows, sources };
+    }
+    function resolve(build, selector, { runnable = false } = {}) {
+        const direct = build.sources.get(selector);
+        if (direct) {
+            if (runnable && direct.row.kind === 'skill')
+                fail('WORKFLOW_ENTRY_NOT_RUNNABLE');
+            return direct;
+        }
+        const matches = [...build.sources.values()].filter(source => source.row.name === selector && (!runnable || source.row.kind !== 'skill'));
+        if (matches.length === 0)
+            fail('WORKFLOW_ENTRY_NOT_FOUND');
+        if (matches.length > 1)
+            fail('WORKFLOW_ENTRY_AMBIGUOUS');
+        return matches[0];
+    }
+    function assertValid(source) { if (!source.row.validation.valid)
+        fail(source.row.validation.code ?? 'WORKFLOW_ENTRY_INVALID', source.row.validation.message ?? source.row.validation.code ?? 'WORKFLOW_ENTRY_INVALID'); }
+    function assertRunnableTrust(source, step = false) {
+        if (source.row.trust.required && !source.row.trust.trusted)
+            fail(step ? 'WORKFLOW_STEP_TRUST_REQUIRED' : 'WORKFLOW_TRUST_REQUIRED');
+    }
+    return {
+        async list() { return (await build()).rows; },
+        async show(selector) { const built = await build(); return resolve(built, selector).row; },
+        async run(selector, args = []) {
+            const built = await build();
+            const source = resolve(built, selector, { runnable: true });
+            assertValid(source);
+            assertRunnableTrust(source);
+            if (!source.command)
+                fail('WORKFLOW_ENTRY_INVALID');
+            const values = vars(args);
+            if (source.row.kind === 'command') {
+                const prompt = renderProjectCommand(source.command, values);
+                return { id: source.row.id, kind: 'command', prompt, steps: [] };
+            }
+            const rendered = [];
+            const chunks = [];
+            for (const step of source.steps ?? []) {
+                if (step.type === 'prompt') {
+                    const text = expandText(step.template, values);
+                    chunks.push(text);
+                    rendered.push({ type: 'prompt', name: null, id: null, text });
+                    continue;
+                }
+                if (step.type === 'skill') {
+                    const matches = [...built.sources.values()].filter(candidate => candidate.row.kind === 'skill' && candidate.row.validation.valid && candidate.row.name === step.name);
+                    if (matches.length === 0)
+                        fail('WORKFLOW_SKILL_NOT_FOUND');
+                    if (matches.length > 1)
+                        fail('WORKFLOW_SKILL_AMBIGUOUS');
+                    const target = matches[0];
+                    if (!target.skill)
+                        fail('WORKFLOW_SKILL_INVALID');
+                    const text = target.skill.corpo;
+                    chunks.push(text);
+                    rendered.push({ type: 'skill', name: step.name, id: target.row.id, text });
+                    continue;
+                }
+                const matches = [...built.sources.values()].filter(candidate => candidate.row.kind === 'command' && candidate.row.name === step.name);
+                if (matches.length === 0)
+                    fail('WORKFLOW_COMMAND_NOT_FOUND');
+                if (matches.length > 1)
+                    fail('WORKFLOW_COMMAND_AMBIGUOUS');
+                const target = matches[0];
+                assertValid(target);
+                assertRunnableTrust(target, true);
+                if (!target.command)
+                    fail('WORKFLOW_COMMAND_INVALID');
+                const expandedArgs = step.args.map(value => expandText(value, values));
+                const text = renderProjectCommand(target.command, vars(expandedArgs));
+                chunks.push(text);
+                rendered.push({ type: 'command', name: step.name, id: target.row.id, text });
+            }
+            return { id: source.row.id, kind: 'workflow', prompt: chunks.join('\n\n'), steps: rendered };
+        }
+    };
+}

package/dist/sessions/export-format.js

@@ -0,0 +1,98 @@
+/*
+ * R5b D1 (owner decision Q-R5-12, gate E16): a session as Markdown that a person can read — their own messages, TALOS's
+ * answers and the tools in English with their target, in order. Before R5b `session-cli.ts` exportMarkdown wrote only the
+ * model's text deltas and `> Tool: leggi`: the person's messages (kept by the kernel only as `RunStarted.input`, R1 lane R)
+ * were lost. Secrets are redacted with the same redactor the rest of the CLI uses. Shared by `talos session export --format
+ * md` and the TUI's `/export`. JSON and JSONL stay the kernel's own lossless rows.
+ */
+import { createRedactor } from "../diagnostics/redact.js";
+import { describeError, errorViewLines } from "../i18n/error-view.js";
+import { runPrompt } from "../tui/event-adapter.js";
+import { toolDisplay } from "../tui/tool-display.js";
+const text = (value) => typeof value === 'string' ? value : '';
+export function exportMarkdown(payload, { secrets = [] } = {}) {
+    const redactor = createRedactor(secrets);
+    const title = text(payload?.name).trim();
+    const out = [`# TALOS session ${text(payload?.sessionId)}${title ? ` · ${title}` : ''}`];
+    const events = Array.isArray(payload?.eventi) ? payload.eventi : [];
+    const answers = new Map(), toolNames = new Map(), toolArgs = new Map();
+    let speaker = null;
+    const say = (who, body) => {
+        if (!body.trim())
+            return;
+        if (speaker !== who) {
+            out.push('', who === 'you' ? '## You' : '## TALOS', '');
+            speaker = who;
+        }
+        out.push(body.trim());
+    };
+    const toolLine = (id) => {
+        const name = toolNames.get(id) ?? 'tool';
+        let args = {};
+        try {
+            const parsed = JSON.parse(toolArgs.get(id) ?? '{}');
+            if (parsed && typeof parsed === 'object')
+                args = parsed;
+        }
+        catch {
+            args = {};
+        }
+        const shown = toolDisplay(name, args);
+        return `- ${[shown.label, shown.primaryArg].filter(Boolean).join(' ')}`;
+    };
+    for (const event of events) {
+        const type = text(event?.type);
+        if (type === 'RunStarted') {
+            const prompt = runPrompt(event.input);
+            if (prompt)
+                say('you', prompt);
+            continue;
+        }
+        if (type === 'TextMessageStart') {
+            if (event.role === 'user')
+                continue;
+            answers.set(text(event.messageId), '');
+            continue;
+        }
+        if (type === 'TextMessageContent') {
+            const id = text(event.messageId);
+            if (answers.has(id) || !id)
+                answers.set(id, (answers.get(id) ?? '') + text(event.delta));
+            continue;
+        }
+        if (type === 'TextMessageEnd') {
+            const id = text(event.messageId);
+            say('talos', answers.get(id) ?? '');
+            answers.delete(id);
+            continue;
+        }
+        if (type === 'ToolCallStart') {
+            toolNames.set(text(event.toolCallId), text(event.toolCallName) || text(event.name));
+            toolArgs.set(text(event.toolCallId), '');
+            continue;
+        }
+        if (type === 'ToolCallArgs') {
+            const id = text(event.toolCallId);
+            toolArgs.set(id, (toolArgs.get(id) ?? '') + text(event.delta));
+            continue;
+        }
+        if (type === 'ToolCallEnd') {
+            const id = text(event.toolCallId);
+            if (toolNames.has(id)) {
+                say('talos', toolLine(id));
+                toolNames.delete(id);
+            }
+            continue;
+        }
+        if (type === 'RunError') {
+            say('talos', `**${errorViewLines(describeError({ code: event.code, message: event.message }))[0] ?? 'The run failed.'}**`);
+            continue;
+        }
+    }
+    /* An answer still streaming when the log ended is kept, not dropped. */
+    for (const body of answers.values())
+        say('talos', body);
+    for (const id of toolNames.keys())
+        say('talos', toolLine(id));
+    return redactor.text(`${out.join('\n')}\n`);
+}