fix(mobile): answer approvals through the detached respond dispatcher

The phone built its own /invoke resume from a stamped records replay. That lands as a
NEW turn (the keepalive trips approval-mismatch (history) -> evict + cold), so the parked
gate is never matched and the interaction row stays pending — the desktop keeps showing
"Approval needed to continue" even after the tool ran.

Call POST /sessions/interactions/{id}/respond instead: the backend CAS-flips the row to
responded and the interactions worker rebuilds the history server-side and replays the
gate's stamped effective config, so the resume lands warm. Approve-all fans out one
respond per pending gate; a 409 (already answered) settles to idle instead of erroring.

respondInteraction now throws instead of swallowing the failure — a mutation's caller has
to tell a real failure from an already-answered gate (isInteractionConflict).

Drops the mobile-only invoke plumbing: approvalStamp.ts and the invoke bearer header.

Author: ardaerzin

web/mobile/src/features/chat/approvalStamp.ts

@@ -0,0 +1,20 @@
+import type {SessionInteraction} from "@agenta/entities/session"
+
+/** Which pending gates a tap answers: one gate (by transcript approval id) or every gate. */
+export type ApprovalTarget = {all: true} | {all?: false; approvalId: string}
+
+/**
+ * Pick the interaction rows to respond to.
+ *
+ * The transcript's approval id is the row's `token` (both come from the runner's
+ * `interaction_request` event id), but `/sessions/interactions/{id}/respond` keys on the
+ * row's `id` — so a row without an `id` is unanswerable and is dropped.
+ */
+export const selectApprovalTargets = (
+    rows: SessionInteraction[] | null | undefined,
+    target: ApprovalTarget,
+): SessionInteraction[] => {
+    const pending = (rows ?? []).filter((row) => row.kind === "user_approval" && !!row.id)
+    if (target.all) return pending
+    return pending.filter((row) => row.token === target.approvalId)
+}

web/mobile/src/features/chat/approvalTargets.ts

@@ -1,60 +1,40 @@
 import {useCallback, useEffect, useRef, useState} from "react"
 
-import {loadSessionMessages} from "@agenta/chat/assets"
-import {getPendingApprovals} from "@agenta/chat/model"
 import {
-    buildAgentResumeRequest,
-    resolveInvocationUrl,
-    type AgentResumeReference,
-} from "@agenta/chat/transport"
-import {queryInteractions} from "@agenta/entities/session"
+    isInteractionConflict,
+    queryInteractions,
+    respondInteraction,
+} from "@agenta/entities/session"
 
-import {getAuthorizationHeader} from "@/lib/auth"
-
-import {stampApprovalResponses} from "./approvalStamp"
+import {selectApprovalTargets, type ApprovalTarget} from "./approvalTargets"
 
 export type ResumePhase = "idle" | "resuming" | "error"
 
+/** Fern's `AgentaApiError` message is transport jargon — show the status instead. */
+const respondErrorText = (error: unknown): string => {
+    const status = (error as {statusCode?: number} | null)?.statusCode
+    return status ? `Approval failed (HTTP ${status}).` : "Approval failed."
+}
+
 export interface ApprovalActions {
     phase: ResumePhase
     errorText: string | null
     /** Answer one gate. Deny also resumes (the runner needs the denial round-trip). */
     respond: (args: {approvalId: string; approved: boolean}) => void
-    /** Approve every pending gate — all responses ride ONE resume POST. */
+    /** Approve every pending gate — one respond call per gate (the endpoint is per-interaction). */
     approveAll: () => void
 }
 
