@fiodos/cli 0.1.0

package/src/renderProbeVue.js

@@ -0,0 +1,136 @@
+/**
+ * Vue real-effect render probe.
+ *
+ * Mounts the user's real .vue component in jsdom using the APP's own `vue`
+ * runtime, compiling SFCs on the fly with `@vue/compiler-sfc` (the standard Vue
+ * toolchain) via a tiny esbuild plugin. Then invokes the generated handler and
+ * confirms the rendered UI mutates.
+ *
+ * NOTE on the test app's pre-existing build errors: we transpile with esbuild
+ * (type-stripping only), so the app's pre-existing `vue-tsc` *type* errors do NOT
+ * block rendering — the effect check is independent of that unrelated noise.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const { decide, installDom, captureSnapshot, short, loadEsbuild, loadJsdom, reqFrom, emptyAssetsPlugin } = require('./renderProbe');
+
+function vuePlugin(compilerSfc) {
+  return {
+    name: 'fyodos-vue-sfc',
+    setup(build) {
+      build.onLoad({ filter: /\.vue$/ }, (args) => {
+        const src = fs.readFileSync(args.path, 'utf8');
+        const id = crypto.createHash('md5').update(args.path).digest('hex').slice(0, 8);
+        const { descriptor, errors } = compilerSfc.parse(src, { filename: args.path });
+        if (errors && errors.length) {
+          return { errors: [{ text: `SFC parse: ${errors[0].message || errors[0]}` }] };
+        }
+        try {
+          if (descriptor.scriptSetup || descriptor.script) {
+            const compiled = compilerSfc.compileScript(descriptor, { id, inlineTemplate: true });
+            return { contents: compiled.content, loader: 'ts', resolveDir: path.dirname(args.path) };
+          }
+          // Template-only component.
+          const tpl = compilerSfc.compileTemplate({ source: descriptor.template ? descriptor.template.content : '', id, filename: args.path });
+          return { contents: `${tpl.code}\nexport default { render };\n`, loader: 'ts', resolveDir: path.dirname(args.path) };
+        } catch (e) {
+          return { errors: [{ text: `SFC compile: ${e && e.message}` }] };
+        }
+      });
+    },
+  };
+}
+
+async function probeVueEffect(appRoot, entry, ctx) {
+  const esbuild = loadEsbuild(appRoot);
+  const jsdomMod = loadJsdom();
+  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` };
+  }
+  const fyodosDirAbs = path.join(appRoot, ctx.fyodosDirRel);
+  const componentAbs = path.join(appRoot, entry.bridge.file);
+  const entryRel = './' + path.relative(fyodosDirAbs, componentAbs).split(path.sep).join('/');
+  const harnessAbs = path.join(fyodosDirAbs, '__fyodos_probe_entry.ts');
+  const outAbs = path.join(os.tmpdir(), `fyodos-vue-probe-${Date.now()}.cjs`);
+  const harness =
+    `import { createApp, nextTick } from 'vue';\n` +
+    `import Component from '${entryRel}';\n` +
+    `import { fyodosGeneratedRegistries } from './handlers.generated';\n` +
+    `export const probe = { createApp, nextTick, Component, registry: fyodosGeneratedRegistries };\n`;
+
+  let restore = () => {};
+  try {
+    fs.writeFileSync(harnessAbs, harness);
+    await esbuild.build({
+      entryPoints: [harnessAbs],
+      outfile: outAbs,
+      bundle: true,
+      format: 'cjs',
+      platform: 'node',
+      resolveExtensions: ['.vue', '.ts', '.mjs', '.js', '.jsx', '.tsx', '.json'],
+      define: {
+        'process.env.NODE_ENV': '"development"',
+        __VUE_OPTIONS_API__: 'true',
+        __VUE_PROD_DEVTOOLS__: 'false',
+        __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: 'false',
+      },
+      plugins: [emptyAssetsPlugin(), vuePlugin(compilerSfc)],
+      logLevel: 'silent',
+      absWorkingDir: fyodosDirAbs,
+    });
+
+    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` };
+
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    let app;
+    try {
+      app = createApp(Component);
+      app.config && (app.config.warnHandler = () => {});
+      app.mount(container);
+      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` };
+    }
+
+    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 (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' };
+    }
+
+    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)}` }; }
+
+    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` };
+  } finally {
+    try { fs.existsSync(harnessAbs) && fs.rmSync(harnessAbs); } catch {}
+    try { fs.existsSync(outAbs) && fs.rmSync(outAbs); } catch {}
+    try { restore(); } catch {}
+  }
+}
+
+module.exports = { probeVueEffect, vuePlugin };

package/src/routes.js

@@ -0,0 +1,81 @@
+/**
+ * Layer 1a — expo-router route tree, derived programmatically from the file
+ * system of the target app (app/ or src/app/).
+ *
+ * Pure static analysis: every route here has provenance "static".
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/** Locates the expo-router app dir ('app' or 'src/app').
+ *  Returns null when none exists (e.g. a web app) instead of throwing, so the
+ *  AI-first pipeline can still run with no static route ground truth. */
+function findAppDir(appRoot) {
+  for (const candidate of ['app', 'src/app']) {
+    const full = path.join(appRoot, candidate);
+    if (fs.existsSync(full) && fs.statSync(full).isDirectory()) return full;
+  }
+  return null;
+}
+
+const SCREEN_EXT = /\.(tsx|jsx|ts|js)$/;
+const IGNORED = new Set(['_layout', '+not-found', '+html']);
+
+/**
+ * Walks the app dir and returns route records:
+ * { routePath, filePath, isDynamic, params[], group }
+ * expo-router conventions handled: (group) segments (stripped from URL),
+ * index files, [param] dynamic segments, +api files (excluded — not screens).
+ */
+function scanRoutes(appRoot) {
+  const appDir = findAppDir(appRoot);
+  const routes = [];
+
+  // No expo-router app/ dir (typical for web apps). Return empty ground truth;
+  // the caller degrades to "routes proposed by the AI, not statically verified".
+  if (!appDir) {
+    return { appDir: null, routes };
+  }
+
+  function walk(dir, urlSegments) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, [...urlSegments, entry.name]);
+        continue;
+      }
+      if (!SCREEN_EXT.test(entry.name)) continue;
+      const base = entry.name.replace(SCREEN_EXT, '');
+      if (IGNORED.has(base)) continue;
+      if (base.endsWith('+api')) continue; // API route, not a screen
+
+      const segments = base === 'index' ? urlSegments : [...urlSegments, base];
+      const urlParts = segments.filter((s) => !(s.startsWith('(') && s.endsWith(')')));
+      const groups = segments.filter((s) => s.startsWith('(') && s.endsWith(')'));
+      const params = urlParts
+        .filter((s) => s.startsWith('[') && s.endsWith(']'))
+        .map((s) => s.slice(1, -1));
+
+      // Route string as the navigation adapter would receive it. Keep the
+      // group prefix for tab roots (expo-router accepts both forms).
+      const routePath = '/' + segments.join('/');
+
+      routes.push({
+        routePath,
+        urlPath: '/' + urlParts.join('/'),
+        filePath: full,
+        relFile: path.relative(appRoot, full),
+        isDynamic: params.length > 0,
+        params,
+        groups,
+      });
+    }
+  }
+
+  walk(appDir, []);
+  return { appDir, routes };
+}
+
+module.exports = { scanRoutes, findAppDir };

