talos-code 0.0.1 → 0.1.0

package/dist/services/library-facade.js

@@ -0,0 +1,174 @@
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { readFile as readFileReal, writeFile as writeFileReal } from 'node:fs/promises';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+import { TEXT_ATTACHMENT_MAX_BYTES, imageMimeFromBytes, validateCliAttachments } from "../runtime/attachments.js";
+const PREVIEW_CHARS = 4_000;
+function fail(code, message = code) { throw Object.assign(new Error(message), { code }); }
+function required(value, field) { if (typeof value !== 'string' || !value.length)
+    throw new TypeError('malformed Library entry: ' + field); return value; }
+function optional(value) { return typeof value === 'string' ? value : null; }
+function textMedia(mediaType) { const value = mediaType.toLowerCase(); return value.startsWith('text/') || value === 'application/json' || value.endsWith('+json') || value === 'application/xml' || value.endsWith('+xml') || value === 'application/yaml' || value === 'application/x-yaml' || value === 'application/javascript' || value === 'application/x-javascript'; }
+function mediaFor(file) { const e = extname(file).toLowerCase(); return { '.md': 'text/markdown', '.txt': 'text/plain', '.json': 'application/json', '.xml': 'application/xml', '.yaml': 'application/yaml', '.yml': 'application/yaml', '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation' }[e] ?? 'application/octet-stream'; }
+function digest(bytes) { return createHash('sha256').update(bytes).digest('hex'); }
+function fatalText(bytes) { let text; try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+}
+catch {
+    fail('LIBRARY_CONTEXT_UNSUPPORTED', 'Library content is not valid UTF-8 text.');
+} if (text.includes('\0'))
+    fail('LIBRARY_CONTEXT_UNSUPPORTED', 'Library content is binary.'); return text; }
+function legacyRow(raw) { if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+    return raw; const { cartella, percorso, creatoDa, sessione, ...rest } = raw; return rest; }
+function exactManagedLine(text, token) { return text.split('\n').some(line => line.trim() === token); }
+export function attachLibraryContextToken(text, token) { if (exactManagedLine(text, token))
+    return text; return text.length ? text.replace(/\n+$/u, '') + '\n' + token : token; }
+export function detachLibraryContextToken(text, token) { return text.split('\n').filter(line => line.trim() !== token).join('\n'); }
+export function createLibraryFacade(input, deps = {}) {
+    const repoRoot = () => input.repoRoot ?? findTalosRepoRoot(input.projectRoot);
+    let storePromise = null;
+    const store = () => storePromise ??= (deps.loadStore ? deps.loadStore() : importTalosModule(repoRoot(), 'library-store.mjs'));
+    const readImport = deps.readImportFile ?? (async (file) => readFileReal(file));
+    const writeExport = deps.writeExportFile ?? (async (file, bytes) => { await writeFileReal(file, bytes); });
+    function projectRow(raw, mod) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new TypeError('malformed Library entry: object');
+        const id = required(raw.id, 'id'), name = required(raw.nome, 'nome'), mediaType = required(raw.mediaType, 'mediaType');
+        const fileType = raw.fileType === 'image' ? 'image' : raw.fileType === 'document' ? 'document' : (() => { throw new TypeError('malformed Library entry: fileType'); })();
+        const origin = raw.origine === 'generated' ? 'generated' : raw.origine === 'uploaded' ? 'uploaded' : (() => { throw new TypeError('malformed Library entry: origine'); })();
+        const created = raw.creatoDa;
+        if (!created || typeof created !== 'object')
+            throw new TypeError('malformed Library entry: creatoDa');
+        const creator = created.tipo === 'persona'
+            ? { type: 'persona', model: null, provider: null }
+            : created.tipo === 'modello'
+                ? { type: 'modello', model: optional(created.modello), provider: optional(created.provider) }
+                : (() => { throw new TypeError('malformed Library entry: creatoDa.tipo'); })();
+        const session = raw.sessione && typeof raw.sessione === 'object' && typeof raw.sessione.id === 'string' && raw.sessione.id
+            ? { id: raw.sessione.id, name: optional(raw.sessione.nome) } : null;
+        const relative = mod.percorsoContenutoVoce(id);
+        const token = relative && typeof relative === 'string' && !/[\0\r\n\s]/u.test(relative) ? '@' + relative : null;
+        return { id, name, mediaType, fileType, origin, creator, session, createdAt: optional(raw.creatoIl), updatedAt: optional(raw.aggiornatoIl), context: { token, mode: 'explicit-visible-reference', autoAttach: false, autoSubmit: false, persistence: 'composer-only-until-send' } };
+    }
+    async function metadata() {
+        const mod = await store(), raw = await mod.elencaVoci({ cartella: input.projectRoot, conProvenienza: true });
+        if (!Array.isArray(raw))
+            throw new TypeError('malformed Library list');
+        return { mod, raw, rows: raw.map(row => projectRow(row, mod)) };
+    }
+    async function exact(id) {
+        const all = await metadata(), index = all.rows.findIndex(row => row.id === id);
+        if (index < 0)
+            fail('LIBRARY_NOT_FOUND');
+        return { ...all, row: all.rows[index], raw: all.raw[index] };
+    }
+    async function bytesFor(id) {
+        const mod = await store(), value = await mod.leggiBytesVoce({ cartella: input.projectRoot, id });
+        if (!value)
+            fail('LIBRARY_NOT_FOUND');
+        return { ...value, bytes: Buffer.from(value.bytes) };
+    }
+    async function scanBytes(source, excludeId) {
+        const mod = await store(), rows = await mod.elencaVoci({ cartella: input.projectRoot });
+        if (!Array.isArray(rows))
+            throw new TypeError('malformed Library list');
+        const wanted = digest(source), duplicates = [], unreadable = [];
+        for (const row of rows) {
+            const id = typeof row?.id === 'string' ? row.id : null;
+            if (!id || id === excludeId)
+                continue;
+            try {
+                const value = await mod.leggiBytesVoce({ cartella: input.projectRoot, id });
+                if (!value) {
+                    unreadable.push(id);
+                    continue;
+                }
+                if (digest(value.bytes) === wanted)
+                    duplicates.push(id);
+            }
+            catch {
+                unreadable.push(id);
+            }
+        }
+        duplicates.sort();
+        unreadable.sort();
+        return { sha256: wanted, duplicateIds: duplicates, unreadableIds: unreadable, state: unreadable.length ? 'partial' : 'complete' };
+    }
+    const list = async () => {
+        try {
+            const x = await metadata();
+            return { state: 'ready', rows: x.rows, error: null, legacyRows: x.raw.map(legacyRow) };
+        }
+        catch (error) {
+            return { state: 'invalid', rows: [], error: { code: 'LIBRARY_STORE_INVALID', message: error instanceof Error ? error.message : String(error) }, legacyRows: [] };
+        }
+    };
+    const search = async (query) => { const mod = await store(), rows = await mod.elencaVociConTesto({ cartella: input.projectRoot }); const legacy = mod.cercaVoci(rows, { query }); return { legacy }; };
+    const read = async (id) => { const mod = await store(), legacy = await mod.leggiVoce({ cartella: input.projectRoot, id }); return { legacy }; };
+    const preview = async (id) => {
+        const entry = await exact(id), value = await bytesFor(id), size = Number.isFinite(value.dimensione) ? Number(value.dimensione) : value.bytes.length;
+        if (entry.row.fileType === 'image' || entry.row.mediaType.startsWith('image/'))
+            return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'metadata', text: null, truncated: false, reason: 'image' };
+        if (!textMedia(entry.row.mediaType))
+            return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'metadata', text: null, truncated: false, reason: 'unsupported-binary' };
+        if (value.bytes.length > TEXT_ATTACHMENT_MAX_BYTES)
+            return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'metadata', text: null, truncated: false, reason: 'text-too-large' };
+        let decoded;
+        try {
+            decoded = new TextDecoder('utf-8', { fatal: true }).decode(value.bytes);
+        }
+        catch {
+            return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'metadata', text: null, truncated: false, reason: 'unsupported-binary' };
+        }
+        if (decoded.includes('\0'))
+            return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'metadata', text: null, truncated: false, reason: 'unsupported-binary' };
+        return { id, name: entry.row.name, mediaType: entry.row.mediaType, size, mode: 'text', text: decoded.slice(0, PREVIEW_CHARS), truncated: decoded.length > PREVIEW_CHARS, reason: null };
+    };
+    const duplicates = async (id) => {
+        await exact(id);
+        let target;
+        try {
+            target = await bytesFor(id);
+        }
+        catch {
+            return { id, state: 'unavailable', sha256: null, duplicateIds: [], unreadableIds: [id], verifiedUnique: false };
+        }
+        const scan = await scanBytes(target.bytes, id);
+        return { id, state: scan.state, sha256: scan.sha256, duplicateIds: scan.duplicateIds, unreadableIds: scan.unreadableIds, verifiedUnique: scan.state === 'complete' && scan.duplicateIds.length === 0 };
+    };
+    const importFile = async (file) => {
+        const bytes = Buffer.from(await readImport(file)), name = basename(file), mediaType = mediaFor(file), scan = await scanBytes(bytes);
+        if (scan.duplicateIds.length) {
+            return { id: scan.duplicateIds[0], nome: name, mediaType, duplicateDecision: 'existing-exact', scanState: scan.state, duplicateIds: scan.duplicateIds, unreadableIds: scan.unreadableIds };
+        }
+        const mod = await store(), id = await mod.salvaVoce({ cartella: input.projectRoot, nome: name, mediaType, origine: 'uploaded', base64: bytes.toString('base64') });
+        return { id, nome: name, mediaType, duplicateDecision: scan.state === 'complete' ? 'created' : 'scan-incomplete-created', scanState: scan.state, duplicateIds: [], unreadableIds: scan.unreadableIds };
+    };
+    const exportFile = async (id, out) => { const value = await bytesFor(id); await writeExport(out, value.bytes); return { legacy: { ok: true, id, out, nome: value.nome, mediaType: value.mediaType } }; };
+    const rename = async (id, name) => { const mod = await store(), legacy = await mod.rinominaVoce({ cartella: input.projectRoot, id, nome: name }); return { legacy }; };
+    const deleteEntry = async (id) => { const mod = await store(), legacy = await mod.eliminaVoce({ cartella: input.projectRoot, id }); return { legacy }; };
+    const prepareContextReference = async (id) => {
+        const entry = await exact(id), relative = entry.mod.percorsoContenutoVoce(id);
+        if (!relative || /[\0\r\n\s]/u.test(relative))
+            fail('LIBRARY_CONTEXT_UNSUPPORTED', 'Library content path cannot be attached safely.');
+        const value = await bytesFor(id);
+        let attachment;
+        if (entry.row.fileType === 'image' || entry.row.mediaType.startsWith('image/')) {
+            const mime = imageMimeFromBytes(value.bytes);
+            if (!mime)
+                fail('LIBRARY_CONTEXT_UNSUPPORTED', 'This image format is not supported by the current CLI attachment model.');
+            attachment = { kind: 'image', path: relative, mimeType: mime, bytes: value.bytes.length, dataBase64: value.bytes.toString('base64') };
+        }
+        else {
+            if (!textMedia(entry.row.mediaType))
+                fail('LIBRARY_CONTEXT_UNSUPPORTED', 'This Library file type is not supported by the current CLI attachment model.');
+            if (value.bytes.length > TEXT_ATTACHMENT_MAX_BYTES)
+                fail('LIBRARY_CONTEXT_UNSUPPORTED', 'This Library text file exceeds the current CLI attachment limit.');
+            const text = fatalText(value.bytes);
+            attachment = { kind: 'text', path: relative, mimeType: 'text/plain', bytes: value.bytes.length, text };
+        }
+        validateCliAttachments([attachment]);
+        return { id, token: '@' + relative, path: relative, kind: attachment.kind, bytes: attachment.bytes };
+    };
+    return { list, search, read, preview, duplicates, importFile, exportFile, rename, delete: deleteEntry, prepareContextReference };
+}

