@appilots/cli 0.11.0 → 0.13.0

package/dist/cli/index.js

@@ -28,10 +28,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/index.ts
-var import_commander8 = require("commander");
+var import_commander9 = require("commander");
 
 // src/version.ts
-var CLI_VERSION = "0.11.0";
+var CLI_VERSION = "0.13.0";
 
 // src/config/index.ts
 var import_fs = require("fs");
@@ -52,7 +52,8 @@ var KNOWN_CONFIG_KEYS = [
   "navigationExclude",
   "platform",
   "manifestPath",
-  "eval"
+  "eval",
+  "knowledge"
 ];
 var KEY_ALIASES = {
   apiUrl: "serverUrl",
@@ -107,12 +108,12 @@ function getEnvOverrides(env = process.env) {
     return trimmed ? trimmed : void 0;
   };
   return {
-    apiKey: clean(env.APPILOTS_API_KEY),
+    apiKey: clean(env.APPILOTS_PUBLISH_KEY) ?? clean(env.APPILOTS_API_KEY),
     projectId: clean(env.APPILOTS_PROJECT_ID),
     serverUrl: clean(env.APPILOTS_SERVER_URL)
   };
 }
-function loadConfig(onWarn) {
+function loadConfig(onWarn, options = {}) {
   const configPath = getConfigPath();
   const env = getEnvOverrides();
   let fileConfig = {};
@@ -151,6 +152,10 @@ function loadConfig(onWarn) {
   };
   const validation = validateConfig(merged);
   validation.warnings.unshift(...legacyWarnings);
+  if (options.requireApiKey === false) {
+    validation.errors = validation.errors.filter((e) => !e.startsWith("apiKey"));
+    validation.valid = validation.errors.length === 0;
+  }
   if (fileConfig.serverUrl === void 0 && env.serverUrl === void 0) {
     for (const key of Object.keys(fileConfig)) {
       if (KNOWN_CONFIG_KEYS.includes(key)) continue;
@@ -196,7 +201,8 @@ function saveConfig(dir, config) {
     navigationExclude: config.navigationExclude || existingConfig?.navigationExclude,
     platform: config.platform || existingConfig?.platform,
     manifestPath: config.manifestPath || existingConfig?.manifestPath,
-    eval: config.eval || existingConfig?.eval
+    eval: config.eval || existingConfig?.eval,
+    knowledge: config.knowledge || existingConfig?.knowledge
   };
   try {
     (0, import_fs.writeFileSync)(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
@@ -289,6 +295,19 @@ function validateConfig(config) {
   if (config.manifestPath !== void 0 && typeof config.manifestPath !== "string") {
     errors.push("manifestPath must be a string");
   }
+  if (config.knowledge !== void 0) {
+    if (typeof config.knowledge !== "object" || config.knowledge === null || Array.isArray(config.knowledge)) {
+      errors.push("knowledge must be an object");
+    } else {
+      const kc = config.knowledge;
+      for (const field of ["sources", "exclude"]) {
+        const value = kc[field];
+        if (value !== void 0 && (!Array.isArray(value) || !value.every((item) => typeof item === "string"))) {
+          errors.push(`knowledge.${field} must be an array of strings`);
+        }
+      }
+    }
+  }
   if (config.eval !== void 0) {
     if (typeof config.eval !== "object" || config.eval === null || Array.isArray(config.eval)) {
       errors.push("eval must be an object");
@@ -630,6 +649,48 @@ var AppilotsAPIClient = class {
       };
     }
   }
+  /**
+   * Syncs knowledge documents with the Appilots backend.
+   *
+   * @param documents Array of documents to sync (filename, base64 content, mimeType, checksum)
+   * @returns KnowledgeSyncResult with counts of uploaded, skipped, and errored docs
+   */
+  async knowledgeSync(documents) {
+    try {
+      const response = await this.request(`${this.baseUrl}/cli/knowledge/sync`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ documents })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          uploaded: 0,
+          skipped: 0,
+          errors: 0,
+          error: describeApiError(errorData, `HTTP ${response.status}: ${response.statusText}`)
+        };
+      }
+      const json = await response.json();
+      const inner = json.data ?? json;
+      return {
+        success: true,
+        ...inner
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        uploaded: 0,
+        skipped: 0,
+        errors: 0,
+        error: error2 instanceof Error ? error2.message : "Failed to sync knowledge with Appilots API"
+      };
+    }
+  }
   /**
    * Checks if the Appilots API server is healthy
    *
@@ -763,12 +824,18 @@ function initCommand() {
 // src/cli/commands/sync.ts
 var import_commander2 = require("commander");
 var import_promises5 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path7 = require("path");
 
 // src/generators/MCPGenerator.ts
 var import_promises4 = require("fs/promises");
-var import_node_crypto = require("crypto");
-var import_node_path3 = __toESM(require("path"));
+var import_node_crypto2 = require("crypto");
+var import_node_path5 = __toESM(require("path"));
+
+// src/generators/checksum.ts
+function serializeForChecksum(document) {
+  const { generatedAt: _generatedAt, ...content } = document;
+  return JSON.stringify(content, null, 2);
+}
 
 // src/pipeline/enrichment.ts
 function enrichScreenForAgent(screen) {
@@ -846,7 +913,10 @@ function mergeTargets(targets) {
   for (const target of targets) {
     if (!target.id) continue;
     const existing = byId.get(target.id);
-    byId.set(target.id, existing ? { ...target, ...existing, locator: existing.locator ?? target.locator } : target);
+    byId.set(
+      target.id,
+      existing ? { ...target, ...existing, locator: existing.locator ?? target.locator } : target
+    );
   }
   return Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id));
 }
@@ -891,7 +961,10 @@ function synthesizeFlows(screen, targets) {
         intent: "destructive_action",
         steps: [
           { type: "press", target: action.id, label: action.label },
-          { type: "confirm", description: "Wait for native or custom confirmation before continuing" },
+          {
+            type: "confirm",
+            description: "Wait for native or custom confirmation before continuing"
+          },
           { type: "wait", description: describeWait(action) }
         ],
         waitPolicy: waitPolicyForAction(action),
@@ -906,10 +979,19 @@ function synthesizeFlows(screen, targets) {
         title: `Act on an item in ${collection.id}`,
         intent: "list_action",
         steps: [
-          { type: "choose-list-item", target: collection.id, description: "Resolve the user reference to a visible or searchable row" },
-          { type: "press", description: collection.rowAction?.description ?? "Open the row action" }
+          {
+            type: "choose-list-item",
+            target: collection.id,
+            description: "Resolve the user reference to a visible or searchable row"
+          },
+          {
+            type: "press",
+            description: collection.rowAction?.description ?? "Open the row action"
+          }
         ],
-        waitPolicy: { expectedOutcome: collection.rowAction?.targetScreen ? "navigation" : "inline-feedback" }
+        waitPolicy: {
+          expectedOutcome: collection.rowAction?.targetScreen ? "navigation" : "inline-feedback"
+        }
       });
     }
   }
@@ -917,25 +999,32 @@ function synthesizeFlows(screen, targets) {
 }
 function waitPolicyForAction(action) {
   const expectedOutcome = action.successSignal?.type === "goBack" ? "goBack" : action.appilotsInferred?.expectedOutcome ?? (action.targetScreen ? "navigation" : void 0);
-  const signals = [action.successSignal, action.failureSignal].filter(Boolean);
+  const signals = [action.successSignal, action.failureSignal].filter(
+    Boolean
+  );
+  const maxMs = action.asyncBudgetMs ?? (action.appilotsInferred?.isAsyncTrigger ? 1e4 : void 0);
   return {
     ...expectedOutcome ? { expectedOutcome } : {},
     ...signals && signals.length > 0 ? { signals } : {},
-    ...action.appilotsInferred?.isAsyncTrigger ? { maxMs: 1e4 } : {}
+    ...maxMs !== void 0 ? { maxMs } : {}
   };
 }
 function describeWait(action) {
   if (action.successSignal?.description) return action.successSignal.description;
-  if (action.successSignal?.type === "goBack") return "Wait for the app to return to the previous screen";
+  if (action.successSignal?.type === "goBack")
+    return "Wait for the app to return to the previous screen";
   if (action.targetScreen) return `Wait for navigation to ${action.targetScreen}`;
-  if (action.appilotsInferred?.expectedOutcome) return `Wait for ${action.appilotsInferred.expectedOutcome}`;
+  if (action.appilotsInferred?.expectedOutcome)
+    return `Wait for ${action.appilotsInferred.expectedOutcome}`;
   return "Wait for the UI to settle";
 }
 function synthesizeAgentHints(screen, targets, flows) {
   const preferredTargets = targets.filter((target) => ["submit", "button", "list"].includes(target.role)).slice(0, 8).map((target) => target.id);
   const commonTasks = flows.slice(0, 6).map((flow) => flow.title);
   const safetyNotes = screen.actions.filter((action) => action.destructive || action.requiresConfirmation).map((action) => `${action.id} requires confirmation`);
-  const firstAsyncAction = screen.actions.find((action) => action.appilotsInferred?.isAsyncTrigger);
+  const firstAsyncAction = screen.actions.find(
+    (action) => action.appilotsInferred?.isAsyncTrigger || action.asyncBudgetMs !== void 0
+  );
   const hints = {
     primaryGoal: synthesizePrimaryGoal(screen),
     commonTasks,
@@ -962,7 +1051,9 @@ function synthesizePrimaryGoal(screen) {
   }
   const fieldCount = uniqueFields.size;
   if (fieldCount > 0) {
-    const requiredCount = Array.from(uniqueFields.values()).filter((field) => field.required).length;
+    const requiredCount = Array.from(uniqueFields.values()).filter(
+      (field) => field.required
+    ).length;
     const fieldLabel = fieldCount === 1 ? "field" : "fields";
     goals.push(
       requiredCount > 0 ? `Complete a form with ${fieldCount} ${fieldLabel} (${requiredCount} required)` : `Complete a form with ${fieldCount} ${fieldLabel}`
@@ -976,7 +1067,9 @@ function synthesizePrimaryGoal(screen) {
   if (submitCount > 0) {
     goals.push(`Submit ${submitCount === 1 ? "the primary form" : `${submitCount} forms/actions`}`);
   }
-  const asyncCount = screen.actions.filter((action) => action.appilotsInferred?.isAsyncTrigger).length;
+  const asyncCount = screen.actions.filter(
+    (action) => action.appilotsInferred?.isAsyncTrigger
+  ).length;
   if (asyncCount > 0) {
     goals.push(`Wait for ${asyncCount === 1 ? "async feedback" : "async action feedback"}`);
   }
@@ -986,15 +1079,370 @@ function synthesizePrimaryGoal(screen) {
 }
 
 // src/analyzers/ReactNativePlatformAnalyzer.ts
-var import_node_path = __toESM(require("path"));
-var import_fast_glob3 = __toESM(require("fast-glob"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/utils/glob.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+async function globSorted(patterns, options) {
+  const files = await (0, import_fast_glob.default)(patterns, options);
+  return files.sort(byCodeUnit);
+}
 
 // src/analyzers/ScreenAnalyzer.ts
 var import_promises = __toESM(require("fs/promises"));
+
+// src/extractors/control-evidence.ts
+var import_node_crypto = require("crypto");
+var import_traverse = __toESM(require("@babel/traverse"));
+var t2 = __toESM(require("@babel/types"));
+
+// src/extractors/control-evidence-bindings.ts
+var t = __toESM(require("@babel/types"));
+var MAX_HOPS = 8;
+function unwrap(path13) {
+  while (path13.isTSAsExpression() || path13.isTSTypeAssertion() || path13.isTSNonNullExpression() || path13.isTSSatisfiesExpression() || path13.isParenthesizedExpression())
+    path13 = path13.get("expression");
+  return path13;
+}
+function constantValue(path13, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path13 = unwrap(path13);
+  if (!path13.isIdentifier()) return path13;
+  const binding = path13.scope.getBinding(path13.node.name);
+  if (!binding?.constant || !binding.path.isVariableDeclarator()) return path13;
+  const init = binding.path.get("init");
+  const resolved = init.node ? constantValue(init, depth + 1) : void 0;
+  if (resolved?.isObjectExpression() && binding.referencePaths.some(
+    (reference) => !reference.parentPath?.isJSXSpreadAttribute() && !reference.parentPath?.isSpreadElement()
+  ))
+    return void 0;
+  return resolved;
+}
+function propValue(path13, name) {
+  const readObject = (path14) => {
+    const resolved = constantValue(path14);
+    if (!resolved?.isObjectExpression()) return { blocked: true };
+    for (const property of [...resolved.get("properties")].reverse()) {
+      if (property.isSpreadElement()) {
+        const found = readObjectBounded(property.get("argument"));
+        if (found.value || found.blocked) return found;
+      } else if (property.isObjectProperty() || property.isObjectMethod()) {
+        if (property.node.computed) return { blocked: true };
+        const key = property.node.key;
+        if ((t.isIdentifier(key) ? key.name : t.isStringLiteral(key) ? key.value : "") === name)
+          return property.isObjectProperty() ? { value: property.get("value") } : { value: property };
+      }
+    }
+    return {};
+  };
+  let objectBudget = MAX_HOPS;
+  const readObjectBounded = (path14) => objectBudget-- > 0 ? readObject(path14) : { blocked: true };
+  for (const attr of [...path13.get("attributes")].reverse()) {
+    if (attr.isJSXAttribute() && t.isJSXIdentifier(attr.node.name, { name })) {
+      const value = attr.get("value");
+      return value.isJSXExpressionContainer() ? unwrap(value.get("expression")) : value.node ? value : void 0;
+    }
+    if (attr.isJSXSpreadAttribute()) {
+      const found = readObjectBounded(attr.get("argument"));
+      if (found.value || found.blocked) return found.value;
+    }
+  }
+  return void 0;
+}
+function importIdentity(path13, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path13 = unwrap(path13);
+  if (path13.isIdentifier() || path13.isJSXIdentifier()) {
+    const binding = path13.scope.getBinding(path13.node.name);
+    if (!binding?.constant) return void 0;
+    const declaration = binding.path;
+    if (declaration.parentPath?.isImportDeclaration()) {
+      const module2 = declaration.parentPath.node.source.value;
+      if (declaration.isImportSpecifier()) {
+        const imported = declaration.node.imported;
+        return { module: module2, imported: t.isIdentifier(imported) ? imported.name : imported.value };
+      }
+      if (declaration.isImportDefaultSpecifier()) return { module: module2, imported: "default" };
+      if (declaration.isImportNamespaceSpecifier()) return { module: module2, imported: "*" };
+    }
+    if (declaration.isVariableDeclarator() && declaration.get("init").node)
+      return importIdentity(declaration.get("init"), depth + 1);
+  }
+  if (path13.isJSXMemberExpression() || path13.isMemberExpression() && !path13.node.computed) {
+    const origin = importIdentity(path13.get("object"), depth + 1);
+    const key = path13.node.property;
+    if (origin && (t.isIdentifier(key) || t.isJSXIdentifier(key)) && (origin.imported === "*" || origin.module === "react" && origin.imported === "default"))
+      return { module: origin.module, imported: key.name };
+  }
+  return void 0;
+}
+function handlerFunction(path13, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path13 = unwrap(path13);
+  if (path13.isFunction()) return path13;
+  if (path13.isIdentifier()) {
+    const binding = path13.scope.getBinding(path13.node.name);
+    if (!binding?.constant) return void 0;
+    if (binding.path.isFunctionDeclaration()) return binding.path;
+    if (binding.path.isVariableDeclarator() && binding.path.get("init").node)
+      return handlerFunction(binding.path.get("init"), depth + 1);
+  }
+  if (path13.isCallExpression()) {
+    const origin = importIdentity(path13.get("callee"));
+    if (origin?.module === "react" && origin.imported === "useCallback") {
+      const callback = path13.get("arguments")[0];
+      if (callback) return handlerFunction(callback, depth + 1);
+    }
+  }
+  if (path13.isMemberExpression() && !path13.node.computed && t.isThisExpression(path13.node.object)) {
+    const key = path13.node.property;
+    if (!t.isIdentifier(key)) return void 0;
+    const owner = path13.findParent((p) => p.isClassDeclaration() || p.isClassExpression());
+    if (!owner || !(owner.isClassDeclaration() || owner.isClassExpression())) return void 0;
+    for (const member of owner.get("body").get("body")) {
+      if (!(member.isClassMethod() || member.isClassProperty()) || member.node.computed || member.node.static)
+        continue;
+      if (!t.isIdentifier(member.node.key, { name: key.name })) continue;
+      if (member.isClassMethod() && member.node.kind === "method") return member;
+      if (member.isClassProperty() && member.get("value").node)
+        return handlerFunction(member.get("value"), depth + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/extractors/control-evidence.ts
+function symbol(node) {
+  if (t2.isTSAsExpression(node) || t2.isTSTypeAssertion(node) || t2.isTSNonNullExpression(node) || t2.isTSSatisfiesExpression(node))
+    return symbol(node.expression);
+  if (t2.isIdentifier(node) || t2.isJSXIdentifier(node)) return node.name;
+  if (t2.isThisExpression(node)) return "this";
+  if (t2.isMemberExpression(node) && !node.computed || t2.isJSXMemberExpression(node)) {
+    const object = symbol(node.object), property = symbol(node.property);
+    return object && property ? `${object}.${property}` : void 0;
+  }
+  if (t2.isUnaryExpression(node) && node.operator === "!") {
+    const value = symbol(node.argument);
+    return value ? `!${value}` : void 0;
+  }
+  return void 0;
+}
+function attribute(node, name) {
+  return node.attributes.find(
+    (a) => t2.isJSXAttribute(a) && t2.isJSXIdentifier(a.name, { name })
+  );
+}
+var ICON_LIBRARIES = [
+  "lucide-react-native",
+  "lucide-react",
+  "@tamagui/lucide-icons",
+  "@expo/vector-icons",
+  "@react-native-vector-icons/",
+  "react-native-vector-icons/"
+];
+function iconLibrary(module2) {
+  return ICON_LIBRARIES.some(
+    (name) => name.endsWith("/") ? module2.startsWith(name) : module2 === name || module2.startsWith(name + "/")
+  );
+}
+function add(values, value, max = 12) {
+  if (value && value.length <= 240 && values.length < max && !values.includes(value))
+    values.push(value);
+}
+function iconName(path13, explicitIcon = false) {
+  const origin = importIdentity(path13);
+  if (origin && iconLibrary(origin.module) && origin.imported !== "*")
+    return origin.imported === "default" ? origin.module : `${origin.module}:${origin.imported}`;
+  const name = symbol(path13.node);
+  return name && (explicitIcon || /icon/i.test(name)) ? name : void 0;
+}
+function iconsInElement(path13, explicitIcon = false) {
+  const name = iconName(path13.get("name"), explicitIcon);
+  if (!name) return void 0;
+  const glyph = propValue(path13, "name");
+  const value = glyph && constantValue(glyph);
+  return value?.isStringLiteral() ? `${name}:${value.node.value}` : name;
+}
+function hasInteraction(path13) {
+  return ["onPress", "onLongPress", "onClick"].some(
+    (name) => attribute(path13.node, name) || propValue(path13, name)
+  );
+}
+function collectPresentationIcons(path13, icons) {
+  const namedIconProps = [
+    "icon",
+    "prefix",
+    "suffix",
+    "left",
+    "right",
+    "leadingIcon",
+    "trailingIcon",
+    "startIcon",
+    "endIcon",
+    "renderIcon"
+  ];
+  const props = new Set(namedIconProps);
+  for (const attr of path13.node.attributes)
+    if (t2.isJSXAttribute(attr) && t2.isJSXIdentifier(attr.name) && !/^on[A-Z]/.test(attr.name.name))
+      props.add(attr.name.name);
+  for (const prop of props) {
+    const icon = propValue(path13, prop);
+    if (icon) {
+      const value = constantValue(icon);
+      if (value?.isStringLiteral()) {
+        if (prop.toLowerCase().includes("icon")) add(icons, value.node.value, 8);
+      } else {
+        const explicitIcon = prop.toLowerCase() === "icon";
+        if (icon.isJSXElement()) {
+          if (hasInteraction(icon.get("openingElement"))) continue;
+          add(icons, iconsInElement(icon.get("openingElement"), explicitIcon), 8);
+        }
+        icon.traverse({
+          JSXAttribute(attr) {
+            if (t2.isJSXIdentifier(attr.node.name) && /^on[A-Z]/.test(attr.node.name.name))
+              attr.skip();
+          },
+          JSXElement(child) {
+            const opening = child.get("openingElement");
+            if (hasInteraction(opening)) {
+              child.skip();
+              return;
+            }
+            add(icons, iconsInElement(opening, explicitIcon), 8);
+          }
+        });
+        if (!icons.length && (namedIconProps.includes(prop) || explicitIcon))
+          add(icons, iconName(icon, explicitIcon), 8);
+      }
+    }
+  }
+}
+function collectIcons(path13) {
+  const icons = [];
+  collectPresentationIcons(path13, icons);
+  const jsx = path13.parentPath;
+  if (jsx.isJSXElement())
+    jsx.traverse({
+      // JSX mentioned inside an event callback is not a rendered child icon.
+      JSXAttribute(attr) {
+        attr.skip();
+      },
+      JSXElement(child) {
+        const opening = child.get("openingElement");
+        if (hasInteraction(opening)) {
+          child.skip();
+          return;
+        }
+        add(icons, iconsInElement(opening), 8);
+        collectPresentationIcons(opening, icons);
+      }
+    });
+  return icons;
+}
+function conditionsAt(path13) {
+  const conditions = [];
+  let child = path13;
+  for (let parent = child.parentPath; parent && !parent.isFunction(); child = parent, parent = parent.parentPath) {
+    let test;
+    let negated = false;
+    if (parent.isLogicalExpression() && parent.node.right === child.node) {
+      if (parent.node.operator === "&&") test = parent.node.left;
+      if (parent.node.operator === "||") {
+        test = parent.node.left;
+        negated = true;
+      }
+    } else if (parent.isConditionalExpression() && parent.node.test !== child.node) {
+      test = parent.node.test;
+      negated = parent.node.alternate === child.node;
+    } else if (parent.isIfStatement() && parent.node.test !== child.node) {
+      test = parent.node.test;
+      negated = parent.node.alternate === child.node;
+    }
+    const name = symbol(test);
+    if (name) add(conditions, negated ? name.startsWith("!") ? name.slice(1) : `!${name}` : name);
+  }
+  return conditions;
+}
+function collectHandlerEvidence(expression, evidence) {
+  const seen = /* @__PURE__ */ new Set();
+  let budget = 100;
+  const visit = (path13, depth) => {
+    if (depth > 4 || budget-- <= 0) return;
+    const fn = handlerFunction(path13);
+    if (!fn || seen.has(fn.node)) return;
+    seen.add(fn.node);
+    fn.traverse({
+      // Ignore uncalled helper definitions; inline callbacks remain source evidence.
+      Function(nested) {
+        if (!nested.parentPath.isCallExpression() && !nested.parentPath.isObjectProperty())
+          nested.skip();
+      },
+      CallExpression(call) {
+        if (budget-- <= 0) {
+          call.skip();
+          return;
+        }
+        add(evidence.calls, symbol(call.node.callee));
+        for (const arg of call.node.arguments) add(evidence.argumentBindings, symbol(arg));
+        visit(call.get("callee"), depth + 1);
+        if (!t2.isMemberExpression(call.node.callee) || call.node.callee.computed || !t2.isIdentifier(call.node.callee.property, { name: "alert" }))
+          return;
+        const callee = call.get("callee");
+        if (!callee.isMemberExpression()) return;
+        const origin = importIdentity(callee.get("object"));
+        if (origin?.module !== "react-native" || origin.imported !== "Alert") return;
+        const options = call.node.arguments[2];
+        const destructiveOption = t2.isArrayExpression(options) && options.elements.some(
+          (option) => t2.isObjectExpression(option) && option.properties.some(
+            (p) => t2.isObjectProperty(p) && !p.computed && symbol(p.key) === "style" && t2.isStringLiteral(p.value, { value: "destructive" })
+          )
+        );
+        if (destructiveOption)
+          evidence.nativeConfirmation = {
+            title: symbol(call.node.arguments[0]),
+            destructiveOption
+          };
+      }
+    });
+  };
+  visit(unwrap(expression), 0);
+}
+function extractControlEvidence(ast, source, file2) {
+  const candidates = [];
+  const sourceHash = (0, import_node_crypto.createHash)("sha256").update(source).digest("hex");
+  (0, import_traverse.default)(ast, {
+    JSXOpeningElement(path13) {
+      const node = path13.node;
+      if (attribute(node, "__appilotsControl")) return;
+      const value = propValue(path13, "onPress");
+      if (!value && !attribute(node, "onPress") || value?.isNullLiteral() || value?.isJSXEmptyExpression())
+        return;
+      const icons = collectIcons(path13);
+      if (!icons.length || node.end == null) return;
+      const evidence = {
+        version: 1,
+        siteId: (0, import_node_crypto.createHash)("sha256").update(`${file2}:${sourceHash}:${node.start}`).digest("hex").slice(0, 20),
+        component: symbol(node.name) ?? "unknown",
+        icons,
+        ...value && symbol(value.node) ? { handler: symbol(value.node) } : {},
+        calls: [],
+        argumentBindings: [],
+        conditions: conditionsAt(path13)
+      };
+      if (value) collectHandlerEvidence(value, evidence);
+      candidates.push({ evidence, sourceHash, offset: node.end - (node.selfClosing ? 2 : 1) });
+    }
+  });
+  return candidates;
+}
+
+// src/analyzers/ScreenAnalyzer.ts
 var import_path3 = __toESM(require("path"));
-var import_traverse4 = __toESM(require("@babel/traverse"));
+var import_traverse5 = __toESM(require("@babel/traverse"));
 var BabelTypes = __toESM(require("@babel/types"));
-var import_fast_glob = __toESM(require("fast-glob"));
 
 // src/ast/parse.ts
 var import_parser = require("@babel/parser");
@@ -1018,25 +1466,25 @@ function parseSource(source, parserPlugins = []) {
 }
 
 // src/ast/jsx/attributes.ts
-var t = __toESM(require("@babel/types"));
+var t3 = __toESM(require("@babel/types"));
 function findJsxAttribute(element, name) {
   return element.attributes.find(
-    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === name
+    (attr) => t3.isJSXAttribute(attr) && t3.isJSXIdentifier(attr.name) && attr.name.name === name
   );
 }
 function getStringAttr(element, name) {
   const attr = findJsxAttribute(element, name);
   if (!attr || !attr.value) return void 0;
-  if (t.isStringLiteral(attr.value)) return attr.value.value;
-  if (t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)) {
+  if (t3.isStringLiteral(attr.value)) return attr.value.value;
+  if (t3.isJSXExpressionContainer(attr.value) && t3.isStringLiteral(attr.value.expression)) {
     return attr.value.expression.value;
   }
   return void 0;
 }
 function getExpressionIdentifierAttr(element, name) {
   const attr = findJsxAttribute(element, name);
-  if (!attr?.value || !t.isJSXExpressionContainer(attr.value)) return void 0;
-  return t.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
+  if (!attr?.value || !t3.isJSXExpressionContainer(attr.value)) return void 0;
+  return t3.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
 }
 function hasJsxAttribute(element, name) {
   return Boolean(findJsxAttribute(element, name));
@@ -1115,18 +1563,18 @@ function classifyJsxComponent(name, element) {
 }
 
 // src/ast/functions/collect.ts
-var import_traverse = __toESM(require("@babel/traverse"));
-var t2 = __toESM(require("@babel/types"));
+var import_traverse2 = __toESM(require("@babel/traverse"));
+var t4 = __toESM(require("@babel/types"));
 function collectFunctions(ast) {
   const handlers = /* @__PURE__ */ new Map();
-  (0, import_traverse.default)(ast, {
+  (0, import_traverse2.default)(ast, {
     FunctionDeclaration: (nodePath) => {
       if (nodePath.node.id?.name) handlers.set(nodePath.node.id.name, nodePath.node);
     },
     VariableDeclarator: (nodePath) => {
-      if (!t2.isIdentifier(nodePath.node.id)) return;
+      if (!t4.isIdentifier(nodePath.node.id)) return;
       const init = nodePath.node.init;
-      if (t2.isArrowFunctionExpression(init) || t2.isFunctionExpression(init)) {
+      if (t4.isArrowFunctionExpression(init) || t4.isFunctionExpression(init)) {
         handlers.set(nodePath.node.id.name, init);
       }
     }
@@ -1135,8 +1583,8 @@ function collectFunctions(ast) {
 }
 
 // src/ast/functions/analyze-async.ts
-var import_traverse2 = __toESM(require("@babel/traverse"));
-var t3 = __toESM(require("@babel/types"));
+var import_traverse3 = __toESM(require("@babel/traverse"));
+var t5 = __toESM(require("@babel/types"));
 var DESTRUCTIVE_VERB = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
 function analyzeFunctionBehavior(name, fn, handlers, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(name)) {
@@ -1158,41 +1606,41 @@ function analyzeFunctionBehavior(name, fn, handlers, seen = /* @__PURE__ */ new
   let destructive = DESTRUCTIVE_VERB.test(name);
   const loadingStateBindings = /* @__PURE__ */ new Set();
   const inspectCall = (node) => {
-    if (t3.isMemberExpression(node.callee) && t3.isIdentifier(node.callee.property)) {
+    if (t5.isMemberExpression(node.callee) && t5.isIdentifier(node.callee.property)) {
       const method = node.callee.property.name;
       if (method === "then" || method === "catch" || method === "finally") hasThen = true;
-      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && ["navigate", "push", "replace"].includes(method)) {
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && ["navigate", "push", "replace"].includes(method)) {
         const firstArg = node.arguments[0];
-        if (t3.isStringLiteral(firstArg)) {
+        if (t5.isStringLiteral(firstArg)) {
           targetScreen = firstArg.value;
           successSignal = { type: "navigation", target: firstArg.value };
         }
       }
-      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && method === "goBack") {
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && method === "goBack") {
         successSignal = { type: "goBack", description: "Action returns to the previous screen" };
       }
-      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "Alert" && method === "alert") {
+      if (t5.isIdentifier(node.callee.object) && node.callee.object.name === "Alert" && method === "alert") {
         nativeConfirmationExpected = true;
       }
-      if (t3.isIdentifier(node.callee.object) && /(toast|notification|snackbar)/i.test(node.callee.object.name)) {
+      if (t5.isIdentifier(node.callee.object) && /(toast|notification|snackbar)/i.test(node.callee.object.name)) {
         const firstArg = node.arguments[0];
         const secondArg = node.arguments[1];
-        const text = t3.isStringLiteral(secondArg) ? secondArg.value : t3.isStringLiteral(firstArg) ? firstArg.value : void 0;
+        const text = t5.isStringLiteral(secondArg) ? secondArg.value : t5.isStringLiteral(firstArg) ? firstArg.value : void 0;
         const signal = { type: "toast", description: text };
-        if (/(error|danger|fail)/i.test(method) || t3.isStringLiteral(firstArg) && /error/i.test(firstArg.value)) {
+        if (/(error|danger|fail)/i.test(method) || t5.isStringLiteral(firstArg) && /error/i.test(firstArg.value)) {
           failureSignal = signal;
         } else {
           successSignal = successSignal ?? signal;
         }
       }
     }
-    if (t3.isIdentifier(node.callee)) {
+    if (t5.isIdentifier(node.callee)) {
       const calleeName = node.callee.name;
       if (/^set[A-Z]/.test(calleeName)) {
         hasStateSetter = true;
         const stateName = setterToStateName(calleeName);
         const firstArg = node.arguments[0];
-        if (stateName && t3.isBooleanLiteral(firstArg)) {
+        if (stateName && t5.isBooleanLiteral(firstArg)) {
           if (/loading|submitting|saving|fetching|refreshing/i.test(stateName)) {
             loadingStateBindings.add(stateName);
           }
@@ -1219,14 +1667,14 @@ function analyzeFunctionBehavior(name, fn, handlers, seen = /* @__PURE__ */ new
     }
   };
   const inspectNode = (node) => {
-    if (t3.isAwaitExpression(node)) hasAwait = true;
-    if (t3.isCallExpression(node)) inspectCall(node);
-    if (t3.isMemberExpression(node) && t3.isIdentifier(node.property) && DESTRUCTIVE_VERB.test(node.property.name)) {
+    if (t5.isAwaitExpression(node)) hasAwait = true;
+    if (t5.isCallExpression(node)) inspectCall(node);
+    if (t5.isMemberExpression(node) && t5.isIdentifier(node.property) && DESTRUCTIVE_VERB.test(node.property.name)) {
       destructive = true;
     }
   };
   if (fn.body) {
-    (0, import_traverse2.default)(fn.body, {
+    (0, import_traverse3.default)(fn.body, {
       noScope: true,
       enter: (nodePath) => inspectNode(nodePath.node)
     });
@@ -1254,21 +1702,21 @@ function setterToStateName(setterName) {
 }
 
 // src/ast/navigation/calls.ts
-var import_traverse3 = __toESM(require("@babel/traverse"));
-var t4 = __toESM(require("@babel/types"));
+var import_traverse4 = __toESM(require("@babel/traverse"));
+var t6 = __toESM(require("@babel/types"));
 function extractNavigationCalls(ast) {
   const calls = [];
-  (0, import_traverse3.default)(ast, {
-    noScope: !t4.isFile(ast),
+  (0, import_traverse4.default)(ast, {
+    noScope: !t6.isFile(ast),
     CallExpression: (nodePath) => {
       const node = nodePath.node;
-      if (!t4.isMemberExpression(node.callee) || !t4.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !t4.isIdentifier(node.callee.property)) {
+      if (!t6.isMemberExpression(node.callee) || !t6.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !t6.isIdentifier(node.callee.property)) {
         return;
       }
       const method = node.callee.property.name;
       if (!["navigate", "push", "replace", "goBack"].includes(method)) return;
       const firstArg = node.arguments[0];
-      const targetScreen = t4.isStringLiteral(firstArg) ? firstArg.value : void 0;
+      const targetScreen = t6.isStringLiteral(firstArg) ? firstArg.value : void 0;
       calls.push({
         method,
         ...targetScreen ? { targetScreen } : {},
@@ -1280,16 +1728,16 @@ function extractNavigationCalls(ast) {
 }
 function extractNavigationParams(arg) {
   const params = {};
-  if (!arg || !t4.isObjectExpression(arg)) return params;
+  if (!arg || !t6.isObjectExpression(arg)) return params;
   for (const prop of arg.properties) {
-    if (!t4.isObjectProperty(prop)) continue;
-    const key = t4.isIdentifier(prop.key) ? prop.key.name : t4.isStringLiteral(prop.key) ? prop.key.value : void 0;
+    if (!t6.isObjectProperty(prop)) continue;
+    const key = t6.isIdentifier(prop.key) ? prop.key.name : t6.isStringLiteral(prop.key) ? prop.key.value : void 0;
     if (!key) continue;
-    if (t4.isMemberExpression(prop.value) && t4.isIdentifier(prop.value.object) && t4.isIdentifier(prop.value.property)) {
+    if (t6.isMemberExpression(prop.value) && t6.isIdentifier(prop.value.object) && t6.isIdentifier(prop.value.property)) {
       params[key] = `${prop.value.object.name}.${prop.value.property.name}`;
-    } else if (t4.isIdentifier(prop.value)) {
+    } else if (t6.isIdentifier(prop.value)) {
       params[key] = prop.value.name;
-    } else if (t4.isStringLiteral(prop.value)) {
+    } else if (t6.isStringLiteral(prop.value)) {
       params[key] = prop.value.value;
     }
   }
@@ -1397,14 +1845,26 @@ var ScreenAnalyzer = class {
   strictScreens;
   /** Glob patterns that identify screen files in strict mode */
   screenPatterns;
+  /**
+   * Arquivos que uma ROTA monta (`component={…}` resolvido pelo
+   * `NavigationAnalyzer`). Passam pelo filtro estrito sem depender de
+   * convenção de nome, porque um componente que uma rota monta É uma tela por
+   * definição — não é heurística, é o que o app declarou.
+   *
+   * É isto que resolve o caso `rocketchat`, cujas telas se chamam `*View.tsx`
+   * em `app/views/`, e o `coopcycle`, que não tem diretório `screens/` nenhum.
+   */
+  routeTargetFiles;
   /** §D: Count of screens filtered out in strict mode (available after analyze()) */
   screensFilteredOut = 0;
+  controlEvidenceFiles = {};
   constructor(config, options) {
     this.config = config;
+    this.routeTargetFiles = options?.routeTargetFiles ?? /* @__PURE__ */ new Set();
     this.strictScreens = options?.strictScreens ?? false;
     this.screenPatterns = options?.screenPatterns ?? [
-      "**/*Screen.{ts,tsx}",
-      "**/screens/**/*.{ts,tsx}"
+      "**/*Screen.{ts,tsx,js,jsx}",
+      "**/screens/**/*.{ts,tsx,js,jsx}"
     ];
   }
   /** Analyze all screens in the project */
@@ -1416,7 +1876,7 @@ var ScreenAnalyzer = class {
         console.log(`[ScreenAnalyzer] Strict mode ON \u2014 screen patterns:`, this.screenPatterns);
       }
     }
-    const files = await (0, import_fast_glob.default)(include, {
+    const files = await globSorted(include, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -1425,7 +1885,7 @@ var ScreenAnalyzer = class {
     }
     let screenPatternFiles = null;
     if (this.strictScreens) {
-      const matched = await (0, import_fast_glob.default)(this.screenPatterns, {
+      const matched = await globSorted(this.screenPatterns, {
         cwd: this.config.rootDir,
         ignore: exclude
       });
@@ -1441,7 +1901,8 @@ var ScreenAnalyzer = class {
         if (this.strictScreens) {
           const hasRegisterScreen = descriptor.__hasRegisterScreen === true;
           const matchesPattern = screenPatternFiles?.has(filePath) ?? false;
-          if (!hasRegisterScreen && !matchesPattern) {
+          const isRouteTarget = this.routeTargetFiles.has(filePath);
+          if (!hasRegisterScreen && !matchesPattern && !isRouteTarget) {
             this.screensFilteredOut++;
             if (this.verbose) {
               console.log(`[ScreenAnalyzer] \u2717 Filtered (strict): ${file2}`);
@@ -1497,6 +1958,11 @@ var ScreenAnalyzer = class {
       title: registerScreenMeta?.title,
       description: registerScreenMeta?.description,
       components,
+      controlCandidates: extractControlEvidence(
+        ast,
+        source,
+        import_path3.default.relative(this.config.rootDir, filePath)
+      ),
       forms,
       actions,
       navigationTargets,
@@ -1507,6 +1973,8 @@ var ScreenAnalyzer = class {
         ...permissionsFromJsDoc.isPii ? { isPii: true } : {}
       } : {}
     };
+    if (descriptor.controlCandidates?.length)
+      this.controlEvidenceFiles[import_path3.default.relative(this.config.rootDir, filePath).split(import_path3.default.sep).join("/")] = descriptor.controlCandidates;
     descriptor.__hasRegisterScreen = hasRegisterScreenCall;
     return descriptor;
   }
@@ -1516,7 +1984,7 @@ var ScreenAnalyzer = class {
    */
   detectRegisterScreenCall(ast) {
     let found = false;
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       CallExpression: (nodePath) => {
         if (found) return;
         const callee = nodePath.node.callee;
@@ -1533,7 +2001,7 @@ var ScreenAnalyzer = class {
    */
   extractRegisterScreenMetadata(ast) {
     let metadata = null;
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
         if (BabelTypes.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.property) && callee.property.name === "registerScreen") {
@@ -1649,6 +2117,8 @@ var ScreenAnalyzer = class {
         action.riskLevel = value.value;
       } else if (key === "nativeConfirmationExpected" && BabelTypes.isBooleanLiteral(value)) {
         action.nativeConfirmationExpected = value.value;
+      } else if (key === "asyncBudgetMs" && BabelTypes.isNumericLiteral(value) && Number.isInteger(value.value) && value.value > 0) {
+        action.asyncBudgetMs = value.value;
       } else if (key === "appilotsInferred" && BabelTypes.isObjectExpression(value)) {
         action.appilotsInferred = this.parseAppilotsInferredObject(value);
       }
@@ -1828,7 +2298,7 @@ var ScreenAnalyzer = class {
    */
   extractDefaultComponentName(ast) {
     let componentName = "";
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       ExportDefaultDeclaration: (nodePath) => {
         const declaration = nodePath.node.declaration;
         if (BabelTypes.isFunctionDeclaration(declaration) && declaration.id?.name) {
@@ -1853,7 +2323,7 @@ var ScreenAnalyzer = class {
    */
   extractNavigationTargets(ast) {
     const targets = /* @__PURE__ */ new Set();
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
         if (BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.object) && callee.object.name === "navigation" && BabelTypes.isIdentifier(callee.property) && callee.property.name === "navigate") {
@@ -1872,7 +2342,7 @@ var ScreenAnalyzer = class {
   extractForms(ast) {
     const forms = [];
     const fields = /* @__PURE__ */ new Map();
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes.isJSXIdentifier(element.name)) {
@@ -1993,7 +2463,7 @@ var ScreenAnalyzer = class {
   extractComponents(ast) {
     const components = [];
     const seen = /* @__PURE__ */ new Set();
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes.isJSXIdentifier(element.name)) {
@@ -2057,7 +2527,7 @@ var ScreenAnalyzer = class {
     const actionLabels = new Map(
       actions.filter((a) => a.label).map((a) => [this.normalizeLabel(a.label), a])
     );
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes.isJSXIdentifier(element.name)) {
@@ -2126,7 +2596,7 @@ var ScreenAnalyzer = class {
   }
   collectButtonHandlersByLabel(ast) {
     const out = /* @__PURE__ */ new Map();
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (!BabelTypes.isJSXIdentifier(element.name)) return;
@@ -2208,7 +2678,7 @@ var ScreenAnalyzer = class {
       }
     };
     if (fn.body) {
-      (0, import_traverse4.default)(
+      (0, import_traverse5.default)(
         fn.body,
         {
           noScope: true,
@@ -2405,7 +2875,7 @@ var ScreenAnalyzer = class {
   extractCollections(ast) {
     const renderItemFns = this.collectRenderItemFunctions(ast);
     const collections = [];
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (!BabelTypes.isJSXIdentifier(element.name)) return;
@@ -2442,7 +2912,7 @@ var ScreenAnalyzer = class {
   }
   collectRenderItemFunctions(ast) {
     const out = /* @__PURE__ */ new Map();
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       VariableDeclarator: (nodePath) => {
         if (!BabelTypes.isIdentifier(nodePath.node.id)) return;
         const init = nodePath.node.init;
@@ -2485,7 +2955,7 @@ var ScreenAnalyzer = class {
   }
   extractRowAction(fn) {
     let action;
-    (0, import_traverse4.default)(
+    (0, import_traverse5.default)(
       fn.body,
       {
         noScope: true,
@@ -2538,7 +3008,7 @@ var ScreenAnalyzer = class {
     } else if (BabelTypes.isIdentifier(firstParam)) {
       itemNames.add(firstParam.name);
     }
-    (0, import_traverse4.default)(
+    (0, import_traverse5.default)(
       fn.body,
       {
         noScope: true,
@@ -2580,7 +3050,7 @@ var ScreenAnalyzer = class {
   inferSearchField(ast, dataSource) {
     if (!dataSource) return void 0;
     let queryBinding;
-    (0, import_traverse4.default)(ast, {
+    (0, import_traverse5.default)(ast, {
       CallExpression: (nodePath) => {
         const node = nodePath.node;
         if (!BabelTypes.isMemberExpression(node.callee)) return;
@@ -2591,7 +3061,7 @@ var ScreenAnalyzer = class {
         const fn = node.arguments[0];
         if (!BabelTypes.isArrowFunctionExpression(fn) && !BabelTypes.isFunctionExpression(fn))
           return;
-        (0, import_traverse4.default)(
+        (0, import_traverse5.default)(
           fn.body,
           {
             noScope: true,
@@ -2636,43 +3106,880 @@ var ScreenAnalyzer = class {
 // src/analyzers/NavigationAnalyzer.ts
 var import_fs4 = require("fs");
 var import_path4 = __toESM(require("path"));
-var import_fast_glob2 = __toESM(require("fast-glob"));
+var parser2 = __toESM(require("@babel/parser"));
+var import_traverse6 = __toESM(require("@babel/traverse"));
+var t8 = __toESM(require("@babel/types"));
+
+// src/ast/navigation/module-graph.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
 var parser = __toESM(require("@babel/parser"));
-var import_traverse5 = __toESM(require("@babel/traverse"));
-var t5 = __toESM(require("@babel/types"));
+var t7 = __toESM(require("@babel/types"));
+var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+var MAX_HOPS2 = 8;
+var ModuleGraph = class {
+  asts = /* @__PURE__ */ new Map();
+  resolved = /* @__PURE__ */ new Map();
+  /** `@src/*` → `<root>/src/*`, lido do tsconfig do app. */
+  aliases;
+  /** `uniswap` → `<repo>/packages/uniswap`, lido do workspace do monorepo. */
+  workspacePackages;
+  constructor(rootDir) {
+    this.aliases = rootDir ? readTsconfigAliases(rootDir) : [];
+    this.workspacePackages = rootDir ? readWorkspacePackages(rootDir) : [];
+  }
+  /** AST de um arquivo, memoizada. `null` quando não parseia. */
+  parse(file2) {
+    const cached = this.asts.get(file2);
+    if (cached !== void 0) return cached;
+    let ast = null;
+    try {
+      ast = parser.parse((0, import_node_fs.readFileSync)(file2, "utf-8"), {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"]
+      });
+    } catch {
+      ast = null;
+    }
+    this.asts.set(file2, ast);
+    return ast;
+  }
+  /**
+   * `./account/Home` a partir de `src/navigation/index.tsx` → caminho absoluto.
+   * Só resolve caminho relativo: import de pacote (`@react-navigation/native`)
+   * é de terceiro e não tem tela nossa dentro.
+   */
+  resolve(fromFile, spec) {
+    const key = `${fromFile} ${spec}`;
+    const cached = this.resolved.get(key);
+    if (cached !== void 0) return cached;
+    let base = null;
+    if (spec.startsWith(".")) {
+      base = import_node_path.default.resolve(import_node_path.default.dirname(fromFile), spec);
+    } else {
+      for (const { prefix, target } of this.aliases) {
+        if (spec === prefix || spec.startsWith(prefix + "/")) {
+          base = import_node_path.default.join(target, spec.slice(prefix.length));
+          break;
+        }
+      }
+      if (!base) {
+        for (const pkg of this.workspacePackages) {
+          if (spec === pkg.name || spec.startsWith(pkg.name + "/")) {
+            base = import_node_path.default.join(pkg.dir, spec.slice(pkg.name.length));
+            break;
+          }
+        }
+      }
+    }
+    if (!base) {
+      this.resolved.set(key, null);
+      return null;
+    }
+    const candidates = [
+      base,
+      ...EXTENSIONS.map((e) => base + e),
+      ...EXTENSIONS.map((e) => import_node_path.default.join(base, "index" + e))
+    ];
+    let found = null;
+    for (const c of candidates) {
+      try {
+        if ((0, import_node_fs.existsSync)(c) && (0, import_node_fs.statSync)(c).isFile()) {
+          found = c;
+          break;
+        }
+      } catch {
+      }
+    }
+    this.resolved.set(key, found);
+    return found;
+  }
+  /** `import`s do arquivo, por nome local. */
+  imports(file2) {
+    const out = /* @__PURE__ */ new Map();
+    const ast = this.parse(file2);
+    if (!ast) return out;
+    for (const stmt of ast.program.body) {
+      if (!t7.isImportDeclaration(stmt)) continue;
+      const source = stmt.source.value;
+      for (const spec of stmt.specifiers) {
+        if (t7.isImportDefaultSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "default" });
+        } else if (t7.isImportNamespaceSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "*" });
+        } else if (t7.isImportSpecifier(spec)) {
+          const imported = t7.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          out.set(spec.local.name, { source, imported });
+        }
+      }
+    }
+    return out;
+  }
+  /** `const X = <init>` no topo do arquivo, incluindo `export const`. */
+  topLevelInit(file2, name) {
+    const ast = this.parse(file2);
+    if (!ast) return null;
+    for (const stmt of ast.program.body) {
+      const decl = t7.isExportNamedDeclaration(stmt) ? stmt.declaration : stmt;
+      if (!t7.isVariableDeclaration(decl)) continue;
+      for (const d of decl.declarations) {
+        if (t7.isIdentifier(d.id) && d.id.name === name && d.init) {
+          return t7.isTSAsExpression(d.init) ? d.init.expression : d.init;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Onde `name` é DEFINIDO — segue import e reexport de barrel.
+   * Devolve o arquivo e o nome sob o qual ele é definido lá.
+   */
+  resolveBinding(file2, name, hops = 0) {
+    if (hops > MAX_HOPS2) return null;
+    if (this.topLevelInit(file2, name) !== null) return { file: file2, name };
+    const binding = this.imports(file2).get(name);
+    if (binding) {
+      const target = this.resolve(file2, binding.source);
+      if (!target) return null;
+      const next = binding.imported === "default" || binding.imported === "*" ? name : binding.imported;
+      const deeper = this.resolveBinding(target, next, hops + 1);
+      return deeper ?? { file: target, name: next };
+    }
+    const ast = this.parse(file2);
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!t7.isExportNamedDeclaration(stmt) || !stmt.source) continue;
+        for (const spec of stmt.specifiers) {
+          if (!t7.isExportSpecifier(spec)) continue;
+          const exported = t7.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+          if (exported !== name) continue;
+          const target = this.resolve(file2, stmt.source.value);
+          if (!target) return null;
+          const local = spec.local.name;
+          return this.resolveBinding(target, local, hops + 1) ?? { file: target, name: local };
+        }
+      }
+    }
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!t7.isExportAllDeclaration(stmt)) continue;
+        const target = this.resolve(file2, stmt.source.value);
+        if (!target || target === file2) continue;
+        const deeper = this.resolveBinding(target, name, hops + 1);
+        if (deeper) return deeper;
+      }
+    }
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!t7.isExportDefaultDeclaration(stmt)) continue;
+        if (t7.isIdentifier(stmt.declaration)) {
+          const local = stmt.declaration.name;
+          if (local === name) return null;
+          return this.resolveBinding(file2, local, hops + 1) ?? { file: file2, name: local };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * O valor string de uma expressão de nome de rota, ou `null`.
+   *
+   * Cobre `"Chat"`, `ROUTES.CHAT`, `ROUTES.ONBOARDING.SPLASH` e `SOME_CONST` —
+   * seguindo import quando o objeto vem de outro arquivo. NÃO cobre template
+   * com interpolação nem valor calculado, de propósito.
+   */
+  stringConstant(file2, node, hops = 0) {
+    if (!node || hops > MAX_HOPS2) return null;
+    if (t7.isStringLiteral(node)) return node.value;
+    if (t7.isTemplateLiteral(node)) {
+      return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? null : null;
+    }
+    if (t7.isTSAsExpression(node)) return this.stringConstant(file2, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file2, chain.root);
+    if (!origin) return null;
+    let current = this.topLevelInit(origin.file, origin.name);
+    if (!current) return null;
+    for (const key of chain.path) {
+      if (!t7.isObjectExpression(current)) return null;
+      const prop = objectProperty(current, key);
+      if (!prop) return null;
+      current = t7.isTSAsExpression(prop) ? prop.expression : prop;
+    }
+    return t7.isStringLiteral(current) ? current.value : null;
+  }
+  /**
+   * O ARQUIVO onde vive o componente de uma rota, ou `null`.
+   *
+   * Aceita as três formas que o corpus mostrou: identificador
+   * (`component={Home}`), membro de barrel (`component={screens.AccountHome}`)
+   * e componente embrulhado em HOC (`component={gestureHandlerRootHOC(Chat)}`,
+   * que é como o `pocketpal` monta todas as telas do Drawer).
+   */
+  componentFile(file2, node, hops = 0) {
+    if (!node || hops > MAX_HOPS2) return null;
+    if (t7.isCallExpression(node)) {
+      for (const arg of node.arguments) {
+        if (t7.isIdentifier(arg) || t7.isMemberExpression(arg)) {
+          const inner = this.componentFile(file2, arg, hops + 1);
+          if (inner) return inner;
+        }
+      }
+      return null;
+    }
+    if (t7.isTSAsExpression(node)) return this.componentFile(file2, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file2, chain.root);
+    if (!origin) return null;
+    if (chain.path.length === 0) return origin.file;
+    const init = this.topLevelInit(origin.file, origin.name);
+    if (init && t7.isObjectExpression(init)) {
+      const prop = objectProperty(init, chain.path[0]);
+      if (prop) return this.componentFile(origin.file, prop, hops + 1);
+    }
+    const viaExport = this.resolveBinding(origin.file, chain.path[0], hops + 1);
+    return viaExport?.file ?? null;
+  }
+  /**
+   * Os arquivos DO PROJETO que este arquivo renderiza como JSX.
+   *
+   * `<ChatView …/>` em `ChatScreen.tsx` → `components/ChatView/ChatView.tsx`.
+   * Import de pacote devolve `null` no `resolve` e fica de fora: componente de
+   * terceiro não tem tela nossa dentro.
+   *
+   * Ignora `<X.Screen>` e `<X.Navigator>` de propósito — navegação é outro
+   * extractor, e um navegador não é conteúdo de tela.
+   */
+  renderedComponentFiles(file2) {
+    const ast = this.parse(file2);
+    if (!ast) return [];
+    const names = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return;
+      if (t7.isJSXOpeningElement(node) && t7.isJSXIdentifier(node.name)) {
+        const n = node.name.name;
+        if (/^[A-Z]/.test(n)) names.add(n);
+      }
+      for (const key of Object.keys(node)) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          for (const item of value) visit(item);
+        } else if (value && typeof value === "object" && "type" in value) {
+          visit(value);
+        }
+      }
+    };
+    visit(ast.program);
+    const out = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const origin = this.resolveBinding(file2, name);
+      if (origin && origin.file !== file2) out.add(origin.file);
+    }
+    return [...out];
+  }
+};
+function memberChain(node) {
+  const chain = [];
+  let current = node;
+  while (t7.isMemberExpression(current)) {
+    if (current.computed) {
+      if (!t7.isStringLiteral(current.property)) return null;
+      chain.unshift(current.property.value);
+    } else if (t7.isIdentifier(current.property)) {
+      chain.unshift(current.property.name);
+    } else {
+      return null;
+    }
+    current = current.object;
+  }
+  return t7.isIdentifier(current) ? { root: current.name, path: chain } : null;
+}
+function objectProperty(obj, key) {
+  for (const prop of obj.properties) {
+    if (!t7.isObjectProperty(prop)) continue;
+    const name = t7.isIdentifier(prop.key) ? prop.key.name : t7.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (name === key && t7.isExpression(prop.value)) return prop.value;
+  }
+  return null;
+}
+function readTsconfigAliases(rootDir) {
+  const file2 = import_node_path.default.join(rootDir, "tsconfig.json");
+  if (!(0, import_node_fs.existsSync)(file2)) return [];
+  let parsed;
+  try {
+    const raw = stripJsonComments((0, import_node_fs.readFileSync)(file2, "utf-8")).replace(/,(\s*[}\]])/g, "$1");
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const paths = parsed.compilerOptions?.paths;
+  if (!paths) return [];
+  const baseUrl = import_node_path.default.resolve(rootDir, parsed.compilerOptions?.baseUrl ?? ".");
+  const out = [];
+  for (const [pattern, targets] of Object.entries(paths)) {
+    const first = targets[0];
+    if (typeof first !== "string") continue;
+    out.push({
+      prefix: pattern.replace(/\/?\*$/, ""),
+      target: import_node_path.default.resolve(baseUrl, first.replace(/\/?\*$/, ""))
+    });
+  }
+  return out.sort((a, b) => b.prefix.length - a.prefix.length);
+}
+function stripJsonComments(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inString) {
+      out += c;
+      if (escaped) escaped = false;
+      else if (c === "\\") escaped = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function readWorkspacePackages(rootDir) {
+  const start = import_node_path.default.resolve(rootDir);
+  let dir = start;
+  for (let i = 0; i < 6; i++) {
+    const globs = workspaceGlobs(dir);
+    if (globs.length > 0) {
+      const packages = expandWorkspaceGlobs(dir, globs);
+      const containsApp = packages.some(
+        (p) => start === p.dir || start.startsWith(p.dir + import_node_path.default.sep)
+      );
+      return containsApp ? packages : [];
+    }
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+function workspaceGlobs(dir) {
+  const pnpm = import_node_path.default.join(dir, "pnpm-workspace.yaml");
+  if ((0, import_node_fs.existsSync)(pnpm)) {
+    try {
+      const lines = (0, import_node_fs.readFileSync)(pnpm, "utf-8").split(/\r?\n/);
+      const out = [];
+      let inPackages = false;
+      for (const line of lines) {
+        if (/^packages:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          const m = /^\s*-\s*["']?([^"'#]+?)["']?\s*$/.exec(line);
+          if (m) out.push(m[1].trim());
+          else if (/^\S/.test(line)) break;
+        }
+      }
+      if (out.length) return out;
+    } catch {
+    }
+  }
+  const pkgPath = import_node_path.default.join(dir, "package.json");
+  if (!(0, import_node_fs.existsSync)(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8"));
+    const ws = pkg.workspaces;
+    if (Array.isArray(ws)) return ws;
+    if (ws && Array.isArray(ws.packages)) return ws.packages;
+  } catch {
+  }
+  return [];
+}
+function expandWorkspaceGlobs(root, globs) {
+  const out = [];
+  const add2 = (dir) => {
+    const pkgPath = import_node_path.default.join(dir, "package.json");
+    if (!(0, import_node_fs.existsSync)(pkgPath)) return;
+    try {
+      const name = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8")).name;
+      if (name) out.push({ name, dir });
+    } catch {
+    }
+  };
+  for (const glob2 of globs) {
+    if (glob2.endsWith("/*")) {
+      const parent = import_node_path.default.join(root, glob2.slice(0, -2));
+      let entries = [];
+      try {
+        entries = (0, import_node_fs.readdirSync)(parent);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const dir = import_node_path.default.join(parent, entry);
+        try {
+          if ((0, import_node_fs.statSync)(dir).isDirectory()) add2(dir);
+        } catch {
+        }
+      }
+    } else if (!glob2.includes("*")) {
+      add2(import_node_path.default.join(root, glob2));
+    }
+  }
+  return out.sort((a, b) => b.name.length - a.name.length);
+}
+
+// src/ast/navigation/expo-router.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"));
+var ROUTE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var PLATFORM_SUFFIXES = [".ios", ".android", ".native", ".web"];
+var ROUTE_DIR_CANDIDATES = ["app", "src/app"];
+function baseName(file2) {
+  let name = file2;
+  for (const ext of ROUTE_EXTENSIONS) {
+    if (name.endsWith(ext)) {
+      name = name.slice(0, -ext.length);
+      break;
+    }
+  }
+  for (const suffix of PLATFORM_SUFFIXES) {
+    if (name.endsWith(suffix)) return name.slice(0, -suffix.length);
+  }
+  return name;
+}
+function isRouteFile(file2) {
+  return ROUTE_EXTENSIONS.some((ext) => file2.endsWith(ext));
+}
+function isSpecial(base) {
+  if (base === "_layout") return true;
+  if (base.startsWith("+")) return base !== "+not-found";
+  return base.startsWith("_");
+}
+function layoutType(file2) {
+  try {
+    const src = (0, import_node_fs2.readFileSync)(file2, "utf-8");
+    if (/<(?:Native)?Tabs\b/.test(src)) return "tab";
+    if (/<Drawer\b/.test(src)) return "drawer";
+  } catch {
+  }
+  return "stack";
+}
+function findLayout(dir) {
+  for (const ext of ROUTE_EXTENSIONS) {
+    const candidate = import_node_path2.default.join(dir, "_layout" + ext);
+    if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
+  }
+  return null;
+}
+function analyzeExpoRouter(appRoot) {
+  let routeDir = null;
+  for (const candidate of ROUTE_DIR_CANDIDATES) {
+    const full = import_node_path2.default.join(appRoot, candidate);
+    if ((0, import_node_fs2.existsSync)(full) && findLayout(full)) {
+      routeDir = full;
+      break;
+    }
+  }
+  if (!routeDir) return null;
+  const routes = [];
+  const navigators = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (dir, segments, navigator) => {
+    const layout = findLayout(dir);
+    const current = layout ? segments.join("/") || "/" : navigator;
+    if (layout && !navigators.has(current)) navigators.set(current, layoutType(layout));
+    let entries;
+    try {
+      entries = (0, import_node_fs2.readdirSync)(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort()) {
+      const full = import_node_path2.default.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = (0, import_node_fs2.statSync)(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        if (entry === "node_modules" || entry.startsWith(".")) continue;
+        walk(full, [...segments, entry], current);
+        continue;
+      }
+      if (!isRouteFile(entry)) continue;
+      const base = baseName(entry);
+      if (isSpecial(base)) continue;
+      const routeSegments = base === "index" ? segments : [...segments, base];
+      const name = "/" + routeSegments.join("/");
+      if (seen.has(name)) continue;
+      seen.add(name);
+      routes.push({
+        name,
+        componentFile: full,
+        navigatorName: current,
+        navigatorType: navigators.get(current) ?? "stack",
+        params: routeSegments.filter((s) => s.startsWith("[") && s.endsWith("]")).map((s) => s.slice(1, -1).replace(/^\.\.\./, ""))
+      });
+    }
+  };
+  walk(routeDir, [], "/");
+  return {
+    routeDir: import_node_path2.default.relative(appRoot, routeDir),
+    routes,
+    navigators: [...navigators.entries()].map(([name, type]) => ({ name, type }))
+  };
+}
+
+// src/analyzers/NavigationAnalyzer.ts
+var NAVIGATOR_FACTORIES = {
+  createStackNavigator: "stack",
+  createNativeStackNavigator: "stack",
+  createBottomTabNavigator: "tab",
+  createTabNavigator: "tab",
+  createMaterialTopTabNavigator: "tab",
+  createMaterialBottomTabNavigator: "tab",
+  createDrawerNavigator: "drawer"
+};
+var CUSTOM_FACTORY = /^create[A-Za-z0-9]*(Navigator|Stack|Tabs?|Drawer)$/;
+function unwrapStaticScreen(value) {
+  if (t8.isCallExpression(value)) {
+    const arg = value.arguments[0];
+    return arg ? unwrapStaticScreen(arg) : null;
+  }
+  if (t8.isObjectExpression(value)) {
+    for (const prop of value.properties) {
+      if (!t8.isObjectProperty(prop)) continue;
+      const key = t8.isIdentifier(prop.key) ? prop.key.name : null;
+      if (key === "screen" && t8.isExpression(prop.value)) return prop.value;
+    }
+    return null;
+  }
+  return t8.isExpression(value) ? value : null;
+}
+function inferNavigatorType(factoryName) {
+  if (/drawer/i.test(factoryName)) return "drawer";
+  if (/tab/i.test(factoryName)) return "tab";
+  return "stack";
+}
+var NAVIGATION_EVIDENCE = new RegExp(
+  // `\.Navigator`/`\.Screen` entram porque o JSX pode estar num arquivo que
+  // não menciona fábrica nenhuma: `comapeo` declara `RootStack` em
+  // `Stack/RootStack.ts` e escreve todas as 120 rotas em `Stack/index.tsx`,
+  // que não cita `createNativeStackNavigator` uma vez sequer. Sem isto a
+  // junção entre arquivos nunca chega a ser tentada.
+  // Sem `\\b` depois da palavra — `createNativeStackNavigatorWithAuth` não tem
+  // fronteira ali, e exigi-la fecharia o portão para o arquivo que declara os
+  // seis navegadores do `bluesky`.
+  `create[A-Za-z0-9]*(?:Navigator|Stack|Tabs?|Drawer)|ParamList|\\.Navigator\\b|\\.Screen\\b`
+);
 var NavigationAnalyzer = class {
   config;
   /** Extra glob patterns for navigation file discovery (added to defaults) */
   navigationInclude;
   /** Extra glob patterns to exclude from navigation analysis */
   navigationExclude;
+  /** Exposto para a composição reusar o cache de AST em vez de reparsear a árvore. */
+  graph;
+  /**
+   * Rota → arquivo do componente que ela monta. É a única ligação entre o grafo
+   * de navegação e a árvore de telas; sem ela as duas metades do documento
+   * falam de coisas diferentes. Populada por `analyze()`.
+   */
+  routeTargets = /* @__PURE__ */ new Map();
+  /**
+   * Arquivos que DECLARAM uma fábrica de navegador.
+   *
+   * Um navegador aninhado é montado como `component=` de uma rota — no
+   * `apps/example-app`, `<Stack.Screen name="Main" component={MainTabNavigator} />`.
+   * Promover esse arquivo a tela criaria seis "telas" sem uma única ação, que é
+   * exatamente o falso positivo que o corpus existe para não repetir. Um
+   * navegador é um contêiner de rotas; a tela está um nível abaixo.
+   *
+   * Entram aqui os dois lados: o arquivo que CHAMA a fábrica e o arquivo que
+   * RENDERIZA `<X.Navigator>`. Não são o mesmo — `bluewallet` declara
+   * `DetailViewStack` num arquivo e escreve o JSX em
+   * `navigation/DetailViewScreensStack.tsx`, e checar só o primeiro deixava o
+   * segundo entrar como tela.
+   */
+  navigatorFiles = /* @__PURE__ */ new Set();
+  /** Preenchido por `analyze()`. Vazio antes disso. */
+  diagnostics = {
+    filesScanned: 0,
+    filesWithEvidence: 0,
+    navigatorsDeclared: 0,
+    navigatorsWithJsx: 0,
+    routes: 0,
+    routesLinkedToFile: 0
+  };
   constructor(config, options) {
     this.config = config;
+    this.graph = new ModuleGraph(config.rootDir);
     this.navigationInclude = options?.navigationInclude ?? [];
     this.navigationExclude = options?.navigationExclude ?? [];
   }
   /** Build the full navigation graph */
   async analyze() {
     const navigationFiles = await this.findNavigationFiles();
-    const parsedNavigators = [];
     const typeExports = [];
+    this.routeTargets.clear();
+    const declarations = /* @__PURE__ */ new Map();
+    const evidenceFiles = [];
+    this.navigatorFiles.clear();
     for (const filePath of navigationFiles) {
       try {
         const content = await import_fs4.promises.readFile(filePath, "utf-8");
-        const navigators = this.parseNavigators(content, filePath);
-        const types = this.parseParamTypes(content, filePath);
-        parsedNavigators.push(...navigators);
-        typeExports.push(...types);
+        if (!NAVIGATION_EVIDENCE.test(content)) continue;
+        evidenceFiles.push(filePath);
+        for (const decl of this.collectDeclarations(filePath)) {
+          declarations.set(`${decl.file}#${decl.name}`, decl);
+          if (decl.confident) this.navigatorFiles.add(decl.file);
+        }
+        typeExports.push(...this.parseParamTypes(content, filePath));
       } catch (error2) {
         console.warn(`Failed to parse ${filePath}:`, error2);
       }
     }
+    const parsedNavigators = [];
+    for (const filePath of evidenceFiles) {
+      try {
+        parsedNavigators.push(...this.parseNavigatorUsages(filePath, declarations));
+      } catch (error2) {
+        console.warn(`Failed to parse navigators in ${filePath}:`, error2);
+      }
+    }
+    let detachedScreens = 0;
+    for (const filePath of evidenceFiles) {
+      try {
+        for (const detached of this.parseDetachedScreens(filePath, declarations)) {
+          const existing = parsedNavigators.find(
+            (nav) => nav.name === detached.name && nav.type === detached.type
+          );
+          if (!existing) {
+            parsedNavigators.push(detached);
+            detachedScreens += detached.screens.length;
+            continue;
+          }
+          const seen = new Set(existing.screens.map((screen) => screen.name));
+          for (const screen of detached.screens) {
+            if (seen.has(screen.name)) continue;
+            seen.add(screen.name);
+            existing.screens.push(screen);
+            detachedScreens++;
+          }
+        }
+      } catch (error2) {
+        console.warn(`Failed to parse detached screens in ${filePath}:`, error2);
+      }
+    }
+    const expo = analyzeExpoRouter(this.config.rootDir);
+    if (expo) {
+      console.log(
+        `[NavigationAnalyzer] expo-router em "${expo.routeDir}": ${expo.routes.length} rotas, ${expo.navigators.length} layouts`
+      );
+      this.diagnostics.fileBasedRouter = {
+        kind: "expo-router",
+        routeDir: expo.routeDir,
+        routes: expo.routes.length
+      };
+      const byNavigator = /* @__PURE__ */ new Map();
+      for (const nav of expo.navigators) {
+        byNavigator.set(nav.name, { name: nav.name, type: nav.type, screens: [] });
+      }
+      for (const route of expo.routes) {
+        const navigator = byNavigator.get(route.navigatorName) ?? byNavigator.set(route.navigatorName, {
+          name: route.navigatorName,
+          type: route.navigatorType,
+          screens: []
+        }).get(route.navigatorName);
+        navigator.screens.push({
+          name: route.name,
+          navigatorName: route.navigatorName,
+          navigatorType: route.navigatorType,
+          componentFile: route.componentFile,
+          ...route.params.length ? {
+            params: route.params.map((name) => ({ name, type: "string", required: true }))
+          } : {}
+        });
+        this.routeTargets.set(route.name, route.componentFile);
+      }
+      parsedNavigators.push(...byNavigator.values());
+    }
+    let staticOnly = 0;
+    for (const decl of declarations.values()) {
+      if (!decl.confident || !decl.staticScreens?.length) continue;
+      const existing = parsedNavigators.find((n) => n.name === decl.name && n.type === decl.type);
+      if (existing) {
+        const seen = new Set(existing.screens.map((s) => s.name));
+        for (const screen of decl.staticScreens) {
+          if (!seen.has(screen.name)) existing.screens.push(screen);
+        }
+        continue;
+      }
+      parsedNavigators.push({ name: decl.name, type: decl.type, screens: decl.staticScreens });
+      staticOnly++;
+    }
+    const confidentDeclarations = [...declarations.values()].filter((d) => d.confident).length;
+    const uniqueRoutes = new Set(
+      parsedNavigators.flatMap((nav) => nav.screens.map((screen) => screen.name))
+    );
+    this.diagnostics = {
+      ...this.diagnostics,
+      filesScanned: navigationFiles.length,
+      filesWithEvidence: evidenceFiles.length,
+      navigatorsDeclared: confidentDeclarations,
+      navigatorsWithJsx: parsedNavigators.length,
+      routes: uniqueRoutes.size,
+      // `routeTargets` é indexado por nome de rota, e uma rota pode ter sido
+      // registrada por um navegador que não sobreviveu. O mínimo evita a
+      // cobertura acima de 100% que a medição do corpus expôs no `coopcycle`.
+      routesLinkedToFile: Math.min(this.routeTargets.size, uniqueRoutes.size)
+    };
+    console.log(
+      `[NavigationAnalyzer] ${staticOnly} navegador(es) s\xF3 de config est\xE1tica \xB7 ${detachedScreens} rota(s) fora de um <X.Navigator> \xB7 ${navigationFiles.length} arquivos varridos, ${evidenceFiles.length} com evid\xEAncia, ${confidentDeclarations} navegadores declarados, ${parsedNavigators.length} com JSX, ${this.routeTargets.size} rotas ligadas a um arquivo`
+    );
     this.attachParamsToNavigators(parsedNavigators, typeExports);
     return this.buildNavigationGraph(parsedNavigators);
   }
-  /** Find all navigation-related files */
+  /** Fase 1: as fábricas `create*Navigator()` atribuídas a um nome neste arquivo. */
+  collectDeclarations(filePath) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const out = /* @__PURE__ */ new Map();
+    (0, import_traverse6.default)(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!t8.isIdentifier(callee)) return;
+        const known = NAVIGATOR_FACTORIES[callee.name] ?? (CUSTOM_FACTORY.test(callee.name) ? inferNavigatorType(callee.name) : null);
+        const type = known ?? inferNavigatorType(callee.name);
+        const confident = known !== null;
+        let up = nodePath.parentPath;
+        for (let i = 0; i < 4 && up; i++) {
+          if (t8.isVariableDeclarator(up.node)) break;
+          if (!t8.isMemberExpression(up.node) && !t8.isCallExpression(up.node)) {
+            up = null;
+            break;
+          }
+          up = up.parentPath;
+        }
+        const declarator = up?.node;
+        if (!declarator || !t8.isVariableDeclarator(declarator) || !t8.isIdentifier(declarator.id)) {
+          return;
+        }
+        const name = declarator.id.name;
+        if (out.get(name)?.confident) return;
+        const staticScreens = confident ? this.parseStaticScreens(filePath, nodePath.node.arguments[0], name, type) : [];
+        out.set(name, {
+          file: filePath,
+          name,
+          type,
+          confident,
+          ...staticScreens.length ? { staticScreens } : {}
+        });
+      }
+    });
+    return [...out.values()];
+  }
+  /**
+   * As rotas de `createXNavigator({ screens: { … } })`.
+   *
+   * Quatro formas no corpus, todas em `rocketchat`:
+   *   `NewServerView`                                  — shorthand, nome = componente
+   *   `LoginView: createNativeStackScreen({ screen })` — embrulho da própria lib
+   *   `SelectListView: SelectListViewScreen`           — identificador direto
+   *   `ChatsStackNavigator: ChatsStack`                — navegador aninhado
+   *
+   * `groups: { G: { screens: { … } } }` também entra: faz parte da API estática
+   * e agrupar rotas não muda o que elas são.
+   */
+  parseStaticScreens(filePath, config, navigatorName, navigatorType, depth = 0) {
+    if (!config || !t8.isObjectExpression(config) || depth > 4) return [];
+    const out = [];
+    for (const prop of config.properties) {
+      if (!t8.isObjectProperty(prop)) continue;
+      const key = t8.isIdentifier(prop.key) ? prop.key.name : t8.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      if (key === "groups" && t8.isObjectExpression(prop.value)) {
+        for (const group of prop.value.properties) {
+          if (!t8.isObjectProperty(group) || !t8.isExpression(group.value)) continue;
+          out.push(
+            ...this.parseStaticScreens(
+              filePath,
+              group.value,
+              navigatorName,
+              navigatorType,
+              depth + 1
+            )
+          );
+        }
+        continue;
+      }
+      if (key !== "screens" || !t8.isObjectExpression(prop.value)) continue;
+      for (const entry of prop.value.properties) {
+        if (!t8.isObjectProperty(entry)) continue;
+        const routeName = t8.isIdentifier(entry.key) ? entry.key.name : t8.isStringLiteral(entry.key) ? entry.key.value : null;
+        if (!routeName) continue;
+        const componentExpr = unwrapStaticScreen(entry.value);
+        const componentFile = componentExpr ? this.graph.componentFile(filePath, componentExpr) : null;
+        if (componentFile) this.routeTargets.set(routeName, componentFile);
+        out.push({
+          name: routeName,
+          navigatorName,
+          navigatorType,
+          ...componentFile ? { componentFile } : {}
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Todo arquivo-fonte do projeto — não os que ficam num diretório com o nome
+   * certo.
+   *
+   * POR QUE ISTO MUDOU. A lista anterior era `**\/navigation/**`,
+   * `**\/navigator*` e `**\/routes*`, o que fazia da descoberta de navegação uma
+   * convenção de caminho. Medido contra 20 apps React Native de terceiros
+   * (`qa/eval-corpus`), o filtro errava por motivos que nada têm a ver com o
+   * app não ter navegação:
+   *
+   *   - `pocketpal` declara 4 navegadores em `App.tsx` e dentro de `src/screens/`;
+   *   - `comapeo` usa `src/frontend/Navigation/` — `N` maiúsculo, e o glob é
+   *     sensível a caixa;
+   *   - `abacus` usa `src/routes/index.tsx` — `routes` é o DIRETÓRIO, e o glob
+   *     pedia um arquivo chamado `routes*`;
+   *   - `discourse` declara em `js/Discourse.js` — o glob só aceitava `.ts`/`.tsx`;
+   *   - `rainbow` tem 11 arquivos com navegador e o glob alcançava 1.
+   *
+   * Varrer tudo não custa uma varredura nova: `ReactNativePlatformAnalyzer` já
+   * globa e parseia a árvore inteira para `ComponentAnalyzer` e `FormAnalyzer`.
+   * O que segura o custo aqui é o portão por evidência em `analyze()`, que só
+   * parseia arquivo cujo texto menciona uma fábrica de navegador.
+   *
+   * Os globs antigos continuam na lista: se um projeto restringir `include`, o
+   * que era encontrado antes continua sendo.
+   */
   async findNavigationFiles() {
     const patterns = [
+      ...this.config.include ?? ["**/*.{ts,tsx,js,jsx}"],
+      // Piso de compatibilidade — nunca encontrar MENOS que a versão anterior.
       "**/navigation/**/*.{ts,tsx}",
       "**/navigator*.{ts,tsx}",
       "**/routes*.{ts,tsx}",
@@ -2683,91 +3990,188 @@ var NavigationAnalyzer = class {
       "**/node_modules/**",
       "**/dist/**",
       "**/build/**",
+      // Um navegador declarado dentro de um teste é fixture, não a navegação
+      // do app. Isto passou a importar quando a varredura deixou de ser por
+      // caminho: em `expensify`, os únicos arquivos que o glob antigo
+      // alcançava eram três de `tests/`.
+      "**/__tests__/**",
+      "**/test/**",
+      "**/tests/**",
+      "**/*.test.{ts,tsx,js,jsx}",
+      "**/*.tests.{ts,tsx,js,jsx}",
+      "**/*.spec.{ts,tsx,js,jsx}",
+      // Sufixo `Test` sem ponto: `expensify` chama os fixtures dele de
+      // `LegalNameStepTest.tsx`, e cada um monta um `<Stack.Screen>` próprio.
+      // Auditando as 144 rotas lidas dele contra `SCREENS.ts`, 2 vinham daqui —
+      // destinos que existem no teste e não no app, para os quais o agente
+      // tentaria navegar.
+      "**/*Test.{ts,tsx,js,jsx}",
+      "**/*Tests.{ts,tsx,js,jsx}",
       ...this.config.exclude || [],
       // §5: Add user-configured navigation excludes
       ...this.navigationExclude
     ];
-    const files = await (0, import_fast_glob2.default)(patterns, {
+    const files = await globSorted(patterns, {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
     return files.map((file2) => import_path4.default.join(this.config.rootDir, file2));
   }
-  /** Parse navigator definitions from a file */
-  parseNavigators(content, filePath) {
-    const navigators = [];
-    try {
-      const ast = parser.parse(content, {
-        sourceType: "module",
-        plugins: [
-          "jsx",
-          "typescript",
-          ...this.config.parserPlugins || []
-        ]
-      });
-      const navigatorCalls = /* @__PURE__ */ new Map();
-      const screensByNavigator = /* @__PURE__ */ new Map();
-      (0, import_traverse5.default)(ast, {
-        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
-        CallExpression: (nodePath) => {
-          const { node } = nodePath;
-          const callee = node.callee;
-          let navigatorType = null;
-          if (t5.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
-            navigatorType = "stack";
-          } else if (t5.isIdentifier(callee) && callee.name === "createStackNavigator") {
-            navigatorType = "stack";
-          } else if (t5.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
-            navigatorType = "tab";
-          } else if (t5.isIdentifier(callee) && callee.name === "createTabNavigator") {
-            navigatorType = "tab";
-          } else if (t5.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
-            navigatorType = "drawer";
-          }
-          if (navigatorType) {
-            const parent = nodePath.parent;
-            if (t5.isVariableDeclarator(parent) && t5.isIdentifier(parent.id)) {
-              const varName = parent.id.name;
-              navigatorCalls.set(varName, {
-                name: varName,
-                type: navigatorType,
-                screens: []
-              });
-            }
-          }
-        },
-        // Detect Stack.Navigator / Tab.Navigator JSX elements
-        JSXElement: (nodePath) => {
-          const { node } = nodePath;
-          const openingElement = node.openingElement;
-          if (t5.isJSXMemberExpression(openingElement.name) && t5.isJSXIdentifier(openingElement.name.object)) {
-            const objectName = openingElement.name.object.name;
-            const propertyName = t5.isJSXIdentifier(openingElement.name.property) ? openingElement.name.property.name : null;
-            if (propertyName === "Navigator") {
-              const navigator = navigatorCalls.get(objectName);
-              if (navigator) {
-                const initialRouteAttr = openingElement.attributes.find(
-                  (attr) => t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
-                );
-                if (t5.isJSXAttribute(initialRouteAttr) && t5.isStringLiteral(initialRouteAttr.value)) {
-                  navigator.initialRouteName = initialRouteAttr.value.value;
-                }
-                const screens = this.extractScreensFromNavigator(node, objectName, navigator.type);
-                screensByNavigator.set(objectName, screens);
-              }
-            }
-          }
+  /**
+   * Fase 2: o JSX `<X.Navigator>` deste arquivo, ligado à declaração de `X` —
+   * que pode estar aqui ou em qualquer arquivo que este importe.
+   */
+  parseNavigatorUsages(filePath, declarations) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const found = /* @__PURE__ */ new Map();
+    (0, import_traverse6.default)(ast, {
+      JSXElement: (nodePath) => {
+        const { node } = nodePath;
+        const openingElement = node.openingElement;
+        if (!t8.isJSXMemberExpression(openingElement.name) || !t8.isJSXIdentifier(openingElement.name.object)) {
+          return;
         }
-      });
-      navigatorCalls.forEach((navigator) => {
-        const screens = screensByNavigator.get(navigator.name) || [];
-        navigator.screens = screens;
-        navigators.push(navigator);
-      });
-    } catch (error2) {
-      console.warn(`Failed to parse navigators in ${filePath}:`, error2);
+        const objectName = openingElement.name.object.name;
+        const propertyName = t8.isJSXIdentifier(openingElement.name.property) ? openingElement.name.property.name : null;
+        if (propertyName !== "Navigator") return;
+        const decl = this.resolveNavigator(filePath, objectName, declarations);
+        if (!decl) return;
+        const navigator = found.get(objectName) ?? {
+          name: objectName,
+          type: decl.type,
+          screens: []
+        };
+        const initialRouteAttr = openingElement.attributes.find(
+          (attr) => t8.isJSXAttribute(attr) && t8.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+        );
+        if (t8.isJSXAttribute(initialRouteAttr)) {
+          const initial = this.attributeString(filePath, initialRouteAttr);
+          if (initial) navigator.initialRouteName = initial;
+        }
+        this.navigatorFiles.add(filePath);
+        this.navigatorFiles.add(decl.file);
+        navigator.screens = this.extractScreensFromNavigator(filePath, node, objectName, decl.type);
+        found.set(objectName, navigator);
+      }
+    });
+    return [...found.values()];
+  }
+  /**
+   * Rotas declaradas FORA de qualquer `<X.Navigator>`.
+   *
+   * O CASO. A fase 2 desce a partir do `<X.Navigator>` e lê as `<X.Screen>`
+   * que estão DENTRO dele. Dois alvos do corpus não escrevem assim, e entre os
+   * dois são 171 rotas invisíveis:
+   *
+   *   `bluesky`  — `function commonScreens(Stack: typeof Flat) { return (<>
+   *                 <Stack.Screen name="NotFound" … /> … </>) }`, chamada de
+   *                dentro de seis navegadores diferentes. 70 rotas.
+   *   `comapeo`  — `export const createAppScreens = ({intl}) => (<>
+   *                 <RootStack.Group><RootStack.Screen … /></RootStack.Group></>)`,
+   *                num arquivo sem `<RootStack.Navigator>` nenhum. 101 rotas.
+   *
+   * A REGRA. Uma `<X.Screen name="…">` sem `<Y.Navigator>` ancestral é rota do
+   * navegador ao qual `X` se resolve. Não há palpite em jogo: o nome da rota é
+   * literal do fonte (ou constante que o resolvedor segue), e `X` precisa
+   * chegar a uma declaração de navegador que já existe. O que não resolve não
+   * vira nada.
+   *
+   * O ancestral é o que evita contar duas vezes — dentro do `<X.Navigator>` a
+   * fase 2 já leu, e somar aqui duplicaria cada rota do corpus inteiro.
+   *
+   * DUAS FORMAS DE RESOLVER `X`, e a segunda é o que o `bluesky` exige. A
+   * primeira é a de sempre (declaração local, ou `import` seguido até a
+   * origem) e resolve o `comapeo`. A segunda lê a ANOTAÇÃO DE TIPO do
+   * parâmetro: em `commonScreens(Stack: typeof Flat)`, quem diz que `Stack` é
+   * o navegador `Flat` é o próprio app, no fonte.
+   *
+   * O QUE ISTO NÃO FAZ. As 70 do `bluesky` ficam atribuídas a `Flat` — que as
+   * contém de fato (`{commonScreens(Flat, numUnread)}`) — e não aos outros
+   * cinco stacks que também chamam a mesma função. Seguir os seis pontos de
+   * chamada é análise interprocedural, e o ganho seria só de atribuição: o nome
+   * da rota e o arquivo da tela, que é o que o agente usa, já saem certos.
+   */
+  parseDetachedScreens(filePath, declarations) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const byNavigator = /* @__PURE__ */ new Map();
+    const resolved = /* @__PURE__ */ new Map();
+    (0, import_traverse6.default)(ast, {
+      JSXElement: (nodePath) => {
+        const name = nodePath.node.openingElement.name;
+        if (!t8.isJSXMemberExpression(name) || !t8.isJSXIdentifier(name.object)) return;
+        if (!t8.isJSXIdentifier(name.property) || name.property.name !== "Screen") return;
+        const insideNavigator = nodePath.findParent((parent) => {
+          if (!parent.isJSXElement()) return false;
+          const parentName = parent.node.openingElement.name;
+          return t8.isJSXMemberExpression(parentName) && t8.isJSXIdentifier(parentName.property) && parentName.property.name === "Navigator";
+        });
+        if (insideNavigator) return;
+        const local = name.object.name;
+        if (!resolved.has(local)) {
+          resolved.set(
+            local,
+            this.resolveDetachedNavigator(filePath, local, nodePath, declarations)
+          );
+        }
+        const decl = resolved.get(local);
+        if (!decl) return;
+        const screen = this.parseScreenElement(filePath, nodePath.node, decl.name, decl.type);
+        if (!screen) return;
+        const nav = byNavigator.get(decl.name) ?? {
+          name: decl.name,
+          type: decl.type,
+          screens: []
+        };
+        if (!nav.screens.some((existing) => existing.name === screen.name))
+          nav.screens.push(screen);
+        byNavigator.set(decl.name, nav);
+      }
+    });
+    return [...byNavigator.values()];
+  }
+  /**
+   * De um `X` usado como `<X.Screen>` até a declaração do navegador.
+   *
+   * Além do caminho normal — declaração local ou `import` seguido até a origem
+   * — aceita `X` como PARÂMETRO anotado com `typeof Y`. É o idioma do
+   * `bluesky`, e a anotação é declaração do app: nada aqui é inferido do nome.
+   */
+  resolveDetachedNavigator(filePath, localName, nodePath, declarations) {
+    const direct = this.resolveNavigator(filePath, localName, declarations);
+    if (direct) return direct;
+    const binding = nodePath.scope.getBinding(localName);
+    if (!binding || binding.kind !== "param") return null;
+    const param = binding.path.node;
+    if (!t8.isIdentifier(param) || !t8.isTSTypeAnnotation(param.typeAnnotation)) return null;
+    const annotation = param.typeAnnotation.typeAnnotation;
+    if (!t8.isTSTypeQuery(annotation) || !t8.isIdentifier(annotation.exprName)) return null;
+    return this.resolveNavigator(filePath, annotation.exprName.name, declarations);
+  }
+  /**
+   * De `<X.Navigator>` até a declaração de `X`.
+   *
+   * Primeiro no próprio arquivo; se não estiver, segue o `import` até onde `X`
+   * é definido. Resolver pelo import é o que torna a junção entre arquivos
+   * segura: dois `Stack` de arquivos diferentes nunca colidem, porque a chave
+   * é o arquivo de DEFINIÇÃO.
+   */
+  resolveNavigator(filePath, localName, declarations) {
+    const local = declarations.get(`${filePath}#${localName}`);
+    if (local) return local;
+    const origin = this.graph.resolveBinding(filePath, localName);
+    if (!origin) return null;
+    return declarations.get(`${origin.file}#${origin.name}`) ?? null;
+  }
+  /** O valor string de um atributo JSX, resolvendo constante importada. */
+  attributeString(filePath, attr) {
+    const value = attr.value;
+    if (t8.isStringLiteral(value)) return value.value;
+    if (t8.isJSXExpressionContainer(value) && t8.isExpression(value.expression)) {
+      return this.graph.stringConstant(filePath, value.expression);
     }
-    return navigators;
+    return null;
   }
   /**
    * Is this JSX element `<navigatorVarName.MEMBER …>`?
@@ -2778,9 +4182,9 @@ var NavigationAnalyzer = class {
   // `never`. It is a question about the member name, not about the node
   // kind.
   isNavigatorMember(node, navigatorVarName, member) {
-    if (!t5.isJSXElement(node)) return false;
+    if (!t8.isJSXElement(node)) return false;
     const name = node.openingElement.name;
-    return t5.isJSXMemberExpression(name) && t5.isJSXIdentifier(name.object) && name.object.name === navigatorVarName && t5.isJSXIdentifier(name.property) && name.property.name === member;
+    return t8.isJSXMemberExpression(name) && t8.isJSXIdentifier(name.object) && name.object.name === navigatorVarName && t8.isJSXIdentifier(name.property) && name.property.name === member;
   }
   /**
    * Flatten a navigator's JSX children into the `<X.Screen>` elements they
@@ -2811,37 +4215,37 @@ var NavigationAnalyzer = class {
         found.push(...this.collectScreenElements(group.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXElement(node)) {
+      if (t8.isJSXElement(node)) {
         const name = node.openingElement.name;
-        const isForeignNavigator = t5.isJSXMemberExpression(name) && t5.isJSXIdentifier(name.property) && name.property.name === "Navigator";
+        const isForeignNavigator = t8.isJSXMemberExpression(name) && t8.isJSXIdentifier(name.property) && name.property.name === "Navigator";
         if (isForeignNavigator) return;
         found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXFragment(node)) {
+      if (t8.isJSXFragment(node)) {
         found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXExpressionContainer(node)) {
+      if (t8.isJSXExpressionContainer(node)) {
         visit(node.expression);
         return;
       }
-      if (t5.isConditionalExpression(node)) {
+      if (t8.isConditionalExpression(node)) {
         visit(node.consequent);
         visit(node.alternate);
         return;
       }
-      if (t5.isLogicalExpression(node)) {
+      if (t8.isLogicalExpression(node)) {
         visit(node.left);
         visit(node.right);
         return;
       }
-      if (t5.isCallExpression(node)) {
+      if (t8.isCallExpression(node)) {
         for (const arg of node.arguments) {
-          if (t5.isArrowFunctionExpression(arg) || t5.isFunctionExpression(arg)) {
-            if (t5.isBlockStatement(arg.body)) {
+          if (t8.isArrowFunctionExpression(arg) || t8.isFunctionExpression(arg)) {
+            if (t8.isBlockStatement(arg.body)) {
               for (const stmt of arg.body.body) {
-                if (t5.isReturnStatement(stmt)) visit(stmt.argument);
+                if (t8.isReturnStatement(stmt)) visit(stmt.argument);
               }
             } else {
               visit(arg.body);
@@ -2850,11 +4254,11 @@ var NavigationAnalyzer = class {
         }
         return;
       }
-      if (t5.isArrayExpression(node)) {
+      if (t8.isArrayExpression(node)) {
         for (const el of node.elements) visit(el);
         return;
       }
-      if (t5.isTSAsExpression(node) || t5.isTSNonNullExpression(node)) {
+      if (t8.isTSAsExpression(node) || t8.isTSNonNullExpression(node)) {
         visit(node.expression);
       }
     };
@@ -2862,28 +4266,54 @@ var NavigationAnalyzer = class {
     return found;
   }
   /** Extract screens from a navigator JSX element */
-  extractScreensFromNavigator(navigatorElement, navigatorVarName, navigatorType) {
+  extractScreensFromNavigator(filePath, navigatorElement, navigatorVarName, navigatorType) {
     const screens = [];
     if (!navigatorElement.children) return screens;
     const seen = /* @__PURE__ */ new Set();
     for (const element of this.collectScreenElements(navigatorElement.children, navigatorVarName)) {
-      const screenName = this.extractAttributeValue(element.openingElement.attributes, "name");
-      if (!screenName || seen.has(screenName)) continue;
-      seen.add(screenName);
-      screens.push({
-        name: screenName,
-        navigatorName: navigatorVarName,
-        navigatorType
-      });
+      const screen = this.parseScreenElement(filePath, element, navigatorVarName, navigatorType);
+      if (!screen || seen.has(screen.name)) continue;
+      seen.add(screen.name);
+      screens.push(screen);
     }
     return screens;
   }
+  /**
+   * Uma `<X.Screen>` isolada até a rota que ela declara.
+   *
+   * Separado de `extractScreensFromNavigator` porque a MESMA leitura serve para
+   * a `<X.Screen>` que mora dentro do `<X.Navigator>` e para a que mora fora
+   * dele — só a forma de chegar até o elemento muda.
+   */
+  parseScreenElement(filePath, element, navigatorName, navigatorType) {
+    const attrs = element.openingElement.attributes;
+    const nameAttr = attrs.find(
+      (a) => t8.isJSXAttribute(a) && t8.isJSXIdentifier(a.name) && a.name.name === "name"
+    );
+    const screenName = t8.isJSXAttribute(nameAttr) ? this.attributeString(filePath, nameAttr) : null;
+    if (!screenName) return null;
+    const componentAttr = attrs.find(
+      (a) => t8.isJSXAttribute(a) && t8.isJSXIdentifier(a.name) && a.name.name === "component"
+    );
+    let componentFile = null;
+    if (t8.isJSXAttribute(componentAttr) && t8.isJSXExpressionContainer(componentAttr.value)) {
+      const expr = componentAttr.value.expression;
+      if (t8.isExpression(expr)) componentFile = this.graph.componentFile(filePath, expr);
+    }
+    if (componentFile) this.routeTargets.set(screenName, componentFile);
+    return {
+      name: screenName,
+      navigatorName,
+      navigatorType,
+      ...componentFile ? { componentFile } : {}
+    };
+  }
   /** Extract string attribute value from JSX attributes */
   extractAttributeValue(attributes, attrName) {
     const attr = attributes.find(
-      (a) => t5.isJSXAttribute(a) && t5.isJSXIdentifier(a.name) && a.name.name === attrName
+      (a) => t8.isJSXAttribute(a) && t8.isJSXIdentifier(a.name) && a.name.name === attrName
     );
-    if (t5.isJSXAttribute(attr) && t5.isStringLiteral(attr.value)) {
+    if (t8.isJSXAttribute(attr) && t8.isStringLiteral(attr.value)) {
       return attr.value.value;
     }
     return null;
@@ -2892,7 +4322,7 @@ var NavigationAnalyzer = class {
   parseParamTypes(content, filePath) {
     const types = [];
     try {
-      const ast = parser.parse(content, {
+      const ast = parser2.parse(content, {
         sourceType: "module",
         plugins: [
           "jsx",
@@ -2900,7 +4330,7 @@ var NavigationAnalyzer = class {
           ...this.config.parserPlugins || []
         ]
       });
-      (0, import_traverse5.default)(ast, {
+      (0, import_traverse6.default)(ast, {
         TSTypeAliasDeclaration: (nodePath) => {
           const { node } = nodePath;
           const typeName = node.id.name;
@@ -2973,7 +4403,7 @@ var NavigationAnalyzer = class {
     if (type.type === "TSUndefinedKeyword") return "undefined";
     if (type.type === "TSNullKeyword") return "null";
     if (type.type === "TSUnionType") {
-      return type.types.map((t15) => this.typeToString(t15)).join(" | ");
+      return type.types.map((t18) => this.typeToString(t18)).join(" | ");
     }
     if (type.type === "TSTypeLiteral") {
       return "object";
@@ -2994,7 +4424,7 @@ var NavigationAnalyzer = class {
   /** Attach parsed type params to navigator screens */
   attachParamsToNavigators(navigators, types) {
     for (const navigator of navigators) {
-      const matchingType = types.find((t15) => t15.type === navigator.type);
+      const matchingType = types.find((t18) => t18.type === navigator.type);
       if (matchingType) {
         for (const screen of navigator.screens) {
           const screenParams = matchingType.paramEntries.get(screen.name);
@@ -3072,9 +4502,9 @@ var NavigationAnalyzer = class {
 
 // src/analyzers/ComponentAnalyzer.ts
 var import_fs5 = require("fs");
-var parser2 = __toESM(require("@babel/parser"));
-var import_traverse6 = __toESM(require("@babel/traverse"));
-var t6 = __toESM(require("@babel/types"));
+var parser3 = __toESM(require("@babel/parser"));
+var import_traverse7 = __toESM(require("@babel/traverse"));
+var t9 = __toESM(require("@babel/types"));
 var ComponentAnalyzer = class {
   config;
   constructor(config) {
@@ -3084,14 +4514,14 @@ var ComponentAnalyzer = class {
   async analyzeFile(filePath) {
     try {
       const code = (0, import_fs5.readFileSync)(filePath, "utf-8");
-      const ast = parser2.parse(code, {
+      const ast = parser3.parse(code, {
         sourceType: "module",
         plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
       });
       const components = [];
-      (0, import_traverse6.default)(ast, {
-        JSXElement: (path11) => {
-          const component = this.extractComponentFromJSXElement(path11.node);
+      (0, import_traverse7.default)(ast, {
+        JSXElement: (path13) => {
+          const component = this.extractComponentFromJSXElement(path13.node);
           if (component) {
             components.push(component);
           }
@@ -3120,19 +4550,19 @@ var ComponentAnalyzer = class {
     };
   }
   getElementName(openingElement) {
-    if (t6.isJSXIdentifier(openingElement.name)) {
+    if (t9.isJSXIdentifier(openingElement.name)) {
       return openingElement.name.name;
     }
-    if (t6.isJSXMemberExpression(openingElement.name)) {
+    if (t9.isJSXMemberExpression(openingElement.name)) {
       const parts = [];
       let current = openingElement.name;
-      while (t6.isJSXMemberExpression(current)) {
-        if (t6.isJSXIdentifier(current.property)) {
+      while (t9.isJSXMemberExpression(current)) {
+        if (t9.isJSXIdentifier(current.property)) {
           parts.unshift(current.property.name);
         }
         current = current.object;
       }
-      if (t6.isJSXIdentifier(current)) {
+      if (t9.isJSXIdentifier(current)) {
         parts.unshift(current.name);
       }
       return parts.join(".");
@@ -3155,13 +4585,13 @@ var ComponentAnalyzer = class {
   extractProps(openingElement) {
     const props = {};
     for (const attr of openingElement.attributes) {
-      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+      if (t9.isJSXAttribute(attr) && t9.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if (attr.value === null) {
           props[propName] = "true";
-        } else if (t6.isStringLiteral(attr.value)) {
+        } else if (t9.isStringLiteral(attr.value)) {
           props[propName] = attr.value.value;
-        } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+        } else if (t9.isJSXExpressionContainer(attr.value) && t9.isStringLiteral(attr.value.expression)) {
           props[propName] = attr.value.expression.value;
         }
       }
@@ -3171,12 +4601,12 @@ var ComponentAnalyzer = class {
   extractAccessibilityProps(openingElement) {
     const result = {};
     for (const attr of openingElement.attributes) {
-      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+      if (t9.isJSXAttribute(attr) && t9.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if ((propName === "testID" || propName === "accessibilityLabel") && attr.value) {
-          if (t6.isStringLiteral(attr.value)) {
+          if (t9.isStringLiteral(attr.value)) {
             result[propName] = attr.value.value;
-          } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+          } else if (t9.isJSXExpressionContainer(attr.value) && t9.isStringLiteral(attr.value.expression)) {
             result[propName] = attr.value.expression.value;
           }
         }
@@ -3188,7 +4618,7 @@ var ComponentAnalyzer = class {
     if (depth >= maxDepth) return [];
     const extracted = [];
     for (const child of children) {
-      if (t6.isJSXElement(child)) {
+      if (t9.isJSXElement(child)) {
         const component = this.extractComponentFromJSXElement(child);
         if (component) {
           extracted.push(component);
@@ -3201,10 +4631,10 @@ var ComponentAnalyzer = class {
 
 // src/analyzers/FormAnalyzer.ts
 var import_fs6 = require("fs");
-var parser3 = __toESM(require("@babel/parser"));
-var import_traverse7 = __toESM(require("@babel/traverse"));
-var t7 = __toESM(require("@babel/types"));
-var path3 = __toESM(require("path"));
+var parser4 = __toESM(require("@babel/parser"));
+var import_traverse8 = __toESM(require("@babel/traverse"));
+var t10 = __toESM(require("@babel/types"));
+var path5 = __toESM(require("path"));
 var FormAnalyzer = class {
   config;
   stateVariables = /* @__PURE__ */ new Map();
@@ -3217,21 +4647,21 @@ var FormAnalyzer = class {
   async analyzeFile(filePath) {
     try {
       const code = (0, import_fs6.readFileSync)(filePath, "utf-8");
-      const ast = parser3.parse(code, {
+      const ast = parser4.parse(code, {
         sourceType: "module",
         plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
       });
       this.stateVariables.clear();
       this.inputElements = [];
       this.submitButtons = [];
-      (0, import_traverse7.default)(ast, {
-        CallExpression: (path11) => {
-          this.extractStateVariables(path11.node);
+      (0, import_traverse8.default)(ast, {
+        CallExpression: (path13) => {
+          this.extractStateVariables(path13.node);
         }
       });
-      (0, import_traverse7.default)(ast, {
-        JSXElement: (path11) => {
-          this.extractFormElements(path11.node);
+      (0, import_traverse8.default)(ast, {
+        JSXElement: (path13) => {
+          this.extractFormElements(path13.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -3242,7 +4672,7 @@ var FormAnalyzer = class {
     }
   }
   extractStateVariables(node) {
-    if (t7.isIdentifier(node.callee) && node.callee.name === "useState" && node.arguments.length > 0) {
+    if (t10.isIdentifier(node.callee) && node.callee.name === "useState" && node.arguments.length > 0) {
       return;
     }
   }
@@ -3263,28 +4693,28 @@ var FormAnalyzer = class {
   extractInputInfo(openingElement) {
     const info2 = { varName: "" };
     for (const attr of openingElement.attributes) {
-      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+      if (t10.isJSXAttribute(attr) && t10.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
-        const propValue = this.extractAttributeValue(attr.value);
+        const propValue2 = this.extractAttributeValue(attr.value);
         switch (propName) {
           case "label":
-            info2.label = propValue;
+            info2.label = propValue2;
             break;
           case "placeholder":
-            info2.placeholder = propValue;
+            info2.placeholder = propValue2;
             break;
           case "keyboardType":
-            info2.keyboardType = propValue;
+            info2.keyboardType = propValue2;
             break;
           case "testID":
-            info2.testID = propValue;
+            info2.testID = propValue2;
             break;
           case "appilotsId":
-            info2.appilotsId = propValue;
-            if (propValue) info2.varName = propValue;
+            info2.appilotsId = propValue2;
+            if (propValue2) info2.varName = propValue2;
             break;
           case "value":
-            if (attr.value && t7.isJSXExpressionContainer(attr.value) && t7.isIdentifier(attr.value.expression)) {
+            if (attr.value && t10.isJSXExpressionContainer(attr.value) && t10.isIdentifier(attr.value.expression)) {
               info2.varName = attr.value.expression.name;
             }
             break;
@@ -3296,16 +4726,16 @@ var FormAnalyzer = class {
   extractButtonInfo(openingElement) {
     const info2 = {};
     for (const attr of openingElement.attributes) {
-      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+      if (t10.isJSXAttribute(attr) && t10.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if (propName === "title" || propName === "label") {
           info2.label = this.extractAttributeValue(attr.value);
         }
         if (propName === "onPress") {
-          if (attr.value && t7.isJSXExpressionContainer(attr.value)) {
-            if (t7.isIdentifier(attr.value.expression)) {
+          if (attr.value && t10.isJSXExpressionContainer(attr.value)) {
+            if (t10.isIdentifier(attr.value.expression)) {
               info2.handler = attr.value.expression.name;
-            } else if (t7.isArrowFunctionExpression(attr.value.expression) || t7.isFunctionExpression(attr.value.expression)) {
+            } else if (t10.isArrowFunctionExpression(attr.value.expression) || t10.isFunctionExpression(attr.value.expression)) {
               info2.handler = "anonymous";
             }
           }
@@ -3316,23 +4746,23 @@ var FormAnalyzer = class {
   }
   extractAttributeValue(value) {
     if (value === null) return void 0;
-    if (t7.isStringLiteral(value)) return value.value;
-    if (t7.isJSXExpressionContainer(value) && t7.isStringLiteral(value.expression)) {
+    if (t10.isStringLiteral(value)) return value.value;
+    if (t10.isJSXExpressionContainer(value) && t10.isStringLiteral(value.expression)) {
       return value.expression.value;
     }
     return void 0;
   }
   getElementName(openingElement) {
-    if (t7.isJSXIdentifier(openingElement.name)) {
+    if (t10.isJSXIdentifier(openingElement.name)) {
       return openingElement.name.name;
     }
     return null;
   }
   extractValidationRules(ast) {
     const rules = {};
-    (0, import_traverse7.default)(ast, {
-      IfStatement: (path11) => {
-        const test = path11.node.test;
+    (0, import_traverse8.default)(ast, {
+      IfStatement: (path13) => {
+        const test = path13.node.test;
         const rule = this.extractRuleFromCondition(test);
         if (rule) {
           const { field, description } = rule;
@@ -3347,36 +4777,36 @@ var FormAnalyzer = class {
   extractRuleFromCondition(test) {
     let fieldName = "";
     let description = "";
-    if (t7.isUnaryExpression(test) && test.operator === "!") {
-      if (t7.isCallExpression(test.argument)) {
+    if (t10.isUnaryExpression(test) && test.operator === "!") {
+      if (t10.isCallExpression(test.argument)) {
         const callExpr = test.argument;
-        if (t7.isMemberExpression(callExpr.callee)) {
+        if (t10.isMemberExpression(callExpr.callee)) {
           const memberExpr = callExpr.callee;
-          if (t7.isIdentifier(memberExpr.object)) {
+          if (t10.isIdentifier(memberExpr.object)) {
             fieldName = memberExpr.object.name;
             description = `${fieldName} is required`;
           }
         }
-      } else if (t7.isIdentifier(test.argument)) {
+      } else if (t10.isIdentifier(test.argument)) {
         fieldName = test.argument.name;
         description = `${fieldName} is required`;
       }
     }
-    if (t7.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
-      if (t7.isMemberExpression(test.left)) {
+    if (t10.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
+      if (t10.isMemberExpression(test.left)) {
         const memberExpr = test.left;
-        if (t7.isIdentifier(memberExpr.object)) {
+        if (t10.isIdentifier(memberExpr.object)) {
           fieldName = memberExpr.object.name;
-          if (t7.isNumericLiteral(test.right)) {
+          if (t10.isNumericLiteral(test.right)) {
             description = `${fieldName} must be at least ${test.right.value} characters`;
           }
         }
       }
     }
-    if (t7.isUnaryExpression(test) && test.operator === "!") {
-      if (t7.isCallExpression(test.argument) && t7.isMemberExpression(test.argument.callee)) {
-        const methodName = t7.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
-        if (methodName === "includes" && t7.isIdentifier(test.argument.callee.object)) {
+    if (t10.isUnaryExpression(test) && test.operator === "!") {
+      if (t10.isCallExpression(test.argument) && t10.isMemberExpression(test.argument.callee)) {
+        const methodName = t10.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
+        if (methodName === "includes" && t10.isIdentifier(test.argument.callee.object)) {
           fieldName = test.argument.callee.object.name;
           description = `${fieldName} format is invalid`;
         }
@@ -3386,7 +4816,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path3.basename(filePath, path3.extname(filePath));
+    const fileName = path5.basename(filePath, path5.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -3436,14 +4866,104 @@ var FormAnalyzer = class {
   }
 };
 
+// src/pipeline/composition.ts
+var MAX_DEPTH = 3;
+var MAX_VISITED_PER_SCREEN = 60;
+var MAX_FAN_IN = 3;
+var ADDRESSABLE = /* @__PURE__ */ new Set(["testID", "appilotsId", "accessibilityLabel", "label"]);
+function descendants(graph, from, screenFiles) {
+  const seen = /* @__PURE__ */ new Set([from]);
+  const out = [];
+  let frontier = [from];
+  for (let depth = 0; depth < MAX_DEPTH && frontier.length > 0; depth++) {
+    const next = [];
+    for (const file2 of frontier) {
+      for (const child of graph.renderedComponentFiles(file2)) {
+        if (seen.has(child)) continue;
+        seen.add(child);
+        if (screenFiles.has(child)) continue;
+        out.push(child);
+        next.push(child);
+        if (out.length >= MAX_VISITED_PER_SCREEN) return out;
+      }
+    }
+    frontier = next;
+  }
+  return out;
+}
+function addressable(locator) {
+  if (!locator || typeof locator !== "object") return false;
+  const l = locator;
+  if (typeof l["source"] === "string" && ADDRESSABLE.has(l["source"])) return true;
+  return typeof l["testID"] === "string" && l["testID"].length > 0;
+}
+async function composeAffordances(options) {
+  const { screens, graph, analyzeFile, screenFiles } = options;
+  const byScreen = /* @__PURE__ */ new Map();
+  const fanIn = /* @__PURE__ */ new Map();
+  for (const screen of screens) {
+    if (!screen.filePath) continue;
+    const children = descendants(graph, screen.filePath, screenFiles);
+    byScreen.set(screen, children);
+    for (const child of children) fanIn.set(child, (fanIn.get(child) ?? 0) + 1);
+  }
+  const analyzed = /* @__PURE__ */ new Map();
+  let screensEnriched = 0;
+  let filesMerged = 0;
+  for (const [screen, children] of byScreen) {
+    const exclusive = children.filter((c) => (fanIn.get(c) ?? 0) <= MAX_FAN_IN);
+    if (exclusive.length === 0) continue;
+    const actionIds = new Set(screen.actions.map((a) => a.id));
+    const targetIds = new Set((screen.targets ?? []).map((t18) => t18.id));
+    const formIds = new Set(screen.forms.map((f) => f.id));
+    let gained = false;
+    for (const file2 of exclusive) {
+      if (!analyzed.has(file2)) {
+        try {
+          analyzed.set(file2, await analyzeFile(file2));
+        } catch {
+          analyzed.set(file2, null);
+        }
+      }
+      const child = analyzed.get(file2);
+      if (!child) continue;
+      let merged = false;
+      for (const action of child.actions) {
+        if (!addressable(action.locator)) continue;
+        if (actionIds.has(action.id)) continue;
+        actionIds.add(action.id);
+        screen.actions.push(action);
+        merged = true;
+      }
+      for (const target of child.targets ?? []) {
+        if (!addressable(target.locator)) continue;
+        if (targetIds.has(target.id)) continue;
+        targetIds.add(target.id);
+        (screen.targets ??= []).push(target);
+        merged = true;
+      }
+      for (const form of child.forms) {
+        if (form.fields.length === 0) continue;
+        const id = formIds.has(form.id) ? `${form.id}:${child.name}` : form.id;
+        if (formIds.has(id)) continue;
+        formIds.add(id);
+        screen.forms.push({ ...form, id });
+        merged = true;
+      }
+      if (merged) {
+        filesMerged++;
+        gained = true;
+      }
+    }
+    if (gained) screensEnriched++;
+  }
+  return { screens, screensEnriched, filesMerged };
+}
+
 // src/analyzers/ReactNativePlatformAnalyzer.ts
 var ReactNativePlatformAnalyzer = class {
   platform = "react-native";
   async analyze(config, options) {
-    const screenAnalyzer = new ScreenAnalyzer(config, {
-      strictScreens: options.strictScreens ?? true,
-      screenPatterns: options.screenPatterns
-    });
     const navigationAnalyzer = new NavigationAnalyzer(config, {
       navigationInclude: options.navigationInclude,
       navigationExclude: options.navigationExclude
@@ -3451,14 +4971,31 @@ var ReactNativePlatformAnalyzer = class {
     const componentAnalyzer = new ComponentAnalyzer(config);
     const formAnalyzer = new FormAnalyzer(config);
     console.log("[ReactNativePlatformAnalyzer] Running analyzers...");
-    const [screens, navigation] = await Promise.all([
-      screenAnalyzer.analyze(),
-      navigationAnalyzer.analyze()
-    ]);
+    const navigation = await navigationAnalyzer.analyze();
+    const screenAnalyzer = new ScreenAnalyzer(config, {
+      strictScreens: options.strictScreens ?? true,
+      screenPatterns: options.screenPatterns,
+      // Menos os arquivos que declaram navegador: ver `navigatorFiles`.
+      routeTargetFiles: new Set(
+        [...navigationAnalyzer.routeTargets.values()].filter(
+          (file2) => !navigationAnalyzer.navigatorFiles.has(file2)
+        )
+      )
+    });
+    const screens = await screenAnalyzer.analyze();
+    const composed = await composeAffordances({
+      screens,
+      graph: navigationAnalyzer.graph,
+      analyzeFile: (file2) => screenAnalyzer.analyzeFile(file2),
+      screenFiles: new Set(screens.map((s) => s.filePath).filter(Boolean))
+    });
+    console.log(
+      `[ReactNativePlatformAnalyzer] Composi\xE7\xE3o: ${composed.filesMerged} componente(s) exclusivo(s) fundido(s) em ${composed.screensEnriched} tela(s)`
+    );
     console.log(
       `[ReactNativePlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens`
     );
-    const screenFiles = await (0, import_fast_glob3.default)(config.include || ["**/*.tsx", "**/*.ts"], {
+    const screenFiles = await globSorted(config.include || ["**/*.tsx", "**/*.ts"], {
       cwd: config.rootDir,
       ignore: config.exclude || ["**/node_modules/**"]
     });
@@ -3466,7 +5003,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file2) => {
-      const filePath = import_node_path.default.resolve(config.rootDir, file2);
+      const filePath = import_node_path3.default.resolve(config.rootDir, file2);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -3519,9 +5056,11 @@ var ReactNativePlatformAnalyzer = class {
     });
     return {
       screens: enrichedScreens,
+      controlEvidenceFiles: screenAnalyzer.controlEvidenceFiles,
       navigation,
       analyzedFiles: screenFiles.length,
-      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {},
+      diagnostics: { navigation: navigationAnalyzer.diagnostics }
     };
   }
   mergeForm(target, source) {
@@ -3539,9 +5078,12 @@ var ReactNativePlatformAnalyzer = class {
   findEquivalentField(fields, incoming) {
     return fields.find((field) => {
       if (field.name && incoming.name && field.name === incoming.name) return true;
-      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
-      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
-      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding)
+        return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id)
+        return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder)
+        return true;
       if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
         return true;
       }
@@ -3574,7 +5116,9 @@ var ReactNativePlatformAnalyzer = class {
     if (incoming.fields.length === 0) return void 0;
     let best;
     for (const form of forms) {
-      const overlap = incoming.fields.filter((field) => this.findEquivalentField(form.fields, field)).length;
+      const overlap = incoming.fields.filter(
+        (field) => this.findEquivalentField(form.fields, field)
+      ).length;
       if (overlap > 0 && (!best || overlap > best.overlap)) {
         best = { form, overlap };
       }
@@ -3601,9 +5145,8 @@ var GenericPlatformAnalyzer = class {
 // src/analyzers/web/WebScreenAnalyzer.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_path5 = __toESM(require("path"));
-var import_fast_glob4 = __toESM(require("fast-glob"));
-var import_traverse9 = __toESM(require("@babel/traverse"));
-var t10 = __toESM(require("@babel/types"));
+var import_traverse10 = __toESM(require("@babel/traverse"));
+var t13 = __toESM(require("@babel/types"));
 
 // src/ast/jsx/web/classify.ts
 var VIEW_TAGS = /* @__PURE__ */ new Set([
@@ -3719,49 +5262,49 @@ function classifyWebJsxComponent(name, element) {
 }
 
 // src/ast/jsx/names.ts
-var t8 = __toESM(require("@babel/types"));
+var t11 = __toESM(require("@babel/types"));
 function getJsxElementName(openingElement) {
   return getJsxName(openingElement.name);
 }
 function getJsxName(name) {
-  if (t8.isJSXIdentifier(name)) return name.name;
-  if (t8.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
-  if (t8.isJSXMemberExpression(name)) {
+  if (t11.isJSXIdentifier(name)) return name.name;
+  if (t11.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+  if (t11.isJSXMemberExpression(name)) {
     const objectName = getJsxName(name.object);
-    const propertyName = t8.isJSXIdentifier(name.property) ? name.property.name : null;
+    const propertyName = t11.isJSXIdentifier(name.property) ? name.property.name : null;
     return objectName && propertyName ? `${objectName}.${propertyName}` : null;
   }
   return null;
 }
 
 // src/ast/navigation/web-calls.ts
-var import_traverse8 = __toESM(require("@babel/traverse"));
-var t9 = __toESM(require("@babel/types"));
+var import_traverse9 = __toESM(require("@babel/traverse"));
+var t12 = __toESM(require("@babel/types"));
 var ROUTERISH_OBJECTS = /^(router|history|navigation)$/;
 function staticRoutePath(node) {
   if (!node) return void 0;
-  if (t9.isStringLiteral(node)) return node.value;
-  if (t9.isTemplateLiteral(node)) {
-    let path11 = "";
+  if (t12.isStringLiteral(node)) return node.value;
+  if (t12.isTemplateLiteral(node)) {
+    let path13 = "";
     node.quasis.forEach((quasi, index) => {
-      path11 += quasi.value.cooked ?? quasi.value.raw;
+      path13 += quasi.value.cooked ?? quasi.value.raw;
       const expr = node.expressions[index];
-      if (expr) path11 += `:${paramNameOf(expr)}`;
+      if (expr) path13 += `:${paramNameOf(expr)}`;
     });
-    return path11;
+    return path13;
   }
   return void 0;
 }
 function paramNameOf(expr) {
-  if (t9.isIdentifier(expr)) return expr.name;
-  if (t9.isMemberExpression(expr) && t9.isIdentifier(expr.property)) return expr.property.name;
+  if (t12.isIdentifier(expr)) return expr.name;
+  if (t12.isMemberExpression(expr) && t12.isIdentifier(expr.property)) return expr.property.name;
   return "param";
 }
 function extractWebNavigationCalls(ast) {
   const calls = [];
   const inspect = (node) => {
-    if (t9.isCallExpression(node)) {
-      if (t9.isIdentifier(node.callee) && node.callee.name === "navigate") {
+    if (t12.isCallExpression(node)) {
+      if (t12.isIdentifier(node.callee) && node.callee.name === "navigate") {
         const first = node.arguments[0];
         const targetPath = staticRoutePath(first);
         if (targetPath !== void 0) {
@@ -3769,12 +5312,12 @@ function extractWebNavigationCalls(ast) {
             method: hasReplaceOption(node.arguments[1]) ? "replace" : "navigate",
             targetPath
           });
-        } else if (t9.isNumericLiteral(first) || t9.isUnaryExpression(first) && first.operator === "-") {
+        } else if (t12.isNumericLiteral(first) || t12.isUnaryExpression(first) && first.operator === "-") {
           calls.push({ method: "goBack" });
         }
         return;
       }
-      if (t9.isMemberExpression(node.callee) && t9.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && t9.isIdentifier(node.callee.property)) {
+      if (t12.isMemberExpression(node.callee) && t12.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && t12.isIdentifier(node.callee.property)) {
         const method = node.callee.property.name;
         const targetPath = staticRoutePath(node.arguments[0]);
         if ((method === "push" || method === "navigate") && targetPath !== void 0) {
@@ -3787,25 +5330,25 @@ function extractWebNavigationCalls(ast) {
       }
       return;
     }
-    if (t9.isAssignmentExpression(node) && t9.isMemberExpression(node.left) && t9.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && t9.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
+    if (t12.isAssignmentExpression(node) && t12.isMemberExpression(node.left) && t12.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && t12.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
       calls.push({ method: "navigate", targetPath: node.right.value });
     }
   };
-  (0, import_traverse8.default)(ast, {
-    noScope: !t9.isFile(ast),
+  (0, import_traverse9.default)(ast, {
+    noScope: !t12.isFile(ast),
     enter: (nodePath) => inspect(nodePath.node)
   });
   return calls;
 }
 function hasReplaceOption(arg) {
-  if (!arg || !t9.isObjectExpression(arg)) return false;
+  if (!arg || !t12.isObjectExpression(arg)) return false;
   return arg.properties.some(
-    (prop) => t9.isObjectProperty(prop) && t9.isIdentifier(prop.key) && prop.key.name === "replace" && t9.isBooleanLiteral(prop.value) && prop.value.value === true
+    (prop) => t12.isObjectProperty(prop) && t12.isIdentifier(prop.key) && prop.key.name === "replace" && t12.isBooleanLiteral(prop.value) && prop.value.value === true
   );
 }
 function isLocationExpression(node) {
-  if (t9.isIdentifier(node)) return node.name === "location";
-  return t9.isMemberExpression(node) && t9.isIdentifier(node.object) && node.object.name === "window" && t9.isIdentifier(node.property) && node.property.name === "location";
+  if (t12.isIdentifier(node)) return node.name === "location";
+  return t12.isMemberExpression(node) && t12.isIdentifier(node.object) && node.object.name === "window" && t12.isIdentifier(node.property) && node.property.name === "location";
 }
 
 // src/analyzers/web/WebScreenAnalyzer.ts
@@ -3833,10 +5376,10 @@ var WebScreenAnalyzer = class {
       include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
       exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
     } = this.config;
-    const files = (await (0, import_fast_glob4.default)(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
+    const files = (await globSorted(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
       (file2) => !file2.endsWith(".d.ts")
     );
-    const patternMatches = await (0, import_fast_glob4.default)(this.screenPatterns, {
+    const patternMatches = await globSorted(this.screenPatterns, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -3913,7 +5456,7 @@ var WebScreenAnalyzer = class {
   // ── registerScreen ────────────────────────────────────────────────
   detectRegisterScreenCall(ast) {
     let found = false;
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       CallExpression: (nodePath) => {
         if (found) return;
         if (isRegisterScreenCallee(nodePath.node.callee)) {
@@ -3926,11 +5469,11 @@ var WebScreenAnalyzer = class {
   }
   extractRegisterScreenMetadata(ast) {
     let plain = null;
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       CallExpression: (nodePath) => {
         if (!isRegisterScreenCallee(nodePath.node.callee)) return;
         const arg = nodePath.node.arguments[0];
-        if (t10.isObjectExpression(arg)) {
+        if (t13.isObjectExpression(arg)) {
           plain = literalToPlain(arg);
         }
       }
@@ -3974,23 +5517,23 @@ var WebScreenAnalyzer = class {
   extractComponentName(ast) {
     let defaultName = "";
     let firstExported = "";
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       ExportDefaultDeclaration: (nodePath) => {
         const declaration = nodePath.node.declaration;
-        if (t10.isFunctionDeclaration(declaration) && declaration.id?.name) {
+        if (t13.isFunctionDeclaration(declaration) && declaration.id?.name) {
           defaultName = declaration.id.name;
-        } else if (t10.isIdentifier(declaration)) {
+        } else if (t13.isIdentifier(declaration)) {
           defaultName = declaration.name;
         }
       },
       ExportNamedDeclaration: (nodePath) => {
         if (firstExported) return;
         const declaration = nodePath.node.declaration;
-        if (t10.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
+        if (t13.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
           firstExported = declaration.id.name;
-        } else if (t10.isVariableDeclaration(declaration)) {
+        } else if (t13.isVariableDeclaration(declaration)) {
           for (const declarator of declaration.declarations) {
-            if (t10.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t10.isArrowFunctionExpression(declarator.init) || t10.isFunctionExpression(declarator.init))) {
+            if (t13.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t13.isArrowFunctionExpression(declarator.init) || t13.isFunctionExpression(declarator.init))) {
               firstExported = declarator.id.name;
               break;
             }
@@ -4003,7 +5546,7 @@ var WebScreenAnalyzer = class {
   extractComponents(ast) {
     const components = [];
     const seen = /* @__PURE__ */ new Set();
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element);
@@ -4024,7 +5567,7 @@ var WebScreenAnalyzer = class {
   // ── <label htmlFor> association ───────────────────────────────────
   collectHtmlForLabels(ast) {
     const labels = /* @__PURE__ */ new Map();
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         if (getJsxElementName(element.openingElement) !== "label") return;
@@ -4067,7 +5610,7 @@ var WebScreenAnalyzer = class {
       formBuckets.set(formElement, bucket);
       return bucket;
     };
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -4084,7 +5627,7 @@ var WebScreenAnalyzer = class {
         if (!bucket.fields.has(field.name)) bucket.fields.set(field.name, field);
       }
     });
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -4162,15 +5705,15 @@ var WebScreenAnalyzer = class {
       });
     }
     for (const attr of opening.attributes) {
-      if (!t10.isJSXAttribute(attr) || !t10.isJSXIdentifier(attr.name)) continue;
+      if (!t13.isJSXAttribute(attr) || !t13.isJSXIdentifier(attr.name)) continue;
       const attrName = attr.name.name;
       if (attrName === "required") {
         if (attr.value === null) field.required = true;
-        else if (t10.isJSXExpressionContainer(attr.value) && t10.isBooleanLiteral(attr.value.expression)) {
+        else if (t13.isJSXExpressionContainer(attr.value) && t13.isBooleanLiteral(attr.value.expression)) {
           field.required = attr.value.expression.value;
         }
       }
-      if ((attrName === "value" || attrName === "checked") && attr.value && t10.isJSXExpressionContainer(attr.value) && t10.isIdentifier(attr.value.expression)) {
+      if ((attrName === "value" || attrName === "checked") && attr.value && t13.isJSXExpressionContainer(attr.value) && t13.isIdentifier(attr.value.expression)) {
         field.valueBinding = attr.value.expression.name;
         if (!field.name) field.name = attr.value.expression.name;
       }
@@ -4220,7 +5763,7 @@ var WebScreenAnalyzer = class {
   extractSelectOptions(selectElement) {
     const options = [];
     for (const child of selectElement.children) {
-      if (!t10.isJSXElement(child)) continue;
+      if (!t13.isJSXElement(child)) continue;
       if (getJsxElementName(child.openingElement) !== "option") continue;
       const value = getStringAttr(child.openingElement, "value");
       const label = jsxTextContent(child) || value || "";
@@ -4262,7 +5805,7 @@ var WebScreenAnalyzer = class {
     const actionLabels = new Map(
       actions.filter((a) => a.label).map((a) => [normalizeLabel(a.label), a])
     );
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -4331,14 +5874,14 @@ var WebScreenAnalyzer = class {
     }
     let handlerName;
     const onClickAttr = opening.attributes.find(
-      (attr) => t10.isJSXAttribute(attr) && t10.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
+      (attr) => t13.isJSXAttribute(attr) && t13.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
     );
-    if (onClickAttr?.value && t10.isJSXExpressionContainer(onClickAttr.value)) {
+    if (onClickAttr?.value && t13.isJSXExpressionContainer(onClickAttr.value)) {
       const expr = onClickAttr.value.expression;
-      if (t10.isIdentifier(expr)) {
+      if (t13.isIdentifier(expr)) {
         handlerName = expr.name;
         action.handler = expr.name;
-      } else if (!t10.isJSXEmptyExpression(expr)) {
+      } else if (!t13.isJSXEmptyExpression(expr)) {
         const inlineNavCalls = extractWebNavigationCalls(expr);
         const inlineNav = inlineNavCalls.find((call) => call.targetPath);
         if (inlineNav?.targetPath) {
@@ -4477,12 +6020,12 @@ var WebScreenAnalyzer = class {
   }
   handlerNameFromAttr(opening, attrName) {
     const attr = opening.attributes.find(
-      (candidate) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+      (candidate) => t13.isJSXAttribute(candidate) && t13.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
     );
-    if (!attr?.value || !t10.isJSXExpressionContainer(attr.value)) return void 0;
+    if (!attr?.value || !t13.isJSXExpressionContainer(attr.value)) return void 0;
     const expr = attr.value.expression;
-    if (t10.isIdentifier(expr)) return expr.name;
-    if (t10.isArrowFunctionExpression(expr) || t10.isFunctionExpression(expr)) {
+    if (t13.isIdentifier(expr)) return expr.name;
+    if (t13.isArrowFunctionExpression(expr) || t13.isFunctionExpression(expr)) {
       return firstCalledFunctionName(expr) ?? "anonymous";
     }
     return void 0;
@@ -4493,7 +6036,7 @@ var WebScreenAnalyzer = class {
     for (const call of extractWebNavigationCalls(ast)) {
       if (call.targetPath && call.targetPath.startsWith("/")) targets.add(call.targetPath);
     }
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element);
@@ -4513,14 +6056,14 @@ var WebScreenAnalyzer = class {
   extractCollections(ast) {
     const collections = [];
     const seen = /* @__PURE__ */ new Set();
-    (0, import_traverse9.default)(ast, {
+    (0, import_traverse10.default)(ast, {
       JSXExpressionContainer: (nodePath) => {
         const expr = nodePath.node.expression;
-        if (!t10.isCallExpression(expr) || !t10.isMemberExpression(expr.callee) || !t10.isIdentifier(expr.callee.object) || !t10.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
+        if (!t13.isCallExpression(expr) || !t13.isMemberExpression(expr.callee) || !t13.isIdentifier(expr.callee.object) || !t13.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
           return;
         }
         const callback = expr.arguments[0];
-        if (!t10.isArrowFunctionExpression(callback) && !t10.isFunctionExpression(callback)) return;
+        if (!t13.isArrowFunctionExpression(callback) && !t13.isFunctionExpression(callback)) return;
         const enclosing = nodePath.findParent(
           (p) => p.isJSXElement()
         );
@@ -4555,22 +6098,22 @@ var WebScreenAnalyzer = class {
   }
 };
 function isRegisterScreenCallee(callee) {
-  return t10.isIdentifier(callee) && callee.name === "registerScreen" || t10.isMemberExpression(callee) && t10.isIdentifier(callee.property) && callee.property.name === "registerScreen";
+  return t13.isIdentifier(callee) && callee.name === "registerScreen" || t13.isMemberExpression(callee) && t13.isIdentifier(callee.property) && callee.property.name === "registerScreen";
 }
 function literalToPlain(node) {
-  if (t10.isStringLiteral(node) || t10.isNumericLiteral(node) || t10.isBooleanLiteral(node)) {
+  if (t13.isStringLiteral(node) || t13.isNumericLiteral(node) || t13.isBooleanLiteral(node)) {
     return node.value;
   }
-  if (t10.isNullLiteral(node)) return null;
-  if (t10.isArrayExpression(node)) {
-    return node.elements.filter((el) => el !== null && t10.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
+  if (t13.isNullLiteral(node)) return null;
+  if (t13.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && t13.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
   }
-  if (t10.isObjectExpression(node)) {
+  if (t13.isObjectExpression(node)) {
     const out = {};
     for (const prop of node.properties) {
-      if (!t10.isObjectProperty(prop)) continue;
-      const key = t10.isIdentifier(prop.key) ? prop.key.name : t10.isStringLiteral(prop.key) ? prop.key.value : void 0;
-      if (!key || !t10.isExpression(prop.value)) continue;
+      if (!t13.isObjectProperty(prop)) continue;
+      const key = t13.isIdentifier(prop.key) ? prop.key.name : t13.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key || !t13.isExpression(prop.value)) continue;
       const value = literalToPlain(prop.value);
       if (value !== void 0) out[key] = value;
     }
@@ -4582,12 +6125,12 @@ function jsxTextContent(element) {
   const parts = [];
   const walk = (children) => {
     for (const child of children) {
-      if (t10.isJSXText(child)) {
+      if (t13.isJSXText(child)) {
         const trimmed = child.value.replace(/\s+/g, " ").trim();
         if (trimmed) parts.push(trimmed);
-      } else if (t10.isJSXExpressionContainer(child) && t10.isStringLiteral(child.expression)) {
+      } else if (t13.isJSXExpressionContainer(child) && t13.isStringLiteral(child.expression)) {
         parts.push(child.expression.value);
-      } else if (t10.isJSXElement(child)) {
+      } else if (t13.isJSXElement(child)) {
         walk(child.children);
       }
     }
@@ -4597,26 +6140,26 @@ function jsxTextContent(element) {
   return text.length > 0 ? text : void 0;
 }
 function firstCalledFunctionName(node) {
-  if (t10.isIdentifier(node)) return node.name;
-  if (t10.isArrowFunctionExpression(node) || t10.isFunctionExpression(node)) {
+  if (t13.isIdentifier(node)) return node.name;
+  if (t13.isArrowFunctionExpression(node) || t13.isFunctionExpression(node)) {
     return firstCalledFunctionName(node.body);
   }
-  if (t10.isBlockStatement(node)) {
+  if (t13.isBlockStatement(node)) {
     for (const statement of node.body) {
       const handler = firstCalledFunctionName(statement);
       if (handler) return handler;
     }
     return void 0;
   }
-  if (t10.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
-  if (t10.isReturnStatement(node)) {
+  if (t13.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
+  if (t13.isReturnStatement(node)) {
     return node.argument ? firstCalledFunctionName(node.argument) : void 0;
   }
-  if (t10.isAwaitExpression(node) || t10.isUnaryExpression(node)) {
+  if (t13.isAwaitExpression(node) || t13.isUnaryExpression(node)) {
     return firstCalledFunctionName(node.argument);
   }
-  if (t10.isCallExpression(node)) {
-    if (t10.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
+  if (t13.isCallExpression(node)) {
+    if (t13.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
       return node.callee.name;
     }
     return void 0;
@@ -4625,14 +6168,14 @@ function firstCalledFunctionName(node) {
 }
 function containsWindowConfirm(body) {
   let found = false;
-  (0, import_traverse9.default)(
+  (0, import_traverse10.default)(
     body,
     {
       noScope: true,
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
-        if (t10.isIdentifier(callee) && callee.name === "confirm") found = true;
-        if (t10.isMemberExpression(callee) && t10.isIdentifier(callee.object) && callee.object.name === "window" && t10.isIdentifier(callee.property) && callee.property.name === "confirm") {
+        if (t13.isIdentifier(callee) && callee.name === "confirm") found = true;
+        if (t13.isMemberExpression(callee) && t13.isIdentifier(callee.object) && callee.object.name === "window" && t13.isIdentifier(callee.property) && callee.property.name === "confirm") {
           found = true;
         }
       }
@@ -4647,9 +6190,9 @@ function routePathAttr(opening, attrName) {
   const literal = getStringAttr(opening, attrName);
   if (literal) return literal;
   const attr = opening.attributes.find(
-    (candidate) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    (candidate) => t13.isJSXAttribute(candidate) && t13.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
   );
-  if (!attr?.value || !t10.isJSXExpressionContainer(attr.value)) return void 0;
+  if (!attr?.value || !t13.isJSXExpressionContainer(attr.value)) return void 0;
   return staticRoutePath(attr.value.expression);
 }
 function slugify(label) {
@@ -4664,10 +6207,10 @@ function isWeakInferredFieldName(name) {
 function collectionItemNames(callback) {
   const names = /* @__PURE__ */ new Set(["item"]);
   const firstParam = callback.params[0];
-  if (t10.isIdentifier(firstParam)) names.add(firstParam.name);
-  if (t10.isObjectPattern(firstParam)) {
+  if (t13.isIdentifier(firstParam)) names.add(firstParam.name);
+  if (t13.isObjectPattern(firstParam)) {
     for (const prop of firstParam.properties) {
-      if (t10.isObjectProperty(prop) && t10.isIdentifier(prop.key) && t10.isIdentifier(prop.value)) {
+      if (t13.isObjectProperty(prop) && t13.isIdentifier(prop.key) && t13.isIdentifier(prop.value)) {
         names.add(prop.value.name);
       }
     }
@@ -4677,13 +6220,13 @@ function collectionItemNames(callback) {
 function collectionDisplayFields(callback, itemNames) {
   const fields = /* @__PURE__ */ new Set();
   if (!callback.body) return [];
-  (0, import_traverse9.default)(
+  (0, import_traverse10.default)(
     callback.body,
     {
       noScope: true,
       MemberExpression: (nodePath) => {
         const node = nodePath.node;
-        if (t10.isIdentifier(node.object) && itemNames.has(node.object.name) && t10.isIdentifier(node.property)) {
+        if (t13.isIdentifier(node.object) && itemNames.has(node.object.name) && t13.isIdentifier(node.property)) {
           fields.add(node.property.name);
         }
       }
@@ -4694,16 +6237,16 @@ function collectionDisplayFields(callback, itemNames) {
 function collectionKeyField(callback, itemNames) {
   let keyField;
   if (!callback.body) return void 0;
-  (0, import_traverse9.default)(
+  (0, import_traverse10.default)(
     callback.body,
     {
       noScope: true,
       JSXAttribute: (nodePath) => {
         const attr = nodePath.node;
-        if (!t10.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
-        if (!attr.value || !t10.isJSXExpressionContainer(attr.value)) return;
+        if (!t13.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
+        if (!attr.value || !t13.isJSXExpressionContainer(attr.value)) return;
         const expr = attr.value.expression;
-        if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.object) && itemNames.has(expr.object.name) && t10.isIdentifier(expr.property)) {
+        if (t13.isMemberExpression(expr) && t13.isIdentifier(expr.object) && itemNames.has(expr.object.name) && t13.isIdentifier(expr.property)) {
           keyField = keyField ?? expr.property.name;
         }
       }
@@ -4726,18 +6269,18 @@ function callbackReturnsTag(callback, tags) {
   let found = false;
   const inspect = (node) => {
     if (!node || found) return;
-    if (t10.isJSXElement(node)) {
+    if (t13.isJSXElement(node)) {
       const name = getJsxElementName(node.openingElement);
       if (name && tags.has(name)) found = true;
       return;
     }
-    if (t10.isBlockStatement(node)) {
+    if (t13.isBlockStatement(node)) {
       for (const statement of node.body) {
-        if (t10.isReturnStatement(statement)) inspect(statement.argument);
+        if (t13.isReturnStatement(statement)) inspect(statement.argument);
       }
     }
-    if (t10.isParenthesizedExpression(node)) inspect(node.expression);
-    if (t10.isConditionalExpression(node)) {
+    if (t13.isParenthesizedExpression(node)) inspect(node.expression);
+    if (t13.isConditionalExpression(node)) {
       inspect(node.consequent);
       inspect(node.alternate);
     }
@@ -4764,9 +6307,8 @@ function inferIdentityFields(keyField, displayFields) {
 // src/analyzers/web/WebNavigationAnalyzer.ts
 var import_fs7 = require("fs");
 var import_path6 = __toESM(require("path"));
-var import_fast_glob5 = __toESM(require("fast-glob"));
-var import_traverse10 = __toESM(require("@babel/traverse"));
-var t11 = __toESM(require("@babel/types"));
+var import_traverse11 = __toESM(require("@babel/traverse"));
+var t14 = __toESM(require("@babel/types"));
 var WEB_NAVIGATOR_TYPE = "route";
 var WebNavigationAnalyzer = class {
   config;
@@ -4783,7 +6325,9 @@ var WebNavigationAnalyzer = class {
     for (const filePath of files) {
       try {
         const content = await import_fs7.promises.readFile(filePath, "utf-8");
-        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(content)) {
+        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(
+          content
+        )) {
           continue;
         }
         const ast = parseSource(content, this.config.parserPlugins);
@@ -4813,7 +6357,7 @@ var WebNavigationAnalyzer = class {
       ...this.config.exclude || [],
       ...this.navigationExclude
     ];
-    const files = await (0, import_fast_glob5.default)(patterns, { cwd: this.config.rootDir, ignore });
+    const files = await globSorted(patterns, { cwd: this.config.rootDir, ignore });
     return files.map((file2) => import_path6.default.join(this.config.rootDir, file2));
   }
   // ── JSX <Route> style ────────────────────────────────────────────
@@ -4824,7 +6368,7 @@ var WebNavigationAnalyzer = class {
       const name = getJsxElementName(opening);
       if (name !== "Route") {
         for (const child of element.children) {
-          if (t11.isJSXElement(child)) visitRoute(child, parentPath);
+          if (t14.isJSXElement(child)) visitRoute(child, parentPath);
         }
         return;
       }
@@ -4833,16 +6377,16 @@ var WebNavigationAnalyzer = class {
       const fullPath = this.joinPaths(parentPath, segment, isIndex);
       const componentName = this.componentNameFromElementAttr(opening) ?? void 0;
       const isLeaf = !element.children.some(
-        (child) => t11.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
+        (child) => t14.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
       );
       if ((segment || isIndex) && (componentName || isLeaf)) {
         routes.push(this.buildRoute(fullPath, componentName, isIndex, !isLeaf));
       }
       for (const child of element.children) {
-        if (t11.isJSXElement(child)) visitRoute(child, fullPath);
+        if (t14.isJSXElement(child)) visitRoute(child, fullPath);
       }
     };
-    (0, import_traverse10.default)(ast, {
+    (0, import_traverse11.default)(ast, {
       JSXElement: (nodePath) => {
         const name = getJsxElementName(nodePath.node.openingElement);
         if (name !== "Routes" && name !== "Route") return;
@@ -4861,13 +6405,13 @@ var WebNavigationAnalyzer = class {
   /** `element={<VehicleList/>}` or `Component={VehicleList}`. */
   componentNameFromElementAttr(opening) {
     for (const attr of opening.attributes) {
-      if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
-      if (attr.name.name === "element" && t11.isJSXExpressionContainer(attr.value)) {
+      if (!t14.isJSXAttribute(attr) || !t14.isJSXIdentifier(attr.name)) continue;
+      if (attr.name.name === "element" && t14.isJSXExpressionContainer(attr.value)) {
         const expr = attr.value.expression;
-        if (t11.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
+        if (t14.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
       }
-      if (attr.name.name === "Component" && t11.isJSXExpressionContainer(attr.value)) {
-        if (t11.isIdentifier(attr.value.expression)) return attr.value.expression.name;
+      if (attr.name.name === "Component" && t14.isJSXExpressionContainer(attr.value)) {
+        if (t14.isIdentifier(attr.value.expression)) return attr.value.expression.name;
       }
     }
     return null;
@@ -4881,12 +6425,12 @@ var WebNavigationAnalyzer = class {
       "createMemoryRouter",
       "useRoutes"
     ]);
-    (0, import_traverse10.default)(ast, {
+    (0, import_traverse11.default)(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
-        if (!t11.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
+        if (!t14.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
         const first = nodePath.node.arguments[0];
-        if (!t11.isArrayExpression(first)) return;
+        if (!t14.isArrayExpression(first)) return;
         this.visitRouteObjects(first, "", routes);
       }
     });
@@ -4894,21 +6438,21 @@ var WebNavigationAnalyzer = class {
   }
   visitRouteObjects(arr, parentPath, out) {
     for (const element of arr.elements) {
-      if (!t11.isObjectExpression(element)) continue;
+      if (!t14.isObjectExpression(element)) continue;
       let segment;
       let isIndex = false;
       let componentName;
       let children;
       for (const prop of element.properties) {
-        if (!t11.isObjectProperty(prop) || !t11.isIdentifier(prop.key)) continue;
+        if (!t14.isObjectProperty(prop) || !t14.isIdentifier(prop.key)) continue;
         const key = prop.key.name;
-        if (key === "path" && t11.isStringLiteral(prop.value)) segment = prop.value.value;
-        if (key === "index" && t11.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
-        if (key === "element" && t11.isJSXElement(prop.value)) {
+        if (key === "path" && t14.isStringLiteral(prop.value)) segment = prop.value.value;
+        if (key === "index" && t14.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
+        if (key === "element" && t14.isJSXElement(prop.value)) {
           componentName = getJsxElementName(prop.value.openingElement) ?? void 0;
         }
-        if (key === "Component" && t11.isIdentifier(prop.value)) componentName = prop.value.name;
-        if (key === "children" && t11.isArrayExpression(prop.value)) children = prop.value;
+        if (key === "Component" && t14.isIdentifier(prop.value)) componentName = prop.value.name;
+        if (key === "children" && t14.isArrayExpression(prop.value)) children = prop.value;
       }
       const fullPath = this.joinPaths(parentPath, segment, isIndex);
       if ((segment !== void 0 || isIndex) && (componentName || !children)) {
@@ -4986,11 +6530,13 @@ var WebNavigationAnalyzer = class {
     return {
       screens,
       initialScreen: initialRoute?.screenName ?? "",
-      navigators: routes.length > 0 ? [{
-        name: navigatorName,
-        type: WEB_NAVIGATOR_TYPE,
-        screens: screenNames
-      }] : []
+      navigators: routes.length > 0 ? [
+        {
+          name: navigatorName,
+          type: WEB_NAVIGATOR_TYPE,
+          screens: screenNames
+        }
+      ] : []
     };
   }
 };
@@ -5067,23 +6613,23 @@ var ReactWebPlatformAnalyzer = class {
   }
   /** Replace route-path references with screen names where the route table resolves them. */
   resolveRoutePaths(screen, routes) {
-    const resolve2 = (target) => {
+    const resolve3 = (target) => {
       if (!target || !target.startsWith("/")) return target;
       return resolvePathToScreen(routes, target) ?? target;
     };
     const navigationTargets = Array.from(
       new Set(
-        screen.navigationTargets.map((target) => resolve2(target)).filter((target) => target !== screen.name)
+        screen.navigationTargets.map((target) => resolve3(target)).filter((target) => target !== screen.name)
       )
     ).sort();
     const actions = screen.actions.map((action) => {
-      const resolved = resolve2(action.targetScreen);
+      const resolved = resolve3(action.targetScreen);
       return resolved === action.targetScreen ? action : { ...action, targetScreen: resolved };
     });
     const collections = screen.collections?.map((collection) => {
       const resolveRow = (row) => {
         if (!row?.targetScreen) return row;
-        const resolved = resolve2(row.targetScreen);
+        const resolved = resolve3(row.targetScreen);
         if (resolved === row.targetScreen) return row;
         return {
           ...row,
@@ -5109,7 +6655,7 @@ var ReactWebPlatformAnalyzer = class {
 
 // src/manifest/loadManifest.ts
 var import_promises3 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"));
+var import_node_path4 = __toESM(require("path"));
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -5316,8 +6862,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t15 = typeof data;
-  switch (t15) {
+  const t18 = typeof data;
+  switch (t18) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -5589,8 +7135,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5706,11 +7252,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -9152,7 +10698,36 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-MKT45LRA.mjs
+// ../shared/dist/chunk-SWQOZWHP.mjs
+var SAFE_IMAGE_URL_RE = /^(?:https?:\/\/|data:image\/(?:png|jpe?g|gif|webp);base64,)/i;
+var HAS_SCHEME_RE = /^[\s\u0000-\u001f]*[a-z][a-z0-9+.-]*:/i;
+function isSafeImageUrl(value) {
+  if (value === null || value === void 0) return true;
+  const trimmed = value.trim();
+  if (trimmed === "") return true;
+  if (!HAS_SCHEME_RE.test(trimmed)) return true;
+  return SAFE_IMAGE_URL_RE.test(trimmed);
+}
+
+// ../shared/dist/chunk-KUMPS6RH.mjs
+var SUPPORTED_APPILOTS_LOCALES = ["pt-BR", "en", "es", "fr"];
+
+// ../shared/dist/chunk-2GTRKNPJ.mjs
+var symbols = external_exports.array(external_exports.string().max(240)).max(12);
+var controlEvidenceSchema = external_exports.object({
+  version: external_exports.literal(1),
+  siteId: external_exports.string().regex(/^[a-f0-9]{20}$/),
+  component: external_exports.string().max(240),
+  icons: symbols,
+  handler: external_exports.string().max(240).optional(),
+  calls: symbols,
+  argumentBindings: symbols,
+  conditions: symbols,
+  nativeConfirmation: external_exports.object({
+    title: external_exports.string().max(240).optional(),
+    destructiveOption: external_exports.boolean()
+  }).optional()
+});
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -9331,6 +10906,23 @@ var actionDescriptorSchema = external_exports.object({
   effect: external_exports.enum(["read", "write", "destructive"]).or(external_exports.string()).optional(),
   riskLevel: external_exports.enum(["low", "medium", "high"]).or(external_exports.string()).optional(),
   requiresConfirmation: external_exports.boolean().optional(),
+  /**
+   * How long this action's work is expected to take, in milliseconds,
+   * DECLARED by the app — not inferred (that is `appilotsInferred`).
+   *
+   * The SDK's post-action wait was a constant: 6s, or 10s when the
+   * generator could prove the handler awaits something. No constant
+   * fits, because app operations run from ~100ms to minutes, and the
+   * failure is silent in both directions — too short and the agent
+   * photographs a loading screen with no controls on it, too long and
+   * every fast press pays for the slowest one. Only the app knows.
+   *
+   * Absent means absent: the SDK keeps its current defaults, so a
+   * document generated before this field existed behaves exactly as it
+   * did. The SDK also clamps the value to its own safety ceiling — a
+   * declared budget is a request, not a licence to hang the session.
+   */
+  asyncBudgetMs: external_exports.number().int().positive().optional(),
   appilotsInferred: appilotsInferredActionSchema.optional()
 }).passthrough();
 var screenPermissionDescriptorSchema = external_exports.object({
@@ -9513,7 +11105,7 @@ var uploadMCPDocumentSchema = external_exports.object({
   version: external_exports.string().default("1.0"),
   content: external_exports.record(external_exports.unknown())
 });
-var apiKeyScopeSchema = external_exports.enum(["sdk", "operator"]);
+var apiKeyScopeSchema = external_exports.enum(["sdk", "operator", "publish"]);
 var apiKeyEnvironmentSchema = external_exports.enum(["test", "live"]);
 var createApiKeySchema = external_exports.object({
   name: external_exports.string().min(1).max(100),
@@ -9524,8 +11116,8 @@ var createApiKeySchema = external_exports.object({
   scope: apiKeyScopeSchema.default("sdk"),
   environment: apiKeyEnvironmentSchema.optional(),
   expiresAt: external_exports.string().datetime().optional()
-}).refine((v) => v.scope !== "sdk" || !!v.projectId, {
-  message: 'projectId is required for scope "sdk"',
+}).refine((v) => v.scope === "operator" || !!v.projectId, {
+  message: "projectId is required for SDK and publishing keys",
   path: ["projectId"]
 });
 var boundedString = (max) => external_exports.string().max(max);
@@ -9550,10 +11142,21 @@ var snapshotInputSchema = external_exports.object({
   type: boundedString(40).optional(),
   required: external_exports.boolean().optional(),
   invalid: external_exports.boolean().optional(),
+  /**
+   * Whether the field holds anything, as its own fact rather than an
+   * inference over `value`. The value is the user's and is the first
+   * thing a privacy policy withholds; the existence of a value is the
+   * agent's and is what stops it filling the same field twice.
+   */
+  filled: external_exports.boolean().optional(),
+  /** This input has keyboard focus right now. */
+  focused: external_exports.boolean().optional(),
   inModal: external_exports.boolean().optional()
 }).passthrough();
 var snapshotButtonSchema = external_exports.object({
+  controlEvidence: controlEvidenceSchema.optional(),
   id: boundedString(160).optional(),
+  dispatchable: external_exports.boolean().optional(),
   provenance: identityProvenanceSchema.optional(),
   /**
    * False when the control is mounted but currently OUTSIDE the window —
@@ -9614,7 +11217,36 @@ var snapshotListSchema = external_exports.object({
    */
   source: boundedString(40).optional(),
   itemCount: external_exports.number().int().optional(),
+  /**
+   * Size of the whole collection when the app declared it, for a list
+   * that is a WINDOW onto more data than it holds.
+   *
+   * `itemCount` is how many rows the list is rendering from and
+   * `visibleItemCount` how many of those are mounted; neither can
+   * express "there are 36 and you are looking at the first 20",
+   * because a paginated list's `data` is the page. Absent means
+   * unknown — never "same as itemCount".
+   */
+  totalItemCount: external_exports.number().int().optional(),
   visibleItemCount: external_exports.number().int().optional(),
+  viewportItemCount: external_exports.number().int().nonnegative().optional(),
+  exploration: external_exports.object({
+    revision: external_exports.number().int().nonnegative(),
+    observedItemCount: external_exports.number().int().min(0).max(5e3),
+    observedRanges: external_exports.array(
+      external_exports.object({
+        start: external_exports.number().int().nonnegative(),
+        end: external_exports.number().int().nonnegative()
+      })
+    ).max(32),
+    rangesTruncated: external_exports.boolean(),
+    coverage: external_exports.enum(["partial", "all-loaded"]),
+    pagination: external_exports.enum(["possible", "not-declared"]),
+    scrollSteps: external_exports.number().int().nonnegative(),
+    remainingScrollSteps: external_exports.number().int().nonnegative(),
+    consecutiveNoProgress: external_exports.number().int().nonnegative(),
+    lastScroll: external_exports.enum(["moved", "no-progress", "boundary", "unverified"]).optional()
+  }).optional(),
   refreshing: external_exports.boolean().optional(),
   empty: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
@@ -9662,6 +11294,7 @@ var snapshotChoiceGroupSchema = external_exports.object({
 }).passthrough();
 var snapshotElementSchema = external_exports.object({
   id: boundedString(160).optional(),
+  dispatchable: external_exports.boolean().optional(),
   role: boundedString(40).optional(),
   label: boundedString(300).optional(),
   texts: external_exports.array(boundedString(500)).max(50).optional(),
@@ -9705,6 +11338,34 @@ var agentSnapshotSchema = external_exports.object({
    * it. Optional: older SDKs never clamp and never send it.
    */
   truncated: external_exports.boolean().optional(),
+  /**
+   * What moved since the previous observation, computed on the device
+   * because that is the only side holding both snapshots.
+   *
+   * Shape only — counts, booleans, and ids the app declared itself — so
+   * it survives an observation whose content was withheld. ABSENT means
+   * there was no previous observation to compare against; `unchanged:
+   * true` means we compared and nothing moved, which is the strongest
+   * evidence available that an action did nothing. The two must not be
+   * collapsed, for the same reason `truncated` exists.
+   */
+  delta: external_exports.object({
+    routeChanged: external_exports.boolean().optional(),
+    modalOpened: external_exports.boolean().optional(),
+    modalClosed: external_exports.boolean().optional(),
+    loadingStarted: external_exports.boolean().optional(),
+    loadingFinished: external_exports.boolean().optional(),
+    textsAdded: external_exports.number().int().nonnegative().optional(),
+    textsRemoved: external_exports.number().int().nonnegative().optional(),
+    buttonsAddedIndices: external_exports.array(external_exports.number().int().nonnegative()).max(12).optional(),
+    buttonsRemoved: external_exports.number().int().nonnegative().optional(),
+    visibleRowsDelta: external_exports.number().int().optional(),
+    totalRowsDelta: external_exports.number().int().optional(),
+    fieldsNewlyFilled: external_exports.array(boundedString(160)).max(12).optional(),
+    fieldsCleared: external_exports.array(boundedString(160)).max(12).optional(),
+    invalidAppeared: external_exports.boolean().optional(),
+    unchanged: external_exports.boolean().optional()
+  }).passthrough().optional(),
   /**
    * How many of this screen's controls the client could name, split by
    * `identityProvenance`. Diagnostic only — the relay never grounds an
@@ -9723,6 +11384,10 @@ var agentSnapshotSchema = external_exports.object({
   }).passthrough().optional()
 }).passthrough();
 var agentContextSchema = external_exports.object({
+  missionProtocol: external_exports.literal(1).optional(),
+  missionId: boundedString(160).optional(),
+  /** Preferred supported device language, reported by the SDK independently of map/UI labels. */
+  deviceLocale: external_exports.enum(SUPPORTED_APPILOTS_LOCALES).optional(),
   /**
    * Client platform this observation was captured on. Optional and
    * additive (see `clientPlatformSchema`) — absent means
@@ -9738,7 +11403,19 @@ var agentContextSchema = external_exports.object({
     rootRouteNames: external_exports.array(boundedString(200)).max(200).optional(),
     currentRouteNames: external_exports.array(boundedString(200)).max(200).optional(),
     routeNames: external_exports.array(boundedString(200)).max(500).optional(),
-    canGoBack: external_exports.boolean().optional()
+    canGoBack: external_exports.boolean().optional(),
+    /**
+     * The stack a back press pops through, oldest first, ending on
+     * the current screen. `canGoBack` says a back exists; this says
+     * where it goes.
+     */
+    backStack: external_exports.array(boundedString(200)).max(50).optional(),
+    /**
+     * Screens the session has been on, oldest first. Names only —
+     * params carry record ids and often personal data, and a route
+     * name is structure.
+     */
+    visited: external_exports.array(boundedString(200)).max(8).optional()
   }).passthrough().optional(),
   screenMetadata: external_exports.object({
     name: boundedString(200).optional(),
@@ -9844,7 +11521,7 @@ var formFillPayloadSchema = external_exports.object({
   submitAfterFill: external_exports.boolean().optional()
 }).passthrough();
 var uiInteractionPayloadSchema = external_exports.object({
-  action: external_exports.enum(["press", "longPress", "scroll", "swipe", "focus", "set_value"]).default("press").optional(),
+  action: external_exports.enum(["press", "longPress", "toggle", "scroll", "swipe", "focus", "set_value"]).default("press").optional(),
   // `targetId` is the canonical server/LLM field. SDK runtimes still
   // accept `componentId` as a compatibility alias.
   targetId: external_exports.string().min(1),
@@ -9961,6 +11638,12 @@ var actionDiagnoseSchema = external_exports.object({
   requiresUserInput: external_exports.boolean().optional()
 });
 var actionResultSchema = external_exports.object({
+  nativeConfirmation: external_exports.object({
+    title: external_exports.string().max(300),
+    message: external_exports.string().max(1e3).optional(),
+    buttonLabel: external_exports.string().max(160).optional(),
+    handlerCompleted: external_exports.boolean()
+  }).optional(),
   actionId: external_exports.string(),
   type: external_exports.string(),
   success: external_exports.boolean(),
@@ -10012,8 +11695,15 @@ var continueAgentSchema = external_exports.object({
   // issue #169 — the observation the server grounds targets against, now
   // validated + bounded at the border instead of z.record(z.unknown()).
   context: agentContextSchema.optional(),
-  /** Hop counter — server enforces a cap to prevent runaway loops */
-  hop: external_exports.number().int().min(1).max(10).optional()
+  /**
+   * Hop counter — server enforces a cap to prevent runaway loops.
+   * The max here must stay ABOVE the server's `MAX_AGENT_HOPS` (10 since
+   * #503, apps/api/src/modules/agents/routes.ts): the first over-budget
+   * hop has to get through validation so the route can answer it with
+   * the friendly automation-limit message instead of a 422. The +3
+   * headroom mirrors what 7/10 was before the recalibration.
+   */
+  hop: external_exports.number().int().min(1).max(13).optional()
 });
 var agentAccessLevelSchema = external_exports.enum(["read", "write", "none"]);
 var screenPermissionSchema = external_exports.object({
@@ -10081,7 +11771,7 @@ var updateProjectBudgetSchema = external_exports.object({
   /** null = remove webhook, undefined = leave unchanged. */
   budgetWebhookUrl: external_exports.string().url().nullable().optional()
 }).strict();
-var localeSchema = external_exports.enum(["pt-BR", "en", "es"]);
+var localeSchema = external_exports.enum(SUPPORTED_APPILOTS_LOCALES);
 var hexColorSchema = external_exports.string().regex(/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
   message: "Must be a hex color like #6366f1"
 });
@@ -10119,15 +11809,18 @@ var themeTokensSchema = external_exports.object({
    */
   mode: external_exports.enum(["auto", "light", "dark"]).optional()
 }).strict();
+var imageSourceField = external_exports.string().max(500).refine(isSafeImageUrl, {
+  message: "Only http(s) URLs, base64 image data URIs, emoji or asset ids are allowed here"
+});
 var projectPersonalizationSchema = external_exports.object({
   /** Tone / persona instructions appended to the system prompt. */
   personaPrompt: external_exports.string().max(2048).nullable(),
   /** Display name in the chat header (e.g. "Aria"). */
   assistantName: external_exports.string().max(60).nullable(),
   /** URL or remote asset id for the avatar shown next to assistant turns. */
-  assistantAvatar: external_exports.string().max(500).nullable(),
+  assistantAvatar: imageSourceField.nullable(),
   /** Emoji or image URL for the empty-state icon. Auto-detected by prefix. */
-  emptyStateIcon: external_exports.string().max(500).nullable(),
+  emptyStateIcon: imageSourceField.nullable(),
   /** First-message text shown in the empty state. */
   welcomeMessage: external_exports.string().max(500).nullable(),
   /** Title rendered at the top of the chat. */
@@ -10141,20 +11834,20 @@ var projectPersonalizationSchema = external_exports.object({
   /** Chat-open FAB background color. Null falls back to theme.colors.primary. */
   triggerButtonColor: hexColorSchema.nullable(),
   /** Image URL rendered inside the FAB instead of the default chat-bubble icon. */
-  triggerButtonImageUrl: external_exports.string().max(500).nullable()
+  triggerButtonImageUrl: imageSourceField.nullable()
 });
 var updateProjectPersonalizationSchema = external_exports.object({
   personaPrompt: external_exports.string().max(2048).nullable().optional(),
   assistantName: external_exports.string().max(60).nullable().optional(),
-  assistantAvatar: external_exports.string().max(500).nullable().optional(),
-  emptyStateIcon: external_exports.string().max(500).nullable().optional(),
+  assistantAvatar: imageSourceField.nullable().optional(),
+  emptyStateIcon: imageSourceField.nullable().optional(),
   welcomeMessage: external_exports.string().max(500).nullable().optional(),
   chatTitle: external_exports.string().max(60).nullable().optional(),
   poweredByVisible: external_exports.boolean().optional(),
   theme: themeTokensSchema.nullable().optional(),
   defaultLocale: localeSchema.nullable().optional(),
   triggerButtonColor: hexColorSchema.nullable().optional(),
-  triggerButtonImageUrl: external_exports.string().max(500).nullable().optional()
+  triggerButtonImageUrl: imageSourceField.nullable().optional()
 }).strict();
 var sandboxObservationSchema = external_exports.object({
   route: external_exports.string().max(200).optional(),
@@ -10174,7 +11867,19 @@ var sandboxObservationSchema = external_exports.object({
       type: external_exports.string().max(40).optional(),
       placeholder: external_exports.string().max(200).optional(),
       /** Inline validation state (SDK snapshot field). */
-      invalid: external_exports.boolean().optional()
+      invalid: external_exports.boolean().optional(),
+      /**
+       * Whether the field holds anything, as its own fact rather than
+       * an inference over `value`.
+       *
+       * Here because the eval posts through this schema: a fact the
+       * SDK produces and this contract has no word for is a fact the
+       * corpus can never grade the agent on. `invalid` and `required`
+       * were already here; these two were the half that was missing.
+       */
+      filled: external_exports.boolean().optional(),
+      /** This input has keyboard focus right now. */
+      focused: external_exports.boolean().optional()
     })
   ).max(100).optional(),
   buttons: external_exports.array(
@@ -10632,7 +12337,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = import_node_path2.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = import_node_path4.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await (0, import_promises3.readFile)(resolvedPath, "utf-8");
@@ -10781,7 +12486,7 @@ var MCPGenerator = class _MCPGenerator {
     const agentReadyScreens = mergedScreens.map(
       (screen) => enrichScreenForAgent({
         ...screen,
-        filePath: screen.filePath ? import_node_path3.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
+        filePath: screen.filePath ? import_node_path5.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
       })
     );
     const projectInfo = await this.getProjectInfo();
@@ -10805,19 +12510,33 @@ var MCPGenerator = class _MCPGenerator {
       }
     };
     const serialized = JSON.stringify(document, null, 2);
-    const checksum = this.calculateChecksum(serialized);
-    const filePath = import_node_path3.default.resolve(outputDir, `mcp-document.${this.options.format}`);
+    const checksum = this.calculateChecksum(serializeForChecksum(document));
+    const filePath = import_node_path5.default.resolve(outputDir, `mcp-document.${this.options.format}`);
     await (0, import_promises4.writeFile)(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
+    const controlFiles = analyzed.controlEvidenceFiles ?? {};
+    await (0, import_promises4.writeFile)(
+      import_node_path5.default.resolve(outputDir, "control-evidence.json"),
+      JSON.stringify({ version: 1, files: controlFiles }, null, 2),
+      "utf-8"
+    );
+    const checksumFilePath = import_node_path5.default.resolve(outputDir, ".appilots-checksum");
     await (0, import_promises4.writeFile)(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
+    const evidenceCount = Object.values(controlFiles).reduce(
+      (sum, entries) => sum + entries.length,
+      0
+    );
+    console.log(
+      `[MCPGenerator] Source evidence: ${evidenceCount} icon controls across ${Object.keys(controlFiles).length} files (runtime binding required)`
+    );
     console.log("[MCPGenerator] Generation complete!");
     return {
       document,
       filePath,
       format: this.options.format,
-      checksum
+      checksum,
+      ...analyzed.diagnostics ? { diagnostics: analyzed.diagnostics } : {}
     };
   }
   /**
@@ -10829,7 +12548,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = import_node_path5.default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await (0, import_promises4.readFile)(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -10841,14 +12560,14 @@ var MCPGenerator = class _MCPGenerator {
    * Calculate SHA-256 checksum of content
    */
   calculateChecksum(content) {
-    return (0, import_node_crypto.createHash)("sha256").update(content).digest("hex");
+    return (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex");
   }
   /**
    * Get project name and version from package.json in rootDir
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = import_node_path3.default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = import_node_path5.default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -10923,8 +12642,8 @@ function reportMetadataLint(document, strict) {
 }
 
 // src/cli/utils/remote-drift.ts
-var import_node_fs = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path6 = require("path");
 var STUB_RATIO = 0.5;
 function compareWithRemote(local, remote) {
   if (remote.screensCount === local.screens) return null;
@@ -10937,7 +12656,7 @@ function compareWithRemote(local, remote) {
 }
 function readLocalDocumentSummary(outputDir) {
   try {
-    const raw = (0, import_node_fs.readFileSync)((0, import_node_path4.join)(outputDir, "mcp-document.json"), "utf-8");
+    const raw = (0, import_node_fs3.readFileSync)((0, import_node_path6.join)(outputDir, "mcp-document.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.metadata?.totalScreens !== "number") return null;
     return { screens: parsed.metadata.totalScreens };
@@ -11022,14 +12741,18 @@ function assertDocumentHasScreens(document, options = {}) {
   }
   error("No screens found \u2014 this application map would give the agent nothing to navigate.");
   info("");
-  info("The analyzer looks for React Navigation: a <NavigationContainer> and");
-  info("<Stack.Screen> / <Tab.Screen> declarations. It found none.");
+  info("The analyzer reads React Navigation \u2014 <X.Navigator> JSX and the static");
+  info("`createXNavigator({ screens })` config \u2014 and Expo Router directory trees.");
+  info("It found no screen in any of them.");
   info("");
   info("The two usual causes:");
-  info("  \u2022 The app uses Expo Router (or another file-based router). It is the");
-  info("    default for `npx create-expo-app` and the analyzer cannot read it.");
-  info("  \u2022 The screens live outside the analyzed paths \u2014 check `include`,");
-  info("    `exclude` and `screenPatterns` in your Appilots config.");
+  info("  \u2022 The screens live outside the analyzed paths, or are named in a way");
+  info("    the screen filter does not match \u2014 check `include`, `exclude` and");
+  info("    `screenPatterns` in your Appilots config. The scan summary printed");
+  info("    above says how many files were reached and how many were filtered.");
+  info("  \u2022 The app uses a router the analyzer does not read yet, such as");
+  info("    react-native-navigation (Wix). Declaring the screens works for any");
+  info("    router \u2014 see the escape hatch below.");
   info("");
   info("The escape hatch, which works for any router: declare your screens in");
   info("an `appilots.manifest.json` at the project root. Its screens are merged");
@@ -11076,7 +12799,7 @@ function syncCommand() {
       const outputDir = config.outputDir || ".appilots";
       let previousChecksum = "";
       try {
-        const checksumPath = (0, import_node_path5.join)(outputDir, ".appilots-checksum");
+        const checksumPath = (0, import_node_path7.join)(outputDir, ".appilots-checksum");
         previousChecksum = (await (0, import_promises5.readFile)(checksumPath, "utf-8")).trim();
       } catch {
       }
@@ -11203,7 +12926,7 @@ function syncCommand() {
 
 // src/cli/commands/watch.ts
 var import_commander3 = require("commander");
-var import_node_fs2 = require("fs");
+var import_node_fs4 = require("fs");
 function watchCommand() {
   return new import_commander3.Command("watch").description("Watch project for changes and auto-sync MCP documents").option("--verbose", "Enable verbose logging", false).action(async (options) => {
     try {
@@ -11250,7 +12973,7 @@ function watchCommand() {
       dim("Press Ctrl+C to stop\n");
       let debounceTimer = null;
       const DEBOUNCE_MS = 500;
-      const watcher = (0, import_node_fs2.watch)(process.cwd(), { recursive: true }, async (eventType, filename) => {
+      const watcher = (0, import_node_fs4.watch)(process.cwd(), { recursive: true }, async (eventType, filename) => {
         if (!filename) return;
         if (filename.startsWith(".") || filename.includes("node_modules") || filename.includes(config.outputDir || ".appilots")) {
           return;
@@ -11302,6 +13025,95 @@ function watchCommand() {
 
 // src/cli/commands/generate.ts
 var import_commander4 = require("commander");
+
+// src/cli/utils/reach-report.ts
+function actionableScreens(document) {
+  return (document.screens ?? []).filter(
+    (screen) => (screen.actions?.length ?? 0) > 0 || (screen.forms?.length ?? 0) > 0 || (screen.targets?.length ?? 0) > 0
+  ).length;
+}
+function pct(part, whole) {
+  if (whole <= 0) return "\u2014";
+  return `${Math.round(100 * part / whole)}%`;
+}
+function reportReach(input) {
+  const { document, navigation } = input;
+  const screens = document.screens?.length ?? 0;
+  const useful = actionableScreens(document);
+  const filteredOut = document.metadata?.screensFilteredOut ?? 0;
+  info("");
+  info("Alcance da varredura");
+  info(
+    `  telas          ${screens} de ${document.metadata?.analyzedFiles ?? 0} arquivos analisados` + (filteredOut > 0 ? `, ${filteredOut} fora pelo filtro de tela` : "")
+  );
+  info(`  com aford\xE2ncia ${useful} (${pct(useful, screens)}) \u2014 a\xE7\xE3o, formul\xE1rio ou target`);
+  if (navigation) {
+    info(
+      `  navega\xE7\xE3o      ${navigation.filesWithEvidence} de ${navigation.filesScanned} arquivos com evid\xEAncia, ${navigation.navigatorsWithJsx} navegador(es) no documento`
+    );
+    info(
+      `  rotas          ${navigation.routes}, ${navigation.routesLinkedToFile} (${pct(navigation.routesLinkedToFile, navigation.routes)}) ligadas a um arquivo de tela`
+    );
+    if (navigation.fileBasedRouter) {
+      info(
+        `  roteador       ${navigation.fileBasedRouter.kind} em "${navigation.fileBasedRouter.routeDir}"`
+      );
+    }
+  }
+  const notes = [];
+  if (navigation && navigation.routes > 0 && useful > navigation.routes * 5) {
+    notes.push([
+      `${useful} tela(s) com aford\xE2ncia para apenas ${navigation.routes} rota(s).`,
+      "A varredura achou o que tocar em muito mais lugares do que sabe alcan\xE7ar.",
+      `S\xF3 ${navigation.filesWithEvidence} de ${navigation.filesScanned} arquivos varridos mencionam navega\xE7\xE3o \u2014`,
+      "se o roteador deste app mora fora deles, `navigationInclude` no `.appilotsrc`",
+      "estende a varredura sem mexer no resto."
+    ]);
+  }
+  if (navigation && navigation.routes === 0 && useful > 0) {
+    notes.push([
+      `${useful} tela(s) com aford\xE2ncia e nenhuma rota: o agente v\xEA o que tocar e n\xE3o sabe chegar l\xE1.`,
+      "O extractor l\xEA React Navigation (JSX e configura\xE7\xE3o est\xE1tica) e expo-router.",
+      "Se o app usa outro roteador, declare as telas em `appilots.manifest.json` \u2014",
+      "elas s\xE3o mescladas por cima do que a an\xE1lise achou."
+    ]);
+  } else if (navigation && navigation.routes > 0 && navigation.routesLinkedToFile < navigation.routes / 2) {
+    notes.push([
+      `${navigation.routes - navigation.routesLinkedToFile} de ${navigation.routes} rotas n\xE3o dizem qual arquivo montam.`,
+      "A liga\xE7\xE3o vem de `component={X}`. Formas indiretas \u2014 `getComponent={() => X}`,",
+      "componente constru\xEDdo em runtime \u2014 n\xE3o resolvem, e o agente fica com destinos vazios."
+    ]);
+  }
+  if (screens > 0 && useful === 0) {
+    notes.push([
+      `${screens} tela(s) encontradas e nenhuma com aford\xE2ncia.`,
+      "O extractor mira `onPress`/`onChangeText` com um locator endere\xE7\xE1vel:",
+      "`testID`, `appilotsId`, `accessibilityLabel` ou r\xF3tulo literal.",
+      "Sem nenhum deles n\xE3o h\xE1 como o agente apontar para o elemento."
+    ]);
+  }
+  if (filteredOut > 0 && screens > 0 && filteredOut > screens * 9) {
+    notes.push([
+      `${filteredOut} arquivos ficaram fora do filtro de tela para ${screens} dentro.`,
+      "Se as telas deste app moram noutro lugar, uma linha de `screenPatterns` no",
+      "`.appilotsrc` aponta onde \u2014 \xE9 o degrau mais barato da escada."
+    ]);
+  }
+  if (navigation && navigation.filesScanned > 0 && navigation.filesWithEvidence === 0) {
+    notes.push([
+      `Nenhum dos ${navigation.filesScanned} arquivos varridos menciona navega\xE7\xE3o.`,
+      "Confira `include`/`exclude` no `.appilotsrc`: o extractor pode n\xE3o estar",
+      "alcan\xE7ando o diret\xF3rio onde o roteador \xE9 declarado."
+    ]);
+  }
+  for (const note of notes) {
+    info("");
+    warn(note[0]);
+    for (const line of note.slice(1)) info(`  ${line}`);
+  }
+}
+
+// src/cli/commands/generate.ts
 function generateCommand() {
   return new import_commander4.Command("generate").description("Generate MCP documents from project source (local only)").option("-o, --output <path>", "Output directory for MCP documents", ".appilots").option("-f, --format <format>", "Output format (only json supported)", "json").option(
     "--strict-metadata",
@@ -11318,7 +13130,7 @@ function generateCommand() {
       spinner.start();
       let loaded = null;
       try {
-        loaded = loadConfig(warn);
+        loaded = loadConfig(warn, { requireApiKey: false });
       } catch {
         loaded = null;
       }
@@ -11326,11 +13138,21 @@ function generateCommand() {
         rootDir: process.cwd(),
         outputDir: options.output || ".appilots",
         format: "json",
+        strictScreens: loaded?.strictScreens,
+        screenPatterns: loaded?.screenPatterns,
+        include: loaded?.include,
+        exclude: loaded?.exclude,
+        navigationInclude: loaded?.navigationInclude,
+        navigationExclude: loaded?.navigationExclude,
         platform: loaded?.platform,
         manifestPath: loaded?.manifestPath
       });
       const output = await generator.generate();
       spinner.stop();
+      reportReach({
+        document: output.document,
+        ...output.diagnostics?.navigation ? { navigation: output.diagnostics.navigation } : {}
+      });
       assertDocumentHasScreens(output.document, {
         rootDir: process.cwd(),
         allowEmpty: Boolean(options.allowEmpty)
@@ -11350,20 +13172,19 @@ function generateCommand() {
 
 // src/cli/commands/annotate.ts
 var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"));
+var import_node_path9 = __toESM(require("path"));
 var import_commander5 = require("commander");
-var import_fast_glob6 = __toESM(require("fast-glob"));
 
 // src/annotate/sites.ts
-var import_traverse12 = __toESM(require("@babel/traverse"));
-var t13 = __toESM(require("@babel/types"));
+var import_traverse13 = __toESM(require("@babel/traverse"));
+var t16 = __toESM(require("@babel/types"));
 
 // src/annotate/forwarding.ts
-var import_node_path6 = __toESM(require("path"));
-var import_node_fs3 = require("fs");
-var import_traverse11 = __toESM(require("@babel/traverse"));
-var t12 = __toESM(require("@babel/types"));
-var traverse11 = import_traverse11.default.default ?? import_traverse11.default;
+var import_node_path8 = __toESM(require("path"));
+var import_node_fs5 = require("fs");
+var import_traverse12 = __toESM(require("@babel/traverse"));
+var t15 = __toESM(require("@babel/types"));
+var traverse12 = import_traverse12.default.default ?? import_traverse12.default;
 var RN_TESTID_CARRIERS = /* @__PURE__ */ new Set([
   "View",
   "Text",
@@ -11390,14 +13211,14 @@ var RN_TESTID_CARRIERS = /* @__PURE__ */ new Set([
 ]);
 function collectImports(ast) {
   const out = /* @__PURE__ */ new Map();
-  traverse11(ast, {
+  traverse12(ast, {
     ImportDeclaration(nodePath) {
       const source = nodePath.node.source.value;
       for (const spec of nodePath.node.specifiers) {
-        if (t12.isImportSpecifier(spec)) {
-          const imported = t12.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+        if (t15.isImportSpecifier(spec)) {
+          const imported = t15.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
           out.set(spec.local.name, { source, local: spec.local.name, imported });
-        } else if (t12.isImportDefaultSpecifier(spec)) {
+        } else if (t15.isImportDefaultSpecifier(spec)) {
           out.set(spec.local.name, { source, local: spec.local.name, imported: "default" });
         }
       }
@@ -11405,17 +13226,17 @@ function collectImports(ast) {
   });
   return out;
 }
-var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
 function resolveRelativeImport(fromFile, source) {
   if (!source.startsWith(".")) return void 0;
-  const base = import_node_path6.default.resolve(import_node_path6.default.dirname(fromFile), source);
-  for (const ext of EXTENSIONS) {
+  const base = import_node_path8.default.resolve(import_node_path8.default.dirname(fromFile), source);
+  for (const ext of EXTENSIONS2) {
     const candidate = `${base}${ext}`;
-    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs5.existsSync)(candidate)) return candidate;
   }
-  for (const ext of EXTENSIONS) {
-    const candidate = import_node_path6.default.join(base, `index${ext}`);
-    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+  for (const ext of EXTENSIONS2) {
+    const candidate = import_node_path8.default.join(base, `index${ext}`);
+    if ((0, import_node_fs5.existsSync)(candidate)) return candidate;
   }
   return void 0;
 }
@@ -11430,7 +13251,7 @@ function inspectModule(file2, exportName, depth = 0) {
   if (depth > 2) return none;
   let source;
   try {
-    source = (0, import_node_fs3.readFileSync)(file2, "utf-8");
+    source = (0, import_node_fs5.readFileSync)(file2, "utf-8");
   } catch {
     return none;
   }
@@ -11445,13 +13266,13 @@ function inspectModule(file2, exportName, depth = 0) {
   let forwards = false;
   let derives = false;
   let barrelTarget;
-  traverse11(ast, {
+  traverse12(ast, {
     // `export { Card } from './Card'` — follow one hop.
     ExportNamedDeclaration(nodePath) {
       const from = nodePath.node.source?.value;
       if (!from) return;
       const named = nodePath.node.specifiers.some(
-        (spec) => t12.isExportSpecifier(spec) && (t12.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === exportName
+        (spec) => t15.isExportSpecifier(spec) && (t15.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === exportName
       );
       if (named) barrelTarget = from;
     },
@@ -11460,11 +13281,11 @@ function inspectModule(file2, exportName, depth = 0) {
     },
     // `interface CardProps { testID?: string }` / `type Props = { testID… }`
     TSPropertySignature(nodePath) {
-      if (t12.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
+      if (t15.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
     },
     // `function Card({ testID }) {}` — the destructured parameter.
     ObjectProperty(nodePath) {
-      if (t12.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
+      if (t15.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
     },
     // `<View {...props} />` — anything spread onto JSX carries it along.
     JSXSpreadAttribute() {
@@ -11475,17 +13296,17 @@ function inspectModule(file2, exportName, depth = 0) {
     // that is one hardcoded name shared by every instance, which is the
     // duplicate-id problem rather than a solution to it.
     JSXAttribute(nodePath) {
-      const name = t12.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
+      const name = t15.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
       if (name !== "testID" && name !== "accessibilityLabel") return;
       const value = nodePath.node.value;
-      if (!t12.isJSXExpressionContainer(value)) return;
-      if (t12.isStringLiteral(value.expression)) return;
+      if (!t15.isJSXExpressionContainer(value)) return;
+      if (t15.isStringLiteral(value.expression)) return;
       derives = true;
     },
     // `useAppilotsTarget(`${groupId}-${option.value}`, …)`
     CallExpression(nodePath) {
       const callee = nodePath.node.callee;
-      if (t12.isIdentifier(callee) && IDENTITY_HOOKS.has(callee.name)) derives = true;
+      if (t15.isIdentifier(callee) && IDENTITY_HOOKS.has(callee.name)) derives = true;
     }
   });
   if (forwards || derives) return { forwards, derives };
@@ -11519,7 +13340,7 @@ function resetForwardingCache() {
 }
 
 // src/annotate/sites.ts
-var traverse12 = import_traverse12.default.default ?? import_traverse12.default;
+var traverse13 = import_traverse13.default.default ?? import_traverse13.default;
 var LABEL_PROPS = ["title", "label", "placeholder"];
 var IDENTITY_PROPS = ["testID", "appilotsId", "accessibilityLabel"];
 function kebab(text) {
@@ -11570,18 +13391,18 @@ function hasLabelText(element) {
 function namedHandler(element, prop) {
   if (!prop) return void 0;
   const attr = findJsxAttribute(element, prop);
-  if (!attr || !t13.isJSXExpressionContainer(attr.value)) return void 0;
-  return t13.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
+  if (!attr || !t16.isJSXExpressionContainer(attr.value)) return void 0;
+  return t16.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
 }
 var ANNOTATABLE_ROLES = /* @__PURE__ */ new Set(["button", "input", "select", "toggle", "date", "list"]);
 function isPerItemRender(nodePath) {
   let current = nodePath.parentPath;
   while (current) {
     const node = current.node;
-    if (t13.isCallExpression(node) && t13.isMemberExpression(node.callee) && t13.isIdentifier(node.callee.property) && (node.callee.property.name === "map" || node.callee.property.name === "flatMap")) {
+    if (t16.isCallExpression(node) && t16.isMemberExpression(node.callee) && t16.isIdentifier(node.callee.property) && (node.callee.property.name === "map" || node.callee.property.name === "flatMap")) {
       return true;
     }
-    if (t13.isJSXAttribute(node) && t13.isJSXIdentifier(node.name) && /^render[A-Z]|^ListHeaderComponent$|^ListFooterComponent$/.test(node.name.name) && node.name.name !== "renderScrollComponent") {
+    if (t16.isJSXAttribute(node) && t16.isJSXIdentifier(node.name) && /^render[A-Z]|^ListHeaderComponent$|^ListFooterComponent$/.test(node.name.name) && node.name.name !== "renderScrollComponent") {
       return /^renderItem$|^renderSectionHeader$|^renderSectionFooter$/.test(node.name.name);
     }
     current = current.parentPath;
@@ -11600,7 +13421,7 @@ function findAnnotationSites(source, file2) {
   const sites = [];
   const perComponent = /* @__PURE__ */ new Map();
   const usedIds = /* @__PURE__ */ new Set();
-  traverse12(ast, {
+  traverse13(ast, {
     JSXOpeningElement(nodePath) {
       for (const prop of IDENTITY_PROPS) {
         const existing = getStringAttr(nodePath.node, prop);
@@ -11608,10 +13429,10 @@ function findAnnotationSites(source, file2) {
       }
     }
   });
-  traverse12(ast, {
+  traverse13(ast, {
     JSXOpeningElement(nodePath) {
       const element = nodePath.node;
-      if (!t13.isJSXIdentifier(element.name)) return;
+      if (!t16.isJSXIdentifier(element.name)) return;
       const component = element.name.name;
       const role = classifyJsxComponent(component, element);
       if (!ANNOTATABLE_ROLES.has(role)) return;
@@ -11693,23 +13514,23 @@ function applyToFile(source, sites) {
 }
 
 // src/annotate/forward.ts
-var import_node_fs4 = require("fs");
+var import_node_fs6 = require("fs");
 var import_magic_string2 = __toESM(require("magic-string"));
-var import_traverse13 = __toESM(require("@babel/traverse"));
-var t14 = __toESM(require("@babel/types"));
-var traverse13 = import_traverse13.default.default ?? import_traverse13.default;
+var import_traverse14 = __toESM(require("@babel/traverse"));
+var t17 = __toESM(require("@babel/types"));
+var traverse14 = import_traverse14.default.default ?? import_traverse14.default;
 function findComponent(ast, name) {
   let found;
-  traverse13(ast, {
+  traverse14(ast, {
     FunctionDeclaration(nodePath) {
       if (nodePath.node.id?.name === name) {
         found ??= { params: nodePath.node.params, body: nodePath.node.body };
       }
     },
     VariableDeclarator(nodePath) {
-      if (!t14.isIdentifier(nodePath.node.id) || nodePath.node.id.name !== name) return;
+      if (!t17.isIdentifier(nodePath.node.id) || nodePath.node.id.name !== name) return;
       const init = nodePath.node.init;
-      if (t14.isArrowFunctionExpression(init) || t14.isFunctionExpression(init)) {
+      if (t17.isArrowFunctionExpression(init) || t17.isFunctionExpression(init)) {
         found ??= { params: init.params, body: init.body };
       }
     }
@@ -11721,26 +13542,26 @@ function findReturnedRoots(body) {
   let unsupported = false;
   const record = (node) => {
     if (!node) return;
-    if (t14.isParenthesizedExpression(node)) return record(node.expression);
-    if (t14.isJSXElement(node)) {
+    if (t17.isParenthesizedExpression(node)) return record(node.expression);
+    if (t17.isJSXElement(node)) {
       roots.push(node.openingElement);
       return;
     }
-    if (t14.isConditionalExpression(node)) {
+    if (t17.isConditionalExpression(node)) {
       record(node.consequent);
       record(node.alternate);
       return;
     }
-    if (t14.isJSXFragment(node)) {
+    if (t17.isJSXFragment(node)) {
       unsupported = true;
       return;
     }
-    if (t14.isNullLiteral(node)) return;
+    if (t17.isNullLiteral(node)) return;
     unsupported = true;
   };
-  if (t14.isBlockStatement(body)) {
-    traverse13(
-      t14.file(t14.program([t14.expressionStatement(t14.functionExpression(null, [], body))])),
+  if (t17.isBlockStatement(body)) {
+    traverse14(
+      t17.file(t17.program([t17.expressionStatement(t17.functionExpression(null, [], body))])),
       {
         ReturnStatement(nodePath) {
           record(nodePath.node.argument);
@@ -11754,7 +13575,7 @@ function findReturnedRoots(body) {
   return roots;
 }
 function isCarrierRoot(element, imports) {
-  if (!t14.isJSXIdentifier(element.name)) return false;
+  if (!t17.isJSXIdentifier(element.name)) return false;
   const name = element.name.name;
   const origin = imports.get(name);
   if (origin?.source !== "react-native") return false;
@@ -11762,7 +13583,7 @@ function isCarrierRoot(element, imports) {
 }
 function hasProp(element, name) {
   return element.attributes.some(
-    (attr) => t14.isJSXAttribute(attr) && t14.isJSXIdentifier(attr.name) && attr.name.name === name
+    (attr) => t17.isJSXAttribute(attr) && t17.isJSXIdentifier(attr.name) && attr.name.name === name
   );
 }
 function indentOf(source, offset) {
@@ -11788,12 +13609,12 @@ ${indent}${text}` };
 }
 function followBarrel(file2, ast, component) {
   let target;
-  traverse13(ast, {
+  traverse14(ast, {
     ExportNamedDeclaration(nodePath) {
       const from = nodePath.node.source?.value;
       if (!from) return;
       const named = nodePath.node.specifiers.some(
-        (spec) => t14.isExportSpecifier(spec) && (t14.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === component
+        (spec) => t17.isExportSpecifier(spec) && (t17.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === component
       );
       if (named) target ??= from;
     }
@@ -11804,7 +13625,7 @@ function planForward(file2, component, depth = 0) {
   const base = { file: file2, component, edits: [], roots: 0 };
   let source;
   try {
-    source = (0, import_node_fs4.readFileSync)(file2, "utf-8");
+    source = (0, import_node_fs6.readFileSync)(file2, "utf-8");
   } catch {
     return { ...base, refusal: `cannot read ${file2}` };
   }
@@ -11821,7 +13642,7 @@ function planForward(file2, component, depth = 0) {
     return { ...base, refusal: `no function named ${component} in this file` };
   }
   const param = found.params[0];
-  if (!t14.isObjectPattern(param)) {
+  if (!t17.isObjectPattern(param)) {
     return {
       ...base,
       refusal: `${component} does not destructure its props, so there is no safe place to add one without knowing what the parameter is called downstream`
@@ -11837,7 +13658,7 @@ function planForward(file2, component, depth = 0) {
   const imports = collectImports(ast);
   const nonCarrier = roots.find((root) => !isCarrierRoot(root, imports));
   if (nonCarrier) {
-    const name = t14.isJSXIdentifier(nonCarrier.name) ? nonCarrier.name.name : "its root";
+    const name = t17.isJSXIdentifier(nonCarrier.name) ? nonCarrier.name.name : "its root";
     return {
       ...base,
       refusal: `${component} renders <${name}> at its root, which is not a React Native element known to accept testID. Forwarding into it would move the problem down a level, not fix it`
@@ -11845,30 +13666,30 @@ function planForward(file2, component, depth = 0) {
   }
   const edits = [];
   const alreadyDestructured = param.properties.some(
-    (prop) => t14.isObjectProperty(prop) && t14.isIdentifier(prop.key) && prop.key.name === "testID"
+    (prop) => t17.isObjectProperty(prop) && t17.isIdentifier(prop.key) && prop.key.name === "testID"
   );
   if (!alreadyDestructured) {
     const insert = insertAfterLastMember(source, param.properties, "testID", param.end ?? 0, ",");
     edits.push({ ...insert, what: "parameter" });
   }
   const annotation = param.typeAnnotation;
-  if (t14.isTSTypeAnnotation(annotation)) {
+  if (t17.isTSTypeAnnotation(annotation)) {
     const declared = annotation.typeAnnotation;
     let body;
     let closing = 0;
-    if (t14.isTSTypeLiteral(declared)) {
+    if (t17.isTSTypeLiteral(declared)) {
       body = declared.members;
       closing = declared.end ?? 0;
-    } else if (t14.isTSTypeReference(declared) && t14.isIdentifier(declared.typeName)) {
+    } else if (t17.isTSTypeReference(declared) && t17.isIdentifier(declared.typeName)) {
       const typeName = declared.typeName.name;
-      traverse13(ast, {
+      traverse14(ast, {
         TSInterfaceDeclaration(nodePath) {
           if (nodePath.node.id.name !== typeName) return;
           body = nodePath.node.body.body;
           closing = nodePath.node.body.end ?? 0;
         },
         TSTypeAliasDeclaration(nodePath) {
-          if (nodePath.node.id.name !== typeName || !t14.isTSTypeLiteral(nodePath.node.typeAnnotation))
+          if (nodePath.node.id.name !== typeName || !t17.isTSTypeLiteral(nodePath.node.typeAnnotation))
             return;
           body = nodePath.node.typeAnnotation.members;
           closing = nodePath.node.typeAnnotation.end ?? 0;
@@ -11883,7 +13704,7 @@ function planForward(file2, component, depth = 0) {
     }
     if (body) {
       const declaresTestId = body.some(
-        (member) => t14.isTSPropertySignature(member) && t14.isIdentifier(member.key) && member.key.name === "testID"
+        (member) => t17.isTSPropertySignature(member) && t17.isIdentifier(member.key) && member.key.name === "testID"
       );
       if (!declaresTestId) {
         const insert = insertAfterLastMember(source, body, "testID?: string;", closing, ";");
@@ -11940,7 +13761,7 @@ function annotateCommand() {
       const spinner = createSpinner("Scanning for unaddressable controls...");
       spinner.start();
       resetForwardingCache();
-      const files = await (0, import_fast_glob6.default)(include, { cwd: rootDir, ignore: exclude, absolute: true });
+      const files = await globSorted(include, { cwd: rootDir, ignore: exclude, absolute: true });
       const scan = async () => {
         const out = [];
         for (const file2 of files) {
@@ -11989,9 +13810,9 @@ function annotateCommand() {
           written: options.write === true,
           annotated: written.length,
           blocked: blocked.length,
-          files: touched.map((edit) => import_node_path7.default.relative(rootDir, edit.file)),
+          files: touched.map((edit) => import_node_path9.default.relative(rootDir, edit.file)),
           sites: [...written, ...blocked].map((site) => ({
-            file: import_node_path7.default.relative(rootDir, site.file),
+            file: import_node_path9.default.relative(rootDir, site.file),
             line: site.line,
             component: site.component,
             role: site.role,
@@ -12034,9 +13855,12 @@ async function planForwards(edits, rootDir) {
   void rootDir;
   return plans;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function findImportSource(source, name) {
   const pattern = new RegExp(
-    String.raw`import\s*\{[^}]*\b${name}\b[^}]*\}\s*from\s*['"]([^'"]+)['"]`
+    String.raw`import\s*\{[^}]*\b${escapeRegExp(name)}\b[^}]*\}\s*from\s*['"]([^'"]+)['"]`
   );
   return pattern.exec(source)?.[1];
 }
@@ -12045,7 +13869,7 @@ function reportSites(rootDir, touched, blocked, didWrite, forwards) {
   if (written.length > 0) {
     heading(didWrite ? "Added" : "Would add");
     for (const edit of touched) {
-      info(import_node_path7.default.relative(rootDir, edit.file));
+      info(import_node_path9.default.relative(rootDir, edit.file));
       for (const site of edit.written) {
         dim(`  ${String(site.line).padStart(4)}  <${site.component}>  testID="${site.testId}"`);
       }
@@ -12057,7 +13881,7 @@ function reportSites(rootDir, touched, blocked, didWrite, forwards) {
   if (teachable.size > 0) {
     heading(didWrite ? "Taught to carry testID" : "Would teach to carry testID");
     for (const plan of teachable.values()) {
-      info(`<${plan.component}>  ${import_node_path7.default.relative(rootDir, plan.file)}`);
+      info(`<${plan.component}>  ${import_node_path9.default.relative(rootDir, plan.file)}`);
       for (const edit of plan.edits) {
         dim(`      ${edit.what}: ${edit.text.trim()}`);
       }
@@ -12365,10 +14189,10 @@ function matchActions(expected, actual, reply = "") {
 var import_fs9 = require("fs");
 var import_path8 = require("path");
 var EMPTY_BASELINE = { generatedAt: null, gitSha: null, perScenario: {} };
-function loadBaseline(path11) {
-  if (!(0, import_fs9.existsSync)(path11)) return { ...EMPTY_BASELINE, perScenario: {} };
+function loadBaseline(path13) {
+  if (!(0, import_fs9.existsSync)(path13)) return { ...EMPTY_BASELINE, perScenario: {} };
   try {
-    const raw = JSON.parse((0, import_fs9.readFileSync)(path11, "utf-8"));
+    const raw = JSON.parse((0, import_fs9.readFileSync)(path13, "utf-8"));
     return {
       generatedAt: raw.generatedAt ?? null,
       gitSha: raw.gitSha ?? null,
@@ -12378,9 +14202,9 @@ function loadBaseline(path11) {
     return { ...EMPTY_BASELINE, perScenario: {} };
   }
 }
-function saveBaseline(path11, baseline) {
-  (0, import_fs9.mkdirSync)((0, import_path8.dirname)(path11), { recursive: true });
-  (0, import_fs9.writeFileSync)(path11, `${JSON.stringify(baseline, null, 2)}
+function saveBaseline(path13, baseline) {
+  (0, import_fs9.mkdirSync)((0, import_path8.dirname)(path13), { recursive: true });
+  (0, import_fs9.writeFileSync)(path13, `${JSON.stringify(baseline, null, 2)}
 `, "utf-8");
 }
 function buildBaseline(outcomes, meta) {
@@ -12408,11 +14232,11 @@ function diffAgainstBaseline(outcomes, baseline, maxTokenRegression) {
       continue;
     }
     if (outcome.status === "passed" && prior.status === "passed" && prior.totalTokens > 0 && outcome.totalTokens > prior.totalTokens * (1 + maxTokenRegression)) {
-      const pct = Math.round((outcome.totalTokens - prior.totalTokens) / prior.totalTokens * 100);
+      const pct2 = Math.round((outcome.totalTokens - prior.totalTokens) / prior.totalTokens * 100);
       regressions.push({
         name: outcome.name,
         kind: "token-regression",
-        detail: `tokens ${prior.totalTokens} \u2192 ${outcome.totalTokens} (+${pct}%, threshold +${Math.round(maxTokenRegression * 100)}%)`
+        detail: `tokens ${prior.totalTokens} \u2192 ${outcome.totalTokens} (+${pct2}%, threshold +${Math.round(maxTokenRegression * 100)}%)`
       });
     }
   }
@@ -12673,9 +14497,145 @@ Pass rate: ${passed}/${total} (${passRatePct}%) \u2014 threshold ${minPassRatePc
   });
 }
 
+// src/cli/commands/knowledge.ts
+var import_commander8 = require("commander");
+var import_promises7 = require("fs/promises");
+var import_node_path10 = require("path");
+var import_node_crypto3 = require("crypto");
+var import_fast_glob2 = __toESM(require("fast-glob"));
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".html", ".htm", ".pdf"]);
+var MIME_MAP = {
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".pdf": "application/pdf"
+};
+function knowledgeCommand() {
+  const cmd = new import_commander8.Command("knowledge").description("Manage the project knowledge base (RAG)");
+  cmd.command("sync").description("Sync local documentation files to the knowledge base").option("--verbose", "Enable verbose logging", false).option("--api-key <key>", "Appilots API key (overrides .appilotsrc)").option("--server <url>", "Appilots server URL (overrides .appilotsrc)").option("--json", "Output a machine-readable JSON result (implies --quiet)", false).option("--quiet", "Suppress banner and informational output", false).action(async (options) => {
+    if (options.json) setLogMode("json");
+    else if (options.quiet) setLogMode("quiet");
+    try {
+      banner();
+      const loaded = loadConfig(warn);
+      const apiKey = options.apiKey || loaded?.apiKey;
+      if (!apiKey) {
+        error("No .appilotsrc configuration found");
+        info("Run: appilots init --api-key <your-key>");
+        jsonOutput({ success: false, error: "No configuration found (missing API key)" });
+        process.exit(1);
+        return;
+      }
+      const config = {
+        serverUrl: DEFAULT_SERVER_URL,
+        ...loaded,
+        apiKey,
+        ...options.server ? { serverUrl: options.server } : {}
+      };
+      const sources = config.knowledge?.sources;
+      if (!sources || sources.length === 0) {
+        error("No knowledge sources configured");
+        info("Add knowledge.sources to .appilotsrc:");
+        info('  { "knowledge": { "sources": ["docs/**/*.md"] } }');
+        jsonOutput({ success: false, error: "No knowledge sources configured" });
+        process.exit(1);
+        return;
+      }
+      const spinner = createSpinner("Scanning for knowledge documents...");
+      spinner.start();
+      const rootDir = process.cwd();
+      const excludePatterns = config.knowledge?.exclude ?? [];
+      const allFiles = [];
+      for (const pattern of sources) {
+        const matches = await (0, import_fast_glob2.default)(pattern, {
+          cwd: rootDir,
+          ignore: ["node_modules/**", ...excludePatterns],
+          onlyFiles: true
+        });
+        for (const match of matches) {
+          const ext = (0, import_node_path10.extname)(match).toLowerCase();
+          if (SUPPORTED_EXTENSIONS.has(ext) && !allFiles.includes(match)) {
+            allFiles.push(match);
+          }
+        }
+      }
+      spinner.stop();
+      if (allFiles.length === 0) {
+        warn("No supported files found matching knowledge.sources patterns");
+        info(`Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`);
+        jsonOutput({ success: true, uploaded: 0, skipped: 0, errors: 0, files: 0 });
+        return;
+      }
+      info(`Found ${allFiles.length} document${allFiles.length === 1 ? "" : "s"}`);
+      const documents = [];
+      for (const filePath of allFiles) {
+        const absolutePath = (0, import_node_path10.resolve)(rootDir, filePath);
+        const buffer = await (0, import_promises7.readFile)(absolutePath);
+        const checksum = (0, import_node_crypto3.createHash)("sha256").update(buffer).digest("hex");
+        const ext = (0, import_node_path10.extname)(filePath).toLowerCase();
+        const mimeType = MIME_MAP[ext] ?? "text/plain";
+        documents.push({
+          filename: (0, import_node_path10.relative)(rootDir, absolutePath),
+          content: buffer.toString("base64"),
+          mimeType,
+          checksum
+        });
+      }
+      const uploadSpinner = createSpinner(
+        `Uploading ${documents.length} document${documents.length === 1 ? "" : "s"}...`
+      );
+      uploadSpinner.start();
+      const apiClient = new AppilotsAPIClient({
+        serverUrl: config.serverUrl,
+        apiKey: config.apiKey,
+        timeoutMs: 12e4
+        // Knowledge sync can take longer (embedding)
+      });
+      const result = await apiClient.knowledgeSync(documents);
+      uploadSpinner.stop();
+      if (!result.success) {
+        error(`Knowledge sync failed: ${result.error}`);
+        jsonOutput({ success: false, error: result.error });
+        process.exit(1);
+        return;
+      }
+      success(
+        `Knowledge sync complete: ${result.uploaded} uploaded, ${result.skipped} skipped, ${result.errors} errors`
+      );
+      if (options.verbose && result.details) {
+        for (const detail of result.details) {
+          if (detail.status === "uploaded") {
+            info(`  + ${detail.filename}`);
+          } else if (detail.status === "skipped") {
+            info(`  = ${detail.filename} (unchanged)`);
+          } else {
+            warn(`  ! ${detail.filename}: ${detail.error}`);
+          }
+        }
+      }
+      jsonOutput({
+        success: true,
+        uploaded: result.uploaded,
+        skipped: result.skipped,
+        errors: result.errors,
+        details: result.details
+      });
+    } catch (err) {
+      error(`Knowledge sync failed: ${stringifyUnknown(err)}`);
+      jsonOutput({ success: false, error: stringifyUnknown(err) });
+      if (options.verbose) {
+        console.error(err);
+      }
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
 // src/cli/index.ts
 async function main() {
-  const program2 = new import_commander8.Command();
+  const program2 = new import_commander9.Command();
   program2.name("appilots").description(
     "Analyze your React Native app and generate MCP documents for AI-powered navigation.\n\nQuick start:\n  $ appilots init --api-key ak_xxx\n  $ appilots sync\n  $ appilots watch"
   ).version(CLI_VERSION).option("--verbose", "Enable verbose logging");
@@ -12686,6 +14646,7 @@ async function main() {
   program2.addCommand(annotateCommand());
   program2.addCommand(statusCommand());
   program2.addCommand(evalCommand());
+  program2.addCommand(knowledgeCommand());
   const args = process.argv.slice(2);
   const firstArg = args[0];
   const hasCommand = firstArg !== void 0 && args.length > 0 && !firstArg.startsWith("-");