@fiodos/cli 0.1.0 → 0.1.2

package/README.md

@@ -43,6 +43,23 @@ npx @fiodos/cli analyze . --publish --api-key fyd_xxx --no-llm
 npx @fiodos/cli analyze . --publish --api-key fyd_xxx --api-url http://localhost:8000
 ```
 
+### Tras publicar: que el orbe NO falle en silencio
+
+El error más común es publicar con una key/URL y correr la app con OTRA: el orbe
+pide su manifest al sitio equivocado, no lo encuentra y se renderiza invisible.
+Para evitarlo, tras `--publish` el CLI:
+
+1. **Re-lee el manifest** con la MISMA key+URL con la que publicó y confirma que
+   el orbe lo encontrará, imprimiendo la key+URL exactas que tu app debe usar.
+2. En web, **ofrece escribir esa key+URL en tu `.env`** (`.env.local` en Next,
+   `.env` en Vite) para que runtime y publicación coincidan. Nunca sobrescribe
+   un valor distinto en silencio: avisa y pregunta. Desactívalo con
+   `--no-write-env`.
+
+Y en **desarrollo**, si aun así el orbe no puede montarse (key rechazada, sin
+manifest, backend inalcanzable), el SDK pinta un aviso visible con el motivo
+exacto donde iría el orbe (en producción sigue invisible).
+
 > Alternativa SIN IA — instalación manual: el flujo base de cualquier SDK
 > siempre funciona y no requiere IA ni clave de proveedor:
 > `npm install @fiodos/react @fiodos/core` y montar `<FiodosAgent/>` (el

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiodos/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Fiodos CLI — analyzes your app's source code and generates the in-app voice-agent manifest, then wires the orb. Powers `npx @fiodos/cli analyze`.",
   "type": "commonjs",
   "bin": {

package/src/index.js

@@ -31,8 +31,18 @@
  *   After analysis, a web target is OFFERED automatic wiring of <FiodosAgent/>
  *   into the app's root layout. It asks before editing your code; on "no" (or a
  *   non-interactive shell) it prints the ready-to-paste snippet instead.
- *     --yes      accept the wiring without the prompt (CI / express installer)
- *     --no-wire  skip wiring entirely (analysis/publish unaffected)
+ *     --yes          accept the wiring/env without the prompt (CI / express)
+ *     --no-wire      skip wiring entirely (analysis/publish unaffected)
+ *     --no-write-env skip the offer to align the app's .env with the published
+ *                    key/URL (see below)
+ *
+ * Avoiding the silent "orb fetches the wrong backend" failure:
+ *   After --publish the CLI (1) re-fetches the manifest with the SAME key+URL to
+ *   confirm the orb will find it, printing the exact key/URL your app must use,
+ *   and (2) on web, OFFERS to write that key/URL into the app's env file
+ *   (.env.local for Next, .env for Vite) so the runtime matches what you
+ *   published. It never overwrites a differing value silently — it warns and
+ *   asks first. Disable with --no-write-env.
  *
  * AI key — HYBRID model:
  *   DEFAULT (hosted): the AI analysis runs on the Fiodos backend with FIODOS'S
@@ -82,6 +92,7 @@ const { analyzeWithAI, correctActionWiring, DEFAULT_MODEL, resolveModel } = requ
 const { verifyManifest } = require('./verify');
 const { wireWebOrb, reportWireResult } = require('./wireWeb');
 const { wireHandlers, reportHandlerResult } = require('./wireHandlers');
+const { offerWriteEnv } = require('./writeEnv');
 
 function arg(flag, fallback) {
   const i = process.argv.indexOf(flag);
@@ -129,7 +140,7 @@ function fyodosTermColors() {
 
 /** Internal diagnostics (tokens, cost, paths…) — only with --verbose. */
 function isVerbose() {
-  return process.argv.includes('--verbose') || process.argv.includes('-v');
+  return process.argv.includes('--verbose') || process.argv.includes('-v') || process.argv.includes('--debug');
 }
 
 function logDev(...args) {
@@ -356,9 +367,27 @@ async function main() {
   // their app, so the onboarding never needs a separate manual step. Mobile is
   // wired by its own installer and is intentionally left untouched here.
   if (platform === 'web') {
-    const { apiUrl } = resolveApiTarget();
+    const { apiKey, apiUrl } = resolveApiTarget();
     const assumeYes = process.argv.includes('--yes') || process.argv.includes('--wire-yes');
     const noWire = process.argv.includes('--no-wire');
+
+    // ── 5b. Offer to align the app's .env with the published key/URL (consent).
+    // Removes the second manual copy of the key — the root cause of the silent
+    // "orb fetches the wrong backend" failure. Skipped with --no-write-env.
+    if (process.argv.includes('--publish') && !process.argv.includes('--no-write-env')) {
+      try {
+        await offerWriteEnv({
+          appRoot: path.resolve(appRoot),
+          apiKey,
+          apiUrl,
+          defaultApiUrl: DEFAULT_API_URL,
+          assumeYes,
+          log: logUser,
+        });
+      } catch (e) {
+        logDev(`[write-env] skipped: ${e.message}`);
+      }
+    }
     // --no-orb-wire skips ONLY the orb mount (useful to test handler wiring in
     // isolation without modifying the app's entrypoint / package.json).
     if (!process.argv.includes('--no-orb-wire')) {
@@ -658,9 +687,57 @@ async function publishManifest(manifest, meta, analysisToken = null) {
   const body = await res.json();
   logUser(`Published to your project — ${body.routes} routes, ${body.actions} actions`);
   logDev(`[publish] OK — ${body.routes} routes, ${body.actions} actions received at ${body.receivedAt}`);
+
+  // ── Self-check: confirm the orb will actually FIND this manifest ───────────
+  // Re-fetch it the way the SDK does at runtime (GET /v1/client/manifest with
+  // the SAME key + URL). This catches the silent-failure setup BEFORE the
+  // developer is left wondering why the orb never appears, and prints the exact
+  // key/URL their app must use so they can compare with their .env.
+  await verifyOrbCanFetch({ apiKey, apiUrl });
+
   logUser('Open the dashboard → Agent settings → "Reload analysis" to review');
 }
 
+/**
+ * Verify the just-published manifest is retrievable through the public client
+ * endpoint with the same credentials, and tell the developer EXACTLY which key
+ * and URL their running app must use. Never hard-fails the publish (the publish
+ * already succeeded); a failed re-fetch is surfaced as an actionable warning.
+ */
+async function verifyOrbCanFetch({ apiKey, apiUrl }) {
+  try {
+    const res = await fetch(`${apiUrl}/v1/client/manifest`, {
+      method: 'GET',
+      headers: { 'x-api-key': apiKey },
+    });
+    if (res.ok) {
+      const data = await res.json().catch(() => null);
+      if (data && data.manifest) {
+        logUser(
+          `✓ Verified: your orb will find this manifest using API key ${apiKey.slice(0, 12)}… ` +
+            `against ${apiUrl}.`,
+        );
+        logUser(
+          'Make sure your app uses this SAME key and URL in its .env ' +
+            '(NEXT_PUBLIC_FYODOS_API_KEY / VITE_FYODOS_API_KEY, and the API URL).',
+        );
+        return true;
+      }
+    }
+    logUser(
+      `⚠︎ Published, but could not re-read the manifest from ${apiUrl} (HTTP ${res.status}). ` +
+        'Check that your app uses this same key and URL.',
+    );
+  } catch (e) {
+    logDev(`[verify] re-fetch failed: ${e.message}`);
+    logUser(
+      `⚠︎ Published, but could not reach ${apiUrl} to verify. ` +
+        'Confirm your app points to this same URL and key.',
+    );
+  }
+  return false;
+}
+
 main().catch((e) => {
   console.error(e);
   process.exit(1);

package/src/postWireTest.js

@@ -61,13 +61,13 @@ async function runPostWireTest(appRoot, opts = {}) {
       ok: true,
       stage: 'skipped-no-deps',
       command: '(none)',
-      output: 'node_modules ausente: no se pudo ejecutar el build (instala dependencias para verificarlo).',
+      output: 'node_modules missing: could not run the build (install dependencies to verify it).',
     };
   }
   const pkg = readPkg(appRoot);
   const chosen = chooseCommand(appRoot, pkg);
   if (!chosen) {
-    return { ok: true, stage: 'skipped-no-deps', command: '(none)', output: 'no hay script de build/typecheck.' };
+    return { ok: true, stage: 'skipped-no-deps', command: '(none)', output: 'no build/typecheck script.' };
   }
 
   const res = spawnSync('npm', chosen.args, {
@@ -79,7 +79,7 @@ async function runPostWireTest(appRoot, opts = {}) {
   });
 
   if (res.error && res.error.code === 'ETIMEDOUT') {
-    return { ok: false, stage: 'timeout', command: chosen.label, output: `build excedió ${Math.round(timeoutMs / 1000)}s` };
+    return { ok: false, stage: 'timeout', command: chosen.label, output: `build exceeded ${Math.round(timeoutMs / 1000)}s` };
   }
   if (res.error) {
     return { ok: false, stage: 'error', command: chosen.label, output: String(res.error.message || res.error) };

package/src/renderProbe.js

@@ -43,6 +43,39 @@ function loadJsdom() {
   try { return require('jsdom'); } catch { return null; }
 }
 
+/** Detailed technical output (jsdom/React internals) only when asked. */
+function isVerboseProbe() {
+  return process.argv.includes('--verbose') || process.argv.includes('-v') || process.argv.includes('--debug');
+}
+
+/**
+ * Capture (swallow) noisy global console output during a probe — React error
+ * boundary logs ("The above error occurred in <X>", "Consider adding an error
+ * boundary…"), uncaught-error dumps, etc. These come from rendering the user's
+ * real pages in a bare jsdom (no router/providers) and are internal noise, not
+ * actionable user information. The captured lines are returned for diagnostics.
+ *
+ * No-op under --verbose/--debug so power users can still see the raw detail.
+ */
+function captureConsole() {
+  if (isVerboseProbe()) return { captured: [], restore() {} };
+  const captured = [];
+  const saved = {
+    log: console.log, error: console.error, warn: console.warn, info: console.info, debug: console.debug,
+  };
+  const sink = (...a) => {
+    try { captured.push(a.map((x) => (typeof x === 'string' ? x : String(x))).join(' ')); } catch { /* ignore */ }
+  };
+  console.log = sink; console.error = sink; console.warn = sink; console.info = sink; console.debug = sink;
+  return {
+    captured,
+    restore() {
+      console.log = saved.log; console.error = saved.error; console.warn = saved.warn;
+      console.info = saved.info; console.debug = saved.debug;
+    },
+  };
+}
+
 /** esbuild plugin that empties style/asset imports (works on old esbuild that
  *  lacks the 'empty' loader). Side-effect CSS imports become no-ops. */
 function emptyAssetsPlugin() {
@@ -100,7 +133,7 @@ async function probeReactEffect(appRoot, entry, ctx) {
   const esbuild = loadEsbuild(appRoot);
   const jsdomMod = loadJsdom();
   if (!esbuild || !jsdomMod) {
-    return { status: 'unverifiable', detail: `no se pudo montar el render headless (${!esbuild ? 'esbuild' : 'jsdom'} no disponible); cableado aplicado, efecto real no verificable automáticamente — probar a mano` };
+    return { status: 'unverifiable', detail: `could not set up the headless render (${!esbuild ? 'esbuild' : 'jsdom'} not available); wiring applied, real effect not automatically verifiable — test by hand` };
   }
   const fyodosDirAbs = path.join(appRoot, ctx.fyodosDirRel);
   const componentAbs = path.join(appRoot, entry.bridge.file);
@@ -118,6 +151,7 @@ async function probeReactEffect(appRoot, entry, ctx) {
     `export const probe = { React: ReactNS.default || ReactNS, createRoot, flushSync, Comp, registry: fyodosGeneratedRegistries };\n`;
 
   let restore = () => {};
+  let cap = { restore() {} };
   try {
     fs.writeFileSync(harnessAbs, harness);
     await esbuild.build({
@@ -134,12 +168,14 @@ async function probeReactEffect(appRoot, entry, ctx) {
       absWorkingDir: fyodosDirAbs,
     });
 
+    // Silence React/jsdom render noise from here through unmount (see captureConsole).
+    cap = captureConsole();
     restore = installDom(jsdomMod, { storageKeys: ctx.storageKeys, kind: ctx.kind });
     delete require.cache[outAbs];
     const mod = require(outAbs);
     const { React, createRoot, flushSync, Comp, registry } = mod.probe;
     const Component = pickComponent(Comp);
-    if (!Component) return { status: 'unverifiable', detail: `no encontré un componente React montable exportado por '${entry.bridge.file}' — efecto real no verificable a mano` };
+    if (!Component) return { status: 'unverifiable', detail: `did not find a mountable React component exported by '${entry.bridge.file}' — real effect not verifiable, test by hand` };
 
     const container = document.createElement('div');
     document.body.appendChild(container);
@@ -150,7 +186,7 @@ async function probeReactEffect(appRoot, entry, ctx) {
       await settle();
       flushSync(() => {});
     } catch (err) {
-      return { status: 'unverifiable', detail: `el componente no se pudo renderizar en aislamiento (${short(err)}); efecto real no verificable automáticamente — probar a mano` };
+      return { status: 'unverifiable', detail: `the component could not be rendered in isolation (${short(err)}); real effect not automatically verifiable — test by hand` };
     }
 
     const beforeHTML = captureSnapshot(container);
@@ -162,22 +198,23 @@ async function probeReactEffect(appRoot, entry, ctx) {
       // Do NOT fire the effect; we proved it mounts and the handler resolves to a
       // live bridge function. Verify the bridge has the method, nothing more.
       try { root.unmount(); } catch {}
-      return { status: 'unverifiable', detail: 'acción con confirmación: no se dispara su efecto en el render de prueba (seguridad); cableado verificado hasta el punto de confirmación' };
+      return { status: 'unverifiable', detail: 'confirmation action: its effect is not fired in the test render (security); wiring verified up to the confirmation point' };
     }
 
     let invokeErr = null;
     try { await handler(ctx.params); } catch (e) { invokeErr = e; }
     await settle();
     try { flushSync(() => {}); } catch {}
-    if (invokeErr) { try { root.unmount(); } catch {} return { status: 'fail', detail: `al invocar el handler la app real lanzó: ${short(invokeErr)}` }; }
+    if (invokeErr) { try { root.unmount(); } catch {} return { status: 'fail', detail: `invoking the handler, the real app threw: ${short(invokeErr)}` }; }
 
     const afterHTML = captureSnapshot(container);
     const afterText = container.textContent || '';
     try { root.unmount(); } catch {}
     return decide(ctx.kind, { beforeHTML, beforeText, afterHTML, afterText });
   } catch (err) {
-    return { status: 'unverifiable', detail: `no se pudo preparar el render de prueba (${short(err)}); efecto real no verificable automáticamente — probar a mano` };
+    return { status: 'unverifiable', detail: `could not prepare the test render (${short(err)}); real effect not automatically verifiable — test by hand` };
   } finally {
+    try { cap.restore(); } catch {}
     try { fs.existsSync(harnessAbs) && fs.rmSync(harnessAbs); } catch {}
     try { fs.existsSync(outAbs) && fs.rmSync(outAbs); } catch {}
     try { restore(); } catch {}
@@ -212,22 +249,22 @@ function decide(kind, snap) {
   const sentinelDisappeared = beforeText.includes(SENTINEL) && !afterText.includes(SENTINEL);
 
   if (kind === 'add') {
-    if (sentinelAppeared) return { status: 'effect-pass', detail: `tras invocar la acción, "${SENTINEL}" aparece en la UI renderizada (el item se añadió de verdad)` };
-    if (htmlChanged) return { status: 'effect-pass', detail: 'la UI cambió tras invocar la acción (efecto observado en el render)' };
-    return { status: 'fail', detail: 'la acción se invocó pero la UI no cambió ni apareció el valor enviado (no produce su efecto)' };
+    if (sentinelAppeared) return { status: 'effect-pass', detail: `after invoking the action, "${SENTINEL}" appears in the rendered UI (the item was really added)` };
+    if (htmlChanged) return { status: 'effect-pass', detail: 'the UI changed after invoking the action (effect observed in the render)' };
+    return { status: 'fail', detail: 'the action was invoked but the UI did not change nor did the sent value appear (it produces no effect)' };
   }
   if (kind === 'delete') {
-    if (sentinelDisappeared) return { status: 'effect-pass', detail: 'el item sembrado desapareció de la UI tras invocar la acción (se borró de verdad)' };
-    if (htmlChanged) return { status: 'effect-pass', detail: 'la UI cambió tras invocar la acción de borrado' };
-    return { status: 'unverifiable', detail: 'no se observó cambio al borrar (quizá no había item sembrado en aislamiento); cableado aplicado, efecto no confirmado — probar a mano' };
+    if (sentinelDisappeared) return { status: 'effect-pass', detail: 'the seeded item disappeared from the UI after invoking the action (it was really deleted)' };
+    if (htmlChanged) return { status: 'effect-pass', detail: 'the UI changed after invoking the delete action' };
+    return { status: 'unverifiable', detail: 'no change observed on delete (maybe there was no seeded item in isolation); wiring applied, effect not confirmed — test by hand' };
   }
   if (kind === 'toggle') {
-    if (htmlChanged) return { status: 'effect-pass', detail: 'la UI cambió tras invocar la acción (estado del item alternado)' };
-    return { status: 'unverifiable', detail: 'no se observó cambio al alternar (quizá sin item sembrado en aislamiento); cableado aplicado, efecto no confirmado — probar a mano' };
+    if (htmlChanged) return { status: 'effect-pass', detail: 'the UI changed after invoking the action (item state toggled)' };
+    return { status: 'unverifiable', detail: 'no change observed on toggle (maybe no seeded item in isolation); wiring applied, effect not confirmed — test by hand' };
   }
   // ui / other
-  if (htmlChanged) return { status: 'effect-pass', detail: 'la UI del componente cambió tras invocar la acción' };
-  return { status: 'unverifiable', detail: 'la acción no produjo un cambio observable en el render aislado; cableado aplicado, efecto no confirmado — probar a mano' };
+  if (htmlChanged) return { status: 'effect-pass', detail: 'the component UI changed after invoking the action' };
+  return { status: 'unverifiable', detail: 'the action produced no observable change in the isolated render; wiring applied, effect not confirmed — test by hand' };
 }
 
 function short(err) {
@@ -240,8 +277,17 @@ function short(err) {
  * toggle actions have something to act on.
  */
 function installDom(jsdomMod, { storageKeys = [], kind } = {}) {
-  const { JSDOM } = jsdomMod;
-  const dom = new JSDOM('<!doctype html><html><body></body></html>', { url: 'http://localhost/', pretendToBeVisual: true });
+  const { JSDOM, VirtualConsole } = jsdomMod;
+  // A VirtualConsole that does NOT forward to the real console: jsdom's default
+  // pipes page errors (uncaught exceptions → "reportException", long stack
+  // traces) to our stderr. That is internal noise from rendering the user's
+  // pages in a bare DOM. We swallow it (or forward only under --verbose).
+  let virtualConsole;
+  try {
+    virtualConsole = new VirtualConsole();
+    if (isVerboseProbe()) virtualConsole.sendTo(console);
+  } catch { virtualConsole = undefined; }
+  const dom = new JSDOM('<!doctype html><html><body></body></html>', { url: 'http://localhost/', pretendToBeVisual: true, virtualConsole });
   const { window } = dom;
   // Seed storage BEFORE the component hydrates (only useful for delete/toggle).
   if (kind === 'delete' || kind === 'toggle') {
@@ -319,15 +365,15 @@ async function probeComponentEffect(appRoot, entry, opts = {}) {
 
   const withTimeout = (p) => Promise.race([
     p,
-    new Promise((resolve) => setTimeout(() => resolve({ status: 'unverifiable', detail: 'el render de prueba excedió el tiempo límite (posible bucle/timer en el componente); efecto real no verificable automáticamente — probar a mano' }), opts.timeoutMs || 25000)),
+    new Promise((resolve) => setTimeout(() => resolve({ status: 'unverifiable', detail: 'the test render exceeded the time limit (possible loop/timer in the component); real effect not automatically verifiable — test by hand' }), opts.timeoutMs || 25000)),
   ]);
 
   if (framework.includes('react')) return withTimeout(probeReactEffect(appRoot, entry, ctx));
   if (framework.includes('vue')) return withTimeout(require('./renderProbeVue').probeVueEffect(appRoot, entry, ctx));
   if (framework.includes('angular')) {
-    return { status: 'unverifiable', detail: 'Angular: el render headless de componentes con TestBed no es fiable fuera de ng test; cableado aplicado y verificado por compilación, efecto real no verificable automáticamente aquí — probar con `ng test` o a mano' };
+    return { status: 'unverifiable', detail: 'Angular: headless component rendering with TestBed is not reliable outside ng test; wiring applied and verified by compilation, real effect not automatically verifiable here — test with `ng test` or by hand' };
   }
-  return { status: 'unverifiable', detail: `framework '${framework}' sin render-probe; efecto real no verificable automáticamente` };
+  return { status: 'unverifiable', detail: `framework '${framework}' has no render-probe; real effect not automatically verifiable` };
 }
 
-module.exports = { probeComponentEffect, actionKind, decide, SENTINEL, SEED_ID, installDom, pickComponent, detectStorageKeys, probeParams, captureSnapshot, short, loadEsbuild, loadJsdom, reqFrom, emptyAssetsPlugin };
+module.exports = { probeComponentEffect, actionKind, decide, SENTINEL, SEED_ID, installDom, pickComponent, detectStorageKeys, probeParams, captureSnapshot, short, loadEsbuild, loadJsdom, reqFrom, emptyAssetsPlugin, captureConsole, isVerboseProbe };

package/src/renderProbeVue.js

@@ -17,7 +17,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 
-const { decide, installDom, captureSnapshot, short, loadEsbuild, loadJsdom, reqFrom, emptyAssetsPlugin } = require('./renderProbe');
+const { decide, installDom, captureSnapshot, short, loadEsbuild, loadJsdom, reqFrom, emptyAssetsPlugin, captureConsole } = require('./renderProbe');
 
 function vuePlugin(compilerSfc) {
   return {
@@ -52,7 +52,7 @@ async function probeVueEffect(appRoot, entry, ctx) {
   const compilerSfc = reqFrom(appRoot, '@vue/compiler-sfc');
   if (!esbuild || !jsdomMod || !compilerSfc) {
     const miss = !esbuild ? 'esbuild' : !jsdomMod ? 'jsdom' : '@vue/compiler-sfc';
-    return { status: 'unverifiable', detail: `no se pudo montar el render headless de Vue (${miss} no disponible); cableado aplicado, efecto real no verificable automáticamente — probar a mano` };
+    return { status: 'unverifiable', detail: `could not set up the Vue headless render (${miss} not available); wiring applied, real effect not automatically verifiable — test by hand` };
   }
   const fyodosDirAbs = path.join(appRoot, ctx.fyodosDirRel);
   const componentAbs = path.join(appRoot, entry.bridge.file);
@@ -66,6 +66,7 @@ async function probeVueEffect(appRoot, entry, ctx) {
     `export const probe = { createApp, nextTick, Component, registry: fyodosGeneratedRegistries };\n`;
 
   let restore = () => {};
+  let cap = { restore() {} };
   try {
     fs.writeFileSync(harnessAbs, harness);
     await esbuild.build({
@@ -86,11 +87,13 @@ async function probeVueEffect(appRoot, entry, ctx) {
       absWorkingDir: fyodosDirAbs,
     });
 
+    // Silence Vue/jsdom render noise from here through unmount.
+    cap = captureConsole();
     restore = installDom(jsdomMod, { storageKeys: ctx.storageKeys, kind: ctx.kind });
     delete require.cache[outAbs];
     const mod = require(outAbs);
     const { createApp, nextTick, Component, registry } = mod.probe;
-    if (!Component) return { status: 'unverifiable', detail: `'${entry.bridge.file}' no exporta un componente Vue montable — efecto real no verificable a mano` };
+    if (!Component) return { status: 'unverifiable', detail: `'${entry.bridge.file}' does not export a mountable Vue component — real effect not verifiable, test by hand` };
 
     const container = document.createElement('div');
     document.body.appendChild(container);
@@ -102,31 +105,32 @@ async function probeVueEffect(appRoot, entry, ctx) {
       await nextTick();
     } catch (err) {
       try { app && app.unmount(); } catch {}
-      return { status: 'unverifiable', detail: `el componente Vue no se pudo montar en aislamiento (${short(err)}); efecto real no verificable automáticamente — probar a mano` };
+      return { status: 'unverifiable', detail: `the Vue component could not be mounted in isolation (${short(err)}); real effect not automatically verifiable — test by hand` };
     }
 
     const beforeHTML = captureSnapshot(container);
     const beforeText = container.textContent || '';
     const handler = registry.handlers[entry.handler];
-    if (typeof handler !== 'function') { try { app.unmount(); } catch {} return { status: 'fail', detail: `el registro no expone el handler '${entry.handler}'` }; }
+    if (typeof handler !== 'function') { try { app.unmount(); } catch {} return { status: 'fail', detail: `the registry does not expose the handler '${entry.handler}'` }; }
 
     if (ctx.sensitive) {
       try { app.unmount(); } catch {}
-      return { status: 'unverifiable', detail: 'acción con confirmación: no se dispara su efecto en el render de prueba (seguridad); cableado verificado hasta el punto de confirmación' };
+      return { status: 'unverifiable', detail: 'confirmation action: its effect is not fired in the test render (security); wiring verified up to the confirmation point' };
     }
 
     let invokeErr = null;
     try { await handler(ctx.params); } catch (e) { invokeErr = e; }
     await nextTick();
-    if (invokeErr) { try { app.unmount(); } catch {} return { status: 'fail', detail: `al invocar el handler la app real lanzó: ${short(invokeErr)}` }; }
+    if (invokeErr) { try { app.unmount(); } catch {} return { status: 'fail', detail: `invoking the handler, the real app threw: ${short(invokeErr)}` }; }
 
     const afterHTML = captureSnapshot(container);
     const afterText = container.textContent || '';
     try { app.unmount(); } catch {}
     return decide(ctx.kind, { beforeHTML, beforeText, afterHTML, afterText });
   } catch (err) {
-    return { status: 'unverifiable', detail: `no se pudo preparar el render de prueba de Vue (${short(err)}); efecto real no verificable automáticamente — probar a mano` };
+    return { status: 'unverifiable', detail: `could not prepare the Vue test render (${short(err)}); real effect not automatically verifiable — test by hand` };
   } finally {
+    try { cap.restore(); } catch {}
     try { fs.existsSync(harnessAbs) && fs.rmSync(harnessAbs); } catch {}
     try { fs.existsSync(outAbs) && fs.rmSync(outAbs); } catch {}
     try { restore(); } catch {}

package/src/verifyWire.js

@@ -145,11 +145,11 @@ async function probeDexie(appRoot, entry, fyodosDirRel) {
     const op = dbMatch[3];
     const grew = after > before;
     const changed = after !== before || /update|put|delete/.test(op);
-    if (op === 'delete') return { status: 'effect-pass', detail: `delete ejecutó sobre la tabla '${table}'` };
-    if (grew || changed) return { status: 'effect-pass', detail: `'${table}' cambió (${before}→${after}) ejecutando la expresión real` };
-    return { status: 'fail', detail: `la expresión ejecutó pero '${table}' no cambió (${before}→${after})` };
+    if (op === 'delete') return { status: 'effect-pass', detail: `delete ran on the table '${table}'` };
+    if (grew || changed) return { status: 'effect-pass', detail: `'${table}' changed (${before}→${after}) running the real expression` };
+    return { status: 'fail', detail: `the expression ran but '${table}' did not change (${before}→${after})` };
   } catch (err) {
-    return { status: 'fail', detail: `la expresión lanzó: ${err && err.message ? err.message : String(err)}` };
+    return { status: 'fail', detail: `the expression threw: ${err && err.message ? err.message : String(err)}` };
   }
 }
 
@@ -200,16 +200,16 @@ async function probeEffect(appRoot, entry, opts = {}) {
         sensitive: opts.sensitive || entry.requireConfirmation,
       });
     } catch (err) {
-      return { status: 'unverifiable', detail: `render-probe no disponible (${err && err.message}); efecto real no verificable automáticamente — probar a mano` };
+      return { status: 'unverifiable', detail: `render-probe not available (${err && err.message}); real effect not automatically verifiable — test by hand` };
     }
   }
   if (opts.sensitive || entry.requireConfirmation) {
-    return { status: 'skipped', detail: 'acción con confirmación: no se dispara su efecto en la simulación (seguridad)' };
+    return { status: 'skipped', detail: 'confirmation action: its effect is not fired in the simulation (security)' };
   }
   // Module strategy: try the Dexie data-layer probe.
   const dexie = await probeDexie(appRoot, entry, opts.fyodosDirRel);
   if (dexie) return dexie;
-  return { status: 'skipped', detail: 'objetivo de módulo no simulable de forma segura en proceso; verificado por compilación' };
+  return { status: 'skipped', detail: 'module target not safely simulable in-process; verified by compilation' };
 }
 
 module.exports = { probeEffect, compileRegressed, extractErrorLines, readDexieStores };