package/dist/services/mcp-facade.js

@@ -0,0 +1,348 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createRequire } from 'node:module';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRedactor, redactObject, secretValuesFromEnvironment } from "../diagnostics/redact.js";
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+import { fingerprintExecutableResourceContent } from "../security/project-trust.js";
+import { createTrustAuthority } from "../security/trust-authority.js";
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,120}$/u;
+const MAX_LOGS = 100;
+const MAX_LOG_TEXT = 4096;
+const UNSAFE = /[\\\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+const BACKSLASH = String.fromCharCode(92);
+function fail(code, message = code) { throw Object.assign(new Error(message), { code }); }
+function serverId(value) { if (!ID.test(value) || value.includes('..'))
+    fail('MCP_SERVER_ID_INVALID'); return value; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : null; }
+function textValue(value) { return typeof value === 'string' && value.length > 0 ? value : null; }
+function inert(value) {
+    return String(value).replace(UNSAFE, character => {
+        if (character === BACKSLASH)
+            return BACKSLASH + BACKSLASH;
+        const code = character.codePointAt(0);
+        return code > 0xffff ? BACKSLASH + 'u{' + code.toString(16) + '}' : BACKSLASH + 'u' + code.toString(16).padStart(4, '0');
+    });
+}
+function safeText(value, redact) { return inert(redact(String(value ?? ''))).slice(0, MAX_LOG_TEXT); }
+function normalizeCapabilities(value, redact) {
+    const row = objectValue(value);
+    if (!row)
+        return null;
+    const experimental = objectValue(row.experimental);
+    return {
+        tools: Boolean(row.tools),
+        resources: Boolean(row.resources),
+        prompts: Boolean(row.prompts),
+        logging: Boolean(row.logging),
+        completions: Boolean(row.completions),
+        tasks: Boolean(row.tasks),
+        experimental: experimental ? Object.keys(experimental).map(value => safeText(value, redact)).sort() : []
+    };
+}
+function boundedLogs(rows, redact) {
+    return rows.slice(-MAX_LOGS).map(row => ({
+        source: row.source,
+        level: row.level ? safeText(row.level, redact) : null,
+        text: safeText(row.text, redact)
+    }));
+}
+function configuredServer(value) {
+    if (!value || typeof value !== 'object')
+        fail('MCP_CONFIG_MALFORMED');
+    const id = serverId(String(value.id ?? ''));
+    const args = value.argomenti ?? [];
+    if (typeof value.comando !== 'string' || !value.comando
+        || !Array.isArray(args) || !args.every((row) => typeof row === 'string')
+        || !Array.isArray(value.allowlist) || !value.allowlist.length
+        || !value.allowlist.every((row) => typeof row === 'string' && row.length > 0))
+        fail('MCP_CONFIG_MALFORMED');
+    return {
+        id, comando: value.comando, argomenti: [...args], allowlist: [...value.allowlist],
+        ...(typeof value.hash === 'string' ? { hash: value.hash } : {}),
+        ...(typeof value.nome === 'string' ? { nome: value.nome } : {}),
+        ...(typeof value.versione === 'string' ? { versione: value.versione } : {})
+    };
+}
+export function createMcpFacade(input, deps = {}) {
+    const authority = deps.authority ?? createTrustAuthority({ projectRoot: input.projectRoot, trustRoot: input.paths.trust.projects });
+    const clock = input.clock ?? (() => new Date().toISOString());
+    const now = input.now ?? (() => Date.now());
+    const secrets = deps.secretValues ?? secretValuesFromEnvironment(input.env ?? process.env);
+    const redactor = createRedactor(secrets);
+    const repoRoot = () => input.repoRoot ?? findTalosRepoRoot(input.projectRoot);
+    let registryPromise = null;
+    let clientPromise = null;
+    const registry = () => registryPromise ??= importTalosModule(repoRoot(), 'mcp-registry.mjs');
+    const clientModule = () => clientPromise ??= importTalosModule(repoRoot(), 'mcp-client.mjs');
+    async function defaultLoadServers() {
+        try {
+            const loaded = await (await registry()).caricaServerMcp({ cartella: input.projectRoot });
+            if (!loaded || !Array.isArray(loaded.server))
+                fail('MCP_CONFIG_MALFORMED');
+            return { server: loaded.server.map(configuredServer) };
+        }
+        catch (error) {
+            if (error?.code === 'RESOURCE_CONFIG_MALFORMED')
+                fail('MCP_CONFIG_MALFORMED');
+            throw error;
+        }
+    }
+    const loadServers = deps.loadServers ?? defaultLoadServers;
+    async function compatibilityRoot() { return (await authority.compatibilityRoots()).mcp; }
+    async function defaultUntrustCompatibility(id) { await rm(join(await compatibilityRoot(), serverId(id) + '.json'), { force: true }); }
+    async function defaultTrustCompatibility(server) {
+        if (!server.hash)
+            fail('MCP_COMPATIBILITY_HASH_MISSING');
+        const root = await compatibilityRoot();
+        await rm(join(root, serverId(server.id) + '.json'), { force: true });
+        await (await registry()).fidaServerMcp({ cartellaTrust: root, serverId: server.id, hash: server.hash });
+    }
+    const untrustCompatibility = deps.untrustCompatibility ?? defaultUntrustCompatibility;
+    const trustCompatibility = deps.trustCompatibility ?? defaultTrustCompatibility;
+    async function defaultFingerprintServer(server, snapshot) {
+        const resource = await fingerprintExecutableResourceContent({
+            workspace: snapshot.workspace,
+            kind: 'mcp',
+            id: server.id,
+            path: join(snapshot.workspace.canonicalRoot, '.harness-ui-mcp.json'),
+            content: JSON.stringify({ comando: server.comando, argomenti: server.argomenti ?? [], allowlist: server.allowlist })
+        });
+        return resource.fingerprint;
+    }
+    const fingerprintServer = deps.fingerprintServer ?? defaultFingerprintServer;
+    async function defaultProbeServer(server) {
+        const rawLogs = [];
+        const push = (entry) => {
+            if (rawLogs.length >= MAX_LOGS)
+                return;
+            rawLogs.push({ ...entry, text: String(entry.text).slice(0, MAX_LOG_TEXT) });
+        };
+        const requireFromHarness = createRequire(join(repoRoot(), 'harness-ui', 'package.json'));
+        const [clientSdk, stdioSdk] = await Promise.all([
+            import(__rewriteRelativeImportExtension(pathToFileURL(requireFromHarness.resolve('@modelcontextprotocol/client')).href)),
+            import(__rewriteRelativeImportExtension(pathToFileURL(requireFromHarness.resolve('@modelcontextprotocol/client/stdio')).href))
+        ]);
+        const ClientBase = clientSdk.Client;
+        const TransportBase = stdioSdk.StdioClientTransport;
+        class CapturingClient extends ClientBase {
+            constructor(...args) {
+                super(...args);
+                this.setNotificationHandler?.('notifications/message', (notification) => {
+                    const params = notification?.params ?? {};
+                    let text;
+                    try {
+                        text = typeof params.data === 'string' ? params.data : JSON.stringify(redactObject(params.data, secrets) ?? '');
+                    }
+                    catch {
+                        text = String(redactObject(params.data, secrets) ?? '');
+                    }
+                    push({ source: 'protocol', level: typeof params.level === 'string' ? params.level : null, text });
+                });
+            }
+            async connect(transport, options) {
+                try {
+                    return options === undefined ? await super.connect(transport) : await super.connect(transport, options);
+                }
+                catch (error) {
+                    try {
+                        await this.close();
+                    }
+                    catch { /* The original connect failure remains authoritative. */ }
+                    throw error;
+                }
+            }
+        }
+        class CapturingTransport extends TransportBase {
+            constructor(params) {
+                super({ ...params, stderr: 'pipe' });
+                this.stderr?.on?.('data', (chunk) => push({
+                    source: 'stderr', level: 'stderr',
+                    text: Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk)
+                }));
+            }
+        }
+        const mcp = await clientModule();
+        let connection = null;
+        let phase = 'connect';
+        const started = now();
+        try {
+            connection = await mcp.connettiServerMcp(server, { ClientCls: CapturingClient, TransportCls: CapturingTransport });
+            phase = 'discovery';
+            const tools = await mcp.elencaToolMcp(connection);
+            const client = connection.client;
+            return {
+                latencyMs: Math.max(0, now() - started),
+                serverInfo: client.getServerVersion?.() ?? null,
+                protocolVersion: client.getNegotiatedProtocolVersion?.() ?? null,
+                protocolEra: client.getProtocolEra?.() ?? null,
+                capabilities: client.getServerCapabilities?.() ?? null,
+                tools: Array.isArray(tools) ? tools : [],
+                logs: rawLogs
+            };
+        }
+        catch (error) {
+            throw Object.assign(new Error(error instanceof Error ? error.message : String(error)), {
+                code: typeof error?.code === 'string' ? error.code : 'MCP_PROBE_FAILED',
+                mcpProbePhase: phase,
+                mcpProbeLogs: rawLogs
+            });
+        }
+        finally {
+            try {
+                await connection?.chiudi?.();
+            }
+            catch (error) {
+                push({ source: 'probe', level: 'warning', text: 'close failed: ' + (error instanceof Error ? error.message : String(error)) });
+            }
+        }
+    }
+    const probeServer = deps.probeServer ?? defaultProbeServer;
+    async function servers() {
+        try {
+            const loaded = await loadServers();
+            if (!loaded || !Array.isArray(loaded.server))
+                fail('MCP_CONFIG_MALFORMED');
+            const rows = loaded.server.map(configuredServer);
+            const seen = new Set();
+            for (const server of rows) {
+                if (seen.has(server.id))
+                    fail('MCP_CONFIG_MALFORMED');
+                seen.add(server.id);
+            }
+            return rows;
+        }
+        catch (error) {
+            if (error?.code === 'RESOURCE_CONFIG_MALFORMED')
+                fail('MCP_CONFIG_MALFORMED');
+            throw error;
+        }
+    }
+    function trustRow(snapshot, id) {
+        return snapshot.resources.find(row => row.kind === 'mcp' && row.id === id && row.current);
+    }
+    function view(server, snapshot) {
+        const row = trustRow(snapshot, server.id);
+        const state = (row?.state ?? 'added');
+        const current = row?.currentFingerprint ?? null;
+        const trusted = row?.trustedFingerprint ?? null;
+        return {
+            id: server.id,
+            launch: { command: safeText(server.comando, redactor.text), argumentCount: server.argomenti?.length ?? 0 },
+            trust: {
+                projectTrusted: snapshot.trusted, state, trusted: state === 'trusted',
+                currentFingerprint: current, trustedFingerprint: trusted,
+                changed: state === 'changed' || Boolean(current && trusted && current !== trusted)
+            },
+            permission: {
+                configuredAllowlist: server.allowlist.map(value => safeText(value, redactor.text)),
+                effectiveTools: [], missingAllowlistedTools: [], perCallApproval: 'not-applied'
+            },
+            health: { state: 'not-probed', checkedAt: null, latencyMs: null, phase: null, message: null },
+            server: null, protocol: null, capabilities: null, logs: []
+        };
+    }
+    async function target(id) {
+        const wanted = serverId(id);
+        const rows = await servers();
+        const server = rows.find(row => row.id === wanted);
+        if (!server)
+            fail('MCP_SERVER_NOT_FOUND');
+        return server;
+    }
+    async function assertTrustedLoaded(server, snapshot) {
+        const row = trustRow(snapshot, server.id);
+        if (!row || row.state !== 'trusted')
+            fail('MCP_TRUST_REQUIRED');
+        if (!snapshot.trusted)
+            fail('PROJECT_TRUST_REQUIRED');
+        const loadedFingerprint = await fingerprintServer(server, snapshot);
+        if (!loadedFingerprint || loadedFingerprint !== row.currentFingerprint)
+            fail('MCP_TRUST_INVALIDATED');
+    }
+    return {
+        async list() {
+            const [rows, snapshot] = await Promise.all([servers(), authority.inspect()]);
+            return rows.map(server => view(server, snapshot));
+        },
+        async probe(id) {
+            const server = await target(id);
+            const snapshot = await authority.inspect();
+            const base = view(server, snapshot);
+            await assertTrustedLoaded(server, snapshot);
+            try {
+                const measured = await probeServer(server);
+                const advertised = [...new Set((measured.tools ?? [])
+                        .map(row => textValue(row?.name))
+                        .filter((row) => Boolean(row)))];
+                const allowedRaw = server.allowlist.filter(name => advertised.includes(name));
+                const missingRaw = server.allowlist.filter(name => !advertised.includes(name));
+                const effective = allowedRaw.map(name => safeText(name, redactor.text));
+                const missing = missingRaw.map(name => safeText(name, redactor.text));
+                const info = objectValue(measured.serverInfo);
+                return {
+                    ...base,
+                    permission: { ...base.permission, effectiveTools: effective, missingAllowlistedTools: missing },
+                    health: {
+                        state: missing.length ? 'degraded' : 'healthy',
+                        checkedAt: clock(),
+                        latencyMs: typeof measured.latencyMs === 'number' && Number.isFinite(measured.latencyMs) ? Math.max(0, measured.latencyMs) : null,
+                        phase: null,
+                        message: missing.length ? 'Configured tools not advertised: ' + missing.join(', ') : null
+                    },
+                    server: info && textValue(info.name) ? {
+                        name: safeText(info.name, redactor.text),
+                        version: textValue(info.version) ? safeText(info.version, redactor.text) : null
+                    } : null,
+                    protocol: {
+                        version: textValue(measured.protocolVersion) ? safeText(measured.protocolVersion, redactor.text) : null,
+                        era: textValue(measured.protocolEra) ? safeText(measured.protocolEra, redactor.text) : null
+                    },
+                    capabilities: normalizeCapabilities(measured.capabilities, redactor.text),
+                    logs: boundedLogs(measured.logs ?? [], redactor.text)
+                };
+            }
+            catch (error) {
+                const raw = error?.mcpProbeLogs;
+                const logs = Array.isArray(raw) ? [...raw] : [];
+                logs.push({ source: 'probe', level: 'error', text: error instanceof Error ? error.message : String(error) });
+                return {
+                    ...base,
+                    health: {
+                        state: 'failed', checkedAt: clock(), latencyMs: null,
+                        phase: textValue(error?.mcpProbePhase),
+                        message: safeText(error instanceof Error ? error.message : String(error), redactor.text)
+                    },
+                    logs: boundedLogs(logs, redactor.text)
+                };
+            }
+        },
+        async trust(id) {
+            const server = await target(id);
+            const reviewed = await authority.inspect();
+            const row = trustRow(reviewed, server.id);
+            if (!row?.current)
+                fail('MCP_RESOURCE_NOT_FOUND');
+            const loadedFingerprint = await fingerprintServer(server, reviewed);
+            if (!loadedFingerprint || loadedFingerprint !== row.currentFingerprint)
+                fail('MCP_TRUST_INVALIDATED');
+            const result = await authority.trustScope({ kind: 'mcp', id: server.id }, { expected: reviewed });
+            await trustCompatibility(server);
+            return { ok: true, id: server.id, changed: result.changed, snapshot: result.snapshot };
+        },
+        async untrust(id) {
+            const server = await target(id);
+            const result = await authority.untrustScope({ kind: 'mcp', id: server.id });
+            await untrustCompatibility(server.id);
+            return { ok: true, id: server.id, changed: result.changed, snapshot: result.snapshot };
+        }
+    };
+}

