@appilots/sdk 0.2.0 → 0.4.0

package/dist/{chunk-SIBKF7AA.js → chunk-V3TUIIT2.js}

@@ -14,10 +14,20 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/version.ts
-var SDK_VERSION = "0.1.0";
+// ../shared/dist/chunk-43YQ52Q7.mjs
+var SENSITIVE_FIELD_NAME_RE = /(\b|_|-)(password|senha|contrase[ñn]a|mot[\s_-]*de[\s_-]*passe|passwd|pwd|secret|token|api[\s_-]*key|access[\s_-]*key|private[\s_-]*key|cvv|cvc|cvn|cvc2|cid|pin(?:[\s_-]*code)?|otp|one[\s_-]*time[\s_-]*code|2fa|mfa|security[\s_-]*code|c[óo]digo[\s_-]*seguran[çc]a|c[óo]digo[\s_-]*verifica[çc][ãa]o|verification[\s_-]*code)(\b|_|-)/i;
+function isSensitiveFieldName(id, label, placeholder, type) {
+  if (type === "password") return true;
+  for (const candidate of [id, label, placeholder]) {
+    if (typeof candidate === "string" && SENSITIVE_FIELD_NAME_RE.test(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
 
-// src/services/AppilotsClient.ts
+// ../client-core/dist/index.mjs
+var SDK_VERSION = "0.1.0";
 var StreamTransportError = class extends Error {
   constructor(message) {
     super(message);
@@ -744,47 +754,2016 @@ var AppilotsClient = class {
             typeof event.operatorName === "string" ? event.operatorName : void 0
           );
         }
-      }
-    };
-    const consumeBuffer = () => {
-      const text = xhr.responseText ?? "";
-      const boundary = text.lastIndexOf("\n\n");
-      if (boundary <= parsedIndex) return;
-      const slice = text.slice(parsedIndex, boundary);
-      parsedIndex = boundary;
-      for (const frame of slice.split("\n\n")) {
-        for (const line of frame.split("\n")) {
-          if (!line.startsWith("data: ")) continue;
+      }
+    };
+    const consumeBuffer = () => {
+      const text = xhr.responseText ?? "";
+      const boundary = text.lastIndexOf("\n\n");
+      if (boundary <= parsedIndex) return;
+      const slice = text.slice(parsedIndex, boundary);
+      parsedIndex = boundary;
+      for (const frame of slice.split("\n\n")) {
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            handleEvent(JSON.parse(line.slice(6)));
+          } catch {
+            this.log("Skipping unparseable escalation SSE line:", line.slice(0, 120));
+          }
+        }
+      }
+    };
+    xhr.open("GET", url);
+    for (const [key, value] of Object.entries(this.headers)) {
+      xhr.setRequestHeader(key, value);
+    }
+    xhr.setRequestHeader("Accept", "text/event-stream");
+    xhr.onprogress = consumeBuffer;
+    xhr.onload = () => {
+      consumeBuffer();
+      end();
+    };
+    xhr.onerror = end;
+    xhr.onabort = end;
+    xhr.send();
+    return () => {
+      closedByCaller = true;
+      try {
+        xhr.abort();
+      } catch {
+      }
+    };
+  }
+};
+var defaultLightTheme = {
+  colors: {
+    primary: "#6366f1",
+    secondary: "#8b5cf6",
+    background: "#ffffff",
+    surface: "#f3f4f6",
+    text: "#1f2937",
+    textSecondary: "#6b7280",
+    border: "#e5e7eb",
+    // NOTE (BACKLOG 4.2): success/warning/error used to have ZERO visual
+    // consumers — nothing read them, so ActionBreadcrumb's tones and the
+    // confirm card's destructive accents were hardcoded separately with
+    // their OWN hex values (#10B981/#EF4444/#9CA3AF-ish grays). Since no
+    // other UI in the SDK reads these three tokens, we picked these
+    // defaults to exactly match those pre-existing hardcoded values —
+    // wiring the tokens up to ActionBreadcrumb (see breadcrumbPresentation.ts)
+    // is now a no-op for anyone on the bundled default theme, while a
+    // custom theme's success/warning/error now actually do something.
+    success: "#10b981",
+    warning: "#9ca3af",
+    error: "#ef4444",
+    // Same value as `text` — split out so an app can diverge them, but
+    // any app that doesn't set these renders pixel-identical to before.
+    buttonText: "#1f2937",
+    bubbleText: "#1f2937",
+    userBubbleText: "#ffffff"
+  },
+  typography: {
+    fontFamily: "System",
+    fontSizeXs: 11,
+    fontSizeSm: 13,
+    fontSizeBase: 15,
+    fontSizeLg: 18
+  },
+  radii: {
+    sm: 8,
+    md: 12,
+    lg: 16
+  },
+  shadows: {
+    appearance: "light"
+  }
+};
+var defaultDarkTheme = {
+  colors: {
+    primary: "#818cf8",
+    secondary: "#a78bfa",
+    background: "#0f172a",
+    surface: "#1e293b",
+    text: "#f1f5f9",
+    textSecondary: "#94a3b8",
+    border: "#334155",
+    // Kept IDENTICAL to the light theme's success/warning/error (not the
+    // usual "lighter for dark bg" adjustment other tokens get) — the
+    // breadcrumb's tones were a fixed, theme-agnostic hardcoded palette
+    // before this token existed, rendering the SAME hex in light and dark
+    // mode. Diverging them here would change dark-mode breadcrumbs even
+    // though nothing in the token tree asked for that.
+    success: "#10b981",
+    warning: "#9ca3af",
+    error: "#ef4444",
+    buttonText: "#f1f5f9",
+    bubbleText: "#f1f5f9",
+    userBubbleText: "#ffffff"
+  },
+  typography: { ...defaultLightTheme.typography },
+  radii: { ...defaultLightTheme.radii },
+  shadows: { appearance: "dark" }
+};
+function mergeThemeTokens(base, partial) {
+  if (!partial) return base;
+  return {
+    colors: { ...base.colors, ...partial.colors ?? {} },
+    typography: { ...base.typography, ...partial.typography ?? {} },
+    radii: { ...base.radii, ...partial.radii ?? {} },
+    shadows: { ...base.shadows, ...partial.shadows ?? {} }
+  };
+}
+function resolveBaseTheme(mode, systemScheme) {
+  if (mode === "dark") return defaultDarkTheme;
+  if (mode === "light") return defaultLightTheme;
+  return systemScheme === "dark" ? defaultDarkTheme : defaultLightTheme;
+}
+var LIST_ITEM_TARGET_RE = /^list-\d+-item-\d+$/i;
+var DESTRUCTIVE_LABEL_RE = /\b(cancelar?\w*|cancel(?:ar|led|ation|amento)?|delete\w*|exclu\w*|delet\w*|remov\w*|remove|apag\w*|destroy\w*|unsubscribe\w*)\b/i;
+function isListItemPressTarget(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  return LIST_ITEM_TARGET_RE.test(value.trim());
+}
+function looksDestructiveActionLabel(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  return DESTRUCTIVE_LABEL_RE.test(value.trim());
+}
+function actionPressTargetId(action) {
+  if (action.type !== "ui_interaction") return null;
+  const payload = action.payload;
+  const componentId = payload?.componentId;
+  if (typeof componentId === "string" && componentId.trim()) return componentId.trim();
+  const targetId = payload?.targetId;
+  if (typeof targetId === "string" && targetId.trim()) return targetId.trim();
+  return null;
+}
+function turnHasConfirmActions(actions) {
+  return actions.some((action) => action.type === "confirm");
+}
+function normalize(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[‘’]/g, "'").toLowerCase();
+}
+function detectLocaleFromUserTexts(texts) {
+  for (const raw of texts) {
+    const normalized = normalize(raw);
+    if (/[ãõáéíóúâêôç]/i.test(raw) || /\b(voce|voces|pra|assinatura|cancela|canela|segunda|certo|quais|tenho|pode|posso)\b/.test(
+      normalized
+    )) {
+      return "pt";
+    }
+    if (/[áéíóúñ¿¡]/i.test(raw) || /\b(cancela|segunda|suscripcion|puedo|cuales|hola)\b/.test(normalized)) {
+      return "es";
+    }
+    if (/[àâçéèêëîïôûùüÿœ]/i.test(raw) || /\b(annuler|deuxieme|abonnement|bonjour)\b/.test(normalized)) {
+      return "fr";
+    }
+  }
+  return "en";
+}
+var copy = {
+  pt: {
+    rateLimit: "O provedor de IA atingiu o limite de uso durante a automa\xE7\xE3o. Aguarde um momento e pe\xE7a para continuar, ou aumente o limite de tokens por minuto.",
+    invalidInput: "N\xE3o consegui continuar a automa\xE7\xE3o por um problema interno de sincroniza\xE7\xE3o. Pode tentar de novo ou fazer essa parte manualmente?",
+    generic: (detail) => `Perdi o fio da automa\xE7\xE3o (${detail}). Pode continuar manualmente ou me pedir de novo?`
+  },
+  es: {
+    rateLimit: "El proveedor de IA alcanz\xF3 su l\xEDmite de uso durante la automatizaci\xF3n. Espera un momento y p\xEDdeme continuar, o aumenta el l\xEDmite de tokens por minuto.",
+    invalidInput: "No pude continuar la automatizaci\xF3n por un problema interno de sincronizaci\xF3n. \xBFPuedes intentarlo de nuevo o hacer esta parte manualmente?",
+    generic: (detail) => `Perd\xED el hilo de la automatizaci\xF3n (${detail}). \xBFPuedes continuar manualmente o ped\xEDrmelo de nuevo?`
+  },
+  fr: {
+    rateLimit: "Le fournisseur d'IA a atteint sa limite d'utilisation pendant l'automatisation. Attendez un instant et demandez-moi de continuer, ou augmentez la limite de tokens par minute.",
+    invalidInput: "Je n'ai pas pu poursuivre l'automatisation \xE0 cause d'un probl\xE8me interne de synchronisation. Pouvez-vous r\xE9essayer ou faire cette \xE9tape manuellement ?",
+    generic: (detail) => `J'ai perdu le fil de l'automatisation (${detail}). Vous pouvez continuer manuellement ou me redemander ?`
+  },
+  en: {
+    rateLimit: "Your AI provider hit its rate limit during automation. Wait a moment and ask me to continue, or raise your TPM limit.",
+    invalidInput: "I could not continue the automation because of an internal sync issue. You can try again or take over manually.",
+    generic: (detail) => `I lost my footing during automation (${detail}). You can take over from here.`
+  }
+};
+function buildContinuationFailureMessage(rawError, recentUserTexts) {
+  const locale = detectLocaleFromUserTexts(recentUserTexts);
+  const strings = copy[locale] ?? copy.en;
+  if (/rate limit|tokens per min|tpm/i.test(rawError)) {
+    return strings.rateLimit;
+  }
+  if (/invalid input|validation_error|422/i.test(rawError)) {
+    return strings.invalidInput;
+  }
+  return strings.generic(rawError);
+}
+function metadataMatchesComponentId(metaId, componentId) {
+  const norm = (s) => s.toLowerCase().replace(/^el:(button|link|input|toggle|listitem)[:_-]/, "").replace(/^(btn-|btn_|button-|button_|link-|link_)/, "").trim();
+  const meta = norm(metaId);
+  const comp = norm(componentId);
+  if (!meta || !comp) return false;
+  return meta === comp;
+}
+function fingerprintAction(action, screen) {
+  const p = action.payload ?? {};
+  const scope = `@${screen ?? "?"}`;
+  switch (action.type) {
+    case "navigate":
+      return `navigate${scope}:${p.screenName ?? "?"}`;
+    case "form_fill": {
+      const fields = p.fields ?? [];
+      const ids = fields.map((f) => String(f?.fieldId ?? "?")).sort();
+      return `form_fill${scope}:${ids.join(",")}`;
+    }
+    case "ui_interaction":
+      return `ui_interaction${scope}:${p.action ?? "?"}:${p.componentId ?? p.targetId ?? "?"}`;
+    case "confirm":
+      return `confirm${scope}:${p.message ?? p.title ?? "?"}`;
+    default:
+      return `${action.type}${scope}:${JSON.stringify(p)}`;
+  }
+}
+var MAX_TRACE_ENTRIES = 200;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+var traceCounter = 0;
+function notify() {
+  const snapshot = [...entries];
+  listeners.forEach((listener) => listener(snapshot));
+}
+function append(entry) {
+  entries.push(entry);
+  if (entries.length > MAX_TRACE_ENTRIES) {
+    entries.splice(0, entries.length - MAX_TRACE_ENTRIES);
+  }
+  notify();
+}
+function recordAppilotsDebugTrace(entry) {
+  append({
+    ...entry,
+    id: entry.id ?? `trace_${++traceCounter}`
+  });
+}
+function actionFromEvent(event) {
+  const action = event.data?.action;
+  if (action && typeof action === "object" && typeof action.id === "string") {
+    return action;
+  }
+  return void 0;
+}
+function recordAppilotsEventTrace(event) {
+  if (!event.type.startsWith("agent:action:")) return;
+  const action = actionFromEvent(event);
+  const actionId = action?.id || (typeof event.data?.actionId === "string" ? event.data.actionId : void 0);
+  const actionType = action?.type || (typeof event.data?.actionType === "string" ? event.data.actionType : void 0);
+  recordAppilotsDebugTrace({
+    timestamp: event.timestamp,
+    type: event.type,
+    messageId: action?.messageId,
+    actionId,
+    actionType,
+    status: event.type === "agent:action:start" ? "started" : event.type === "agent:action:complete" ? "completed" : "error",
+    data: event.data
+  });
+}
+function getAppilotsDebugTraces() {
+  return [...entries];
+}
+function clearAppilotsDebugTraces() {
+  entries.splice(0, entries.length);
+  notify();
+}
+function subscribeAppilotsDebugTraces(listener) {
+  listeners.add(listener);
+  listener([...entries]);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var INTERNAL_MARKER_RE = /^\[(?:Permission policy notice|Recovery exhausted|User rejected the proposed action)[^\]]*\]:\s*/i;
+var TECHNICAL_TRACE_RE = /(^|\n)\s*(?:Results:|[-*]\s*[✓✗]\s+|(?:press|click|tap|navigate|form_fill|ui_interaction|scroll_list)\b|(?:Cliquei|Clicked)\s+em\s+(?:el:|list-\d+-item-\d+|[A-Za-z]+:))/i;
+var TECHNICAL_SELECTOR_RE = /\b(?:el:[^\s]+|list-\d+-item-\d+|[A-Za-z][\w-]*:(?!\/\/)[^\s]+|(?:testID|test-id|accessibilityId|accessibility-id)[:=_-][^\s]+)/i;
+function sanitizeVisibleAssistantContent(content) {
+  return content.split("\n").map((line) => line.replace(INTERNAL_MARKER_RE, "").trimEnd()).filter((line) => !INTERNAL_MARKER_RE.test(line)).join("\n").trim();
+}
+function humanizeAssistantFallback(content) {
+  let text = sanitizeVisibleAssistantContent(content).replace(/\blist-\d+-item-\d+\b/gi, "o item da lista").replace(/\bel:[^\s".]+/gi, "o elemento").replace(
+    /"\s*(?:press|click|tap|navigate|form_fill|ui_interaction|scroll_list)\s+on\s+[^"]+"/gi,
+    '"a a\xE7\xE3o solicitada"'
+  ).replace(/\bsubscription-cancel-[^\s"]+/gi, "cancelamento de assinatura").trim();
+  if (text.length < 16) return null;
+  const probe = {
+    role: "assistant",
+    content: text
+  };
+  if (isInternalTraceMessage(probe)) return null;
+  return text;
+}
+function isInternalTraceMessage(message) {
+  if (message.role !== "assistant") return false;
+  const content = message.content.trim();
+  if (!content) return true;
+  return TECHNICAL_TRACE_RE.test(content) || TECHNICAL_SELECTOR_RE.test(content);
+}
+var CREATE_FORM_ROUTE_RE = /vehiclecreate|subscriptioncreate|vehicleedit|subscriptionedit|maintenancecreate|create|cadastr|register|novo|edit/i;
+var SUBMIT_BUTTON_RE = /cadastrar|registrar|salvar|submit|register|guardar|enviar|confirmar|save/i;
+var FORM_VALIDATION_TEXT_RE = /(inv[aá]lid|obrigat[oó]ri|required|invalid|j[aá]\s+existe|already\s+exists|duplicad|formato|format|too\s+short|muito\s+curto|n[aã]o\s+(?:foi|pode)|must\s+be|deve\s+ser|selecione|escolha|select\s+(?:the|a|o|an))/i;
+function normalize2(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+}
+function routeHintsCreateForm(routeNames) {
+  return routeNames.some((name) => CREATE_FORM_ROUTE_RE.test(normalize2(name)));
+}
+function snapshotHasSubmitControl(snap) {
+  return (snap.buttons ?? []).some(
+    (btn) => SUBMIT_BUTTON_RE.test(normalize2(`${btn.label ?? btn.id ?? ""}`))
+  );
+}
+function snapshotHasVisibleSubmitButton(snap) {
+  return (snap.buttons ?? []).some(
+    (btn) => !btn.disabled && SUBMIT_BUTTON_RE.test(normalize2(`${btn.label ?? btn.id ?? ""}`))
+  );
+}
+function snapshotHasVisibleValidation(snap) {
+  return (snap.texts ?? []).some((text) => typeof text === "string" && FORM_VALIDATION_TEXT_RE.test(text));
+}
+function snapshotShowsOpenCreateForm(snap, activePath = []) {
+  if (!snap) return false;
+  const routeNames = [
+    ...typeof snap.route === "string" && snap.route ? [snap.route] : [],
+    ...activePath
+  ];
+  const hasFormInputs = (snap.inputs?.length ?? 0) > 0;
+  const hasValidation = snapshotHasVisibleValidation(snap);
+  const hasFormContext = routeHintsCreateForm(routeNames) || hasFormInputs || hasValidation;
+  if (!hasFormContext) return false;
+  if (snap.loading === true) return true;
+  if (snapshotHasVisibleSubmitButton(snap)) return true;
+  if (snapshotHasSubmitControl(snap) && hasFormInputs) return true;
+  if (hasValidation) return true;
+  return false;
+}
+function formFillLackedWriteEffect(action, snap, activePath = []) {
+  if (action.type !== "form_fill") return false;
+  if (!snapshotShowsOpenCreateForm(snap, activePath)) return false;
+  const payload = action.payload;
+  if (payload?.submitAfterFill === true) return true;
+  return Array.isArray(payload?.fields) && payload.fields.length > 0;
+}
+function summarizeAction(action) {
+  const p = action.payload;
+  switch (action.type) {
+    case "navigate":
+      return `navigate to ${p?.screenName ?? "?"}`;
+    case "form_fill": {
+      const fields = p?.fields ?? [];
+      if (fields.length === 0) return "form_fill (no fields)";
+      const parts = fields.slice(0, 3).map((f) => `${f.fieldId}=${JSON.stringify(f.value)}`);
+      const extra = fields.length > 3 ? ` +${fields.length - 3} more` : "";
+      return `form_fill ${parts.join(", ")}${extra}`;
+    }
+    case "ui_interaction":
+      return `${p?.action ?? "press"} on ${p?.componentId ?? "?"}`;
+    case "scroll_list": {
+      const target = typeof p?.toIndex === "number" ? `to item #${p.toIndex}` : p?.direction ?? "down";
+      return `scroll_list ${p?.listId ? `"${p.listId}" ` : ""}${target}`;
+    }
+    case "confirm":
+      return `confirm: ${p?.message ?? p?.title ?? ""}`;
+    default:
+      return action.type;
+  }
+}
+function extractPressedComponentId(actions) {
+  for (let i = actions.length - 1; i >= 0; i--) {
+    const a = actions[i];
+    if (!a || a.type !== "ui_interaction") continue;
+    const p = a.payload;
+    const interaction = p?.action ?? "press";
+    if (interaction !== "press" && interaction !== "longPress") continue;
+    const id = p?.componentId;
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return null;
+}
+function extractNavigateTargetScreen(actions) {
+  for (let i = actions.length - 1; i >= 0; i--) {
+    const a = actions[i];
+    if (!a || a.type !== "navigate") continue;
+    const screenName = a.payload?.screenName;
+    if (typeof screenName === "string" && screenName.length > 0) return screenName;
+  }
+  return null;
+}
+function idLooselyMatches(candidate, target) {
+  if (!candidate || !target) return false;
+  if (candidate === target) return true;
+  const c = candidate.toLowerCase();
+  const t = target.toLowerCase();
+  if (c === t) return true;
+  return c.endsWith(`-${t}`) || c.endsWith(`_${t}`) || t.endsWith(`-${c}`) || t.endsWith(`_${c}`);
+}
+var ESCALATION_RECONNECT_MAX_MS = 3e4;
+var MAX_RECOVERY_ATTEMPTS_PER_ACTION = 2;
+var INITIAL_STATE = {
+  messages: [],
+  isLoading: false,
+  loadingStatusKey: "thinking",
+  error: null,
+  pendingActions: [],
+  escalation: null
+};
+var ChatSessionMachine = class {
+  deps;
+  options = {};
+  state = INITIAL_STATE;
+  listeners = /* @__PURE__ */ new Set();
+  messageIdCounter = 0;
+  currentTurn = null;
+  continuationInFlight = false;
+  /**
+   * BACKLOG 3.2 — per-message-thread retry counter, keyed on action
+   * fingerprint. Reset on every fresh `sendMessage`, persists across
+   * /agent/continue hops within the same user turn so two retries of
+   * the same action add up across hops.
+   */
+  recoveryCountByFingerprint = /* @__PURE__ */ new Map();
+  /** Abort controller for the in-flight generation (cancelMessage). */
+  abortController = null;
+  // ── Escalation channel bookkeeping (docs/human-escalation.md) ──
+  escalationStreamClose = null;
+  escalationReconnectAttempt = 0;
+  escalationReconnectTimer = null;
+  /** createdAt of the newest operator message — reconnect catch-up cursor. */
+  escalationSince = void 0;
+  /** Operator message ids already appended (SSE replay dedupe). */
+  seenHumanMessageIds = /* @__PURE__ */ new Set();
+  disposed = false;
+  constructor(deps, options = {}) {
+    this.deps = deps;
+    this.options = options;
+    this.subscribeState = this.subscribeState.bind(this);
+    this.getState = this.getState.bind(this);
+    this.handleEvent = this.handleEvent.bind(this);
+    this.sendMessage = this.sendMessage.bind(this);
+    this.cancelMessage = this.cancelMessage.bind(this);
+    this.clearMessages = this.clearMessages.bind(this);
+    this.clearError = this.clearError.bind(this);
+    this.requestHuman = this.requestHuman.bind(this);
+  }
+  // ── State plumbing ───────────────────────────────────────────
+  getState() {
+    return this.state;
+  }
+  subscribeState(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Update mutable options (errorPrefix, streaming, escalation copy). */
+  setOptions(options) {
+    this.options = options;
+  }
+  /** Tear down timers and the escalation stream. Safe to call twice. */
+  dispose() {
+    this.disposed = true;
+    this.closeEscalationStream();
+  }
+  setState(partial) {
+    this.state = { ...this.state, ...partial };
+    for (const listener of this.listeners) listener();
+  }
+  warn(message, ...args) {
+    (this.deps.warn ?? console.warn)(message, ...args);
+  }
+  // ── Message helpers ──────────────────────────────────────────
+  addAssistantMessage(message) {
+    const visibleContent = message.role === "assistant" ? sanitizeVisibleAssistantContent(message.content) : message.content;
+    const candidate = { ...message, content: visibleContent };
+    if (isInternalTraceMessage(candidate)) {
+      recordAppilotsDebugTrace({
+        type: "agent:trace",
+        timestamp: Date.now(),
+        messageId: candidate.id,
+        summary: "Suppressed internal assistant trace from visible chat",
+        data: { role: candidate.role, content: message.content }
+      });
+      const fallback = humanizeAssistantFallback(message.content);
+      if (fallback) {
+        this.setState({ messages: [...this.state.messages, { ...candidate, content: fallback }] });
+      }
+      return;
+    }
+    this.setState({ messages: [...this.state.messages, candidate] });
+  }
+  appendLocalSystemMessage(content, metadata) {
+    if (!content) return;
+    this.setState({
+      messages: [
+        ...this.state.messages,
+        {
+          id: `system_${++this.messageIdCounter}`,
+          role: "system",
+          content,
+          timestamp: Date.now(),
+          ...metadata ? { metadata } : {}
+        }
+      ]
+    });
+  }
+  // ── Escalation: request, stream, and message routing ─────────
+  async requestHuman(reason = "user_requested") {
+    if (this.state.escalation) return;
+    try {
+      const lastError = this.state.messages.slice().reverse().find((m) => m.role === "assistant" && m.id.startsWith("error_"));
+      const result = await this.deps.client.requestEscalation(reason, lastError?.content);
+      this.setState({ escalation: { id: result.escalationId, status: result.status } });
+      this.escalationReconnectAttempt = 0;
+      this.appendLocalSystemMessage(this.options.escalationStrings?.requested ?? "");
+      this.deps.emit({
+        type: "chat:escalation:start",
+        timestamp: Date.now(),
+        data: { escalationId: result.escalationId, reason }
+      });
+      this.openEscalationStream(result.escalationId);
+    } catch (err) {
+      this.setState({ error: err instanceof Error ? err.message : "Failed to request a human" });
+    }
+  }
+  /**
+   * Live channel: operator replies + status changes. Reopens with
+   * capped exponential backoff (and a `since` catch-up cursor) when
+   * the transport drops, for as long as the escalation stays open.
+   */
+  openEscalationStream(escalationId) {
+    this.closeEscalationStream();
+    if (this.disposed) return;
+    this.escalationStreamClose = this.deps.client.openEscalationStream(escalationId, {
+      since: this.escalationSince,
+      onHumanMessage: (message) => {
+        this.escalationReconnectAttempt = 0;
+        if (this.seenHumanMessageIds.has(message.id)) return;
+        this.seenHumanMessageIds.add(message.id);
+        this.escalationSince = message.createdAt;
+        this.setState({
+          messages: [
+            ...this.state.messages,
+            {
+              id: message.id,
+              role: "human_agent",
+              content: message.content,
+              timestamp: Date.now()
+            }
+          ]
+        });
+        this.deps.emit({
+          type: "chat:escalation:message",
+          timestamp: Date.now(),
+          data: { escalationId, messageId: message.id }
+        });
+      },
+      onStatus: (status, operatorName) => {
+        this.escalationReconnectAttempt = 0;
+        const current = this.state.escalation;
+        if (status === "active") {
+          if (!current || current.id !== escalationId) return;
+          if (current.status === "active") return;
+          this.appendLocalSystemMessage(this.options.escalationStrings?.connected ?? "");
+          this.setState({ escalation: { ...current, status: "active", operatorName } });
+        } else if (status === "resolved") {
+          this.appendLocalSystemMessage(this.options.escalationStrings?.resolved ?? "");
+          this.setState({ escalation: null });
+          this.closeEscalationStream();
+          this.deps.emit({
+            type: "chat:escalation:end",
+            timestamp: Date.now(),
+            data: { escalationId }
+          });
+        }
+      },
+      onClose: () => {
+        const current = this.state.escalation;
+        if (this.disposed || !current || current.id !== escalationId) return;
+        const attempt = ++this.escalationReconnectAttempt;
+        const delay = Math.min(ESCALATION_RECONNECT_MAX_MS, 1e3 * 2 ** Math.min(attempt, 5));
+        this.escalationReconnectTimer = setTimeout(() => {
+          const still = this.state.escalation;
+          if (this.disposed || !still || still.id !== escalationId) return;
+          this.openEscalationStream(escalationId);
+        }, delay);
+      }
+    });
+  }
+  closeEscalationStream() {
+    if (this.escalationReconnectTimer) {
+      clearTimeout(this.escalationReconnectTimer);
+      this.escalationReconnectTimer = null;
+    }
+    if (this.escalationStreamClose) {
+      const close = this.escalationStreamClose;
+      this.escalationStreamClose = null;
+      close();
+    }
+  }
+  /** Route a user message to the human channel while escalated. */
+  async sendEscalationMessage(content) {
+    const current = this.state.escalation;
+    if (!current) return;
+    const userMessage = {
+      id: `local_${++this.messageIdCounter}`,
+      role: "user",
+      content,
+      timestamp: Date.now()
+    };
+    this.setState({ messages: [...this.state.messages, userMessage] });
+    try {
+      await this.deps.client.sendEscalationMessage(current.id, content);
+    } catch (err) {
+      this.setState({ error: err instanceof Error ? err.message : "Failed to send message" });
+    }
+  }
+  // ── Start a turn (or sub-turn): register actions + emit events ──
+  beginTurn(assistantMessageId, actions, hop) {
+    if (!actions || actions.length === 0) {
+      this.currentTurn = null;
+      return;
+    }
+    const stamped = actions.map((a) => ({ ...a, messageId: assistantMessageId }));
+    this.setState({ pendingActions: [...this.state.pendingActions, ...stamped] });
+    const turn = {
+      messageId: assistantMessageId,
+      actionIds: new Set(stamped.map((a) => a.id)),
+      results: /* @__PURE__ */ new Map(),
+      reportedIds: /* @__PURE__ */ new Set(),
+      hop,
+      hadNavigate: stamped.some((a) => a.type === "navigate"),
+      // Snapshot the current screen NOW, before any navigate
+      // dispatches. The platform settle will use this as the
+      // baseline to detect that the navigate completed.
+      preNavigateScreen: this.deps.adapter.getCurrentScreen(),
+      // Full route+params signature — lets settle detect navigate
+      // to the same route name with different params.
+      preNavigateSignature: this.deps.adapter.getCurrentScreenSignature()
+    };
+    const originScreen = this.deps.adapter.getCurrentScreen() ?? void 0;
+    for (const a of stamped) {
+      turn.results.set(a.id, {
+        type: a.type,
+        success: false,
+        summary: summarizeAction(a),
+        fingerprint: fingerprintAction(a, originScreen)
+      });
+    }
+    this.currentTurn = turn;
+    for (const action of stamped) {
+      this.deps.emit({
+        type: "agent:action:start",
+        timestamp: Date.now(),
+        data: { action }
+      });
+    }
+    if (turnHasConfirmActions(stamped)) {
+      this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+    }
+  }
+  registerSynthesizedTurnAction(action) {
+    const turn = this.currentTurn;
+    if (!turn || turn.actionIds.has(action.id)) return;
+    const stamped = { ...action, messageId: turn.messageId };
+    turn.actionIds.add(stamped.id);
+    turn.results.set(stamped.id, {
+      type: stamped.type,
+      success: false,
+      summary: summarizeAction(stamped),
+      fingerprint: fingerprintAction(stamped, this.deps.adapter.getCurrentScreen() ?? void 0)
+    });
+    if (!this.state.pendingActions.some((candidate) => candidate.id === stamped.id)) {
+      this.setState({ pendingActions: [...this.state.pendingActions, stamped] });
+    }
+    if (stamped.type === "confirm") {
+      this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+    }
+  }
+  // ── Continuation: when all current-turn actions finish, ask the
+  // model what to do next, given the outcomes + fresh snapshot.
+  async runContinuation(turn) {
+    if (this.continuationInFlight) return;
+    this.continuationInFlight = true;
+    try {
+      this.setState({ isLoading: true, loadingStatusKey: "statusWaitingApp" });
+      const toolWithoutEffectIds = /* @__PURE__ */ new Set();
+      const turnActions = this.state.pendingActions.filter(
+        (a) => turn.actionIds.has(a.id)
+      );
+      const pressedId = extractPressedComponentId(turnActions);
+      const navigateTargetScreen = extractNavigateTargetScreen(turnActions);
+      const settle = await this.deps.adapter.settleTurn({
+        hadNavigate: turn.hadNavigate,
+        preNavigateScreen: turn.preNavigateScreen,
+        preNavigateSignature: turn.preNavigateSignature,
+        turnActions,
+        results: Array.from(turn.results.entries()).map(([actionId, r]) => ({
+          actionId,
+          type: r.type,
+          success: r.success
+        })),
+        pressedComponentId: pressedId,
+        navigateTargetScreen
+      });
+      const loadingPending = settle.loadingPending;
+      for (const id of settle.toolWithoutEffectIds) toolWithoutEffectIds.add(id);
+      const context = this.deps.adapter.buildContext({ loadingPending });
+      const snap = context.snapshot;
+      const activePath = context.navigationState?.activePath ?? [];
+      for (const action of turnActions) {
+        const result = turn.results.get(action.id);
+        if (result?.success && formFillLackedWriteEffect(action, snap, activePath)) {
+          toolWithoutEffectIds.add(action.id);
+          this.warn(
+            `tool-without-effect: form_fill succeeded but create form is still open (actionId="${action.id}")`
+          );
+        }
+      }
+      const results = Array.from(turn.actionIds).map((actionId) => {
+        const r = turn.results.get(actionId);
+        if (!r) {
+          return {
+            actionId,
+            type: "unknown",
+            success: false,
+            error: "no result reported",
+            summary: actionId,
+            diagnose: void 0,
+            recoveryAttempt: 0,
+            recoveryExhausted: false,
+            toolWithoutEffect: false,
+            effect: "unknown"
+          };
+        }
+        const hasToolWithoutEffect = toolWithoutEffectIds.has(actionId);
+        let recoveryAttempt = 0;
+        let recoveryExhausted = false;
+        if (!r.success || hasToolWithoutEffect) {
+          const previous = this.recoveryCountByFingerprint.get(r.fingerprint) ?? 0;
+          const next = previous + 1;
+          this.recoveryCountByFingerprint.set(r.fingerprint, next);
+          recoveryAttempt = next;
+          recoveryExhausted = next >= MAX_RECOVERY_ATTEMPTS_PER_ACTION;
+        }
+        return {
+          actionId,
+          type: r.type,
+          success: r.success,
+          error: r.error,
+          summary: r.summary,
+          diagnose: r.diagnose,
+          recoveryAttempt,
+          recoveryExhausted,
+          toolWithoutEffect: hasToolWithoutEffect,
+          effect: hasToolWithoutEffect ? "none" : r.effect,
+          userVisibleStatusKey: r.userVisibleStatusKey
+        };
+      });
+      const exhausted = results.filter((r) => r.recoveryExhausted);
+      this.setState({
+        loadingStatusKey: results.some((r) => !r.success || r.toolWithoutEffect) ? "statusAdjusting" : "statusAnalyzing"
+      });
+      console.log(
+        `[Appilots] ChatSessionMachine: running continuation hop=${turn.hop} (${results.filter((r) => r.success).length}/${results.length} succeeded` + (exhausted.length > 0 ? `, ${exhausted.length} recovery-exhausted` : "") + ")"
+      );
+      const response = await this.deps.client.continueAgent(results, context, turn.hop);
+      this.addAssistantMessage(response.message);
+      this.deps.emit({
+        type: "agent:message",
+        timestamp: Date.now(),
+        data: { message: response.message, usage: response.usage }
+      });
+      if (response.isDone || !response.actions || response.actions.length === 0) {
+        this.currentTurn = null;
+        this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+        return;
+      }
+      this.beginTurn(response.message.id, response.actions, response.hop);
+    } catch (err) {
+      const raw = err instanceof Error ? err.message : "Continuation failed";
+      this.warn("ChatSessionMachine: continuation failed \u2014", raw);
+      const recentUserTexts = this.state.messages.filter((m) => m.role === "user").slice(-4).map((m) => m.content);
+      const friendly = buildContinuationFailureMessage(raw, recentUserTexts);
+      this.addAssistantMessage({
+        id: `error_${++this.messageIdCounter}`,
+        role: "assistant",
+        content: friendly,
+        timestamp: Date.now()
+      });
+      if (!this.state.escalation && this.options.escalationStrings?.offer) {
+        this.appendLocalSystemMessage(this.options.escalationStrings.offer, {
+          escalationOffer: true
+        });
+      }
+      if (turn) {
+        this.setState({
+          pendingActions: this.state.pendingActions.map(
+            (a) => turn.actionIds.has(a.id) && (a.status === "pending" || a.status === "executing") ? { ...a, status: "failed", error: friendly } : a
+          )
+        });
+        for (const actionId of turn.actionIds) {
+          if (turn.reportedIds.has(actionId)) continue;
+          this.deps.emit({
+            type: "agent:action:error",
+            timestamp: Date.now(),
+            data: { actionId, error: friendly, abandoned: true }
+          });
+        }
+      }
+      this.currentTurn = null;
+      this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+    } finally {
+      this.continuationInFlight = false;
+    }
+  }
+  // ── Event intake: action lifecycle events drive the loop ─────
+  handleEvent(event) {
+    if (event.type === "agent:action:start") {
+      const action = event.data?.action;
+      if (!action?.id || action.type !== "confirm") return;
+      const injectedBy = action.payload?.injectedBy;
+      if (injectedBy !== "sdk-local") return;
+      this.registerSynthesizedTurnAction(action);
+      return;
+    }
+    if (event.type !== "agent:action:complete" && event.type !== "agent:action:error") return;
+    const turn = this.currentTurn;
+    if (!turn) return;
+    const actionId = event.data?.actionId;
+    if (!actionId || !turn.actionIds.has(actionId)) return;
+    if (turn.reportedIds.has(actionId)) return;
+    const success = event.type === "agent:action:complete";
+    const errorMsg = event.data?.error || void 0;
+    const diagnose = event.data?.diagnose;
+    const effect = event.data?.effect;
+    const userVisibleStatusKey = event.data?.userVisibleStatusKey;
+    const existing = turn.results.get(actionId);
+    if (existing) {
+      existing.success = success;
+      existing.error = errorMsg;
+      existing.diagnose = diagnose;
+      existing.effect = effect;
+      existing.userVisibleStatusKey = userVisibleStatusKey;
+    }
+    turn.reportedIds.add(actionId);
+    if (turn.reportedIds.size >= turn.actionIds.size) {
+      void this.runContinuation(turn);
+    }
+  }
+  // ── Send / cancel / clear ────────────────────────────────────
+  async sendMessage(content) {
+    if (!content.trim() || this.state.isLoading) return;
+    if (this.state.escalation) {
+      await this.sendEscalationMessage(content.trim());
+      return;
+    }
+    const errorPrefix = this.options.errorPrefix ?? "Algo deu errado";
+    const streamingEnabled = this.options.streaming !== false;
+    this.setState({ error: null, isLoading: true, loadingStatusKey: "statusAnalyzing" });
+    this.currentTurn = null;
+    this.recoveryCountByFingerprint = /* @__PURE__ */ new Map();
+    const userMessage = {
+      id: `local_${++this.messageIdCounter}`,
+      role: "user",
+      content: content.trim(),
+      timestamp: Date.now()
+    };
+    this.setState({ messages: [...this.state.messages, userMessage] });
+    const streamingId = `streaming_${++this.messageIdCounter}`;
+    let streamedVisible = false;
+    const removeStreamingPlaceholder = () => {
+      if (!streamedVisible) return;
+      streamedVisible = false;
+      this.setState({ messages: this.state.messages.filter((m) => m.id !== streamingId) });
+    };
+    const abortController = new AbortController();
+    this.abortController = abortController;
+    try {
+      const context = this.deps.adapter.buildContext();
+      console.log(
+        `[Appilots] ChatSessionMachine sendMessage: context \u2014 currentScreen="${context.currentScreen ?? "unknown"}", snapshot={texts:${context.snapshot?.texts?.length ?? 0}, inputs:${context.snapshot?.inputs?.length ?? 0}, buttons:${context.snapshot?.buttons?.length ?? 0}, elements:${context.snapshot?.elements?.length ?? 0}, lists:${context.snapshot?.lists?.length ?? 0}, listItems:${(context.snapshot?.lists ?? []).reduce((acc, l) => acc + (l.items?.length ?? 0), 0)}, choiceGroups:${context.snapshot?.choiceGroups?.length ?? 0}}`
+      );
+      let response;
+      if (streamingEnabled) {
+        try {
+          response = await this.deps.client.sendMessageStream(content.trim(), context, {
+            signal: abortController.signal,
+            onTextDelta: (_chunk, fullText) => {
+              const visible = sanitizeVisibleAssistantContent(fullText);
+              if (!streamedVisible) {
+                streamedVisible = true;
+                this.setState({
+                  messages: [
+                    ...this.state.messages,
+                    { id: streamingId, role: "assistant", content: visible, timestamp: Date.now() }
+                  ]
+                });
+              } else {
+                this.setState({
+                  messages: this.state.messages.map(
+                    (m) => m.id === streamingId ? { ...m, content: visible } : m
+                  )
+                });
+              }
+            }
+          });
+        } catch (err) {
+          if (err instanceof StreamTransportError) {
+            console.warn(
+              `[Appilots] streaming unavailable, falling back to JSON: ${err.message}`
+            );
+            response = await this.deps.client.sendMessage(content.trim(), context);
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        response = await this.deps.client.sendMessage(content.trim(), context);
+      }
+      console.log(
+        `[Appilots] ChatSessionMachine sendMessage: response received \u2014 actions=${response.actions?.length ?? 0}, hasSummary=${!!response.summaryMessage}`
+      );
+      removeStreamingPlaceholder();
+      this.addAssistantMessage(response.message);
+      this.beginTurn(response.message.id, response.actions, 1);
+      if (response.summaryMessage) {
+        this.addAssistantMessage(response.summaryMessage);
+      }
+      this.deps.emit({
+        type: "agent:message",
+        timestamp: Date.now(),
+        data: { message: response.message, usage: response.usage }
+      });
+      if (!response.actions || response.actions.length === 0) {
+        this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+      }
+    } catch (err) {
+      if (err instanceof StreamAbortError || err instanceof Error && err.name === "AbortError") {
+        this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+        return;
+      }
+      removeStreamingPlaceholder();
+      const errorMessage = err instanceof Error ? err.message : "Failed to send message";
+      this.setState({ error: errorMessage });
+      this.addAssistantMessage({
+        id: `error_${++this.messageIdCounter}`,
+        role: "assistant",
+        content: `${errorPrefix}: ${errorMessage}`,
+        timestamp: Date.now()
+      });
+      this.setState({ isLoading: false, loadingStatusKey: "thinking" });
+    } finally {
+      if (this.abortController === abortController) {
+        this.abortController = null;
+      }
+    }
+  }
+  /**
+   * Cancels the in-flight generation. Streamed partial text is kept in
+   * the transcript; a no-op when nothing is in flight. Cancellation
+   * only covers the generation phase — once actions start executing
+   * they run to completion.
+   */
+  cancelMessage() {
+    this.abortController?.abort();
+  }
+  clearMessages() {
+    this.setState({
+      messages: [],
+      pendingActions: [],
+      error: null,
+      isLoading: false,
+      loadingStatusKey: "thinking"
+    });
+    this.currentTurn = null;
+    this.continuationInFlight = false;
+    this.recoveryCountByFingerprint = /* @__PURE__ */ new Map();
+    if (this.state.escalation) {
+      void this.deps.client.abandonEscalation(this.state.escalation.id);
+    }
+    this.setState({ escalation: null });
+    this.closeEscalationStream();
+    this.escalationSince = void 0;
+    this.seenHumanMessageIds = /* @__PURE__ */ new Set();
+    this.escalationReconnectAttempt = 0;
+    void this.deps.client.destroySession();
+  }
+  clearError() {
+    this.setState({ error: null });
+  }
+};
+function readPayload(action) {
+  return action.payload ?? {};
+}
+function isStructuredRisky(value) {
+  return value === true || value === "destructive" || value === "danger" || value === "high";
+}
+function actionMetadataRequiresConfirmation(meta) {
+  if (meta.requiresConfirmation === true || meta.destructive === true || meta.effect === "destructive" || meta.riskLevel === "high" || meta.risk === "destructive") {
+    return { required: true, label: typeof meta.label === "string" ? meta.label : void 0, source: "screen-metadata" };
+  }
+  return { required: false };
+}
+function payloadRequiresConfirmation(action) {
+  const payload = readPayload(action);
+  if (action.destructive === true || payload.destructive === true || payload.requiresConfirmation === true || isStructuredRisky(payload.effect) || isStructuredRisky(payload.risk) || isStructuredRisky(payload.riskLevel) || isStructuredRisky(payload.actionRisk)) {
+    return {
+      required: true,
+      label: typeof payload.actionDescription === "string" && payload.actionDescription || typeof payload.label === "string" && payload.label || void 0,
+      source: "action-policy"
+    };
+  }
+  const policy = payload._appilotsPolicy;
+  if (policy && typeof policy === "object") {
+    const p = policy;
+    if (p.requiresConfirmation === true || isStructuredRisky(p.effect) || isStructuredRisky(p.risk) || isStructuredRisky(p.riskLevel)) {
+      return {
+        required: true,
+        label: typeof p.summary === "string" ? p.summary : void 0,
+        source: "inline-policy"
+      };
+    }
+  }
+  return { required: false };
+}
+function isConfirmGateFor(confirm, target) {
+  if (confirm.type !== "confirm") return false;
+  const payload = readPayload(confirm);
+  const injectedBy = payload.injectedBy;
+  return payload.gatedActionId === target.id && (injectedBy === "permissions" || injectedBy === "sdk-local");
+}
+function findGatingConfirm(target, actions) {
+  return actions.find((a) => isConfirmGateFor(a, target));
+}
+function toDestructiveConfirmPayload(confirm, policy, fallbackLabel) {
+  const payload = readPayload(confirm);
+  const existingDescription = typeof payload.actionDescription === "string" && payload.actionDescription ? payload.actionDescription : void 0;
+  const labelText = policy.label ?? existingDescription ?? fallbackLabel ?? "esta a\xE7\xE3o";
+  return {
+    ...payload,
+    title: "A\xE7\xE3o destrutiva",
+    message: `Tem certeza que deseja "${labelText}"?`,
+    actionDescription: labelText,
+    severity: "danger",
+    destructive: true,
+    confirmLabel: typeof payload.confirmLabel === "string" && payload.confirmLabel ? payload.confirmLabel : "Sim, executar",
+    cancelLabel: typeof payload.cancelLabel === "string" && payload.cancelLabel ? payload.cancelLabel : "Cancelar"
+  };
+}
+function confirmNeedsDestructiveUpgrade(confirm) {
+  const payload = readPayload(confirm);
+  return confirm.destructive !== true || payload.destructive !== true || payload.severity !== "danger";
+}
+function actionHasCompletedConfirmGate(action, actions) {
+  return actions.some((candidate) => {
+    if (!isConfirmGateFor(candidate, action)) return false;
+    if (candidate.status !== "completed") return false;
+    const payload = readPayload(candidate);
+    return payload.destructive === true || payload.severity === "danger";
+  });
+}
+var ActionQueueMachine = class {
+  deps;
+  options;
+  state = { actions: [] };
+  listeners = /* @__PURE__ */ new Set();
+  /** Action ids already dispatched — never auto-executed twice. */
+  processed = /* @__PURE__ */ new Set();
+  /** Guards against overlapping sequential runs. */
+  draining = false;
+  /** Set when new work arrives while a drain is in flight. */
+  drainRequested = false;
+  /** Set while a drain is queued on the microtask queue. */
+  drainScheduled = false;
+  constructor(deps, options = {}) {
+    this.deps = deps;
+    this.options = options;
+    this.getState = this.getState.bind(this);
+    this.subscribeState = this.subscribeState.bind(this);
+    this.handleEvent = this.handleEvent.bind(this);
+    this.approveAction = this.approveAction.bind(this);
+    this.rejectAction = this.rejectAction.bind(this);
+  }
+  // ── State plumbing ───────────────────────────────────────────
+  getState() {
+    return this.state;
+  }
+  subscribeState(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  setActions(next) {
+    if (next === this.state.actions) return;
+    this.state = { actions: next };
+    for (const listener of this.listeners) listener();
+  }
+  updateActions(updater) {
+    this.setActions(updater(this.state.actions));
+  }
+  warn(message, ...args) {
+    (this.deps.warn ?? console.warn)(message, ...args);
+  }
+  // ── Event intake: new actions from the agent ─────────────────
+  handleEvent(event) {
+    if (event.type !== "agent:action:start") return;
+    const action = event.data?.action;
+    if (!action?.id) return;
+    console.log(
+      `[Appilots] ActionQueueMachine: received agent:action:start event, action id="${action.id}", type="${action.type}"`
+    );
+    if (this.state.actions.some((a) => a.id === action.id)) return;
+    this.setActions([...this.state.actions, action]);
+    this.scheduleDrain();
+  }
+  /**
+   * Kick the sequential executor. Safe to call at any time — it
+   * coalesces while a drain is already running so a burst of arriving
+   * actions produces exactly one in-order pass.
+   *
+   * The drain is deferred to a microtask, and that is load-bearing, not
+   * a nicety. A turn's actions arrive as a synchronous burst of
+   * `agent:action:start` events, and a confirm gating a destructive
+   * action can arrive AFTER the action it protects. Draining
+   * synchronously on the first event would execute that action while
+   * its gate is still in flight — a delete running before the user
+   * confirmed it. Deferring lets the whole burst land first, so the
+   * gate is visible by the time anything executes. (The React hook this
+   * was extracted from got the same guarantee for free, from state
+   * batching before its effect ran.)
+   */
+  scheduleDrain() {
+    if (!this.options.autoExecute) return;
+    if (this.draining) {
+      this.drainRequested = true;
+      return;
+    }
+    if (this.drainScheduled) return;
+    this.drainScheduled = true;
+    queueMicrotask(() => {
+      this.drainScheduled = false;
+      if (!this.options.autoExecute) return;
+      if (this.draining) {
+        this.drainRequested = true;
+        return;
+      }
+      void this.drain();
+    });
+  }
+  async drain() {
+    this.draining = true;
+    try {
+      do {
+        this.drainRequested = false;
+        await this.executeSequentially();
+      } while (this.drainRequested);
+    } finally {
+      this.draining = false;
+    }
+  }
+  // ── Confirm gating (defense-in-depth) ────────────────────────
+  /**
+   * Client-side defense-in-depth confirm injection.
+   *
+   * When the server's permission filter MISSES a destructive action
+   * (e.g. the MCP doc is stale and doesn't have the destructive flag
+   * for that action, but the live screen metadata DOES have
+   * `requiresConfirmation: true`), the action would otherwise execute
+   * immediately with no user confirmation — exactly the "delete
+   * executed before I confirmed" bug.
+   *
+   * Returns `true` when the target must NOT execute this pass (either
+   * a synthetic confirm was injected, or one is already gating it).
+   */
+  ensureLocalConfirmIfNeeded(target) {
+    if (target.type !== "ui_interaction") return false;
+    const payload = target.payload;
+    const componentId = typeof payload?.componentId === "string" && payload.componentId || typeof payload?.targetId === "string" && payload.targetId || "";
+    let policy = payloadRequiresConfirmation(target);
+    if (!policy.required && componentId) {
+      const screen = this.deps.adapter.getCurrentScreen();
+      const actionsMeta = screen ? this.deps.adapter.getScreenActionsMetadata(screen) : void 0;
+      if (actionsMeta && Array.isArray(actionsMeta)) {
+        const match = actionsMeta.find((a) => {
+          if (typeof a === "string") return false;
+          return metadataMatchesComponentId(a.id, componentId);
+        });
+        if (match && typeof match !== "string") {
+          policy = actionMetadataRequiresConfirmation(match);
+        }
+      }
+    }
+    const existingGate = findGatingConfirm(target, this.state.actions);
+    if (existingGate) {
+      if (policy.required && confirmNeedsDestructiveUpgrade(existingGate)) {
+        this.updateActions(
+          (prev) => prev.map(
+            (a) => a.id === existingGate.id ? {
+              ...a,
+              destructive: true,
+              payload: toDestructiveConfirmPayload(a, policy, componentId || target.id)
+            } : a
+          )
+        );
+      }
+      return false;
+    }
+    if (!policy.required) return false;
+    const confirmId = `confirm-local-${target.id}`;
+    if (this.state.actions.some((a) => a.id === confirmId)) return true;
+    console.log(
+      `[Appilots] ActionQueueMachine: action "${componentId || target.id}" requires confirmation (${policy.source ?? "local-policy"}) \u2014 synthesising local confirm (id="${confirmId}")`
+    );
+    const synth = {
+      id: confirmId,
+      type: "confirm",
+      // Flagged at the top level too, not only inside the payload: this
+      // is the field a chat surface reads to render the danger variant,
+      // and we only synthesize a confirm because the target IS
+      // destructive. The upgrade path above sets it for the same reason.
+      destructive: true,
+      payload: toDestructiveConfirmPayload(
+        {
+          payload: {
+            gatedActionId: target.id,
+            gatedActionType: target.type,
+            injectedBy: "sdk-local"
+          },
+          messageId: target.messageId
+        },
+        policy,
+        componentId || "esta a\xE7\xE3o"
+      ),
+      status: "pending",
+      messageId: target.messageId
+    };
+    this.updateActions((prev) => {
+      const idx = prev.findIndex((a) => a.id === target.id);
+      if (idx < 0) return [...prev, synth];
+      return [...prev.slice(0, idx), synth, ...prev.slice(idx)];
+    });
+    this.deps.emit({
+      type: "agent:action:start",
+      timestamp: Date.now(),
+      data: { action: synth }
+    });
+    return true;
+  }
+  // ── Sequential auto-execution ────────────────────────────────
+  /**
+   * Execute pending actions in order so chained actions (e.g.
+   * form_fill → press button) run in the correct sequence.
+   */
+  async executeSequentially() {
+    const pending = this.state.actions.filter(
+      (a) => a.status === "pending" && !this.processed.has(a.id)
+    );
+    console.log(
+      `[Appilots] ActionQueueMachine: autoExecute check \u2014 ${pending.length} pending action(s) to process`
+    );
+    let lastWasNavigate = false;
+    let preNavScreen = null;
+    let preNavSignature = null;
+    for (const action of pending) {
+      if (action.type === "confirm") {
+        continue;
+      }
+      if (this.ensureLocalConfirmIfNeeded(action)) {
+        continue;
+      }
+      const gate = findGatingConfirm(action, this.state.actions);
+      if (gate) {
+        if (gate.status === "pending" || gate.status === "executing") {
+          console.log(
+            `[Appilots] ActionQueueMachine: action id="${action.id}" is gated by confirm id="${gate.id}" (status=${gate.status}); waiting for user decision`
+          );
+          continue;
+        }
+        if (gate.status === "failed") {
+          console.log(
+            `[Appilots] ActionQueueMachine: confirm id="${gate.id}" was rejected; skipping gated action id="${action.id}"`
+          );
+          this.processed.add(action.id);
+          this.updateActions(
+            (prev) => prev.map(
+              (a) => a.id === action.id ? { ...a, status: "failed", error: "Confirm canceled by user" } : a
+            )
+          );
           try {
-            handleEvent(JSON.parse(line.slice(6)));
+            await this.deps.client.completeAction(action.id, false, "Confirm canceled by user");
           } catch {
-            this.log("Skipping unparseable escalation SSE line:", line.slice(0, 120));
           }
+          this.deps.emit({
+            type: "agent:action:error",
+            timestamp: Date.now(),
+            data: {
+              actionId: action.id,
+              actionType: action.type,
+              success: false,
+              error: "Confirm canceled by user"
+            }
+          });
+          continue;
         }
       }
-    };
-    xhr.open("GET", url);
-    for (const [key, value] of Object.entries(this.headers)) {
-      xhr.setRequestHeader(key, value);
+      if (lastWasNavigate) {
+        const settle = await this.deps.adapter.waitForScreenSettle({
+          expectingChange: true,
+          fromScreen: preNavScreen,
+          fromSignature: preNavSignature,
+          maxMs: 3500
+        });
+        console.log(
+          `[Appilots] ActionQueueMachine: post-navigate settle done \u2014 screen="${settle.screen}" transitioned=${settle.transitioned} timedOut=${settle.timedOut} waitedMs=${settle.waitedMs}`
+        );
+      }
+      console.log(
+        `[Appilots] ActionQueueMachine: auto-executing action id="${action.id}" type="${action.type}"`
+      );
+      this.processed.add(action.id);
+      if (action.type === "navigate") {
+        preNavScreen = this.deps.adapter.getCurrentScreen();
+        preNavSignature = this.deps.adapter.getCurrentScreenSignature();
+      }
+      const succeeded = await this.approveAction(action.id);
+      if (!succeeded) {
+        this.warn(
+          `ActionQueueMachine: stopping current action batch after failed action id="${action.id}"`
+        );
+        break;
+      }
+      lastWasNavigate = action.type === "navigate";
     }
-    xhr.setRequestHeader("Accept", "text/event-stream");
-    xhr.onprogress = consumeBuffer;
-    xhr.onload = () => {
-      consumeBuffer();
-      end();
-    };
-    xhr.onerror = end;
-    xhr.onabort = end;
-    xhr.send();
-    return () => {
-      closedByCaller = true;
+  }
+  // ── Approve & execute an action ─────────────────────────────
+  async approveAction(actionId) {
+    const action = this.state.actions.find((a) => a.id === actionId);
+    if (!action) return false;
+    console.log(
+      `[Appilots] ActionQueueMachine: action status transition: pending \u2192 executing (id="${actionId}", type="${action.type}")`
+    );
+    this.updateActions(
+      (prev) => prev.map((a) => a.id === actionId ? { ...a, status: "executing" } : a)
+    );
+    try {
+      const confirmedDestructive = actionHasCompletedConfirmGate(action, this.state.actions);
+      const result = await this.deps.adapter.execute(
+        { ...action, status: "executing" },
+        { confirmedDestructive }
+      );
+      if (result.success) {
+        console.log(
+          `[Appilots] ActionQueueMachine: action status transition: executing \u2192 completed (id="${actionId}", type="${action.type}")`
+        );
+        this.updateActions(
+          (prev) => prev.map((a) => a.id === actionId ? { ...a, status: "completed" } : a)
+        );
+        try {
+          await this.deps.client.completeAction(actionId, true);
+        } catch {
+        }
+        this.scheduleDrain();
+        return true;
+      }
+      this.warn(
+        `ActionQueueMachine: action status transition: executing \u2192 failed (id="${actionId}", type="${action.type}", error="${result.error}")`
+      );
+      this.updateActions(
+        (prev) => prev.map(
+          (a) => a.id === actionId ? { ...a, status: "failed", error: result.error } : a
+        )
+      );
       try {
-        xhr.abort();
+        await this.deps.client.completeAction(
+          actionId,
+          false,
+          result.error,
+          result.diagnose
+        );
       } catch {
       }
-    };
+      return false;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Action failed";
+      this.warn(
+        `ActionQueueMachine: action status transition: executing \u2192 failed (exception) (id="${actionId}", error="${errorMsg}")`
+      );
+      this.updateActions(
+        (prev) => prev.map(
+          (a) => a.id === actionId ? { ...a, status: "failed", error: errorMsg } : a
+        )
+      );
+      try {
+        await this.deps.client.completeAction(actionId, false, errorMsg);
+      } catch {
+      }
+      return false;
+    }
+  }
+  // ── Reject an action ────────────────────────────────────────
+  async rejectAction(actionId) {
+    this.updateActions(
+      (prev) => prev.map(
+        (a) => a.id === actionId ? { ...a, status: "failed", error: "Rejected by user" } : a
+      )
+    );
+    const action = this.state.actions.find((a) => a.id === actionId);
+    this.deps.emit({
+      type: "agent:action:error",
+      timestamp: Date.now(),
+      data: {
+        actionId,
+        actionType: action?.type,
+        success: false,
+        error: "Rejected by user"
+      }
+    });
+    try {
+      await this.deps.client.completeAction(actionId, false, "Rejected by user");
+    } catch {
+    }
+    this.scheduleDrain();
+  }
+  // ── Derived views ───────────────────────────────────────────
+  get pendingActions() {
+    return this.state.actions.filter((a) => a.status === "pending");
+  }
+  get executingActions() {
+    return this.state.actions.filter((a) => a.status === "executing");
+  }
+  get completedActions() {
+    return this.state.actions.filter(
+      (a) => a.status === "completed" || a.status === "failed"
+    );
   }
 };
+function normalize3(s) {
+  return s.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]/g, "");
+}
+function matchScore(needle, hay) {
+  if (!needle || !hay) return 0;
+  if (needle === hay) return 100;
+  if (hay.startsWith(needle) || needle.startsWith(hay)) return 75;
+  if (hay.endsWith(needle) || needle.endsWith(hay)) return 60;
+  if (hay.includes(needle) || needle.includes(hay)) return 40;
+  return 0;
+}
+function isGenericSelectValue(value) {
+  if (value === void 0 || value === null || value === "") return true;
+  const normalized = normalize3(String(value));
+  if (!normalized) return true;
+  return /^(any|qualquer|random|aleatorio|aleatoria|auto|automatico|automatica|mock|mockado|mockada|mockados|mockadas|dummy|sample|exemplo|default|padrao|teste|test)$/.test(
+    normalized
+  );
+}
+var LIST_ORDINAL_RE = /^list-\d+-item-\d+$/i;
+function normalizeId(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+}
+function isOptionalCosmeticTargetId(targetId) {
+  if (typeof targetId !== "string" || !targetId.trim()) return false;
+  const id = normalizeId(targetId);
+  return /foto|photo|avatar|icone|icon|emoji|sheetaction|sheet-action|btn-foto/.test(id) || id.includes("photo-sheet");
+}
+function routeLooksLikeFormContext(route) {
+  const haystack = normalizeId(route ?? "");
+  return /create|edit|form|cadastr|register|novo|vehiclecreate|subscriptioncreate|vehicleedit|subscriptioncreate/.test(
+    haystack
+  );
+}
+function screenPathParts(screen) {
+  if (!screen) return [];
+  return screen.split("/").map((part) => part.trim()).filter(Boolean);
+}
+function isMisappliedListOrdinalOnForm(targetId, screen, activePath) {
+  if (typeof targetId !== "string" || !LIST_ORDINAL_RE.test(targetId.trim())) {
+    return false;
+  }
+  const routes = [...screenPathParts(screen), ...activePath ?? []];
+  if (routes.length === 0) return routeLooksLikeFormContext(screen);
+  return routes.some((route) => routeLooksLikeFormContext(route));
+}
+function isOptionalStepAutomationFailure(targetId, screen, activePath) {
+  return isOptionalCosmeticTargetId(targetId) || isMisappliedListOrdinalOnForm(targetId, screen, activePath);
+}
+var OPTIONAL_STEP_AUTOMATION_HINT = "optional-step-automation-failed";
+function describeAction(action) {
+  const state = mapStatus(action.status);
+  const label = labelFor(action, state);
+  return { label, state };
+}
+function mapStatus(status) {
+  switch (status) {
+    case "pending":
+      return "pending";
+    case "executing":
+      return "running";
+    case "completed":
+      return "success";
+    case "failed":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+function labelFor(action, state) {
+  if (state === "failed") {
+    return failureLabel(action);
+  }
+  switch (action.type) {
+    case "navigate":
+      return navigateLabel(action, state);
+    case "form_fill":
+      return formFillLabel(action, state);
+    case "ui_interaction":
+      return uiInteractionLabel(action, state);
+    case "scroll_list":
+      return scrollListLabel(action, state);
+    case "confirm":
+      return confirmLabel(state);
+    default:
+      return genericLabel(action.type, state);
+  }
+}
+function navigateLabel(action, state) {
+  const screen = readString(action.payload, "screenName") || "a outra tela";
+  switch (state) {
+    case "pending":
+      return `Vou navegar para ${screen}`;
+    case "running":
+      return `Navegando para ${screen}...`;
+    case "success":
+      return `Naveguei para ${screen}`;
+    default:
+      return `Navega\xE7\xE3o para ${screen}`;
+  }
+}
+function formFillLabel(action, state) {
+  const fields = readArray(action.payload, "fields");
+  const summary = summariseFields(fields);
+  switch (state) {
+    case "pending":
+      return summary ? `Vou preencher ${summary}` : "Vou preencher o formul\xE1rio";
+    case "running":
+      return summary ? `Preenchendo ${summary}...` : "Preenchendo formul\xE1rio...";
+    case "success":
+      return summary ? `Preenchi ${summary}` : "Preenchi o formul\xE1rio";
+    default:
+      return "Preenchimento do formul\xE1rio";
+  }
+}
+function uiInteractionLabel(action, state) {
+  const verbBase = uiVerb(readString(action.payload, "action"));
+  const target = humanActionTarget(action.payload);
+  const where = target ? ` em ${target}` : "";
+  switch (state) {
+    case "pending":
+      return `Vou ${verbBase.infinitive}${where}`;
+    case "running":
+      return `${verbBase.gerund}${where}...`;
+    case "success":
+      return `${verbBase.past}${where}`;
+    default:
+      return `Intera\xE7\xE3o${where}`;
+  }
+}
+function scrollListLabel(action, state) {
+  const payload = action.payload;
+  const toIndex = typeof payload?.toIndex === "number" ? payload.toIndex : void 0;
+  const direction = payload?.direction === "up" ? "para cima" : "para baixo";
+  const target = toIndex !== void 0 ? `at\xE9 o item ${toIndex}` : direction;
+  switch (state) {
+    case "pending":
+      return `Vou rolar a lista ${target}`;
+    case "running":
+      return `Rolando a lista ${target}...`;
+    case "success":
+      return `Rolei a lista ${target}`;
+    default:
+      return "Rolagem da lista";
+  }
+}
+function confirmLabel(state) {
+  switch (state) {
+    case "pending":
+    case "running":
+      return "Aguardando confirma\xE7\xE3o";
+    case "success":
+      return "Voc\xEA confirmou";
+    case "failed":
+      return "Confirma\xE7\xE3o cancelada";
+    default:
+      return "Confirma\xE7\xE3o";
+  }
+}
+function genericLabel(type, state) {
+  switch (state) {
+    case "pending":
+      return `Vou executar ${type}`;
+    case "running":
+      return `Executando ${type}...`;
+    case "success":
+      return `Executei ${type}`;
+    default:
+      return type;
+  }
+}
+function failureLabel(action) {
+  const cause = humanizeError(action.error);
+  const head = failureHead(action);
+  return cause ? `${head} (${cause})` : head;
+}
+function failureHead(action) {
+  switch (action.type) {
+    case "navigate": {
+      const screen = readString(action.payload, "screenName") || "a tela";
+      return `N\xE3o consegui navegar para ${screen}`;
+    }
+    case "form_fill":
+      return "N\xE3o consegui preencher o formul\xE1rio";
+    case "ui_interaction": {
+      const verb = uiVerb(readString(action.payload, "action"));
+      const target = humanComponentId(
+        readString(action.payload, "componentId") || readString(action.payload, "targetId")
+      );
+      return target ? `N\xE3o consegui ${verb.infinitive} em ${target}` : `N\xE3o consegui ${verb.infinitive}`;
+    }
+    case "scroll_list":
+      return "N\xE3o consegui rolar a lista";
+    case "confirm":
+      return "Voc\xEA cancelou";
+    default:
+      return `N\xE3o consegui executar ${action.type}`;
+  }
+}
+var TECHNICAL_PATTERNS = [
+  /\bat\s+\S+\s*\(/,
+  // stack trace frame
+  /TypeError|ReferenceError|SyntaxError|RangeError/i,
+  /HTTP\s*[45]\d{2}/i,
+  /^\s*\{[\s\S]*\}\s*$/,
+  // JSON dump
+  /undefined is not a function/i,
+  /Cannot read propert/i
+];
+var FRIENDLY_REWRITES = [
+  [/rejected by user/i, "cancelado pelo usu\xE1rio"],
+  [/component '([^']+)' not found/i, "componente $1 n\xE3o encontrado"],
+  [/field '([^']+)' not found/i, "campo $1 n\xE3o encontrado"],
+  [/screen '([^']+)' not registered/i, "tela $1 n\xE3o registrada"],
+  [/permission denied/i, "sem permiss\xE3o"],
+  [/timeout|timed out/i, "tempo esgotado"],
+  [/network/i, "falha de rede"]
+];
+var MAX_REASON_LEN = 80;
+function humanizeError(raw, _action) {
+  if (!raw) return void 0;
+  const trimmed = String(raw).trim();
+  if (!trimmed) return void 0;
+  for (const [pattern, replacement] of FRIENDLY_REWRITES) {
+    if (pattern.test(trimmed)) {
+      return finalize(trimmed.replace(pattern, replacement));
+    }
+  }
+  if (TECHNICAL_PATTERNS.some((p) => p.test(trimmed))) {
+    return "algo deu errado";
+  }
+  if (trimmed.length > MAX_REASON_LEN) {
+    return "algo deu errado";
+  }
+  return finalize(trimmed);
+}
+function finalize(text) {
+  let out = text.trim();
+  if (out.length > MAX_REASON_LEN) out = out.slice(0, MAX_REASON_LEN - 1).trimEnd() + "\u2026";
+  if (out.length > 0) out = out[0].toLowerCase() + out.slice(1);
+  return out;
+}
+function uiVerb(raw) {
+  switch ((raw ?? "press").toLowerCase()) {
+    case "press":
+    case "tap":
+    case "click":
+      return { infinitive: "clicar", gerund: "Clicando", past: "Cliquei" };
+    case "longpress":
+    case "long_press":
+      return { infinitive: "pressionar", gerund: "Pressionando", past: "Pressionei" };
+    case "scroll":
+    case "scroll_to":
+      return { infinitive: "rolar", gerund: "Rolando", past: "Rolei" };
+    case "focus":
+      return { infinitive: "focar", gerund: "Focando", past: "Foquei" };
+    default:
+      return { infinitive: "interagir", gerund: "Interagindo", past: "Interagi" };
+  }
+}
+function summariseFields(fields) {
+  if (!Array.isArray(fields) || fields.length === 0) return void 0;
+  const parts = [];
+  const visible = fields.slice(0, 3);
+  for (const f of visible) {
+    if (!f || typeof f !== "object") continue;
+    const obj = f;
+    const name = humanFieldName(obj.label, obj.fieldId);
+    if (!name) continue;
+    const fieldIdStr = typeof obj.fieldId === "string" ? obj.fieldId : void 0;
+    const labelStr = typeof obj.label === "string" ? obj.label : void 0;
+    const fieldTypeStr = typeof obj.fieldType === "string" ? obj.fieldType : void 0;
+    const sensitive = isSensitiveFieldName(fieldIdStr, labelStr, void 0, fieldTypeStr);
+    if (sensitive) {
+      parts.push(`${name}=\u2022\u2022\u2022\u2022`);
+      continue;
+    }
+    const value = formatFieldValue(obj.value);
+    parts.push(value !== void 0 ? `${name}=${value}` : name);
+  }
+  if (parts.length === 0) return void 0;
+  const extra = fields.length - parts.length;
+  return extra > 0 ? `${parts.join(", ")} +${extra}` : parts.join(", ");
+}
+function formatFieldValue(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "string") {
+    const v = value.length > 18 ? `${value.slice(0, 17)}\u2026` : value;
+    return `"${v}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return void 0;
+}
+function humanActionTarget(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const record = payload;
+  const friendly = readFriendlyString(record, "label") || readFriendlyString(record, "actionDescription") || readFriendlyString(record, "title") || readFriendlyString(record, "name");
+  if (friendly) return friendly;
+  return humanComponentId(
+    readString(payload, "componentId") || readString(payload, "targetId")
+  );
+}
+function humanFieldName(label, fieldId) {
+  if (typeof label === "string" && label.trim()) return label.trim();
+  if (typeof fieldId !== "string" || isTechnicalIdentifier(fieldId)) return void 0;
+  return humanComponentId(fieldId) || void 0;
+}
+function readFriendlyString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed || isTechnicalIdentifier(trimmed)) return "";
+  return trimmed;
+}
+function humanComponentId(id) {
+  if (!id) return "";
+  if (isTechnicalIdentifier(id)) return "";
+  const cleaned = id.replace(/^(btn-|btn_|button-|component-)/i, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim();
+  if (!cleaned) return "";
+  return cleaned[0].toUpperCase() + cleaned.slice(1);
+}
+function isTechnicalIdentifier(value) {
+  const raw = value.trim();
+  if (!raw) return false;
+  if (/^el:/i.test(raw)) return true;
+  if (/^list-\d+-item-\d+$/i.test(raw)) return true;
+  if (/(testid|test-id|accessibilityid|accessibility-id|automationid|automation-id)/i.test(raw)) {
+    return true;
+  }
+  if (/^[a-z]+:[^ ]+:[^ ]+/i.test(raw)) return true;
+  if (/^[A-Za-z][\w-]*:[^\s]+$/i.test(raw)) return true;
+  if (/^[a-z]+(?:[-_][a-z]+)*[-_][a-z0-9]{5,}$/i.test(raw)) return true;
+  return false;
+}
+function readString(payload, key) {
+  if (!payload || typeof payload !== "object") return "";
+  const v = payload[key];
+  return typeof v === "string" ? v : "";
+}
+function readArray(payload, key) {
+  if (!payload || typeof payload !== "object") return [];
+  const v = payload[key];
+  return Array.isArray(v) ? v : [];
+}
+function normalizePart(value) {
+  return String(value ?? "").toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function hashString(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function stableElementId(parts) {
+  const raw = parts.filter((p) => p !== void 0 && String(p).length > 0).join("|");
+  const readable = parts.map(normalizePart).filter(Boolean).join(":").slice(0, 120);
+  return `el:${readable}:${hashString(raw)}`;
+}
+function parseStableElementId(id) {
+  if (typeof id !== "string") return null;
+  const trimmed = id.trim();
+  if (!/^el:/i.test(trimmed)) return null;
+  const parts = trimmed.split(":");
+  if (parts.length < 3) return null;
+  const hash = parts[parts.length - 1];
+  const segments = parts.slice(1, -1);
+  if (segments.length === 0) return null;
+  const role = segments[0];
+  const result = { role, segments, hash };
+  if (role === "option" && segments.length >= 4) {
+    result.listId = segments[segments.length - 2];
+    result.itemKey = segments[segments.length - 1];
+  }
+  return result;
+}
+function uniqueTexts(texts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const text of texts) {
+    const t = typeof text === "string" ? text.trim() : "";
+    if (!t || seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+  }
+  return out;
+}
+function labelForListItem(item) {
+  return uniqueTexts([
+    ...item.texts ?? [],
+    ...(item.buttons ?? []).map((button) => button.label ?? button.id)
+  ]).slice(0, 2).join(" \xB7 ") || void 0;
+}
+function listItemElement(route, list, item) {
+  const texts = uniqueTexts([
+    ...item.texts ?? [],
+    ...(item.buttons ?? []).map((button) => button.label ?? button.id)
+  ]);
+  const label = labelForListItem(item);
+  const key = item.itemKey ?? item.reactKey ?? label ?? item.syntheticId;
+  const id = stableElementId([
+    "option",
+    route ?? "unknown",
+    list.id ?? list.label ?? `list-${list.index}`,
+    key
+  ]);
+  const inModal = (item.buttons ?? []).some((button) => button.inModal) || (item.inputs ?? []).some((input) => input.inModal) || (item.toggles ?? []).some((toggle) => toggle.inModal);
+  return {
+    id,
+    role: "option",
+    label,
+    texts,
+    actions: ["press"],
+    disabled: false,
+    source: "list",
+    targetId: item.syntheticId,
+    ...inModal ? { inModal: true } : {},
+    listContext: {
+      listIndex: list.index,
+      listId: list.id,
+      listLabel: list.label,
+      itemIndex: item.index,
+      itemKey: item.itemKey,
+      reactKey: item.reactKey,
+      syntheticId: item.syntheticId
+    }
+  };
+}
+function buttonElement(route, button, index) {
+  const label = button.label ?? button.id;
+  const id = stableElementId([
+    "button",
+    route ?? "unknown",
+    button.id ?? label ?? `button-${index}`
+  ]);
+  return {
+    id,
+    role: "button",
+    label,
+    texts: uniqueTexts([label]),
+    actions: ["press"],
+    disabled: button.disabled,
+    selected: button.selected,
+    source: "button",
+    targetId: button.id ?? button.label,
+    ...button.inModal ? { inModal: true } : {}
+  };
+}
+function inputElement(route, input, index) {
+  const label = input.label ?? input.placeholder ?? input.id;
+  const id = stableElementId([
+    "input",
+    route ?? "unknown",
+    input.id ?? label ?? `input-${index}`
+  ]);
+  return {
+    id,
+    role: "input",
+    label,
+    texts: uniqueTexts([label, input.placeholder]),
+    actions: ["focus", "setValue"],
+    disabled: input.editable === false,
+    source: "input",
+    targetId: input.id ?? input.label ?? input.placeholder,
+    ...input.inModal ? { inModal: true } : {}
+  };
+}
+function toggleElement(route, toggle, index) {
+  const label = toggle.label ?? toggle.id;
+  const id = stableElementId([
+    "toggle",
+    route ?? "unknown",
+    toggle.id ?? label ?? `toggle-${index}`
+  ]);
+  return {
+    id,
+    role: "toggle",
+    label,
+    texts: uniqueTexts([label]),
+    actions: ["toggle", "press"],
+    selected: toggle.value,
+    source: "toggle",
+    targetId: toggle.id ?? toggle.label,
+    ...toggle.inModal ? { inModal: true } : {}
+  };
+}
+function sliderElement(route, slider, index) {
+  const label = slider.label ?? slider.id;
+  const id = stableElementId([
+    "slider",
+    route ?? "unknown",
+    slider.id ?? label ?? `slider-${index}`
+  ]);
+  return {
+    id,
+    role: "slider",
+    label,
+    texts: uniqueTexts([label]),
+    actions: ["setValue"],
+    disabled: slider.disabled,
+    source: "slider",
+    targetId: slider.id ?? slider.label,
+    ...slider.inModal ? { inModal: true } : {}
+  };
+}
+function deriveInteractionElements(snapshot) {
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (element) => {
+    if (!element.id || seen.has(element.id)) return;
+    seen.add(element.id);
+    elements.push(element);
+  };
+  for (const list of snapshot.lists ?? []) {
+    for (const item of list.items ?? []) {
+      push(listItemElement(snapshot.route, list, item));
+    }
+  }
+  for (const [index, button] of (snapshot.buttons ?? []).entries()) {
+    push(buttonElement(snapshot.route, button, index));
+  }
+  for (const [index, input] of (snapshot.inputs ?? []).entries()) {
+    push(inputElement(snapshot.route, input, index));
+  }
+  for (const [index, toggle] of (snapshot.toggles ?? []).entries()) {
+    push(toggleElement(snapshot.route, toggle, index));
+  }
+  for (const [index, slider] of (snapshot.sliders ?? []).entries()) {
+    push(sliderElement(snapshot.route, slider, index));
+  }
+  return elements;
+}
+function findElementForChoice(elements, option) {
+  if (option.targetId) {
+    const byTarget = elements.find((element) => element.targetId === option.targetId);
+    if (byTarget) return byTarget;
+  }
+  const optionLabel = normalizePart(option.label ?? option.texts?.join(" "));
+  if (!optionLabel) return void 0;
+  return elements.find((element) => {
+    if (element.role !== "option" && element.role !== "button") return false;
+    const label = normalizePart(element.label ?? element.texts.join(" "));
+    return label === optionLabel || label.includes(optionLabel) || optionLabel.includes(label);
+  });
+}
+function attachElementIdsToChoiceGroups(choiceGroups, elements) {
+  return choiceGroups.map((group) => ({
+    ...group,
+    options: group.options.map((option) => {
+      const element = findElementForChoice(elements, option);
+      if (!element) return option;
+      const handle = element.listContext?.syntheticId ?? element.id;
+      return {
+        ...option,
+        syntheticId: handle,
+        targetId: handle
+      };
+    })
+  }));
+}
 
 // src/registry/ComponentRegistry.ts
 var ComponentRegistryImpl = class {
@@ -1018,7 +2997,7 @@ function getDefaultRegistry() {
 }
 
 // src/auto/idExtraction.ts
-function normalizeId(raw) {
+function normalizeId2(raw) {
   return raw.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/^(input-|btn-|toggle-|switch-)/, "").replace(/[^a-z0-9\s-_]/g, "").trim().replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-_\s]+$/, "");
 }
 function deriveSemanticInputId(props) {
@@ -1066,7 +3045,7 @@ function sectionListFlatIndex(sections, section, localIndex) {
 function extractId(props) {
   const raw = props?.testID ?? props?.nativeID ?? props?.id ?? props?.accessibilityLabel ?? props?.name ?? props?.placeholder ?? (typeof props?.autoComplete === "string" && props.autoComplete !== "off" ? props.autoComplete : void 0);
   if (raw && typeof raw === "string") {
-    const normalized = normalizeId(raw);
+    const normalized = normalizeId2(raw);
     if (normalized && normalized.length > 0) {
       console.log(`[Appilots] extractId: raw="${raw}" \u2192 normalized="${normalized}"`);
       return normalized;
@@ -1217,7 +3196,7 @@ function componentDisplayName(type) {
 function extractListId(props, componentName) {
   const raw = props?.appilotsListId ?? props?.testID ?? props?.nativeID ?? props?.id ?? props?.accessibilityLabel ?? props?.name;
   if (typeof raw === "string" && raw.trim().length > 0) {
-    const normalized = normalizeId(raw);
+    const normalized = normalizeId2(raw);
     if (normalized) return normalized;
   }
   _generatedListIdCounter += 1;
@@ -1647,65 +3626,6 @@ function getGlobalConfig() {
   return _globalConfig;
 }
 
-// src/debug/actionTraceStore.ts
-var MAX_TRACE_ENTRIES = 200;
-var entries = [];
-var listeners = /* @__PURE__ */ new Set();
-var traceCounter = 0;
-function notify() {
-  const snapshot = [...entries];
-  listeners.forEach((listener) => listener(snapshot));
-}
-function append(entry) {
-  entries.push(entry);
-  if (entries.length > MAX_TRACE_ENTRIES) {
-    entries.splice(0, entries.length - MAX_TRACE_ENTRIES);
-  }
-  notify();
-}
-function recordAppilotsDebugTrace(entry) {
-  append({
-    ...entry,
-    id: entry.id ?? `trace_${++traceCounter}`
-  });
-}
-function actionFromEvent(event) {
-  const action = event.data?.action;
-  if (action && typeof action === "object" && typeof action.id === "string") {
-    return action;
-  }
-  return void 0;
-}
-function recordAppilotsEventTrace(event) {
-  if (!event.type.startsWith("agent:action:")) return;
-  const action = actionFromEvent(event);
-  const actionId = action?.id || (typeof event.data?.actionId === "string" ? event.data.actionId : void 0);
-  const actionType = action?.type || (typeof event.data?.actionType === "string" ? event.data.actionType : void 0);
-  recordAppilotsDebugTrace({
-    timestamp: event.timestamp,
-    type: event.type,
-    messageId: action?.messageId,
-    actionId,
-    actionType,
-    status: event.type === "agent:action:start" ? "started" : event.type === "agent:action:complete" ? "completed" : "error",
-    data: event.data
-  });
-}
-function getAppilotsDebugTraces() {
-  return [...entries];
-}
-function clearAppilotsDebugTraces() {
-  entries.splice(0, entries.length);
-  notify();
-}
-function subscribeAppilotsDebugTraces(listener) {
-  listeners.add(listener);
-  listener([...entries]);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-
 // src/introspection/fiberRoot.ts
 var _fiberRoot = null;
 function setFiberRoot(fiber) {
@@ -2351,20 +4271,27 @@ function clearScreenRegistry() {
   screenRegistry.clear();
 }
 
+exports.ActionQueueMachine = ActionQueueMachine;
 exports.AppilotsClient = AppilotsClient;
 exports.AppilotsProvider = AppilotsProvider;
 exports.AppilotsRegistryProvider = AppilotsRegistryProvider;
+exports.ChatSessionMachine = ChatSessionMachine;
+exports.OPTIONAL_STEP_AUTOMATION_HINT = OPTIONAL_STEP_AUTOMATION_HINT;
 exports.SDK_VERSION = SDK_VERSION;
-exports.StreamAbortError = StreamAbortError;
-exports.StreamTransportError = StreamTransportError;
 exports._patchJsxRuntimes = _patchJsxRuntimes;
+exports.actionPressTargetId = actionPressTargetId;
 exports.appilotsDebugWarn = appilotsDebugWarn;
+exports.attachElementIdsToChoiceGroups = attachElementIdsToChoiceGroups;
 exports.clearAppilotsDebugTraces = clearAppilotsDebugTraces;
 exports.clearScreenRegistry = clearScreenRegistry;
 exports.componentRegistry = componentRegistry;
 exports.createComponentRegistry = createComponentRegistry;
 exports.createElementRegistry = createElementRegistry;
 exports.createListRegistry = createListRegistry;
+exports.defaultDarkTheme = defaultDarkTheme;
+exports.defaultLightTheme = defaultLightTheme;
+exports.deriveInteractionElements = deriveInteractionElements;
+exports.describeAction = describeAction;
 exports.elementRegistry = elementRegistry;
 exports.enableAppilotsAutoTracking = enableAppilotsAutoTracking;
 exports.getActiveRouteNames = getActiveRouteNames;
@@ -2378,16 +4305,28 @@ exports.getGlobalConfig = getGlobalConfig;
 exports.getNavigationRef = getNavigationRef;
 exports.getNavigationStateSnapshot = getNavigationStateSnapshot;
 exports.getScreenMetadata = getScreenMetadata;
+exports.humanizeError = humanizeError;
+exports.idLooselyMatches = idLooselyMatches;
 exports.initAppilots = initAppilots;
 exports.isAutoTrackingEnabled = isAutoTrackingEnabled;
+exports.isGenericSelectValue = isGenericSelectValue;
+exports.isListItemPressTarget = isListItemPressTarget;
+exports.isOptionalStepAutomationFailure = isOptionalStepAutomationFailure;
 exports.listRegistry = listRegistry;
+exports.looksDestructiveActionLabel = looksDestructiveActionLabel;
+exports.matchScore = matchScore;
+exports.mergeThemeTokens = mergeThemeTokens;
+exports.normalize3 = normalize3;
+exports.parseStableElementId = parseStableElementId;
 exports.probeLoadingState = probeLoadingState;
 exports.recordAppilotsDebugTrace = recordAppilotsDebugTrace;
 exports.registerScreen = registerScreen;
+exports.resolveBaseTheme = resolveBaseTheme;
 exports.routesBelongToSameFeature = routesBelongToSameFeature;
 exports.screenDepartedBaseline = screenDepartedBaseline;
 exports.setCurrentScreen = setCurrentScreen;
 exports.setNavigationRef = setNavigationRef;
+exports.snapshotShowsOpenCreateForm = snapshotShowsOpenCreateForm;
 exports.subscribeAppilotsDebugTraces = subscribeAppilotsDebugTraces;
 exports.useAppilotsContext = useAppilotsContext;
 exports.useResolvedRegistry = useResolvedRegistry;