talos-code 0.0.1 → 0.2.0

package/dist/security/workspace-identity.js

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import { lstat, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeProjectRoot } from "../paths.js";
+async function exists(pathname) {
+    try {
+        await lstat(pathname);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function strictlyInside(root, candidate) {
+    return candidate !== root && inside(root, candidate);
+}
+function canonicalWorkspaceCandidate(workspace, candidate) {
+    const resolved = path.resolve(candidate);
+    if (!inside(workspace.requestedRoot, resolved))
+        return resolved;
+    const relative = path.relative(workspace.requestedRoot, resolved);
+    return path.resolve(workspace.canonicalRoot, relative);
+}
+export function isPathInsideWorkspace(workspace, candidate) {
+    return inside(workspace.canonicalRoot, canonicalWorkspaceCandidate(workspace, candidate));
+}
+/** Resolves an existing candidate through the filesystem and accepts it only when the real target stays inside the canonical workspace. */
+export async function resolvePathInsideWorkspace(workspace, candidate) {
+    const resolved = path.resolve(candidate);
+    if (!inside(workspace.requestedRoot, resolved) && !inside(workspace.canonicalRoot, resolved))
+        return null;
+    let canonical;
+    try {
+        canonical = await realpath(resolved);
+    }
+    catch {
+        return null;
+    }
+    return inside(workspace.canonicalRoot, canonical) ? canonical : null;
+}
+/**
+ * Innermost repository root strictly between the workspace root and the given resource, or null when the
+ * resource is covered by the workspace's own repository. Every comparison happens on paths already rooted at
+ * `canonicalRoot`, which `realpath` has collapsed, so short 8.3 names, the `\\?\` prefix, the UNC form and
+ * case differences are all resolved before this walk starts.
+ */
+async function innerRepositoryRoot(canonicalRoot, resource) {
+    let cursor = path.dirname(resource);
+    while (strictlyInside(canonicalRoot, cursor)) {
+        if (await exists(path.join(cursor, '.git')))
+            return cursor;
+        const parent = path.dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return null;
+}
+/**
+ * Groups the project's resources by the repository boundary they sit behind. An empty result means every
+ * resource belongs to the project's own repository, which is the common case and must stay indistinguishable
+ * from the behaviour before this function existed.
+ */
+export async function findNestedRepositories(workspace, resourcePaths) {
+    const found = new Map();
+    for (const relativePath of [...resourcePaths].sort()) {
+        const absolute = path.resolve(workspace.canonicalRoot, ...relativePath.split('/'));
+        if (!strictlyInside(workspace.canonicalRoot, absolute))
+            continue;
+        const root = await innerRepositoryRoot(workspace.canonicalRoot, absolute);
+        if (root === null)
+            continue;
+        const key = path.relative(workspace.canonicalRoot, root).split(path.sep).join('/');
+        const entry = found.get(key) ?? { relativePath: key, root, resources: [] };
+        entry.resources.push(relativePath);
+        found.set(key, entry);
+    }
+    return [...found.values()].sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+export async function resolveWorkspaceIdentity({ projectRoot }) {
+    const requestedRoot = path.resolve(projectRoot);
+    const canonicalRoot = await realpath(requestedRoot);
+    const repositoryRoots = [];
+    let cursor = canonicalRoot;
+    for (;;) {
+        if (await exists(path.join(cursor, '.git')))
+            repositoryRoots.push(cursor);
+        const parent = path.dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    const normalized = normalizeProjectRoot(canonicalRoot);
+    const identityHash = createHash('sha256').update(`talos-workspace-v1\0${normalized}`).digest('hex');
+    return { requestedRoot, canonicalRoot, gitRoot: repositoryRoots[0] ?? null, nestedRepository: repositoryRoots.length > 1, identityHash };
+}

package/dist/services/automation-facade.js

@@ -0,0 +1,59 @@
+import { join } from 'node:path';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+import { createAutomationPolicyStore } from "../automations/policy-store.js";
+import { createAutomationHistoryStore } from "../automations/history-store.js";
+import { dryRunAutomation } from "../automations/runner.js";
+import { probeWindowsAutomationRunner } from "../automations/windows-task.js";
+import { validateTimeZone } from "../automations/schedule.js";
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+function rowOf(row, policy) {
+    if (!row || typeof row.id !== 'string' || typeof row.taskId !== 'string')
+        fail('AUTOMATION_STORE_INVALID');
+    const daily = policy?.schedule.kind === 'daily' ? policy.schedule : null;
+    return { id: row.id, taskId: row.taskId, name: typeof row.nome === 'string' ? row.nome : row.taskId, active: Boolean(row.attiva), schedule: daily ? 'daily ' + daily.at : 'interval ' + String(row.intervalloMinuti ?? '?') + 'm', timezone: daily?.timezone ?? null, nextRunAt: typeof row.prossimaEsecuzione === 'string' ? row.prossimaEsecuzione : null };
+}
+export function createAutomationFacade(input, deps = {}) {
+    const policyStore = deps.policyStore ?? createAutomationPolicyStore(join(input.dataRoot, 'automation-policies'));
+    const historyStore = deps.historyStore ?? createAutomationHistoryStore(join(input.dataRoot, 'automation-history'));
+    let storePromise = null;
+    const store = () => storePromise ??= (deps.loadAutomationStore ? deps.loadAutomationStore() : (async () => { const mod = await importTalosModule(input.repoRoot ?? findTalosRepoRoot(input.projectRoot), 'automation-store.mjs'); return mod.createAutomationStore({ cartella: join(input.dataRoot, 'automations') }); })());
+    const dry = deps.dryRun ?? dryRunAutomation, healthProbe = deps.probeHealth ?? probeWindowsAutomationRunner;
+    async function list() {
+        try {
+            const rows = await (await store()).elenca();
+            const joined = [];
+            for (const raw of rows) {
+                const policy = await policyStore.get(raw.id);
+                joined.push(rowOf(raw, policy));
+            }
+            return { state: 'ready', rows: joined, error: null };
+        }
+        catch (error) {
+            return { state: 'invalid', rows: [], error: { code: 'AUTOMATION_STORE_INVALID', message: error instanceof Error ? error.message : String(error) } };
+        }
+    }
+    async function read(id) {
+        const raw = await (await store()).leggi(id);
+        if (!raw)
+            fail('AUTOMATION_NOT_FOUND');
+        const policy = await policyStore.get(id), base = rowOf(raw, policy);
+        const [history, dryRun, adapterHealth] = await Promise.all([historyStore.list(id), dry({ row: raw, policy, now: Date.now() }), healthProbe({ platform: process.platform })]);
+        return { ...base, policy, missedRun: policy?.missedRun ?? null, backoff: policy?.backoff ?? null, history, dryRun, adapterHealth };
+    }
+    async function configureDaily(id, options) {
+        const raw = await (await store()).leggi(id);
+        if (!raw)
+            fail('AUTOMATION_NOT_FOUND');
+        validateTimeZone(options.timezone);
+        const policy = await policyStore.put(id, { version: 1, schedule: { kind: 'daily', at: options.at, timezone: options.timezone }, missedRun: { mode: options.missed, graceMinutes: options.graceMinutes, catchupWindowMinutes: options.catchupWindowMinutes }, backoff: { baseSeconds: options.baseSeconds, maxSeconds: options.maxSeconds, consecutiveFailures: 0, nextRetryAt: null }, lastHandledSlot: null });
+        return { ...rowOf(raw, policy), policy };
+    }
+    async function dryRun(id) { const raw = await (await store()).leggi(id); if (!raw)
+        fail('AUTOMATION_NOT_FOUND'); const policy = await policyStore.get(id); return dry({ row: raw, policy, now: Date.now() }); }
+    const history = (id) => historyStore.list(id);
+    const health = () => healthProbe({ platform: process.platform });
+    async function setEnabled(id, active) { const s = await store(); if (typeof s.imposta !== 'function')
+        fail('AUTOMATION_STORE_INVALID'); const updated = await s.imposta(id, active); if (!updated)
+        fail('AUTOMATION_NOT_FOUND'); return rowOf(updated, await policyStore.get(id)); }
+    return { list, read, configureDaily, dryRun, history, health, setEnabled, policyStore, historyStore };
+}

package/dist/services/forge-facade.js

@@ -0,0 +1,77 @@
+import { createHash } from 'node:crypto';
+import { findTalosRepoRoot, importTalosModule } from "../runtime/repo.js";
+import { scanForgeManifest, validateForgeOwnerPackage } from "../security/forge-scan.js";
+function err(code, message = code) { throw Object.assign(new Error(code + ': ' + message), { code }); }
+function stable(value) { if (Array.isArray(value))
+    return '[' + value.map(stable).join(',') + ']'; if (value && typeof value === 'object') {
+    return '{' + Object.keys(value).sort().map(k => JSON.stringify(k) + ':' + stable(value[k])).join(',') + '}';
+} const encoded = JSON.stringify(value); return encoded === undefined ? 'null' : encoded; }
+function digest(pkg) { return createHash('sha256').update(stable(pkg)).digest('hex'); }
+function handle(result) { if (result?.erroreAvvio)
+    err(typeof result.code === 'string' ? result.code : 'FORGE_OWNER_ACTION_FAILED', String(result.erroreAvvio)); return result; }
+export function createForgeFacade(input, deps = {}) {
+    const repoRoot = () => input.repoRoot ?? findTalosRepoRoot(input.forgeRoot);
+    let storeP = null, contractP = null;
+    const store = () => storeP ??= (deps.loadStore ? deps.loadStore() : importTalosModule(repoRoot(), 'tool-forge-store.mjs'));
+    const contract = () => contractP ??= (deps.loadContract ? deps.loadContract() : importTalosModule(repoRoot(), 'forge-contract.mjs'));
+    const now = deps.now ?? (() => new Date());
+    async function analyzePackage(value) {
+        const pkg = validateForgeOwnerPackage(value), c = await contract(), validation = c.validaManifestForgeLocale(pkg.manifest), scan = scanForgeManifest(pkg.manifest, validation);
+        const capabilityRequests = [];
+        let simulation = { ok: false, status: 'blocked', trace: [], capabilityRequests, error: null };
+        if (validation?.ok && scan.ok) {
+            try {
+                const result = await c.eseguiFlowForgeLocale(pkg.manifest, pkg.simulation.input, { capacitaFn: async (capability, request) => {
+                        const simulated = Object.prototype.hasOwnProperty.call(pkg.simulation.capabilityResults, capability) ? pkg.simulation.capabilityResults[capability] : null;
+                        capabilityRequests.push({ capability, input: request, result: simulated });
+                        return simulated;
+                    } });
+                const ok = result?.ok === true || result?.status === 'succeeded';
+                simulation = { ok, status: String(result?.status ?? (ok ? 'succeeded' : 'failed')), trace: Array.isArray(result?.trace) ? result.trace : [], capabilityRequests, ...(result?.error ? { error: result.error } : {}), ...(result?.output !== undefined ? { output: result.output } : {}), ...(result?.value !== undefined ? { value: result.value } : {}) };
+            }
+            catch (error) {
+                simulation = { ok: false, status: 'failed', trace: [], capabilityRequests, error: { message: error instanceof Error ? error.message : String(error) } };
+            }
+        }
+        const evidence = { packageDigest: digest(pkg), ownerRevision: pkg.revision, analyzedAt: now().toISOString(), sideEffects: false, sandbox: { kind: 'declarative-fake-capability-boundary', osProcessSandbox: false }, validation: { ok: Boolean(validation?.ok), diagnostics: Array.isArray(validation?.diagnostica) ? validation.diagnostica : [] }, scan, simulation: { ok: simulation.ok, status: simulation.status, trace: simulation.trace, capabilityRequests } };
+        return { package: pkg, validation, scan, simulation, evidence };
+    }
+    const validatePackage = (value) => validateForgeOwnerPackage(value);
+    const scanPackage = async (value) => { const pkg = validateForgeOwnerPackage(value), validation = (await contract()).validaManifestForgeLocale(pkg.manifest); return { package: pkg, validation, scan: scanForgeManifest(pkg.manifest, validation) }; };
+    async function installPackage(sessionId, value) {
+        const analysis = await analyzePackage(value);
+        if (!analysis.validation?.ok || !analysis.scan.ok || !analysis.simulation.ok)
+            err('FORGE_ANALYSIS_BLOCKED', 'package must pass canonical validation, static scan and side-effect-free simulation');
+        const fn = deps.registry?.installaVersioneToolForgiato;
+        if (typeof fn !== 'function')
+            err('FORGE_OWNER_API_UNAVAILABLE');
+        const result = handle(await fn.call(deps.registry, sessionId, { revision: analysis.package.revision, manifest: analysis.package.manifest, capacita: analysis.validation.capacita ?? [], azioni: analysis.validation.azioni ?? [], rischio: analysis.validation.rischio ?? 'R1', evidence: analysis.evidence }));
+        return { instrument: result.strumento, analysis };
+    }
+    async function list() { try {
+        const rows = await (await store()).elencaToolForgiati({ cartella: input.forgeRoot });
+        return { state: 'ready', rows: rows.map((x) => ({ id: String(x.id), title: String(x.manifest?.title ?? x.id), enabled: x.abilitato === true, ownerRevision: Number.isSafeInteger(x.ownerRevision) ? Number(x.ownerRevision) : null, risk: String(x.rischio ?? 'R1'), ownerManaged: x.ownerManaged === true })), error: null };
+    }
+    catch (error) {
+        return { state: 'invalid', rows: [], error: { code: 'FORGE_STORE_INVALID', message: error instanceof Error ? error.message : String(error) } };
+    } }
+    async function read(id) {
+        const s = await store();
+        let row = typeof s.leggiToolForgiato === 'function' ? await s.leggiToolForgiato({ cartella: input.forgeRoot, id }) : null;
+        if (!row) {
+            const all = await s.elencaToolForgiati({ cartella: input.forgeRoot });
+            row = all.find((x) => x?.id === id) ?? null;
+        }
+        if (!row)
+            err('FORGE_NOT_FOUND');
+        const versions = row.ownerManaged === true && typeof s.elencaVersioniToolForgiatoOwner === 'function' ? await s.elencaVersioniToolForgiatoOwner({ cartella: input.forgeRoot, id }) : [];
+        return { id: String(row.id), title: String(row.manifest?.title ?? row.id), description: String(row.manifest?.description ?? ''), enabled: row.abilitato === true, ownerManaged: row.ownerManaged === true, ownerRevision: Number.isSafeInteger(row.ownerRevision) ? Number(row.ownerRevision) : null, risk: String(row.rischio ?? 'R1'), capabilities: Array.isArray(row.capacita) ? row.capacita : [], actions: Array.isArray(row.azioni) ? row.azioni : [], evidence: row.evidence ?? null, scan: row.evidence?.scan ?? null, versions };
+    }
+    async function versions(sessionId, id) { const fn = deps.registry?.versioniToolForgiato; if (typeof fn !== 'function')
+        err('FORGE_OWNER_API_UNAVAILABLE'); return handle(await fn.call(deps.registry, sessionId, id)).versioni ?? []; }
+    async function rollback(sessionId, id, revision) { const fn = deps.registry?.ripristinaVersioneToolForgiato; if (typeof fn !== 'function')
+        err('FORGE_OWNER_API_UNAVAILABLE'); return handle(await fn.call(deps.registry, sessionId, id, revision)); }
+    async function setEnabled(sessionId, id, enabled) { const fn = deps.registry?.abilitaToolForgiato; if (typeof fn !== 'function')
+        err('FORGE_OWNER_API_UNAVAILABLE'); return handle(await fn.call(deps.registry, sessionId, id, enabled)); }
+    return { validatePackage, scanPackage, analyzePackage, installPackage, list, read, versions, rollback, setEnabled };
+}

package/dist/services/hook-facade.js

@@ -0,0 +1,240 @@
+import { readdir, realpath, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { normalizeProjectRoot } from "../paths.js";
+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 VALID_EVENTS = new Set(['pre_tool_call', 'post_tool_call', 'session_start', 'session_end']);
+const MAX_HISTORY = 50;
+const MAX_SESSION_FILES = 5000;
+const MAX_SESSION_READS = 200;
+function fail(code, message = code) { throw Object.assign(new Error(message), { code }); }
+function hookId(value) { if (!ID.test(value) || value.includes('..'))
+    fail('HOOK_ID_INVALID'); return value; }
+function text(value) { return typeof value === 'string' ? value : null; }
+function safeResult(value, secrets) { return redactObject(value, secrets); }
+function configuredHook(value) {
+    if (!value || typeof value !== 'object')
+        fail('HOOK_CONFIG_MALFORMED');
+    const id = hookId(String(value.id ?? ''));
+    const eventi = value.eventi;
+    if (!Array.isArray(eventi) || !eventi.length || !eventi.every((row) => typeof row === 'string' && VALID_EVENTS.has(row))
+        || new Set(eventi).size !== eventi.length || typeof value.comando !== 'string' || !value.comando.trim())
+        fail('HOOK_CONFIG_MALFORMED');
+    return { id, eventi: [...eventi], comando: value.comando, ...(typeof value.hash === 'string' ? { hash: value.hash } : {}) };
+}
+export function createHookFacade(input, deps = {}) {
+    const authority = deps.authority ?? createTrustAuthority({ projectRoot: input.projectRoot, trustRoot: input.paths.trust.projects });
+    const secrets = secretValuesFromEnvironment(input.env ?? process.env);
+    const redactor = createRedactor(secrets);
+    const repoRoot = () => input.repoRoot ?? findTalosRepoRoot(input.projectRoot);
+    let registryPromise = null;
+    let storePromise = null;
+    const registry = () => registryPromise ??= importTalosModule(repoRoot(), 'hook-registry.mjs');
+    const store = () => storePromise ??= importTalosModule(repoRoot(), 'session-store.mjs');
+    async function defaultLoadHooks() {
+        try {
+            const loaded = await (await registry()).caricaHooks({ cartella: input.projectRoot });
+            if (!loaded || !Array.isArray(loaded.hooks))
+                fail('HOOK_CONFIG_MALFORMED');
+            return { hooks: loaded.hooks.map(configuredHook) };
+        }
+        catch (error) {
+            if (error?.code === 'HOOK_MALFORMED' || error?.code === 'RESOURCE_CONFIG_MALFORMED')
+                fail('HOOK_CONFIG_MALFORMED');
+            throw error;
+        }
+    }
+    const loadHooks = deps.loadHooks ?? defaultLoadHooks;
+    async function compatibilityRoot() { return (await authority.compatibilityRoots()).hooks; }
+    async function defaultUntrustCompatibility(id) { await rm(join(await compatibilityRoot(), hookId(id) + '.json'), { force: true }); }
+    async function defaultTrustCompatibility(hook) {
+        if (!hook.hash)
+            fail('HOOK_COMPATIBILITY_HASH_MISSING');
+        const root = await compatibilityRoot();
+        await rm(join(root, hookId(hook.id) + '.json'), { force: true });
+        await (await registry()).fidaHook({ cartellaTrust: root, hookId: hook.id, hash: hook.hash });
+    }
+    const untrustCompatibility = deps.untrustCompatibility ?? defaultUntrustCompatibility;
+    const trustCompatibility = deps.trustCompatibility ?? defaultTrustCompatibility;
+    async function defaultFingerprintHook(hook, snapshot) {
+        const resource = await fingerprintExecutableResourceContent({
+            workspace: snapshot.workspace, kind: 'hook', id: hook.id,
+            path: join(snapshot.workspace.canonicalRoot, '.harness-ui-hooks.json'),
+            content: JSON.stringify({ eventi: hook.eventi, comando: hook.comando })
+        });
+        return resource.fingerprint;
+    }
+    const fingerprintHook = deps.fingerprintHook ?? defaultFingerprintHook;
+    const executeHook = deps.executeHook ?? (async (input) => (await registry()).eseguiHook(input));
+    async function defaultListSessionIds() {
+        try {
+            const rows = (await readdir(input.paths.sessionsRoot, { withFileTypes: true }))
+                .filter(row => row.isFile() && row.name.endsWith('.jsonl'))
+                .map(row => row.name.slice(0, -6))
+                .slice(0, MAX_SESSION_FILES);
+            const measured = await Promise.all(rows.map(async (id) => {
+                try {
+                    return { id, mtimeMs: (await stat(join(input.paths.sessionsRoot, id + '.jsonl'))).mtimeMs };
+                }
+                catch {
+                    return { id, mtimeMs: 0 };
+                }
+            }));
+            return measured.sort((a, b) => b.mtimeMs - a.mtimeMs || a.id.localeCompare(b.id)).slice(0, MAX_SESSION_READS).map(row => row.id);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    const listSessionIds = deps.listSessionIds ?? defaultListSessionIds;
+    const readSession = deps.readSession ?? (async (id) => (await store()).leggiRegistro({ cartellaStore: input.paths.sessionsRoot, sessionId: id }));
+    async function hooks() {
+        try {
+            const loaded = await loadHooks();
+            if (!loaded || !Array.isArray(loaded.hooks))
+                fail('HOOK_CONFIG_MALFORMED');
+            const rows = loaded.hooks.map(configuredHook);
+            const seen = new Set();
+            for (const hook of rows) {
+                if (seen.has(hook.id))
+                    fail('HOOK_CONFIG_MALFORMED');
+                seen.add(hook.id);
+            }
+            return rows;
+        }
+        catch (error) {
+            if (error?.code === 'HOOK_MALFORMED' || error?.code === 'RESOURCE_CONFIG_MALFORMED')
+                fail('HOOK_CONFIG_MALFORMED');
+            throw error;
+        }
+    }
+    async function target(id) { const wanted = hookId(id); const rows = await hooks(); const row = rows.find(item => item.id === wanted); if (!row)
+        fail('HOOK_NOT_FOUND'); return row; }
+    function trustRow(snapshot, id) { return snapshot.resources.find(row => row.kind === 'hook' && row.id === id && row.current); }
+    async function assertLoadedFingerprint(hook, snapshot) {
+        const row = trustRow(snapshot, hook.id);
+        if (!row?.currentFingerprint)
+            fail('HOOK_RESOURCE_NOT_FOUND');
+        const loaded = await fingerprintHook(hook, snapshot);
+        if (!loaded || loaded !== row.currentFingerprint)
+            fail('HOOK_TRUST_INVALIDATED');
+        return row;
+    }
+    async function quarantineOf(id) { return authority.quarantineStatus({ kind: 'hook', id }); }
+    async function historyFor(id, limit = 8) {
+        const wanted = hookId(id);
+        const snapshot = await authority.inspect();
+        const canonical = normalizeProjectRoot(snapshot.workspace.canonicalRoot);
+        const sessionIds = (await listSessionIds()).slice(0, MAX_SESSION_READS);
+        const out = [];
+        for (const sessionId of sessionIds) {
+            let records = null;
+            try {
+                records = await readSession(sessionId);
+            }
+            catch {
+                continue;
+            }
+            if (!Array.isArray(records) || !records.length)
+                continue;
+            const header = records.find(row => row?.tipo === 'intestazione');
+            if (!header || typeof header.cartella !== 'string')
+                continue;
+            let sessionRoot = normalizeProjectRoot(header.cartella);
+            if (sessionRoot !== canonical) {
+                try {
+                    sessionRoot = normalizeProjectRoot(await realpath(header.cartella));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (sessionRoot !== canonical)
+                continue;
+            const started = text(header.avviataAlle);
+            for (const row of records) {
+                if (row?.type !== 'HookInvoked' || row.hookId !== wanted || !Number.isSafeInteger(row._sequenza))
+                    continue;
+                out.push({
+                    sessionId: String(header.sessionId ?? sessionId), sessionStartedAt: started, sequence: row._sequenza,
+                    eventType: String(row.tipo ?? ''), action: text(row.azione), result: safeResult(row.esito, secrets), executedAt: null
+                });
+            }
+        }
+        out.sort((a, b) => String(b.sessionStartedAt ?? '').localeCompare(String(a.sessionStartedAt ?? '')) || b.sequence - a.sequence);
+        return out.slice(0, Math.max(0, Math.min(MAX_HISTORY, limit)));
+    }
+    async function view(hook, snapshot, history) {
+        const row = trustRow(snapshot, hook.id);
+        const state = (row?.state ?? 'added');
+        const quarantine = await quarantineOf(hook.id);
+        const current = row?.currentFingerprint ?? null;
+        const trusted = row?.trustedFingerprint ?? null;
+        return {
+            id: hook.id, events: [...hook.eventi], launch: { command: redactor.text(hook.comando) },
+            trust: { projectTrusted: snapshot.trusted, state, trusted: state === 'trusted' && !quarantine, currentFingerprint: current, trustedFingerprint: trusted, changed: state === 'changed' || Boolean(current && trusted && current !== trusted) },
+            quarantine: { active: Boolean(quarantine), reason: quarantine?.reason ?? null, quarantinedAt: quarantine?.quarantinedAt ?? null, reviewedFingerprint: quarantine?.reviewedFingerprint ?? null },
+            lastExecutions: history, lastDryRun: null
+        };
+    }
+    return {
+        async list() {
+            const [rows, snapshot] = await Promise.all([hooks(), authority.inspect()]);
+            const histories = await Promise.all(rows.map(row => historyFor(row.id, 8)));
+            return Promise.all(rows.map((row, index) => view(row, snapshot, histories[index] ?? [])));
+        },
+        async history(id, options = {}) {
+            await target(id);
+            return historyFor(id, options.limit ?? 8);
+        },
+        async dryRun(id, { eventType, action }) {
+            const hook = await target(id);
+            const snapshot = await authority.inspect();
+            if (await quarantineOf(hook.id))
+                fail('HOOK_QUARANTINED');
+            if (!snapshot.trusted)
+                fail('PROJECT_TRUST_REQUIRED');
+            if (!await authority.verifyScope({ kind: 'hook', id: hook.id }))
+                fail('HOOK_TRUST_REQUIRED');
+            await assertLoadedFingerprint(hook, snapshot);
+            if (!hook.eventi.includes(eventType))
+                fail('HOOK_EVENT_NOT_DECLARED');
+            const event = { tipo: eventType, ...(action ? { azione: action } : {}), dryRun: true };
+            const result = await executeHook({ hook, evento: event, cartella: input.projectRoot });
+            return { realProcess: true, syntheticEvent: true, eventType, action: action ?? null, result: safeResult(result, secrets) };
+        },
+        async trust(id) {
+            const hook = await target(id);
+            const reviewed = await authority.inspect();
+            await assertLoadedFingerprint(hook, reviewed);
+            const result = await authority.trustScope({ kind: 'hook', id: hook.id }, { expected: reviewed });
+            await trustCompatibility(hook);
+            return { ok: true, id: hook.id, changed: result.changed, snapshot: result.snapshot };
+        },
+        async untrust(id) {
+            const hook = await target(id);
+            const result = await authority.untrustScope({ kind: 'hook', id: hook.id });
+            await untrustCompatibility(hook.id);
+            return { ok: true, id: hook.id, changed: result.changed, snapshot: result.snapshot };
+        },
+        async quarantine(id, reason = null) {
+            const hook = await target(id);
+            const reviewed = await authority.inspect();
+            await assertLoadedFingerprint(hook, reviewed);
+            const result = await authority.quarantineScope({ kind: 'hook', id: hook.id }, { reason, expected: reviewed });
+            await untrustCompatibility(hook.id);
+            return { ok: true, id: hook.id, changed: result.changed, record: result.record, snapshot: result.snapshot };
+        },
+        async releaseQuarantine(id) {
+            const hook = await target(id);
+            const result = await authority.releaseQuarantine({ kind: 'hook', id: hook.id });
+            await untrustCompatibility(hook.id);
+            return { ok: true, id: hook.id, changed: result.changed };
+        }
+    };
+}

package/dist/services/index.js

@@ -0,0 +1,16 @@
+function publicRow(x) { if (!x || typeof x !== 'object')
+    return x; const o = {}; for (const [k, v] of Object.entries(x)) {
+    if (/path|percorso/i.test(k))
+        continue;
+    o[k === 'titolo' ? 'title' : k === 'testo' ? 'body' : k] = v;
+} return o; }
+export function createServiceFacades(stores) {
+    return {
+        notes: { list: async () => ((await stores.notes.list()) ?? []).map(publicRow), add: async (v) => publicRow(await stores.notes.create(v)) },
+        tasks: { list: async () => ((await stores.tasks.list()) ?? []).map(publicRow) },
+        memory: { search: async (q) => ((await stores.memory.search(q)) ?? []).map(publicRow) },
+        library: { list: async () => ((await stores.library.list()) ?? []).map(publicRow) },
+        research: { list: async () => ((await stores.research.list()) ?? []).map(publicRow) },
+        forge: { list: async () => ((await stores.forge.list()) ?? []).map(publicRow) },
+    };
+}