package/dist/services/memory-facade.js

@@ -0,0 +1,126 @@
+import { join } from 'node:path';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+const KINDS = new Set(['preference', 'project_fact', 'procedure', 'policy_note']);
+const SCOPE = { kind: 'global', evidence: 'derived-store-contract', projectId: null, sessionId: null };
+const DUPLICATE_POLICY = {
+    mode: 'create-title-normalized',
+    normalization: 'trim-lowercase',
+    onCreateDuplicate: 'return-existing-no-write',
+    onUpdate: 'not-checked',
+    semanticDetection: false,
+    merge: false
+};
+const USAGE = { status: 'unavailable', reason: 'store-does-not-persist-memory-usage' };
+const COST = { status: 'unavailable', reason: 'store-does-not-persist-memory-cost' };
+function stringOrNull(value) { return typeof value === 'string' ? value : null; }
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new TypeError('malformed persisted memory row: ' + field);
+    return value;
+}
+function invalid(error) {
+    return { state: 'invalid', scope: { ...SCOPE }, rows: [], error: { code: 'MEMORY_STORE_INVALID', message: error instanceof Error ? error.message : String(error) }, legacyRows: [] };
+}
+function projectRow(raw, store) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        throw new TypeError('malformed persisted memory row: object required');
+    const shaped = typeof store.formaPubblicaMemoria === 'function' ? store.formaPubblicaMemoria(raw) : raw;
+    if (!shaped || typeof shaped !== 'object' || Array.isArray(shaped))
+        throw new TypeError('malformed persisted memory row: public shape');
+    const id = requiredString(shaped.id, 'id');
+    const title = requiredString(shaped.titolo, 'titolo');
+    const content = requiredString(shaped.contenuto, 'contenuto');
+    const kind = KINDS.has(shaped.genere) ? shaped.genere : null;
+    const writerPersisted = raw.origine === 'persona' || raw.origine === 'modello';
+    const writer = shaped.origine === 'persona' || shaped.origine === 'modello' ? shaped.origine : 'modello';
+    return {
+        id, title, content, kind,
+        createdAt: stringOrNull(shaped.creataAlle),
+        updatedAt: stringOrNull(shaped.aggiornataAlle),
+        provenance: {
+            writer,
+            writerEvidence: writerPersisted ? 'persisted' : 'derived-legacy-default',
+            scope: 'global',
+            scopeEvidence: 'derived-store-contract',
+            projectId: null,
+            sessionId: null,
+            source: null
+        },
+        duplicateControl: { ...DUPLICATE_POLICY },
+        usage: { ...USAGE },
+        cost: { ...COST }
+    };
+}
+export function createMemoryFacade(input, deps = {}) {
+    const memoryRoot = () => {
+        if (input.memoryRoot)
+            return input.memoryRoot;
+        const dataRoot = input.paths?.dataRoot;
+        if (!dataRoot)
+            throw new Error('MEMORY_DATA_ROOT_REQUIRED');
+        return join(dataRoot, 'memory');
+    };
+    const repoRoot = () => {
+        if (input.repoRoot)
+            return input.repoRoot;
+        if (input.projectRoot)
+            return findTalosRepoRoot(input.projectRoot);
+        throw new Error('MEMORY_REPO_ROOT_REQUIRED');
+    };
+    let loaded = null;
+    const load = () => loaded ??= (deps.loadStore ? deps.loadStore() : importTalosModule(repoRoot(), 'memory-store.mjs'));
+    const list = async () => {
+        try {
+            const store = await load();
+            const raw = await store.elencaMemorie({ cartella: memoryRoot() });
+            if (!Array.isArray(raw))
+                throw new TypeError('malformed persisted memory list');
+            const rows = raw.map(row => projectRow(row, store));
+            return { state: 'ready', scope: { ...SCOPE }, rows, error: null, legacyRows: raw };
+        }
+        catch (error) {
+            return invalid(error);
+        }
+    };
+    const search = async (query, limit = 5) => {
+        try {
+            const store = await load();
+            const raw = await store.elencaMemorie({ cartella: memoryRoot() });
+            if (!Array.isArray(raw))
+                throw new TypeError('malformed persisted memory list');
+            const found = store.cercaMemorie(raw, { query, limit });
+            if (!found || !Array.isArray(found.memorie) || !Number.isFinite(found.totale))
+                throw new TypeError('malformed memory search result');
+            const rows = found.memorie.map(row => projectRow(row, store));
+            return {
+                state: 'ready', scope: { ...SCOPE }, rows, error: null, legacyRows: raw,
+                total: found.totale,
+                legacy: { memorie: found.memorie, totale: found.totale }
+            };
+        }
+        catch (error) {
+            return { ...invalid(error), total: 0, legacy: null };
+        }
+    };
+    const add = async (value) => {
+        const store = await load();
+        const result = await store.creaMemoria({ cartella: memoryRoot(), title: value.title, content: value.content, kind: value.kind ?? 'preference', origine: 'persona' });
+        return {
+            memory: projectRow(result.voce, store),
+            duplicateDecision: result.duplicato ? 'existing-title-no-write' : 'created',
+            legacy: result
+        };
+    };
+    const update = async (id, value) => {
+        const store = await load();
+        const row = await store.aggiornaMemoria({ cartella: memoryRoot(), id, ...(value.title !== undefined ? { title: value.title } : {}), ...(value.content !== undefined ? { content: value.content } : {}), ...(value.kind !== undefined ? { kind: value.kind } : {}) });
+        return { memory: projectRow(row, store), duplicateDecision: 'not-checked-on-update', legacy: row };
+    };
+    const deleteMemory = async (id) => {
+        const store = await load();
+        await store.eliminaMemoria({ cartella: memoryRoot(), id });
+        const legacy = { ok: true, id };
+        return { ok: true, id, legacy };
+    };
+    return { list, search, add, update, delete: deleteMemory };
+}