pi-jev-guard 0.4.0 → 0.5.0

package/README.md

@@ -6,6 +6,7 @@ Verifica le risposte con [TypeSafe Jev](https://docs.typesafe.ai) dentro [pi](ht
 - **Domande tipate**: tool `jev_ask` per giudizi calibrati definiti dal modello (noul/choice/score) invece di prosa.
 - **Automatica**: gemello guarded `<modello>__jev` dentro lo stesso provider, che trattiene la risposta, la verifica con Jev e pubblica solo l'output approvato (con rigenerazione privata su `block`). Stessa auth del provider: nessun login extra, funziona anche con Codex/OAuth.
 - **Giudice output** (solo `automatic`, fail-open): dopo ogni `bash` cerca secret nel testo e classifica i fallimenti, allegando un consiglio al risultato.
+- **Verifica progetto** (opt-in): footer deterministico da `edit`/`write` osservati e check esplicitamente autorizzati nel manifest locale; il modello può eseguire soltanto quegli id, mai shell arbitraria.
 
 ## Installazione
 
@@ -180,6 +181,57 @@ le contraddizioni ad alta confidenza. Fail-open: se il verificatore non
 risponde, il testo passa senza nota. `/jev last` mostra anche l'esito
 grounding (`warned`/`repaired`/`held`).
 
+### Verifica progetto deterministica (opt-in)
+
+Il grounding è probabilistico; per **compilazione, lint e test** è meglio una
+prova deterministica. La verifica progetto mantiene, solo nella sessione,
+una lista di `edit`/`write` riusciti e degli esiti osservati dei check. Il
+footer della risposta viene generato dall'estensione, non dal modello:
+quindi non può trasformare un test non eseguito in “test passati”.
+
+1. Copia e adatta il manifest versionato/localmente controllato:
+
+```bash
+mkdir -p .pi
+cp config/jev-verification.example.json .pi/jev-verification.json
+```
+
+2. Controllalo tu e acquisiscilo nella sessione (o riacquisiscilo dopo una
+   modifica manuale):
+
+```text
+/jev verification reload
+/jev verification warn       # footer trasparente, nessuna rigenerazione
+# oppure: /jev verification repair|hold
+```
+
+3. Dopo un edit, il modello può eseguire soltanto gli id dichiarati nel
+   manifest — mai una shell string fornita dal modello:
+
+```text
+/jev verify recommended      # i check pertinenti non ancora freschi
+/jev verify all              # tutti, fino a verification.maxCommands
+/jev verify typecheck        # un id esplicito del manifest
+```
+
+Il tool LLM `jev_verify` ha lo stesso vincolo. Richiede un progetto trusted e
+non accetta comandi arbitrari. Footer/repair/hold operano nel twin in
+`automatic`; `/jev verify` può essere usato manualmente anche per controllare
+un progetto senza pubblicare un footer. Il manifest è acquisito a inizio sessione o
+con `/jev verification reload`; se cambia dopo, la verifica rifiuta di
+eseguire fino a una nuova acquisizione utente. `write`/`edit` del modello sul
+manifest sono bloccati; anche modifiche via shell vengono rilevate dal
+fingerprint e non aggiornano i comandi autorizzati. Il manifest è quindi una
+policy dell'utente/progetto, non una superficie di prompt injection.
+
+Modalità: `warn` aggiunge il footer; `repair` rigenera una volta con feedback
+che chiede di invocare `jev_verify`; `hold` trattiene le risposte quando un
+check è fallito, e dopo il tentativo bounded anche quando resta mancante.
+Nessun manifest o nessun check pertinente è una limitazione dichiarata, non
+un fallimento del codice e non produce hold. La raccolta delle modifiche è
+limitata a `edit`/`write` osservati: una modifica fatta con shell non viene
+attribuita automaticamente al modello.
+
 ## Configurazione
 
 `~/.pi/agent/jev-config.json` (o `$JEV_CONFIG`). Env: `JEV_MODE`, `JEV_BACKEND`
@@ -234,3 +286,6 @@ echo '{"requirements":"...","candidate":"..."}' | npm run jev-check
 - Il grounding controlla solo affermazioni verificabili sulla sessione
   (comandi, file, test, modifiche): niente fact-check di fatti esterni,
   e con contesti lunghi l'evidenza oltre budget viene elisa.
+- La verifica progetto dimostra solo i check dichiarati ed eseguiti dopo gli
+  `edit`/`write` osservati; non è una prova formale di correttezza, non vede
+  modifiche effettuate via shell e non sostituisce review umana.

package/config/jev-config.example.json

@@ -65,6 +65,15 @@
     "minConfidence": 0.6,
     "cacheSeconds": 120
   },
