@appilots/sdk 0.3.0 → 0.4.0

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

@@ -979,56 +979,6 @@ function fingerprintAction(action, screen) {
       return `${action.type}${scope}:${JSON.stringify(p)}`;
   }
 }
-function normalize2(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 = normalize2(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";
 var MAX_TRACE_ENTRIES = 200;
 var entries = [];
 var listeners = /* @__PURE__ */ new Set();
@@ -1086,6 +1036,1223 @@ function subscribeAppilotsDebugTraces(listener) {
     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 {
+            await this.deps.client.completeAction(action.id, false, "Confirm canceled by user");
+          } catch {
+          }
+          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;
+        }
+      }
+      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";
+    }
+  }
+  // ── 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 {
+        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);
@@ -1380,6 +2547,223 @@ function readArray(payload, key) {
   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 {
@@ -2887,17 +4271,17 @@ 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.buildContinuationFailureMessage = buildContinuationFailureMessage;
+exports.attachElementIdsToChoiceGroups = attachElementIdsToChoiceGroups;
 exports.clearAppilotsDebugTraces = clearAppilotsDebugTraces;
 exports.clearScreenRegistry = clearScreenRegistry;
 exports.componentRegistry = componentRegistry;
@@ -2906,10 +4290,10 @@ 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.fingerprintAction = fingerprintAction;
 exports.getActiveRouteNames = getActiveRouteNames;
 exports.getAllScreens = getAllScreens;
 exports.getAppilotsDebugTraces = getAppilotsDebugTraces;
@@ -2922,6 +4306,7 @@ exports.getNavigationRef = getNavigationRef;
 exports.getNavigationStateSnapshot = getNavigationStateSnapshot;
 exports.getScreenMetadata = getScreenMetadata;
 exports.humanizeError = humanizeError;
+exports.idLooselyMatches = idLooselyMatches;
 exports.initAppilots = initAppilots;
 exports.isAutoTrackingEnabled = isAutoTrackingEnabled;
 exports.isGenericSelectValue = isGenericSelectValue;
@@ -2931,8 +4316,8 @@ exports.listRegistry = listRegistry;
 exports.looksDestructiveActionLabel = looksDestructiveActionLabel;
 exports.matchScore = matchScore;
 exports.mergeThemeTokens = mergeThemeTokens;
-exports.metadataMatchesComponentId = metadataMatchesComponentId;
-exports.normalize2 = normalize2;
+exports.normalize3 = normalize3;
+exports.parseStableElementId = parseStableElementId;
 exports.probeLoadingState = probeLoadingState;
 exports.recordAppilotsDebugTrace = recordAppilotsDebugTrace;
 exports.registerScreen = registerScreen;
@@ -2941,8 +4326,8 @@ exports.routesBelongToSameFeature = routesBelongToSameFeature;
 exports.screenDepartedBaseline = screenDepartedBaseline;
 exports.setCurrentScreen = setCurrentScreen;
 exports.setNavigationRef = setNavigationRef;
+exports.snapshotShowsOpenCreateForm = snapshotShowsOpenCreateForm;
 exports.subscribeAppilotsDebugTraces = subscribeAppilotsDebugTraces;
-exports.turnHasConfirmActions = turnHasConfirmActions;
 exports.useAppilotsContext = useAppilotsContext;
 exports.useResolvedRegistry = useResolvedRegistry;
 exports.waitForLoadingSettle = waitForLoadingSettle;