package/src/verify.js

@@ -0,0 +1,172 @@
+/**
+ * Output verifier — the mechanical layer in its NEW role.
+ *
+ * The AI reads the code and proposes; this module confirms. It can only drop
+ * an individual unproven claim — it can never blind the analysis (the old
+ * candidate-gatekeeper failure mode).
+ *
+ * Checks per action:
+ *   1. evidence file exists among the files sent to the model
+ *   2. the handler (and evidence symbol) appears as a real identifier in that
+ *      file — word-boundary match, so 'addToCart' can't pass via 'addToCartX'
+ * Checks per route:
+ *   3. the route href maps to a statically-scanned expo-router screen
+ *      (or BACK, the SDK convention)
+ *
+ * Anything that fails is REMOVED from the manifest and recorded in
+ * provenance as dropped. A hallucinated action that ships is worse than a
+ * missed one.
+ */
+'use strict';
+
+/** Extract candidate identifiers from an evidence symbol string.
+ *  e.g. "useAuthStore (signOut action)" → ['useAuthStore', 'signOut'] */
+function identifiersIn(text) {
+  return String(text || '').match(/[A-Za-z_$][A-Za-z0-9_$]*/g) || [];
+}
+
+function fileHasIdentifier(content, identifier) {
+  if (!identifier) return false;
+  const re = new RegExp(`(^|[^A-Za-z0-9_$])${identifier}([^A-Za-z0-9_$]|$)`);
+  return re.test(content);
+}
+
+/** Normalize an expo-router href for comparison: strip (groups), trailing /index. */
+function normalizeHref(href) {
+  return ('/' + String(href || '')
+    .replace(/\([^)]*\)\//g, '')
+    .replace(/^\/+/, '')
+    .replace(/\/index$/, ''))
+    .replace(/\/+$/, '') || '/';
+}
+
+/**
+ * @param manifest  manifest as the model produced it
+ * @param evidence  { routes: {intent: {file, symbol}}, actions: {intent: {file, symbol, whatItDoes}} }
+ * @param sentFiles array of { rel, content } that were in the prompt
+ * @param staticRoutes array of { routePath, urlPath, relFile } from scanRoutes
+ * @param opts.verifyRoutes  when false, AI-proposed routes are kept WITHOUT
+ *        filesystem verification (web apps have no expo-router ground truth).
+ *        Actions are always verified against real code regardless.
+ *        Defaults to true when there is a static route ground truth.
+ * @returns { manifest, provenance }
+ */
+function verifyManifest(manifest, evidence, sentFiles, staticRoutes, opts = {}) {
+  const byRel = new Map(sentFiles.map((f) => [f.rel.replace(/\\/g, '/'), f.content]));
+  const verifyRoutes = opts.verifyRoutes ?? staticRoutes.length > 0;
+  const provenance = {
+    engine: 'auto-manifest-v3-ai-first',
+    routeVerification: verifyRoutes ? 'filesystem' : 'ai-proposed (no static ground truth)',
+    routes: [],
+    actions: [],
+    notes: [],
+  };
+
+  const validHrefs = new Set();
+  for (const r of staticRoutes) {
+    validHrefs.add(normalizeHref(r.routePath));
+    validHrefs.add(normalizeHref(r.urlPath));
+  }
+
+  const routes = [];
+  for (const route of manifest.routes || []) {
+    if (route.route === 'BACK') {
+      routes.push(route);
+      provenance.routes.push({ intent: route.intent, included: true, verification: 'static (SDK convention)' });
+      continue;
+    }
+    // Web mode: no filesystem route ground truth, so we cannot statically
+    // confirm routes. Keep what the AI proposed, but flag it as unverified —
+    // honesty over false precision.
+    if (!verifyRoutes) {
+      routes.push(route);
+      provenance.routes.push({
+        intent: route.intent, included: true,
+        verification: 'ai-proposed (route NOT statically verified — web app)',
+        evidence: evidence.routes?.[route.intent] || null,
+      });
+      continue;
+    }
+    const ok = validHrefs.has(normalizeHref(route.route));
+    if (!ok) {
+      provenance.routes.push({
+        intent: route.intent, included: false,
+        reason: `route '${route.route}' not found in expo-router file scan — DROPPED`,
+      });
+      continue;
+    }
+    routes.push(route);
+    provenance.routes.push({
+      intent: route.intent, included: true,
+      verification: 'route exists in filesystem scan',
+      evidence: evidence.routes?.[route.intent] || null,
+    });
+  }
+
+  const actions = [];
+  for (const action of manifest.actions || []) {
+    const ev = evidence.actions?.[action.intent] || {};
+    const evFile = String(ev.file || '').replace(/\\/g, '/').replace(/^\.\//, '');
+    const content = byRel.get(evFile);
+
+    if (!content) {
+      provenance.actions.push({
+        intent: action.intent, included: false,
+        reason: `evidence file '${ev.file || '(none)'}' was not among the files sent — DROPPED`,
+      });
+      continue;
+    }
+
+    // The handler must be a real identifier in the evidence file. Also accept
+    // any identifier from the symbol (covers "store.addItem"-style handlers).
+    const candidates = [action.handler, ...identifiersIn(ev.symbol)].filter(Boolean);
+    const found = candidates.find((c) => fileHasIdentifier(content, c));
+    if (!found) {
+      provenance.actions.push({
+        intent: action.intent, included: false,
+        reason: `neither handler '${action.handler}' nor symbol '${ev.symbol}' found in '${evFile}' — DROPPED`,
+      });
+      continue;
+    }
+
+    actions.push(action);
+    provenance.actions.push({
+      intent: action.intent, included: true,
+      verification: `identifier '${found}' confirmed in ${evFile}`,
+      evidence: ev,
+    });
+  }
+
+  // Intent namespace is shared between routes and actions (core validator).
+  const seen = new Set();
+  const dedupedRoutes = routes.filter((r) => !seen.has(r.intent) && seen.add(r.intent));
+  const dedupedActions = actions.filter((a) => {
+    if (seen.has(a.intent)) {
+      provenance.notes.push(`duplicate intent '${a.intent}' — kept first occurrence, action dropped`);
+      return false;
+    }
+    seen.add(a.intent);
+    return true;
+  });
+
+  // Schema coercion the model sometimes needs (same as the old engine).
+  for (const action of dedupedActions) {
+    for (const spec of Object.values(action.parameters || {})) {
+      if (spec.type === 'integer' || spec.type === 'float') spec.type = 'number';
+      else if (!['string', 'number', 'boolean'].includes(spec.type)) spec.type = 'string';
+      if (typeof spec.required !== 'boolean') spec.required = false;
+      if (typeof spec.description !== 'string' || !spec.description) spec.description = action.label || action.intent;
+    }
+    if (action.requireConfirmation && !action.confirmationMessageTemplate) {
+      action.confirmationMessageTemplate = `Confirm: ${action.label || action.intent}?`;
+      provenance.notes.push(`action '${action.intent}': confirmation template filled mechanically`);
+    }
+  }
+
+  return {
+    manifest: { ...manifest, routes: dedupedRoutes, actions: dedupedActions },
+    provenance,
+  };
+}
+
+module.exports = { verifyManifest, normalizeHref };

package/src/verifyWire.js

@@ -0,0 +1,215 @@
+/**
+ * verifyWire — install-time verification of a SINGLE wired action.
+ *
+ * Two complementary signals drive the auto-correction loop:
+ *   1) COMPILE: does the project still build/typecheck with ONLY this action's
+ *      wiring applied? (catches the real TS/shape errors that made Angular flaky).
+ *      We diff against a pre-captured baseline so a pre-broken app (e.g. Vue with
+ *      stale vue-tsc) is judged on "did WE add an error", not absolute success.
+ *   2) EFFECT: when the action's behaviour is safely simulable IN-PROCESS, run it
+ *      against a REAL instance and confirm observable state changed. Today this
+ *      covers the local-first data layer (Dexie) reliably; component-local state
+ *      (React useState / Vue ref / Angular DI) is not rendered in-process, so it
+ *      is honestly reported as "effect not simulated" (compile-verified instead).
+ *
+ * Nothing here ever fires a sensitive/irreversible action: callers pass
+ * `sensitive` for requireConfirmation actions and we skip execution for them.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function normRel(p) {
+  return String(p || '').replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+// ── Compile-error attribution ──────────────────────────────────────────────────
+
+/** Extract "path(line,col): error" / "ERROR ... path:line" style lines. */
+function extractErrorLines(output) {
+  const lines = String(output || '').split('\n');
+  return lines.filter((l) => /error\s+TS\d+|: error|ERROR\b|is not assignable|Cannot find|does not exist/i.test(l));
+}
+
+/**
+ * Normalize an error line so the SAME pre-existing error matches across builds
+ * even when our inserted lines shifted its line/column numbers. Without this, a
+ * pre-broken app (e.g. Vue with stale vue-tsc JSX errors) would report every
+ * shifted error as "new" the moment we add a single line → false regressions.
+ */
+function normErr(line) {
+  return String(line)
+    .replace(/\(\d+,\s*\d+\)/g, '(L,C)') // tsc:  file(123,3)
+    .replace(/:\d+:\d+/g, ':L:C') // esbuild: file:123:3
+    .replace(/\bline\s+\d+/gi, 'line N')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Did applying THIS action introduce a NEW build problem? Compare position-
+ * normalized error lines after vs. baseline. Any error that is new (not present
+ * in baseline) AND references a file we touched or our generated modules is
+ * attributed to this action. Returns { ok, newErrors: string[] }.
+ */
+function compileRegressed(baselineOutput, afterOutput, touchedFiles) {
+  const before = new Set(extractErrorLines(baselineOutput).map(normErr));
+  const afterRaw = extractErrorLines(afterOutput).map((l) => l.trim());
+  const fresh = afterRaw.filter((l) => !before.has(normErr(l)));
+  const touched = (touchedFiles || []).map((f) => path.basename(normRel(f)));
+  const ours = fresh.filter(
+    (l) => /handlers\.generated|fyodos[\\/]bridge|FYODOS/i.test(l) || touched.some((t) => t && l.includes(t)),
+  );
+  if (ours.length) return { ok: false, newErrors: ours };
+  // Only when the app built cleanly before (no baseline errors) do we treat any
+  // unattributable fresh error as a regression. If it was already broken, an
+  // unattributable error is almost certainly pre-existing → don't blame ourselves.
+  if (fresh.length && !before.size) return { ok: false, newErrors: fresh.slice(0, 8) };
+  return { ok: true, newErrors: [] };
+}
+
+// ── Effect probe (in-process, real instance) ─────────────────────────────────────
+
+/** Read a Dexie schema `version(n).stores({ table: 'idx', ... })` from a file. */
+function readDexieStores(appRoot, fileRel) {
+  const abs = path.join(appRoot, normRel(fileRel));
+  if (!fs.existsSync(abs)) return null;
+  const src = fs.readFileSync(abs, 'utf8');
+  const m = src.match(/\.stores\(\s*\{([\s\S]*?)\}\s*\)/);
+  if (!m) return null;
+  const stores = {};
+  const body = m[1];
+  const re = /(['"]?[\w$]+['"]?)\s*:\s*(['"])([\s\S]*?)\2/g;
+  let mm;
+  while ((mm = re.exec(body))) {
+    const key = mm[1].replace(/['"]/g, '');
+    stores[key] = mm[3];
+  }
+  return Object.keys(stores).length ? stores : null;
+}
+
+/** Resolve the file that the entry imports `db` (or similar) from. */
+function findImportFile(appRoot, entry, localName, fyodosDirRel) {
+  const imps = entry.imports || [];
+  const fyodosDir = fyodosDirRel || entry.fyodosDirRel || 'src/fyodos';
+  for (const imp of imps) {
+    if (imp.name === localName) {
+      // importPath is relative to the fyodos dir; resolve to a repo-relative file.
+      const base = path.join(appRoot, fyodosDir, imp.importPath);
+      for (const ext of ['.ts', '.js', '.mjs', '/index.ts', '/index.js']) {
+        if (fs.existsSync(base + ext)) return path.relative(appRoot, base + ext);
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Try to PROVE the effect of a Dexie-backed action by executing its exact
+ * expression against a real (fake-indexeddb) database with the app's schema.
+ * Returns { status: 'effect-pass'|'fail'|'skipped', detail }.
+ */
+async function probeDexie(appRoot, entry, fyodosDirRel) {
+  const expr = entry.callExpr || '';
+  const dbMatch = /\b([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)\.(add|put|bulkAdd|bulkPut|update|delete)\s*\(/.exec(expr);
+  if (!dbMatch) return null; // not a dexie op
+  const dbVar = dbMatch[1];
+  const table = dbMatch[2];
+  const dbFile = findImportFile(appRoot, entry, dbVar, fyodosDirRel);
+  if (!dbFile) return null;
+  const stores = readDexieStores(appRoot, dbFile);
+  if (!stores || !stores[table]) return null;
+
+  let Dexie;
+  try {
+    require(path.join(appRoot, 'node_modules/fake-indexeddb/auto'));
+    const mod = require(path.join(appRoot, 'node_modules/dexie'));
+    Dexie = mod.Dexie || mod.default || mod;
+  } catch {
+    return { status: 'skipped', detail: 'dexie/fake-indexeddb no disponible para simular el efecto' };
+  }
+
+  try {
+    const db = new Dexie(`fyodos-probe-${Date.now()}`);
+    const verObj = {};
+    for (const [t, idx] of Object.entries(stores)) verObj[t] = idx;
+    db.version(1).stores(verObj);
+    const before = await db.table(table).count();
+    const params = sampleParams(entry);
+    // Execute the EXACT generated expression with db + params in scope.
+    // eslint-disable-next-line no-new-func
+    const run = new Function(dbVar, 'params', 'crypto', `return (async () => { return ${expr}; })();`);
+    await run(db, params, globalThis.crypto || require('crypto').webcrypto);
+    const after = await db.table(table).count();
+    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})` };
+  } catch (err) {
+    return { status: 'fail', detail: `la expresión lanzó: ${err && err.message ? err.message : String(err)}` };
+  }
+}
+
+/** Reasonable test params from the action's declared manifest params. */
+function sampleParams(entry) {
+  const p = {};
+  for (const mp of entry.manifestParams || []) {
+    const n = (mp.name || '').toLowerCase();
+    if (/title|text|name|label|todo|task|note/.test(n)) p[mp.name] = 'Fiodos probe item';
+    else if (/id|key/.test(n)) p[mp.name] = 1;
+    else if (/count|qty|amount|number/.test(n)) p[mp.name] = 1;
+    else if (/done|complete|checked/.test(n)) p[mp.name] = true;
+    else p[mp.name] = 'probe';
+  }
+  return p;
+}
+
+/**
+ * Effect verification for one action. Returns:
+ *   { status: 'effect-pass'|'fail'|'skipped', detail }
+ * 'skipped' = couldn't simulate safely (component-local/sensitive); the caller
+ * then relies on the compile signal and reports honestly.
+ */
+function detectComponentFramework(appRoot) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'));
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    if (deps['@angular/core']) return 'angular';
+    if (deps.vue || deps['@vue/runtime-dom']) return 'vue';
+    if (deps.svelte || deps['@sveltejs/kit']) return 'svelte';
+    if (deps.react || deps['react-dom']) return 'react';
+  } catch { /* ignore */ }
+  return 'web';
+}
+
+async function probeEffect(appRoot, entry, opts = {}) {
+  if (entry.kind === 'bridge') {
+    // Component-local state: prove the real effect by RENDERING the component and
+    // confirming the UI mutates (not just that it compiles). Sensitive actions are
+    // not fired inside the render (handled by the render probe itself).
+    const framework = (opts.framework && opts.framework !== 'web') ? opts.framework : detectComponentFramework(appRoot);
+    try {
+      const { probeComponentEffect } = require('./renderProbe');
+      return await probeComponentEffect(appRoot, entry, {
+        framework,
+        fyodosDirRel: opts.fyodosDirRel,
+        sources: opts.sources,
+        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` };
+    }
+  }
+  if (opts.sensitive || entry.requireConfirmation) {
+    return { status: 'skipped', detail: 'acción con confirmación: no se dispara su efecto en la simulación (seguridad)' };
+  }
+  // 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' };
+}
+
+module.exports = { probeEffect, compileRegressed, extractErrorLines, readDexieStores };