+  "verification": {
+    "enabled": false,
+    "mode": "warn",
+    "manifestPath": ".pi/jev-verification.json",
+    "maxRepairs": 1,
+    "commandTimeoutMs": 120000,
+    "outputChars": 6000,
+    "maxCommands": 3
+  },
   "exfilCheck": {
     "enabled": true,
     "tools": [

package/config/jev-verification.example.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "checks": [
+    {
+      "id": "typecheck",
+      "description": "TypeScript static check",
+      "command": "npm run typecheck",
+      "files": ["src/**/*.ts", "extensions/**/*.ts", "test/**/*.ts"]
+    },
+    {
+      "id": "unit",
+      "description": "Unit tests",
+      "command": "npm run test:unit",
+      "files": ["src/**/*.ts", "extensions/**/*.ts", "test/**/*.ts"]
+    },
+    {
+      "id": "diff-check",
+      "description": "Whitespace and patch integrity",
+      "command": "git diff --check"
+    }
+  ]
+}

package/extensions/index.ts

@@ -3,6 +3,7 @@ import type { Model, Provider } from "@earendil-works/pi-ai";
 import type { Api } from "@earendil-works/pi-ai";
 import { registerJevCommand, type UpstreamResult } from "../src/commands.ts";
 import { registerJevAskTool } from "../src/ask.ts";
+import { registerVerificationTool, type VerificationToolRunResult } from "../src/verification-tool.ts";
 import {
   configSnapshot,
   loadConfig,
@@ -58,11 +59,33 @@ import {
   groundingKey,
   recordEvidence,
   recordToolResult,
+  parseExitCode,
   GROUNDING_QUESTIONS,
   type EvidenceEntry,
   type GroundingEvaluation,
 } from "../src/grounding.ts";
-import type { PostPublishCheckFn } from "../src/automatic/guardian.ts";
+import type { PostPublishCheckFn, PostPublishCheckResult } from "../src/automatic/guardian.ts";
+import {
+  buildVerificationStatus,
+  createVerificationState,
+  isVerificationManifestPath,
+  decideVerificationAction,
+  loadVerificationManifest,
+  manifestCheckForCommand,
+  normalizeObservedPath,
+  recordObservedModification,
+  recordVerificationRun,
+  selectVerificationChecks,
+  trustVerificationManifest,
+  trustedVerificationManifest,
+  type VerificationManifestTrust,
+  type VerificationStatus,
+} from "../src/verification.ts";
+import {
+  formatVerificationExecutions,
+  runVerificationChecks,
+  type VerificationExecution,
+} from "../src/verification-runner.ts";
 
 export interface GateStatus {
   active: boolean;
@@ -100,6 +123,17 @@ export default function (pi: ExtensionAPI) {
   // Resettato a ogni session_start; solo automatic lo alimenta e lo usa.
   let evidenceLedger: EvidenceEntry[] = [];
   let evidenceSeq = 0;
+  // Stato distinto dal grounding: resta utile anche quando il grounding
+  // probabilistico è spento. Registra solo edit/write osservati e run di
+  // comandi approvati dal manifest del progetto.
+  let verificationState = createVerificationState();
+  let verificationSeq = 0;
+  /** Check bash/powershell iniziati davvero: seq=start, non result order. */
+  const verificationCheckStarts = new Map<string, { id: string; command: string; seq: number; source: "bash" | "powershell" }>();
+  let verificationCwd: string | undefined;
+  // Acquisito solo all'avvio sessione o con un comando utente esplicito.
+  // Il modello non può trasformare un edit al manifest in un comando eseguito.
+  let verificationManifestTrust: VerificationManifestTrust | undefined;
   let lastOutput: { tool: string; verdict: OutputVerdict; at: number } | undefined;
   let lastGate: { report: GateVerdictReport; at: number } | undefined;
 
@@ -189,6 +223,104 @@ export default function (pi: ExtensionAPI) {
     return getConfig();
   }
 
+  function captureVerificationManifest(cwd: string): VerificationManifestTrust {
+    verificationCwd = cwd;
+    verificationManifestTrust = trustVerificationManifest(cwd, config.verification.manifestPath);
+    return verificationManifestTrust;
+  }
+
+  function verificationSnapshot(cwd: string): {
+    loaded: ReturnType<typeof loadVerificationManifest>;
+    status: VerificationStatus;
+  } {
+    const loaded = trustedVerificationManifest(
+      verificationManifestTrust,
+      cwd,
+      config.verification.manifestPath,
+    );
+    return { loaded, status: buildVerificationStatus(verificationState, loaded) };
+  }
+
+  function verificationReport(
+    status: VerificationStatus,
+    action: "passed" | "warned" | "repaired" | "held",
+  ): NonNullable<GateVerdictReport["verification"]> {
+    return {
+      action,
+      changedFiles: [...status.changedFiles],
+      checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+    };
+  }
+
+  function recordVerificationExecution(
+    execution: VerificationExecution,
+    source: "jev_verify" | "bash" | "powershell" | "manual",
+    /** Marker al momento dell'avvio, non al tool_result. */
+    startedSeq = ++verificationSeq,
+  ): void {
+    recordVerificationRun(verificationState, {
+      id: execution.id,
+      command: execution.command,
+      ok: execution.ok,
+      ...(execution.exitCode !== undefined ? { exitCode: execution.exitCode } : {}),
+      seq: startedSeq,
+      source,
+    });
+  }
+
+  /**
+   * Esegue SOLO check estratti dal manifest locale validato. Questa funzione
+   * serve sia al tool del modello sia al comando utente /jev verify.
+   */
+  async function runProjectVerification(args: {
+    cwd: string;
+    selection: string | undefined;
+    signal?: AbortSignal;
+    trusted: boolean;
+  }): Promise<VerificationToolRunResult> {
+    const settings = config.verification;
+    if (!settings.enabled) {
+      return {
+        ok: false,
+        message: "[jev_verify] Verifica progetto disattivata. Attivala con /jev verification warn|repair|hold.",
+        results: [],
+      };
+    }
+    if (!args.trusted) {
+      return {
+        ok: false,
+        message: "[jev_verify] Progetto non trusted: nessun comando del manifest è stato eseguito.",
+        results: [],
+      };
+    }
+    const { loaded, status } = verificationSnapshot(args.cwd);
+    const selected = selectVerificationChecks(
+      loaded,
+      status,
+      args.selection,
+      settings.maxCommands,
+    );
+    if (!selected.ok) {
+      return { ok: false, message: `[jev_verify] ${selected.error}`, results: [] };
+    }
+    // Snapshot dell'ordine PRIMA dell'esecuzione: se un edit concorrente
+    // termina mentre il runner è attivo, questi risultati restano
+    // conservativamente stale/pending invece di essere falsamente freschi.
+    const startedSeq = ++verificationSeq;
+    const results = await runVerificationChecks({
+      checks: selected.checks,
+      cwd: args.cwd,
+      settings,
+      signal: args.signal,
+    });
+    for (const result of results) recordVerificationExecution(result, "jev_verify", startedSeq);
+    return {
+      ok: results.length > 0 && results.every((result) => result.ok),
+      message: formatVerificationExecutions(results),
+      results,
+    };
+  }
+
   /** Provider live corrente dal registry (sempre fresco, mai snapshot). */
   function liveUpstreamProvider(
     registry: ModelRegistry,
@@ -226,7 +358,7 @@ export default function (pi: ExtensionAPI) {
       getConfig,
       getReview: getGateReview,
       onVerdict: recordGateVerdict,
-      createPostCheck: createGroundingCheck,
+      createPostCheck,
     });
   }
 
@@ -435,6 +567,8 @@ export default function (pi: ExtensionAPI) {
     keyPresent: () => resolveBackend(getConfig()).apiKeyPresent,
   });
 
+  registerVerificationTool(pi, { run: runProjectVerification });
+
   registerJevCommand(pi, {
     config: getConfig,
     setMode: (mode) => {
@@ -476,6 +610,36 @@ export default function (pi: ExtensionAPI) {
       saveConfig(next);
       return refresh();
     },
+    verificationStatus: (cwd) => {
+      const { loaded, status } = verificationSnapshot(cwd);
+      return {
+        enabled: config.verification.enabled,
+        mode: config.verification.mode,
+        manifestPath: config.verification.manifestPath,
+        ...(loaded.ok ? { manifestLoaded: true } : { manifestLoaded: false, manifestError: loaded.error }),
+        changedFiles: status.changedFiles,
+        checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+      };
+    },
+    setVerification: (mode) => {
+      const next = configSnapshot(config);
+      if (mode === "off") {
+        next.verification.enabled = false;
+      } else {
+        next.verification.enabled = true;
+        next.verification.mode = mode;
+      }
+      saveConfig(next);
+      return refresh();
+    },
+    reloadVerificationManifest: (cwd) => {
+      const trusted = captureVerificationManifest(cwd);
+      return trusted.ok
+        ? { ok: true, path: trusted.path }
+        : { ok: false, error: trusted.error };
+    },
+    runVerification: ({ cwd, selection, signal, trusted }) =>
+      runProjectVerification({ cwd, selection, signal, trusted }),
     getLastGate: () => lastGate,
   });
 
@@ -492,6 +656,10 @@ export default function (pi: ExtensionAPI) {
     // Nuova sessione = nuova evidenza: il ledger non attraversa le sessioni.
     evidenceLedger = [];
     evidenceSeq = 0;
+    verificationState = createVerificationState();
+    verificationSeq = 0;
+    verificationCheckStarts.clear();
+    captureVerificationManifest(ctx.cwd);
     // Patch dei twin salvati in OGNI modalità (nessun setModel qui): senza,
     // un twin persistito non esisterebbe nel catalogo. Silenzioso: la
     // diagnostica resta agli hook di turno.
@@ -637,6 +805,7 @@ export default function (pi: ExtensionAPI) {
   // before_agent_start, ripatcha in silenzio (mai register/unregister).
   pi.on("turn_start", async (_event, ctx) => {
     try {
+      verificationCwd = ctx.cwd;
       ensurePatches(ctx.modelRegistry);
     } catch {
       // Mai bloccare il turno.
@@ -645,6 +814,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("before_agent_start", async (_event, ctx) => {
     try {
+      verificationCwd = ctx.cwd;
       noteReassert(ensurePatches(ctx.modelRegistry));
     } catch {
       // mai bloccare il turno
@@ -749,6 +919,38 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
+  /**
+   * Marca l'INIZIO reale di un check shell già autorizzato. Non basta
+   * l'ordine dei tool_result: bash e edit possono essere concorrenti e un
+   * test avviato prima di un edit non deve risultare fresco dopo di esso.
+   */
+  pi.on("tool_execution_start", async (event, ctx) => {
+    try {
+      if (sessionMode !== "automatic") return;
+      if (event.toolName !== "bash" && event.toolName !== "powershell") return;
+      verificationCwd = ctx.cwd;
+      const { loaded } = verificationSnapshot(ctx.cwd);
+      if (!loaded.ok) return;
+      const args = event.args as { command?: unknown };
+      const check = manifestCheckForCommand(loaded.manifest, args.command);
+      if (!check) return;
+      verificationCheckStarts.set(event.toolCallId, {
+        id: check.id,
+        command: check.command,
+        seq: ++verificationSeq,
+        source: event.toolName,
+      });
+      // Difesa memoria contro toolcall senza result (abort esterno).
+      while (verificationCheckStarts.size > 100) {
+        const oldest = verificationCheckStarts.keys().next().value;
+        if (oldest === undefined) break;
+        verificationCheckStarts.delete(oldest);
+      }
+    } catch {
+      // Nessun impatto sull'esecuzione del tool.
+    }
+  });
+
   // Policy pre-esecuzione tool (solo automatic).
   pi.on("tool_call", async (event, ctx) => {
     try {
@@ -780,6 +982,20 @@ export default function (pi: ExtensionAPI) {
 
       if (event.toolName === "write" || event.toolName === "edit") {
         const input = event.input as { path?: unknown };
+        if (isVerificationManifestPath(input.path, ctx.cwd, config.verification.manifestPath)) {
+          pi.appendEntry("jev-tool-block", {
+            tool: event.toolName,
+            ruleId: "verification-manifest-immutable",
+            revision: TOOL_POLICY_REVISION,
+          });
+          if (ctx.hasUI) {
+            ctx.ui.notify("Jev tool policy: il modello non può modificare il manifest che autorizza i suoi check.", "warning");
+          }
+          return {
+            block: true,
+            reason: "Bloccato da jev tool policy (verification-manifest-immutable): modifica il manifest manualmente e poi usa /jev verification reload.",
+          };
+        }
         const verdict = checkFilePath(input.path);
         if (verdict.blocked) {
           pi.appendEntry("jev-tool-block", {
@@ -872,6 +1088,60 @@ export default function (pi: ExtensionAPI) {
     return allow ? undefined : { block: true, reason: `Bloccato da jev exfil check (${summary}) (declined).` };
   }
 
+  /**
+   * Registra modifiche e risultati dei check configurati. È deliberatamente
+   * separato dal grounding: il footer deterministico deve funzionare anche
+   * senza una chiamata Jev aggiuntiva. I bash nativi contano soltanto se il
+   * loro comando coincide ESATTAMENTE con un id del manifest.
+   */
+  function recordVerificationResult(event: {
+    toolCallId?: string;
+    toolName: string;
+    input: unknown;
+    content: unknown;
+    isError: boolean;
+  }, cwd: string): void {
+    try {
+      // Raccolta locale senza costo anche se il footer è spento: attivarlo a
+      // metà sessione conserva gli edit/write già osservati. Pubblicazione,
+      // repair ed esecuzione restano rigorosamente opt-in in config.
+      if (sessionMode !== "automatic") return;
+      verificationCwd = cwd;
+      if (event.toolName === "edit" || event.toolName === "write") {
+        if (event.isError) return;
+        const input = event.input as { path?: unknown };
+        const path = normalizeObservedPath(input.path, cwd);
+        if (path) recordObservedModification(verificationState, path, ++verificationSeq);
+        return;
+      }
+      if (event.toolName !== "bash" && event.toolName !== "powershell") return;
+      const input = event.input as { command?: unknown };
+      const started = event.toolCallId
+        ? verificationCheckStarts.get(event.toolCallId)
+        : undefined;
+      if (event.toolCallId) verificationCheckStarts.delete(event.toolCallId);
+      const { loaded } = verificationSnapshot(cwd);
+      if (!loaded.ok) return;
+      const check = manifestCheckForCommand(loaded.manifest, input.command);
+      if (!check) return;
+      const output = toolResultText(event.content);
+      const exitCode = parseExitCode(output);
+      recordVerificationRun(verificationState, {
+        id: check.id,
+        command: check.command,
+        ok: !event.isError,
+        ...(exitCode !== undefined ? { exitCode } : {}),
+        // In runtime il marker esiste perché tool_execution_start precede il
+        // result. Fallback conservativo per adapter/test legacy senza evento:
+        // allocato qui, mai riusa un pass precedente.
+        seq: started?.seq ?? ++verificationSeq,
+        source: event.toolName,
+      });
+    } catch {
+      // Un footer non deve mai cambiare il risultato di un tool.
+    }
+  }
+
   /** Registra un tool_result nel ledger evidenza (solo automatic, mai bloccare). */
   function recordGroundingResult(event: {
     toolName: string;
@@ -1020,12 +1290,127 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  /**
+   * Post-check deterministico del codice: non dichiara il codice corretto,
+   * ma allega il fatto osservato (edit/write + check manifest). In repair il
+   * modello ha un solo giro per invocare `jev_verify` e correggere l'errore;
+   * in hold una failure concreta non viene pubblicata.
+   */
+  function createVerificationCheck(): PostPublishCheckFn | undefined {
+    try {
+      if (sessionMode !== "automatic" || !config.verification.enabled) return undefined;
+      const cwd = verificationCwd;
+      if (!cwd) return undefined;
+      const mode = config.verification.mode;
+      const maxRepairs = config.verification.maxRepairs;
+      let repairsUsed = 0;
+      return async () => {
+        const { status } = verificationSnapshot(cwd);
+        if (status.changedFiles.length === 0) return { action: "publish" };
+        const decision = decideVerificationAction({
+          status,
+          mode,
+          repairsUsed,
+          maxRepairs,
+        });
+        if (decision.action === "regenerate") {
+          repairsUsed++;
+          try {
+            pi.appendEntry("jev-verification-repair", {
+              files: status.changedFiles,
+              checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            });
+          } catch {
+            // solo diagnostica
+          }
+          return {
+            action: "regenerate",
+            feedback: decision.feedback,
+            verification: verificationReport(status, "repaired"),
+          };
+        }
+        if (decision.action === "hold") {
+          try {
+            pi.appendEntry("jev-verification-hold", {
+              files: status.changedFiles,
+              checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            });
+          } catch {
+            // solo diagnostica
+          }
+          return {
+            action: "hold",
+            holdText: decision.holdText,
+            verification: verificationReport(status, "held"),
+          };
+        }
+        // "repaired" solo se il giro di repair è arrivato davvero a check
+        // freschi tutti passati; altrimenti resta un warning, mai un successo
+        // inventato solo perché il modello ha ricevuto feedback.
+        const action = status.allPassed
+          ? repairsUsed > 0 ? "repaired" : "passed"
+          : "warned";
+        try {
+          pi.appendEntry("jev-verification-status", {
+            action,
+            files: status.changedFiles,
+            checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            ...(status.manifestError ? { manifestError: status.manifestError } : {}),
+          });
+        } catch {
+          // solo diagnostica
+        }
+        return {
+          action: "publish",
+          ...(decision.notice ? { notice: decision.notice } : {}),
+          verification: verificationReport(status, action),
+        };
+      };
+    } catch {
+      // Fail-open: errore del footer non deve bloccare il gate.
+      return undefined;
+    }
+  }
+
+  /** Compone grounding probabilistico e verifica deterministica senza perderne le note. */
+  function createPostCheck(): PostPublishCheckFn | undefined {
+    const grounding = createGroundingCheck();
+    const verification = createVerificationCheck();
+    if (!grounding && !verification) return undefined;
+    return async (args) => {
+      let groundingResult: PostPublishCheckResult | undefined;
+      if (grounding) {
+        groundingResult = await grounding(args);
+        if (groundingResult.action !== "publish") return groundingResult;
+      }
+      let verificationResult: PostPublishCheckResult | undefined;
+      if (verification) {
+        verificationResult = await verification(args);
+        if (verificationResult.action !== "publish") {
+          return {
+            ...verificationResult,
+            ...(groundingResult?.grounding ? { grounding: groundingResult.grounding } : {}),
+          };
+        }
+      }
+      const notices = [groundingResult?.notice, verificationResult?.notice]
+        .filter((notice): notice is string => Boolean(notice));
+      return {
+        action: "publish",
+        ...(notices.length > 0 ? { notice: notices.join("") } : {}),
+        ...(groundingResult?.grounding ? { grounding: groundingResult.grounding } : {}),
+        ...(verificationResult?.verification ? { verification: verificationResult.verification } : {}),
+      };
+    };
+  }
+
   // Giudice output (solo automatic, fail-open): dopo l'esecuzione cerca
   // secret nel testo e classifica i fallimenti. Non blocca mai: allega
   // una riga al risultato che il modello legge.
   pi.on("tool_result", async (event, ctx) => {
     try {
       // Ledger prima di tutto: vale anche con outputJudge disattivato.
+      recordVerificationResult(event, ctx.cwd);
       recordGroundingResult(event);
       if (sessionMode !== "automatic") return;
       if (!config.outputJudge.enabled) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-guard",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Jev validation guard for pi: on-demand tool + automatic provider gate. Dual backend: TypeSafe direct + OpenRouter.",
   "keywords": [