-/** Keep only `{id, slug, version}` string fields of the interaction row's role-keyed refs. */
-const sanitizeReferences = (
-    raw: Record<string, unknown> | null | undefined,
-): Record<string, AgentResumeReference> | null => {
-    if (!raw) return null
-    const out: Record<string, AgentResumeReference> = {}
-    for (const [key, value] of Object.entries(raw)) {
-        if (!value || typeof value !== "object") continue
-        const {id, slug, version} = value as Record<string, unknown>
-        const ref: AgentResumeReference = {}
-        if (typeof id === "string") ref.id = id
-        if (typeof slug === "string") ref.slug = slug
-        if (typeof version === "string") ref.version = version
-        if (Object.keys(ref).length > 0) out[key] = ref
-    }
-    return Object.keys(out).length > 0 ? out : null
-}
-
-/** The gated turn's stamped effective config, or null when the row predates stamping. */
-const sanitizeParameters = (raw: unknown): Record<string, unknown> | null => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null
-    const params = raw as Record<string, unknown>
-    return Object.keys(params).length > 0 ? params : null
-}
-
 /**
- * Approve/deny pending HITL gates from the phone — the lite resume path (plan M1.3):
- * fresh records → stamp `approval-responded` on the tail → ONE resume invoke POST
- * (`buildAgentResumeRequest`), fire-and-forget. No live SSE consumption: the response is
- * drained in the background and the tightened records poll repaints the transcript until the
- * turn settles (`phase` drops back to idle once no gate is pending).
+ * Approve/deny pending HITL gates from the phone via the DETACHED respond dispatcher:
+ * `POST /sessions/interactions/{id}/respond`. The backend CAS-flips the row to `responded`,
+ * then the interactions worker rebuilds the turn's history from the durable records and
+ * replays the gate's stamped effective config, so the parked run resumes WARM.
+ *
+ * Never hand-build an `/invoke` resume here: an invoke carrying stamped messages runs as a
+ * NEW turn (`approval-mismatch (history)` → evict + cold) and leaves the interaction row
+ * `pending`, so the gate never clears. Fire-and-forget: no stream is consumed, and the
+ * records poll repaints the transcript until `pendingCount` drops to 0.
  */
 export const useApprovalActions = ({
     sessionId,
@@ -77,7 +57,7 @@ export const useApprovalActions = ({
         }
     }, [pendingCount])
 
-    // Failure-path re-arm: if the resume was accepted but the run dies before the gate
+    // Failure-path re-arm: if the respond was accepted but the run dies before the gate
     // resolves, the poll never settles us — drop back to idle so the buttons re-arm.
     useEffect(() => {
         if (phase !== "resuming") return
@@ -86,99 +66,43 @@ export const useApprovalActions = ({
     }, [phase])
 
     const submit = useCallback(
-        async (target: {all: true} | {all?: false; approvalId: string}, approved: boolean) => {
+        async (target: ApprovalTarget, approved: boolean) => {
             if (busyRef.current) return
             busyRef.current = true
             setPhase("resuming")
             setErrorText(null)
             try {
-                // Never stamp a stale tail — re-read the durable records first.
-                const messages = (await loadSessionMessages(sessionId)) ?? []
-                const pending = getPendingApprovals(messages)
-                if (pending.length === 0) {
-                    throw new Error("No pending approval found — the turn may have moved on.")
-                }
-                const ids = target.all ? pending.map((p) => p.approvalId) : [target.approvalId]
-                const stamped = stampApprovalResponses(messages, ids, approved)
-                if (stamped === messages) {
-                    throw new Error("This approval is no longer pending — refresh and retry.")
-                }
-                // The interaction row stores the run's role-keyed workflow references and,
-                // when the runner stamped it, the turn's effective config.
-                const interactions = await queryInteractions({
+                // Never answer a stale gate — re-read the actionable rows (pending + in TTL).
+                const rows = await queryInteractions({
                     sessionId,
                     projectId,
                     actionableOnly: true,
                 })
-                const withRefs = (interactions ?? []).filter(
-                    (row) => row.data?.references && Object.keys(row.data.references).length > 0,
-                )
-                // Bind to the answered gate's own row when possible — two parked runs on
-                // different revisions in one session must not resume with the wrong config.
-                const answeredId = target.all ? undefined : target.approvalId
-                const matched = answeredId
-                    ? withRefs.find((row) => row.token === answeredId)
-                    : undefined
-                const row = matched ?? withRefs[0]
-                const references = sanitizeReferences(row?.data?.references)
-                // Replay the turn's own config when the runner stamped it — references alone
-                // hydrate the variant's HEAD, which is a different model and, worse, a
-                // different tool-permission map than the gate was approved under. Rows without
-                // it (legacy, over-cap, pre-restart runner) fall back to hydration silently.
-                const parameters = sanitizeParameters(row?.data?.parameters)
-                if (!references) {
+                const targets = selectApprovalTargets(rows, target)
+                if (targets.length === 0) {
                     throw new Error(
-                        "This approval carries no workflow reference — answer on desktop.",
+                        target.all
+                            ? "No pending approval found — the turn may have moved on."
+                            : "This approval is no longer pending — refresh and retry.",
                     )
                 }
-                const invocationUrl = await resolveInvocationUrl({
-                    projectId,
-                    revisionId:
-                        references.workflow_revision?.id ?? references.application_revision?.id,
-                    workflowId: references.workflow?.id ?? references.application?.id,
-                })
-                if (!invocationUrl) {
-                    throw new Error("Could not resolve the agent's invoke URL.")
-                }
-                const request = buildAgentResumeRequest({
-                    invocationUrl,
-                    references,
-                    sessionId,
-                    messages: stamped,
-                    parameters,
-                    projectId,
-                    applicationId: references.application?.id ?? undefined,
-                })
-                const authHeader = await getAuthorizationHeader()
-                const response = await fetch(request.invocationUrl, {
-                    method: "POST",
-                    headers: {
-                        ...request.headers,
-                        ...authHeader,
-                        "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify(request.requestBody),
-                    credentials: "include",
-                })
-                if (!response.ok) {
-                    throw new Error(`Resume failed (HTTP ${response.status}).`)
-                }
-                // Fire-and-forget, but NEVER cancel: cancelling the body aborts the request,
-                // and the agent service treats that disconnect as "stop" — the resumed run
-                // dies ~200ms in and the gate stays pending (observed live). Drain instead.
-                void (async () => {
-                    const reader = response.body?.getReader()
-                    if (!reader) return
+                let answered = 0
+                for (const row of targets) {
                     try {
-                        for (;;) {
-                            const {done} = await reader.read()
-                            if (done) return
-                        }
-                    } catch {
-                        // Connection dropped (screen locked, network change) — the run
-                        // continues server-side; records polling picks the result up.
+                        await respondInteraction({
+                            interactionId: row.id as string,
+                            projectId,
+                            answer: {approved},
+                        })
+                        answered += 1
+                    } catch (err) {
+                        // Someone (desktop, another tab) already answered this gate — benign.
+                        if (!isInteractionConflict(err)) throw new Error(respondErrorText(err))
                     }
-                })()
+                }
+                // Every target was already answered: nothing is resuming, so re-arm now
+                // instead of waiting out the 60s timeout.
+                if (answered === 0) setPhase("idle")
             } catch (err) {
                 setPhase("error")
                 setErrorText(err instanceof Error ? err.message : "Resume failed.")

web/mobile/src/features/chat/useApprovalActions.ts

@@ -87,25 +87,6 @@ export async function signInWithEmailPassword(
     }
 }
 
-/**
- * `Authorization` for an invoke, mirroring the desktop's `getJWT()`
- * (web/oss/src/services/api.ts). The cookie alone authenticates the invoke, but the SDK
- * resolves the model connection by fetching the vault with the caller's Authorization
- * header ONLY — without it the run proceeds with no injected credential and the model
- * rejects it ("no connection resolved for provider …").
- */
-export async function getAuthorizationHeader(): Promise<Record<string, string>> {
-    if (typeof window === "undefined") return {}
-    ensureAuthInit()
-    try {
-        if (!(await Session.doesSessionExist())) return {}
-        const jwt = await Session.getAccessToken()
-        return jwt ? {Authorization: `Bearer ${jwt}`} : {}
-    } catch {
-        return {}
-    }
-}
-
 /**
  * Attempt a cookie-based session refresh. Resolves false when there is no
  * refresh token or the backend rejects it — the caller's signed-out verdict